mono_decompose_opcode (struct MonoCompile * cfg, struct MonoInst * ins)
{
  unsigned char D.26975;
  short unsigned int D.26976;
  int D.26977;
  struct MonoMemPool * D.26979;
  int D.26980;
  struct MonoInst * D.26981;
  int D.26982;
  int D.26983;
  const unsigned char * D.26984;
  struct MonoBasicBlock * D.26985;
  struct MonoInst * D.26986;
  int D.26991;
  struct MonoInst * D.26992;
  int D.26993;
  int D.26994;
  int D.26999;
  struct MonoInst * D.27000;
  int D.27001;
  int D.27002;
  int D.27007;
  struct MonoInst * D.27008;
  int D.27009;
  int D.27010;
  int D.27014;
  struct MonoInst * D.27015;
  int D.27016;
  int D.27017;
  int D.27018;
  int D.27022;
  struct MonoInst * D.27023;
  int D.27024;
  int D.27025;
  int D.27029;
  struct MonoInst * D.27030;
  int D.27031;
  int D.27032;
  int D.27036;
  struct MonoInst * D.27037;
  int D.27038;
  int D.27039;
  int D.27043;
  struct MonoInst * D.27044;
  int D.27045;
  int D.27046;
  int D.27047;
  int D.27051;
  int D.27052;
  int D.27053;
  struct MonoInst * D.27054;
  int D.27055;
  int D.27056;
  int D.27060;
  struct MonoInst * D.27061;
  int D.27062;
  int D.27063;
  int D.27067;
  struct MonoInst * D.27068;
  int D.27069;
  int D.27070;
  int D.27074;
  struct MonoInst * D.27075;
  int D.27076;
  int D.27077;
  int D.27081;
  struct MonoInst * D.27082;
  int D.27083;
  int D.27084;
  int D.27088;
  struct MonoInst * D.27089;
  int D.27090;
  int D.27091;
  int D.27095;
  struct MonoInst * D.27096;
  int D.27097;
  int D.27098;
  int D.27102;
  struct MonoInst * D.27103;
  int D.27104;
  int D.27105;
  int D.27109;
  struct MonoInst * D.27110;
  int D.27111;
  int D.27112;
  int D.27116;
  struct MonoInst * D.27117;
  int D.27118;
  int D.27119;
  int D.27123;
  struct MonoInst * D.27124;
  int D.27125;
  int D.27126;
  int D.27130;
  struct MonoInst * D.27131;
  int D.27132;
  int D.27133;
  int D.27137;
  struct MonoInst * D.27138;
  int D.27139;
  int D.27140;
  int D.27144;
  struct MonoInst * D.27145;
  int D.27146;
  int D.27147;
  int D.27151;
  struct MonoInst * D.27152;
  int D.27153;
  int D.27154;
  int D.27158;
  struct MonoInst * D.27159;
  int D.27160;
  int D.27161;
  int D.27165;
  struct MonoInst * D.27166;
  int D.27167;
  int D.27168;
  int D.27172;
  struct MonoInst * D.27173;
  int D.27174;
  int D.27175;
  int D.27179;
  struct MonoInst * D.27180;
  int D.27181;
  int D.27182;
  int D.27186;
  struct MonoInst * D.27187;
  int D.27188;
  int D.27189;
  gchar * D.27193;
  int D.27194;
  unsigned int D.27197;
  unsigned int D.27198;
  int D.27199;
  struct MonoInst * D.27200;
  int D.27201;
  int D.27202;
  int D.27206;
  struct MonoInst * D.27207;
  int D.27208;
  int D.27209;
  short unsigned int D.27213;
  _Bool D.27214;
  _Bool D.27215;
  _Bool D.27216;
  int D.27219;
  struct MonoInst * D.27220;
  int D.27221;
  int D.27222;
  int D.27226;
  struct MonoInst * D.27227;
  int D.27228;
  int D.27229;
  int D.27233;
  struct MonoInst * D.27234;
  int D.27235;
  int D.27236;
  int D.27240;
  struct MonoInst * D.27241;
  int D.27242;
  int D.27243;
  int D.27247;
  struct MonoInst * D.27248;
  int D.27249;
  int D.27250;
  int D.27254;
  struct MonoInst * D.27255;
  int D.27256;
  int D.27257;
  int D.27261;
  struct MonoInst * D.27262;
  int D.27263;
  int D.27264;
  int D.27268;
  struct MonoInst * D.27269;
  int D.27270;
  int D.27271;
  struct MonoMethodSignature * D.27284;
  unsigned char D.27285;
  unsigned char D.27286;
  _Bool D.27287;
  long int D.27288;
  long int D.27289;
  short unsigned int D.27292;
  _Bool D.27293;
  long int D.27294;
  long int D.27295;
  unsigned int D.27298;
  unsigned int D.27299;
  int D.27302;
  signed char D.27303;
  int D.27304;
  _Bool D.27305;
  long int D.27306;
  long int D.27307;
  unsigned int i.0;
  unsigned int D.27311;
  struct MonoInst * * D.27312;
  void * D.27313;
  struct MonoInst * D.27314;
  int D.27315;
  struct MonoInst * D.27316;
  int D.27317;
  int D.27318;
  int D.27319;
  const void * D.27320;
  struct MonoInst * repl.1;
  unsigned char D.27326;
  struct MonoInst * D.27327;
  _Bool D.27328;
  long int D.27329;
  long int D.27330;
  _Bool D.27333;
  long int D.27334;
  long int D.27335;
  struct MonoInst * repl;
  int type;
  int dreg;
  gboolean emulate;

  try
    {
      repl = 0B;
      D.26975 = ins->type;
      type = (int) D.26975;
      dreg = ins->dreg;
      emulate = 0;
      D.26976 = ins->opcode;
      D.26977 = (int) D.26976;
      switch (D.26977) <default: <D.26448>, case 568: <D.26432>, case 569: <D.26434>, case 570: <D.26433>, case 571: <D.26435>, case 582: <D.26413>, case 586: <D.26414>, case 589: <D.26420>, case 592: <D.26419>, case 593: <D.26417>, case 594: <D.26408>, case 595: <D.26367>, case 596: <D.26370>, case 599: <D.26372>, case 600: <D.26374>, case 601: <D.26382>, case 602: <D.26397>, case 603: <D.26407>, case 605: <D.26387>, case 606: <D.26402>, case 607: <D.26416>, case 609: <D.26409>, case 610: <D.26418>, case 611: <D.26376>, case 612: <D.26386>, case 613: <D.26391>, case 614: <D.26401>, case 615: <D.26415>, case 616: <D.26406>, case 682: <D.26421>, case 696: <D.26422>, case 697: <D.26423>, case 698: <D.26424>, case 699: <D.26425>, case 700: <D.26426>, case 701: <D.26427>, case 702: <D.26428>, case 703: <D.26429>, case 704: <D.26430>, case 705: <D.26431>>
      <D.26367>:
      if (0 != 0) goto <D.26368>; else goto <D.26978>;
      <D.26978>:
      ins->opcode = 623;
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.26980 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.26980;
        inst->prev = 0B;
        D.26981 = inst->prev;
        inst->next = D.26981;
        inst->opcode = 475;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.26982 = inst->sreg3;
        inst->sreg2 = D.26982;
        D.26983 = inst->sreg2;
        inst->sreg1 = D.26983;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.26987>; else goto <D.26988>;
        <D.26987>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.26989>;
        <D.26988>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.26989>:
      }
      goto <D.26368>;
      <D.26370>:
      if (0 != 0) goto <D.26368>; else goto <D.26990>;
      <D.26990>:
      ins->opcode = 623;
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.26991 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.26991;
        inst->prev = 0B;
        D.26992 = inst->prev;
        inst->next = D.26992;
        inst->opcode = 477;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.26993 = inst->sreg3;
        inst->sreg2 = D.26993;
        D.26994 = inst->sreg2;
        inst->sreg1 = D.26994;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.26995>; else goto <D.26996>;
        <D.26995>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.26997>;
        <D.26996>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.26997>:
      }
      goto <D.26368>;
      <D.26372>:
      if (0 != 0) goto <D.26368>; else goto <D.26998>;
      <D.26998>:
      ins->opcode = 624;
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.26999 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.26999;
        inst->prev = 0B;
        D.27000 = inst->prev;
        inst->next = D.27000;
        inst->opcode = 475;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27001 = inst->sreg3;
        inst->sreg2 = D.27001;
        D.27002 = inst->sreg2;
        inst->sreg1 = D.27002;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27003>; else goto <D.27004>;
        <D.27003>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27005>;
        <D.27004>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27005>:
      }
      goto <D.26368>;
      <D.26374>:
      if (0 != 0) goto <D.26368>; else goto <D.27006>;
      <D.27006>:
      ins->opcode = 624;
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27007 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27007;
        inst->prev = 0B;
        D.27008 = inst->prev;
        inst->next = D.27008;
        inst->opcode = 477;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27009 = inst->sreg3;
        inst->sreg2 = D.27009;
        D.27010 = inst->sreg2;
        inst->sreg1 = D.27010;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27011>; else goto <D.27012>;
        <D.27011>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27013>;
        <D.27012>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27013>:
      }
      goto <D.26368>;
      <D.26376>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27014 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27014;
        inst->prev = 0B;
        D.27015 = inst->prev;
        inst->next = D.27015;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27016 = inst->sreg3;
        inst->sreg2 = D.27016;
        D.27017 = inst->sreg2;
        inst->sreg1 = D.27017;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 127;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27019>; else goto <D.27020>;
        <D.27019>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27021>;
        <D.27020>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27021>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27022 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27022;
        inst->prev = 0B;
        D.27023 = inst->prev;
        inst->next = D.27023;
        inst->opcode = 467;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27024 = inst->sreg3;
        inst->sreg2 = D.27024;
        D.27025 = inst->sreg2;
        inst->sreg1 = D.27025;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27026>; else goto <D.27027>;
        <D.27026>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27028>;
        <D.27027>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27028>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27029 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27029;
        inst->prev = 0B;
        D.27030 = inst->prev;
        inst->next = D.27030;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27031 = inst->sreg3;
        inst->sreg2 = D.27031;
        D.27032 = inst->sreg2;
        inst->sreg1 = D.27032;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = -128;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27033>; else goto <D.27034>;
        <D.27033>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27035>;
        <D.27034>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27035>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27036 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27036;
        inst->prev = 0B;
        D.27037 = inst->prev;
        inst->next = D.27037;
        inst->opcode = 469;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27038 = inst->sreg3;
        inst->sreg2 = D.27038;
        D.27039 = inst->sreg2;
        inst->sreg1 = D.27039;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27040>; else goto <D.27041>;
        <D.27040>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27042>;
        <D.27041>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27042>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27043 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27043;
        inst->prev = 0B;
        D.27044 = inst->prev;
        inst->next = D.27044;
        inst->opcode = 580;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27045 = inst->sreg3;
        inst->sreg2 = D.27045;
        D.27046 = inst->sreg2;
        inst->sreg1 = D.27046;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27048>; else goto <D.27049>;
        <D.27048>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27050>;
        <D.27049>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27050>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26382>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27053 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27053;
        inst->prev = 0B;
        D.27054 = inst->prev;
        inst->next = D.27054;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27055 = inst->sreg3;
        inst->sreg2 = D.27055;
        D.27056 = inst->sreg2;
        inst->sreg1 = D.27056;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 127;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27057>; else goto <D.27058>;
        <D.27057>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27059>;
        <D.27058>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27059>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27060 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27060;
        inst->prev = 0B;
        D.27061 = inst->prev;
        inst->next = D.27061;
        inst->opcode = 472;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27062 = inst->sreg3;
        inst->sreg2 = D.27062;
        D.27063 = inst->sreg2;
        inst->sreg1 = D.27063;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27064>; else goto <D.27065>;
        <D.27064>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27066>;
        <D.27065>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27066>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27067 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27067;
        inst->prev = 0B;
        D.27068 = inst->prev;
        inst->next = D.27068;
        inst->opcode = 580;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27069 = inst->sreg3;
        inst->sreg2 = D.27069;
        D.27070 = inst->sreg2;
        inst->sreg1 = D.27070;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27071>; else goto <D.27072>;
        <D.27071>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27073>;
        <D.27072>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27073>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26386>:
      <D.26387>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27074 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27074;
        inst->prev = 0B;
        D.27075 = inst->prev;
        inst->next = D.27075;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27076 = inst->sreg3;
        inst->sreg2 = D.27076;
        D.27077 = inst->sreg2;
        inst->sreg1 = D.27077;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 255;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27078>; else goto <D.27079>;
        <D.27078>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27080>;
        <D.27079>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27080>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27081 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27081;
        inst->prev = 0B;
        D.27082 = inst->prev;
        inst->next = D.27082;
        inst->opcode = 472;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27083 = inst->sreg3;
        inst->sreg2 = D.27083;
        D.27084 = inst->sreg2;
        inst->sreg1 = D.27084;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27085>; else goto <D.27086>;
        <D.27085>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27087>;
        <D.27086>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27087>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27088 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27088;
        inst->prev = 0B;
        D.27089 = inst->prev;
        inst->next = D.27089;
        inst->opcode = 632;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27090 = inst->sreg3;
        inst->sreg2 = D.27090;
        D.27091 = inst->sreg2;
        inst->sreg1 = D.27091;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 255;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27092>; else goto <D.27093>;
        <D.27092>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27094>;
        <D.27093>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27094>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26391>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27095 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27095;
        inst->prev = 0B;
        D.27096 = inst->prev;
        inst->next = D.27096;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27097 = inst->sreg3;
        inst->sreg2 = D.27097;
        D.27098 = inst->sreg2;
        inst->sreg1 = D.27098;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 32767;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27099>; else goto <D.27100>;
        <D.27099>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27101>;
        <D.27100>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27101>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27102 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27102;
        inst->prev = 0B;
        D.27103 = inst->prev;
        inst->next = D.27103;
        inst->opcode = 467;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27104 = inst->sreg3;
        inst->sreg2 = D.27104;
        D.27105 = inst->sreg2;
        inst->sreg1 = D.27105;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27106>; else goto <D.27107>;
        <D.27106>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27108>;
        <D.27107>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27108>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27109 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27109;
        inst->prev = 0B;
        D.27110 = inst->prev;
        inst->next = D.27110;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27111 = inst->sreg3;
        inst->sreg2 = D.27111;
        D.27112 = inst->sreg2;
        inst->sreg1 = D.27112;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = -32768;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27113>; else goto <D.27114>;
        <D.27113>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27115>;
        <D.27114>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27115>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27116 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27116;
        inst->prev = 0B;
        D.27117 = inst->prev;
        inst->next = D.27117;
        inst->opcode = 469;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27118 = inst->sreg3;
        inst->sreg2 = D.27118;
        D.27119 = inst->sreg2;
        inst->sreg1 = D.27119;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27120>; else goto <D.27121>;
        <D.27120>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27122>;
        <D.27121>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27122>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27123 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27123;
        inst->prev = 0B;
        D.27124 = inst->prev;
        inst->next = D.27124;
        inst->opcode = 581;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27125 = inst->sreg3;
        inst->sreg2 = D.27125;
        D.27126 = inst->sreg2;
        inst->sreg1 = D.27126;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27127>; else goto <D.27128>;
        <D.27127>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27129>;
        <D.27128>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27129>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26397>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27130 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27130;
        inst->prev = 0B;
        D.27131 = inst->prev;
        inst->next = D.27131;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27132 = inst->sreg3;
        inst->sreg2 = D.27132;
        D.27133 = inst->sreg2;
        inst->sreg1 = D.27133;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 32767;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27134>; else goto <D.27135>;
        <D.27134>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27136>;
        <D.27135>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27136>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27137 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27137;
        inst->prev = 0B;
        D.27138 = inst->prev;
        inst->next = D.27138;
        inst->opcode = 472;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27139 = inst->sreg3;
        inst->sreg2 = D.27139;
        D.27140 = inst->sreg2;
        inst->sreg1 = D.27140;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27141>; else goto <D.27142>;
        <D.27141>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27143>;
        <D.27142>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27143>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27144 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27144;
        inst->prev = 0B;
        D.27145 = inst->prev;
        inst->next = D.27145;
        inst->opcode = 581;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27146 = inst->sreg3;
        inst->sreg2 = D.27146;
        D.27147 = inst->sreg2;
        inst->sreg1 = D.27147;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27148>; else goto <D.27149>;
        <D.27148>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27150>;
        <D.27149>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27150>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26401>:
      <D.26402>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27151 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27151;
        inst->prev = 0B;
        D.27152 = inst->prev;
        inst->next = D.27152;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27153 = inst->sreg3;
        inst->sreg2 = D.27153;
        D.27154 = inst->sreg2;
        inst->sreg1 = D.27154;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 65535;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27155>; else goto <D.27156>;
        <D.27155>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27157>;
        <D.27156>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27157>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27158 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27158;
        inst->prev = 0B;
        D.27159 = inst->prev;
        inst->next = D.27159;
        inst->opcode = 472;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27160 = inst->sreg3;
        inst->sreg2 = D.27160;
        D.27161 = inst->sreg2;
        inst->sreg1 = D.27161;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27162>; else goto <D.27163>;
        <D.27162>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27164>;
        <D.27163>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27164>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27165 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27165;
        inst->prev = 0B;
        D.27166 = inst->prev;
        inst->next = D.27166;
        inst->opcode = 632;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27167 = inst->sreg3;
        inst->sreg2 = D.27167;
        D.27168 = inst->sreg2;
        inst->sreg1 = D.27168;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 65535;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27169>; else goto <D.27170>;
        <D.27169>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27171>;
        <D.27170>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27171>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26406>:
      <D.26407>:
      <D.26408>:
      <D.26409>:
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27172 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27172;
        inst->prev = 0B;
        D.27173 = inst->prev;
        inst->next = D.27173;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27174 = inst->sreg3;
        inst->sreg2 = D.27174;
        D.27175 = inst->sreg2;
        inst->sreg1 = D.27175;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        inst->data.op[1].const_val = 0;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27176>; else goto <D.27177>;
        <D.27176>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27178>;
        <D.27177>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27178>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27179 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27179;
        inst->prev = 0B;
        D.27180 = inst->prev;
        inst->next = D.27180;
        inst->opcode = 469;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27181 = inst->sreg3;
        inst->sreg2 = D.27181;
        D.27182 = inst->sreg2;
        inst->sreg1 = D.27182;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        inst->data.op[1].p = "OverflowException";
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27183>; else goto <D.27184>;
        <D.27183>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27185>;
        <D.27184>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27185>:
      }
      {
        struct MonoInst * inst;

        D.26979 = cfg->mempool;
        inst = mono_mempool_alloc (D.26979, 56);
        inst->data.op[1].const_val = 0;
        D.27186 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27186;
        inst->prev = 0B;
        D.27187 = inst->prev;
        inst->next = D.27187;
        inst->opcode = 424;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27188 = inst->sreg3;
        inst->sreg2 = D.27188;
        D.27189 = inst->sreg2;
        inst->sreg1 = D.27189;
        D.26984 = cfg->ip;
        inst->cil_code = D.26984;
        D.27047 = ins->dreg;
        inst->dreg = D.27047;
        D.27018 = ins->sreg1;
        inst->sreg1 = D.27018;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        if (D.26986 != 0B) goto <D.27190>; else goto <D.27191>;
        <D.27190>:
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        D.26986->next = inst;
        D.26985 = cfg->cbb;
        D.26986 = D.26985->last_ins;
        inst->prev = D.26986;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        goto <D.27192>;
        <D.27191>:
        D.26985 = cfg->cbb;
        D.26985 = cfg->cbb;
        D.26985->last_ins = inst;
        D.26986 = D.26985->last_ins;
        D.26985->code = D.26986;
        <D.27192>:
      }
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.27051 = ins->sreg3;
      ins->sreg2 = D.27051;
      D.27052 = ins->sreg2;
      ins->sreg1 = D.27052;
      goto <D.26368>;
      <D.26413>:
      <D.26414>:
      <D.26415>:
      <D.26416>:
      <D.26417>:
      <D.26418>:
      ins->opcode = 424;
      goto <D.26368>;
      <D.26419>:
      ins->opcode = 424;
      goto <D.26368>;
      <D.26420>:
      ins->opcode = 424;
      goto <D.26368>;
      <D.26421>:
      ins->opcode = 426;
      goto <D.26368>;
      <D.26422>:
      <D.26423>:
      <D.26424>:
      <D.26425>:
      <D.26426>:
      <D.26427>:
      <D.26428>:
      <D.26429>:
      <D.26430>:
      <D.26431>:
      cfg->exception_type = 3;
      D.27193 = monoeg_g_strdup_printf ("float conv.ovf.un opcodes not supported.");
      cfg->exception_message = D.27193;
      goto <D.26368>;
      <D.26432>:
      <D.26433>:
      <D.26434>:
      <D.26435>:
      D.26976 = ins->opcode;
      D.26977 = (int) D.26976;
      D.27194 = mono_arch_opcode_needs_emulation (cfg, D.26977);
      if (D.27194 == 0) goto <D.27195>; else goto <D.27196>;
      <D.27195>:
      {
        int reg1;
        int reg2;

        D.27197 = alloc_ireg (cfg);
        reg1 = (int) D.27197;
        D.27198 = alloc_ireg (cfg);
        reg2 = (int) D.27198;
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27199 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27199;
          inst->prev = 0B;
          D.27200 = inst->prev;
          inst->next = D.27200;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27201 = inst->sreg3;
          inst->sreg2 = D.27201;
          D.27202 = inst->sreg2;
          inst->sreg1 = D.27202;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          D.27052 = ins->sreg2;
          inst->sreg1 = D.27052;
          inst->data.op[1].const_val = 0;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27203>; else goto <D.27204>;
          <D.27203>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27205>;
          <D.27204>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27205>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27206 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27206;
          inst->prev = 0B;
          D.27207 = inst->prev;
          inst->next = D.27207;
          inst->opcode = 465;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27208 = inst->sreg3;
          inst->sreg2 = D.27208;
          D.27209 = inst->sreg2;
          inst->sreg1 = D.27209;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          inst->data.op[1].p = "DivideByZeroException";
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27210>; else goto <D.27211>;
          <D.27210>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27212>;
          <D.27211>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27212>:
        }
        D.27213 = ins->opcode;
        D.27214 = D.27213 == 568;
        D.27215 = D.27213 == 570;
        D.27216 = D.27214 | D.27215;
        if (D.27216 != 0) goto <D.27217>; else goto <D.27218>;
        <D.27217>:
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27219 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27219;
          inst->prev = 0B;
          D.27220 = inst->prev;
          inst->next = D.27220;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27221 = inst->sreg3;
          inst->sreg2 = D.27221;
          D.27222 = inst->sreg2;
          inst->sreg1 = D.27222;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          D.27052 = ins->sreg2;
          inst->sreg1 = D.27052;
          inst->data.op[1].const_val = -1;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27223>; else goto <D.27224>;
          <D.27223>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27225>;
          <D.27224>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27225>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27226 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27226;
          inst->prev = 0B;
          D.27227 = inst->prev;
          inst->next = D.27227;
          inst->opcode = 638;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27228 = inst->sreg3;
          inst->sreg2 = D.27228;
          D.27229 = inst->sreg2;
          inst->sreg1 = D.27229;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          inst->dreg = reg1;
          inst->sreg1 = -1;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27230>; else goto <D.27231>;
          <D.27230>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27232>;
          <D.27231>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27232>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27233 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27233;
          inst->prev = 0B;
          D.27234 = inst->prev;
          inst->next = D.27234;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27235 = inst->sreg3;
          inst->sreg2 = D.27235;
          D.27236 = inst->sreg2;
          inst->sreg1 = D.27236;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          D.27018 = ins->sreg1;
          inst->sreg1 = D.27018;
          inst->data.op[1].const_val = -2147483648;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27237>; else goto <D.27238>;
          <D.27237>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27239>;
          <D.27238>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27239>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27240 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27240;
          inst->prev = 0B;
          D.27241 = inst->prev;
          inst->next = D.27241;
          inst->opcode = 638;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27242 = inst->sreg3;
          inst->sreg2 = D.27242;
          D.27243 = inst->sreg2;
          inst->sreg1 = D.27243;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          inst->dreg = reg2;
          inst->sreg1 = -1;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27244>; else goto <D.27245>;
          <D.27244>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27246>;
          <D.27245>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27246>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27247 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27247;
          inst->prev = 0B;
          D.27248 = inst->prev;
          inst->next = D.27248;
          inst->opcode = 572;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27249 = inst->sreg3;
          inst->sreg2 = D.27249;
          D.27250 = inst->sreg2;
          inst->sreg1 = D.27250;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          inst->dreg = reg1;
          inst->sreg1 = reg1;
          inst->sreg2 = reg2;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27251>; else goto <D.27252>;
          <D.27251>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27253>;
          <D.27252>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27253>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27254 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27254;
          inst->prev = 0B;
          D.27255 = inst->prev;
          inst->next = D.27255;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27256 = inst->sreg3;
          inst->sreg2 = D.27256;
          D.27257 = inst->sreg2;
          inst->sreg1 = D.27257;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          inst->sreg1 = reg1;
          inst->data.op[1].const_val = 1;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27258>; else goto <D.27259>;
          <D.27258>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27260>;
          <D.27259>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27260>:
        }
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27261 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27261;
          inst->prev = 0B;
          D.27262 = inst->prev;
          inst->next = D.27262;
          inst->opcode = 465;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27263 = inst->sreg3;
          inst->sreg2 = D.27263;
          D.27264 = inst->sreg2;
          inst->sreg1 = D.27264;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          inst->data.op[1].p = "DivideByZeroException";
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27265>; else goto <D.27266>;
          <D.27265>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27267>;
          <D.27266>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27267>:
        }
        <D.27218>:
        {
          struct MonoInst * inst;

          D.26979 = cfg->mempool;
          inst = mono_mempool_alloc (D.26979, 56);
          inst->data.op[1].const_val = 0;
          D.27268 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.27268;
          inst->prev = 0B;
          D.27269 = inst->prev;
          inst->next = D.27269;
          D.26976 = ins->opcode;
          inst->opcode = D.26976;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.27270 = inst->sreg3;
          inst->sreg2 = D.27270;
          D.27271 = inst->sreg2;
          inst->sreg1 = D.27271;
          D.26984 = cfg->ip;
          inst->cil_code = D.26984;
          D.27047 = ins->dreg;
          inst->dreg = D.27047;
          D.27018 = ins->sreg1;
          inst->sreg1 = D.27018;
          D.27052 = ins->sreg2;
          inst->sreg2 = D.27052;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          if (D.26986 != 0B) goto <D.27272>; else goto <D.27273>;
          <D.27272>:
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          D.26986->next = inst;
          D.26985 = cfg->cbb;
          D.26986 = D.26985->last_ins;
          inst->prev = D.26986;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          goto <D.27274>;
          <D.27273>:
          D.26985 = cfg->cbb;
          D.26985 = cfg->cbb;
          D.26985->last_ins = inst;
          D.26986 = D.26985->last_ins;
          D.26985->code = D.26986;
          <D.27274>:
        }
        ins->opcode = 316;
      }
      goto <D.27275>;
      <D.27196>:
      emulate = 1;
      <D.27275>:
      goto <D.26368>;
      <D.26448>:
      emulate = 1;
      goto <D.26368>;
      <D.26368>:
      if (emulate != 0) goto <D.27276>; else goto <D.27277>;
      <D.27276>:
      {
        struct MonoJitICallInfo * info;

        info = 0B;
        if (0 != 0) goto <D.27278>; else goto <D.27279>;
        <D.27278>:
        emulate = 0;
        <D.27279>:
        if (emulate != 0) goto <D.27280>; else goto <D.27281>;
        <D.27280>:
        D.26976 = ins->opcode;
        D.26977 = (int) D.26976;
        info = mono_find_jit_opcode_emulation (D.26977);
        <D.27281>:
        if (info != 0B) goto <D.27282>; else goto <D.27283>;
        <D.27282>:
        {
          struct MonoInst * * args;
          struct MonoInst * call;

          D.27284 = info->sig;
          D.27285 = BIT_FIELD_REF <*D.27284, 8, 80>;
          D.27286 = D.27285 & 64;
          D.27287 = D.27286 != 0;
          D.27288 = (long int) D.27287;
          D.27289 = __builtin_expect (D.27288, 0);
          if (D.27289 != 0) goto <D.27290>; else goto <D.27291>;
          <D.27290>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 468, "!info->sig->hasthis");
          <D.27291>:
          D.27284 = info->sig;
          D.27292 = D.27284->param_count;
          D.27293 = D.27292 > 3;
          D.27294 = (long int) D.27293;
          D.27295 = __builtin_expect (D.27294, 0);
          if (D.27295 != 0) goto <D.27296>; else goto <D.27297>;
          <D.27296>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 469, "info->sig->param_count <= MONO_MAX_SRC_REGS");
          <D.27297>:
          D.26979 = cfg->mempool;
          D.27284 = info->sig;
          D.27292 = D.27284->param_count;
          D.27298 = (unsigned int) D.27292;
          D.27299 = D.27298 * 4;
          args = mono_mempool_alloc0 (D.26979, D.27299);
          D.27284 = info->sig;
          D.27292 = D.27284->param_count;
          if (D.27292 != 0) goto <D.27300>; else goto <D.27301>;
          <D.27300>:
          {
            int sregs[3];
            int num_sregs;
            int i;

            try
              {
                D.27018 = ins->sreg1;
                sregs[0] = D.27018;
                D.27052 = ins->sreg2;
                sregs[1] = D.27052;
                D.27051 = ins->sreg3;
                sregs[2] = D.27051;
                D.26976 = ins->opcode;
                D.26977 = (int) D.26976;
                D.27302 = D.26977 + -313;
                D.27303 = ins_sreg_counts[D.27302];
                num_sregs = (int) D.27303;
                D.27284 = info->sig;
                D.27292 = D.27284->param_count;
                D.27304 = (int) D.27292;
                D.27305 = D.27304 != num_sregs;
                D.27306 = (long int) D.27305;
                D.27307 = __builtin_expect (D.27306, 0);
                if (D.27307 != 0) goto <D.27308>; else goto <D.27309>;
                <D.27308>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 476, "num_sregs == info->sig->param_count");
                <D.27309>:
                i = 0;
                goto <D.26456>;
                <D.26455>:
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.26979 = cfg->mempool;
                D.27313 = mono_mempool_alloc (D.26979, 56);
                *D.27312 = D.27313;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->data.op[1].const_val = 0;
                D.27315 = D.27314->data.op[1].const_val;
                D.27314->data.op[0].const_val = D.27315;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->prev = 0B;
                D.27316 = D.27314->prev;
                D.27314->next = D.27316;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->opcode = 330;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->flags = 0;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->type = 0;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->dreg = -1;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27314->sreg3 = -1;
                D.27317 = D.27314->sreg3;
                D.27314->sreg2 = D.27317;
                D.27318 = D.27314->sreg2;
                D.27314->sreg1 = D.27318;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.26984 = cfg->ip;
                D.27314->cil_code = D.26984;
                i.0 = (unsigned int) i;
                D.27311 = i.0 * 4;
                D.27312 = args + D.27311;
                D.27314 = *D.27312;
                D.27319 = sregs[i];
                D.27314->dreg = D.27319;
                i = i + 1;
                <D.26456>:
                if (i < num_sregs) goto <D.26455>; else goto <D.26457>;
                <D.26457>:
              }
            finally
              {
                sregs = {CLOBBER};
              }
          }
          <D.27301>:
          D.27320 = mono_icall_get_wrapper (info);
          D.27284 = info->sig;
          call = mono_emit_native_call (cfg, D.27320, D.27284, args);
          D.27047 = ins->dreg;
          call->dreg = D.27047;
          ins->opcode = 316;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.27051 = ins->sreg3;
          ins->sreg2 = D.27051;
          D.27052 = ins->sreg2;
          ins->sreg1 = D.27052;
        }
        <D.27283>:
      }
      <D.27277>:
      D.26976 = ins->opcode;
      if (D.26976 == 316) goto <D.27321>; else goto <D.27322>;
      <D.27321>:
      repl.1 = repl;
      if (repl.1 != 0B) goto <D.27324>; else goto <D.27325>;
      <D.27324>:
      repl.1 = repl;
      D.27326 = (unsigned char) type;
      repl.1->type = D.27326;
      D.27327 = repl;
      return D.27327;
      <D.27325>:
      D.26985 = cfg->cbb;
      ins = D.26985->last_ins;
      D.27328 = ins == 0B;
      D.27329 = (long int) D.27328;
      D.27330 = __builtin_expect (D.27329, 0);
      if (D.27330 != 0) goto <D.27331>; else goto <D.27332>;
      <D.27331>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 497, "ins");
      <D.27332>:
      D.27326 = (unsigned char) type;
      ins->type = D.27326;
      D.27047 = ins->dreg;
      D.27333 = D.27047 != dreg;
      D.27334 = (long int) D.27333;
      D.27335 = __builtin_expect (D.27334, 0);
      if (D.27335 != 0) goto <D.27336>; else goto <D.27337>;
      <D.27336>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 499, "ins->dreg == dreg");
      <D.27337>:
      D.27327 = ins;
      return D.27327;
      <D.27322>:
      D.27327 = ins;
      return D.27327;
    }
  finally
    {
      repl = {CLOBBER};
    }
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.27344;
  unsigned int D.27345;
  unsigned int D.27346;
  unsigned int D.27347;

  D.27345 = cfg->next_vreg;
  D.27346 = D.27345;
  D.27347 = D.27346 + 1;
  cfg->next_vreg = D.27347;
  D.27344 = D.27346;
  return D.27344;
}


mono_decompose_long_opts (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.27349;
  void * D.27350;
  struct MonoBasicBlock * D.27351;
  struct MonoInst * D.27352;
  short unsigned int D.27353;
  int D.27354;
  int D.27355;
  struct MonoInst * D.27356;
  int D.27357;
  int D.27358;
  const unsigned char * D.27359;
  int D.27360;
  int D.27361;
  int D.27362;
  int D.27366;
  struct MonoInst * D.27367;
  int D.27368;
  int D.27369;
  int D.27370;
  int D.27371;
  int D.27375;
  struct MonoInst * D.27376;
  int D.27377;
  int D.27378;
  int D.27379;
  int D.27380;
  int D.27384;
  struct MonoInst * D.27385;
  int D.27386;
  int D.27387;
  int D.27388;
  int D.27392;
  struct MonoInst * D.27393;
  int D.27394;
  int D.27395;
  int D.27396;
  int D.27400;
  struct MonoInst * D.27401;
  int D.27402;
  int D.27403;
  int D.27407;
  struct MonoInst * D.27408;
  int D.27409;
  int D.27410;
  int D.27414;
  struct MonoInst * D.27415;
  int D.27416;
  int D.27417;
  int D.27421;
  struct MonoInst * D.27422;
  int D.27423;
  int D.27424;
  int D.27428;
  struct MonoInst * D.27429;
  int D.27430;
  int D.27431;
  int D.27435;
  struct MonoInst * D.27436;
  int D.27437;
  int D.27438;
  int tmpreg.2;
  int D.27443;
  struct MonoInst * D.27444;
  int D.27445;
  int D.27446;
  int D.27450;
  struct MonoInst * D.27451;
  int D.27452;
  int D.27453;
  int D.27457;
  struct MonoInst * D.27458;
  int D.27459;
  int D.27460;
  int D.27464;
  struct MonoInst * D.27465;
  int D.27466;
  int D.27467;
  int D.27471;
  struct MonoInst * D.27472;
  int D.27473;
  int D.27474;
  int D.27478;
  struct MonoInst * D.27479;
  int D.27480;
  int D.27481;
  int D.27485;
  struct MonoInst * D.27486;
  int D.27487;
  int D.27488;
  int D.27492;
  struct MonoInst * D.27493;
  int D.27494;
  int D.27495;
  int D.27499;
  struct MonoInst * D.27500;
  int D.27501;
  int D.27502;
  int D.27506;
  struct MonoInst * D.27507;
  int D.27508;
  int D.27509;
  int D.27513;
  struct MonoInst * D.27514;
  int D.27515;
  int D.27516;
  int D.27520;
  struct MonoInst * D.27521;
  int D.27522;
  int D.27523;
  int D.27527;
  struct MonoInst * D.27528;
  int D.27529;
  int D.27530;
  int D.27534;
  struct MonoInst * D.27535;
  int D.27536;
  int D.27537;
  int D.27541;
  struct MonoInst * D.27542;
  int D.27543;
  int D.27544;
  int D.27548;
  struct MonoInst * D.27549;
  int D.27550;
  int D.27551;
  int D.27555;
  struct MonoInst * D.27556;
  int D.27557;
  int D.27558;
  int D.27562;
  struct MonoInst * D.27563;
  int D.27564;
  int D.27565;
  int D.27569;
  struct MonoInst * D.27570;
  int D.27571;
  int D.27572;
  unsigned int D.27576;
  unsigned int D.27577;
  unsigned int D.27578;
  int D.27579;
  unsigned int D.27580;
  unsigned int D.27581;
  int D.27582;
  int D.27583;
  struct MonoInst * D.27584;
  int D.27585;
  int D.27586;
  int D.27590;
  struct MonoInst * D.27591;
  int D.27592;
  int D.27593;
  int D.27597;
  struct MonoInst * D.27598;
  int D.27599;
  int D.27600;
  int D.27604;
  struct MonoInst * D.27605;
  int D.27606;
  int D.27607;
  int D.27611;
  struct MonoInst * D.27612;
  int D.27613;
  int D.27614;
  int D.27618;
  struct MonoInst * D.27619;
  int D.27620;
  int D.27621;
  unsigned int D.27624;
  unsigned int D.27625;
  int D.27626;
  unsigned char * D.27630;
  struct MonoBasicBlock * * D.27633;
  int D.27634;
  unsigned char * D.27635;
  int D.27636;
  int D.27637;
  unsigned int D.27638;
  unsigned int D.27639;
  struct MonoBasicBlock * * D.27640;
  unsigned int D.27641;
  short unsigned int D.27646;
  short unsigned int D.27647;
  _Bool D.27648;
  short unsigned int D.27649;
  _Bool D.27650;
  _Bool D.27651;
  short unsigned int D.27653;
  short unsigned int D.27654;
  struct MonoBasicBlock * * D.27655;
  struct MonoBasicBlock * * D.27656;
  struct MonoBasicBlock * D.27657;
  short unsigned int D.27662;
  _Bool D.27663;
  _Bool D.27664;
  _Bool D.27665;
  short unsigned int D.27667;
  short unsigned int D.27668;
  _Bool D.27669;
  short unsigned int D.27670;
  _Bool D.27671;
  _Bool D.27672;
  void * D.27675;
  struct MonoBasicBlock * * D.27676;
  struct MonoBasicBlock * * D.27677;
  unsigned char D.27681;
  unsigned char D.27682;
  unsigned int D.27685;
  unsigned int D.27686;
  int D.27687;
  short unsigned int D.27694;
  short unsigned int D.27695;
  _Bool D.27696;
  short unsigned int D.27697;
  _Bool D.27698;
  _Bool D.27699;
  short unsigned int D.27705;
  _Bool D.27706;
  _Bool D.27707;
  _Bool D.27708;
  short unsigned int D.27710;
  short unsigned int D.27711;
  _Bool D.27712;
  short unsigned int D.27713;
  _Bool D.27714;
  _Bool D.27715;
  int D.27718;
  struct MonoInst * D.27719;
  int D.27720;
  int D.27721;
  int D.27725;
  struct MonoInst * D.27726;
  int D.27727;
  int D.27728;
  int D.27732;
  struct MonoInst * D.27733;
  int D.27734;
  int D.27735;
  unsigned int D.27738;
  unsigned int D.27739;
  int D.27740;
  unsigned char * D.27744;
  int D.27747;
  int D.27748;
  unsigned int D.27749;
  unsigned int D.27750;
  struct MonoBasicBlock * * D.27751;
  short unsigned int D.27756;
  short unsigned int D.27757;
  _Bool D.27758;
  short unsigned int D.27759;
  _Bool D.27760;
  _Bool D.27761;
  short unsigned int D.27767;
  _Bool D.27768;
  _Bool D.27769;
  _Bool D.27770;
  short unsigned int D.27772;
  short unsigned int D.27773;
  _Bool D.27774;
  short unsigned int D.27775;
  _Bool D.27776;
  _Bool D.27777;
  void * D.27780;
  struct MonoBasicBlock * * D.27781;
  struct MonoBasicBlock * * D.27782;
  unsigned int D.27788;
  unsigned int D.27789;
  int D.27790;
  short unsigned int D.27797;
  short unsigned int D.27798;
  _Bool D.27799;
  short unsigned int D.27800;
  _Bool D.27801;
  _Bool D.27802;
  short unsigned int D.27808;
  _Bool D.27809;
  _Bool D.27810;
  _Bool D.27811;
  short unsigned int D.27813;
  short unsigned int D.27814;
  _Bool D.27815;
  short unsigned int D.27816;
  _Bool D.27817;
  _Bool D.27818;
  unsigned char * D.27821;
  int D.27824;
  int D.27825;
  unsigned int D.27826;
  unsigned int D.27827;
  struct MonoBasicBlock * * D.27828;
  short unsigned int D.27833;
  short unsigned int D.27834;
  _Bool D.27835;
  short unsigned int D.27836;
  _Bool D.27837;
  _Bool D.27838;
  short unsigned int D.27844;
  _Bool D.27845;
  _Bool D.27846;
  _Bool D.27847;
  short unsigned int D.27849;
  short unsigned int D.27850;
  _Bool D.27851;
  short unsigned int D.27852;
  _Bool D.27853;
  _Bool D.27854;
  int D.27856;
  struct MonoInst * D.27857;
  int D.27858;
  int D.27859;
  int D.27863;
  struct MonoInst * D.27864;
  int D.27865;
  int D.27866;
  unsigned char * D.27870;
  int D.27873;
  int D.27874;
  unsigned int D.27875;
  unsigned int D.27876;
  struct MonoBasicBlock * * D.27877;
  short unsigned int D.27882;
  short unsigned int D.27883;
  _Bool D.27884;
  short unsigned int D.27885;
  _Bool D.27886;
  _Bool D.27887;
  short unsigned int D.27893;
  _Bool D.27894;
  _Bool D.27895;
  _Bool D.27896;
  short unsigned int D.27898;
  short unsigned int D.27899;
  _Bool D.27900;
  short unsigned int D.27901;
  _Bool D.27902;
  _Bool D.27903;
  int D.27905;
  struct MonoInst * D.27906;
  int D.27907;
  int D.27908;
  int D.27912;
  struct MonoInst * D.27913;
  int D.27914;
  int D.27915;
  int D.27919;
  struct MonoInst * D.27920;
  int D.27921;
  int D.27922;
  int D.27926;
  struct MonoInst * D.27927;
  int D.27928;
  int D.27929;
  int D.27933;
  struct MonoInst * D.27934;
  int D.27935;
  int D.27936;
  int D.27940;
  struct MonoInst * D.27941;
  int D.27942;
  int D.27943;
  int D.27947;
  struct MonoInst * D.27948;
  int D.27949;
  int D.27950;
  int D.27954;
  struct MonoInst * D.27955;
  int D.27956;
  int D.27957;
  int D.27961;
  struct MonoInst * D.27962;
  int D.27963;
  int D.27964;
  int D.27968;
  struct MonoInst * D.27969;
  int D.27970;
  int D.27971;
  int D.27975;
  struct MonoInst * D.27976;
  int D.27977;
  int D.27978;
  int D.27982;
  struct MonoInst * D.27983;
  int D.27984;
  int D.27985;
  int D.27989;
  struct MonoInst * D.27990;
  int D.27991;
  int D.27992;
  unsigned int D.27996;
  unsigned int D.27997;
  int D.27998;
  unsigned int D.27999;
  unsigned int D.28000;
  int D.28001;
  int D.28002;
  struct MonoInst * D.28003;
  int D.28004;
  int D.28005;
  int D.28009;
  struct MonoInst * D.28010;
  int D.28011;
  int D.28012;
  int D.28016;
  struct MonoInst * D.28017;
  int D.28018;
  int D.28019;
  int D.28023;
  struct MonoInst * D.28024;
  int D.28025;
  int D.28026;
  int D.28030;
  struct MonoInst * D.28031;
  int D.28032;
  int D.28033;
  int D.28037;
  struct MonoInst * D.28038;
  int D.28039;
  int D.28040;
  unsigned int D.28043;
  unsigned int D.28044;
  int D.28045;
  unsigned char * D.28049;
  int D.28052;
  int D.28053;
  unsigned int D.28054;
  unsigned int D.28055;
  struct MonoBasicBlock * * D.28056;
  short unsigned int D.28061;
  short unsigned int D.28062;
  _Bool D.28063;
  short unsigned int D.28064;
  _Bool D.28065;
  _Bool D.28066;
  short unsigned int D.28072;
  _Bool D.28073;
  _Bool D.28074;
  _Bool D.28075;
  short unsigned int D.28077;
  short unsigned int D.28078;
  _Bool D.28079;
  short unsigned int D.28080;
  _Bool D.28081;
  _Bool D.28082;
  void * D.28085;
  struct MonoBasicBlock * * D.28086;
  struct MonoBasicBlock * * D.28087;
  unsigned int D.28093;
  unsigned int D.28094;
  int D.28095;
  short unsigned int D.28102;
  short unsigned int D.28103;
  _Bool D.28104;
  short unsigned int D.28105;
  _Bool D.28106;
  _Bool D.28107;
  short unsigned int D.28113;
  _Bool D.28114;
  _Bool D.28115;
  _Bool D.28116;
  short unsigned int D.28118;
  short unsigned int D.28119;
  _Bool D.28120;
  short unsigned int D.28121;
  _Bool D.28122;
  _Bool D.28123;
  int D.28126;
  struct MonoInst * D.28127;
  int D.28128;
  int D.28129;
  int D.28133;
  struct MonoInst * D.28134;
  int D.28135;
  int D.28136;
  int D.28140;
  struct MonoInst * D.28141;
  int D.28142;
  int D.28143;
  unsigned int D.28146;
  unsigned int D.28147;
  int D.28148;
  unsigned char * D.28152;
  int D.28155;
  int D.28156;
  unsigned int D.28157;
  unsigned int D.28158;
  struct MonoBasicBlock * * D.28159;
  short unsigned int D.28164;
  short unsigned int D.28165;
  _Bool D.28166;
  short unsigned int D.28167;
  _Bool D.28168;
  _Bool D.28169;
  short unsigned int D.28175;
  _Bool D.28176;
  _Bool D.28177;
  _Bool D.28178;
  short unsigned int D.28180;
  short unsigned int D.28181;
  _Bool D.28182;
  short unsigned int D.28183;
  _Bool D.28184;
  _Bool D.28185;
  void * D.28188;
  struct MonoBasicBlock * * D.28189;
  struct MonoBasicBlock * * D.28190;
  unsigned int D.28196;
  unsigned int D.28197;
  int D.28198;
  short unsigned int D.28205;
  short unsigned int D.28206;
  _Bool D.28207;
  short unsigned int D.28208;
  _Bool D.28209;
  _Bool D.28210;
  short unsigned int D.28216;
  _Bool D.28217;
  _Bool D.28218;
  _Bool D.28219;
  short unsigned int D.28221;
  short unsigned int D.28222;
  _Bool D.28223;
  short unsigned int D.28224;
  _Bool D.28225;
  _Bool D.28226;
  unsigned char * D.28229;
  int D.28232;
  int D.28233;
  unsigned int D.28234;
  unsigned int D.28235;
  struct MonoBasicBlock * * D.28236;
  short unsigned int D.28241;
  short unsigned int D.28242;
  _Bool D.28243;
  short unsigned int D.28244;
  _Bool D.28245;
  _Bool D.28246;
  short unsigned int D.28252;
  _Bool D.28253;
  _Bool D.28254;
  _Bool D.28255;
  short unsigned int D.28257;
  short unsigned int D.28258;
  _Bool D.28259;
  short unsigned int D.28260;
  _Bool D.28261;
  _Bool D.28262;
  int D.28264;
  struct MonoInst * D.28265;
  int D.28266;
  int D.28267;
  int D.28271;
  struct MonoInst * D.28272;
  int D.28273;
  int D.28274;
  unsigned char * D.28278;
  int D.28281;
  int D.28282;
  unsigned int D.28283;
  unsigned int D.28284;
  struct MonoBasicBlock * * D.28285;
  short unsigned int D.28290;
  short unsigned int D.28291;
  _Bool D.28292;
  short unsigned int D.28293;
  _Bool D.28294;
  _Bool D.28295;
  short unsigned int D.28301;
  _Bool D.28302;
  _Bool D.28303;
  _Bool D.28304;
  short unsigned int D.28306;
  short unsigned int D.28307;
  _Bool D.28308;
  short unsigned int D.28309;
  _Bool D.28310;
  _Bool D.28311;
  int D.28313;
  struct MonoInst * D.28314;
  int D.28315;
  int D.28316;
  int D.28320;
  struct MonoInst * D.28321;
  int D.28322;
  int D.28323;
  int D.28327;
  struct MonoInst * D.28328;
  int D.28329;
  int D.28330;
  int D.28334;
  struct MonoInst * D.28335;
  int D.28336;
  int D.28337;
  int D.28341;
  struct MonoInst * D.28342;
  int D.28343;
  int D.28344;
  int D.28348;
  struct MonoInst * D.28349;
  int D.28350;
  int D.28351;
  int D.28355;
  struct MonoInst * D.28356;
  int D.28357;
  int D.28358;
  int D.28362;
  struct MonoInst * D.28363;
  int D.28364;
  int D.28365;
  int D.28369;
  struct MonoInst * D.28370;
  int D.28371;
  int D.28372;
  int D.28376;
  struct MonoInst * D.28377;
  int D.28378;
  int D.28379;
  int D.28383;
  struct MonoInst * D.28384;
  int D.28385;
  int D.28386;
  int D.28390;
  struct MonoInst * D.28391;
  int D.28392;
  int D.28393;
  int D.28397;
  struct MonoInst * D.28398;
  int D.28399;
  int D.28400;
  int D.28404;
  struct MonoInst * D.28405;
  int D.28406;
  int D.28407;
  int D.28411;
  struct MonoInst * D.28412;
  int D.28413;
  int D.28414;
  int D.28418;
  struct MonoInst * D.28419;
  int D.28420;
  int D.28421;
  int D.28425;
  struct MonoInst * D.28426;
  int D.28427;
  int D.28428;
  int D.28432;
  struct MonoInst * D.28433;
  int D.28434;
  int D.28435;
  int D.28439;
  struct MonoInst * D.28440;
  int D.28441;
  int D.28442;
  int D.28446;
  struct MonoInst * D.28447;
  int D.28448;
  int D.28449;
  int D.28453;
  struct MonoInst * D.28454;
  int D.28455;
  int D.28456;
  int D.28460;
  struct MonoInst * D.28461;
  int D.28462;
  int D.28463;
  int D.28467;
  struct MonoInst * D.28468;
  int D.28469;
  int D.28470;
  int D.28474;
  struct MonoInst * D.28475;
  int D.28476;
  int D.28477;
  int D.28481;
  struct MonoInst * D.28482;
  int D.28483;
  int D.28484;
  int D.28488;
  struct MonoInst * D.28489;
  int D.28490;
  int D.28491;
  int D.28495;
  struct MonoInst * D.28496;
  int D.28497;
  int D.28498;
  int D.28502;
  struct MonoInst * D.28503;
  int D.28504;
  int D.28505;
  int D.28509;
  struct MonoInst * D.28510;
  int D.28511;
  int D.28512;
  int D.28516;
  struct MonoInst * D.28517;
  int D.28518;
  int D.28519;
  int D.28523;
  struct MonoInst * D.28524;
  int D.28525;
  int D.28526;
  int D.28527;
  int D.28528;
  int D.28532;
  struct MonoInst * D.28533;
  int D.28534;
  int D.28535;
  int D.28536;
  int D.28540;
  struct MonoInst * D.28541;
  int D.28542;
  int D.28543;
  int D.28547;
  struct MonoInst * D.28548;
  int D.28549;
  int D.28550;
  int D.28554;
  struct MonoInst * D.28555;
  int D.28556;
  int D.28557;
  int D.28561;
  struct MonoInst * D.28562;
  int D.28563;
  int D.28564;
  int D.28568;
  struct MonoInst * D.28569;
  int D.28570;
  int D.28571;
  int D.28575;
  struct MonoInst * D.28576;
  int D.28577;
  int D.28578;
  int D.28582;
  struct MonoInst * D.28583;
  int D.28584;
  int D.28585;
  int D.28589;
  struct MonoInst * D.28590;
  int D.28591;
  int D.28592;
  int D.28596;
  struct MonoInst * D.28597;
  int D.28598;
  int D.28599;
  int D.28603;
  struct MonoInst * D.28604;
  int D.28605;
  int D.28606;
  int D.28610;
  struct MonoInst * D.28611;
  int D.28612;
  int D.28613;
  int D.28617;
  struct MonoInst * D.28618;
  int D.28619;
  int D.28620;
  int D.28624;
  struct MonoInst * D.28625;
  int D.28626;
  int D.28627;
  int D.28631;
  struct MonoInst * D.28632;
  int D.28633;
  int D.28634;
  int D.28638;
  struct MonoInst * D.28639;
  int D.28640;
  int D.28641;
  int D.28645;
  struct MonoInst * D.28646;
  int D.28647;
  int D.28648;
  int D.28652;
  struct MonoInst * D.28653;
  int D.28654;
  int D.28655;
  int D.28659;
  struct MonoInst * D.28660;
  int D.28661;
  int D.28662;
  int D.28666;
  struct MonoInst * D.28667;
  int D.28668;
  int D.28669;
  int D.28673;
  struct MonoInst * D.28674;
  int D.28675;
  int D.28676;
  int D.28680;
  struct MonoInst * D.28681;
  int D.28682;
  int D.28683;
  int D.28687;
  struct MonoInst * D.28688;
  int D.28689;
  int D.28690;
  int D.28694;
  struct MonoInst * D.28695;
  int D.28696;
  int D.28697;
  int D.28701;
  struct MonoInst * D.28702;
  int D.28703;
  int D.28704;
  int D.28708;
  struct MonoInst * D.28709;
  int D.28710;
  int D.28711;
  int D.28715;
  struct MonoInst * D.28716;
  int D.28717;
  int D.28718;
  int D.28722;
  struct MonoInst * D.28723;
  int D.28724;
  int D.28725;
  int D.28729;
  struct MonoInst * D.28730;
  int D.28731;
  int D.28732;
  int D.28736;
  struct MonoInst * D.28737;
  int D.28738;
  int D.28739;
  int D.28743;
  struct MonoInst * D.28744;
  int D.28745;
  int D.28746;
  int D.28750;
  struct MonoInst * D.28751;
  int D.28752;
  int D.28753;
  int D.28757;
  struct MonoInst * D.28758;
  int D.28759;
  int D.28760;
  int D.28766;
  struct MonoInst * D.28767;
  int D.28768;
  int D.28769;
  int D.28773;
  struct MonoInst * D.28774;
  int D.28775;
  int D.28776;
  int D.28782;
  struct MonoInst * D.28783;
  int D.28784;
  int D.28785;
  int D.28789;
  struct MonoInst * D.28790;
  int D.28791;
  int D.28792;
  _Bool D.28796;
  long int D.28797;
  long int D.28798;
  short unsigned int D.28801;
  int D.28802;
  unsigned int D.28803;
  unsigned int D.28804;
  int D.28805;
  struct MonoInst * D.28806;
  int D.28807;
  int D.28808;
  int D.28812;
  struct MonoInst * D.28813;
  int D.28814;
  int D.28815;
  int D.28819;
  struct MonoInst * D.28820;
  int D.28821;
  int D.28822;
  int D.28826;
  struct MonoInst * D.28827;
  int D.28828;
  int D.28829;
  int D.28833;
  struct MonoInst * D.28834;
  guint16 iftmp.3;
  int D.28839;
  int D.28840;
  void * D.28841;
  struct MonoBasicBlock * * D.28842;
  struct MonoBasicBlock * * D.28843;
  struct MonoBasicBlock * D.28844;
  struct MonoBasicBlock * * D.28845;
  struct MonoBasicBlock * D.28846;
  struct MonoBasicBlock * * D.28847;
  struct MonoBasicBlock * D.28848;
  int D.28852;
  struct MonoInst * D.28853;
  int D.28854;
  int D.28855;
  int D.28859;
  struct MonoInst * D.28860;
  int D.28861;
  int D.28862;
  short unsigned int D.28863;
  int D.28864;
  int D.28865;
  unsigned int D.28868;
  unsigned int D.28869;
  int D.28870;
  unsigned char * D.28874;
  int D.28877;
  int D.28878;
  unsigned int D.28879;
  unsigned int D.28880;
  struct MonoBasicBlock * * D.28881;
  short unsigned int D.28886;
  short unsigned int D.28887;
  _Bool D.28888;
  short unsigned int D.28889;
  _Bool D.28890;
  _Bool D.28891;
  short unsigned int D.28897;
  _Bool D.28898;
  _Bool D.28899;
  _Bool D.28900;
  short unsigned int D.28902;
  short unsigned int D.28903;
  _Bool D.28904;
  short unsigned int D.28905;
  _Bool D.28906;
  _Bool D.28907;
  void * D.28910;
  struct MonoBasicBlock * * D.28911;
  struct MonoBasicBlock * * D.28912;
  unsigned int D.28918;
  unsigned int D.28919;
  int D.28920;
  short unsigned int D.28927;
  short unsigned int D.28928;
  _Bool D.28929;
  short unsigned int D.28930;
  _Bool D.28931;
  _Bool D.28932;
  short unsigned int D.28938;
  _Bool D.28939;
  _Bool D.28940;
  _Bool D.28941;
  short unsigned int D.28943;
  short unsigned int D.28944;
  _Bool D.28945;
  short unsigned int D.28946;
  _Bool D.28947;
  _Bool D.28948;
  int D.28951;
  struct MonoInst * D.28952;
  int D.28953;
  int D.28954;
  int D.28958;
  struct MonoInst * D.28959;
  int D.28960;
  int D.28961;
  unsigned int D.28964;
  unsigned int D.28965;
  int D.28966;
  unsigned char * D.28970;
  int D.28973;
  int D.28974;
  unsigned int D.28975;
  unsigned int D.28976;
  struct MonoBasicBlock * * D.28977;
  short unsigned int D.28982;
  short unsigned int D.28983;
  _Bool D.28984;
  short unsigned int D.28985;
  _Bool D.28986;
  _Bool D.28987;
  short unsigned int D.28993;
  _Bool D.28994;
  _Bool D.28995;
  _Bool D.28996;
  short unsigned int D.28998;
  short unsigned int D.28999;
  _Bool D.29000;
  short unsigned int D.29001;
  _Bool D.29002;
  _Bool D.29003;
  void * D.29006;
  struct MonoBasicBlock * * D.29007;
  struct MonoBasicBlock * * D.29008;
  unsigned int D.29014;
  unsigned int D.29015;
  int D.29016;
  short unsigned int D.29023;
  short unsigned int D.29024;
  _Bool D.29025;
  short unsigned int D.29026;
  _Bool D.29027;
  _Bool D.29028;
  short unsigned int D.29034;
  _Bool D.29035;
  _Bool D.29036;
  _Bool D.29037;
  short unsigned int D.29039;
  short unsigned int D.29040;
  _Bool D.29041;
  short unsigned int D.29042;
  _Bool D.29043;
  _Bool D.29044;
  int D.29047;
  struct MonoInst * D.29048;
  int D.29049;
  int D.29050;
  int D.29054;
  struct MonoInst * D.29055;
  int D.29056;
  short unsigned int D.29057;
  int D.29058;
  int D.29059;
  void * D.29060;
  struct MonoBasicBlock * * D.29061;
  struct MonoBasicBlock * * D.29062;
  unsigned int D.29066;
  unsigned int D.29067;
  int D.29068;
  struct MonoInst * D.29069;
  int D.29070;
  int D.29071;
  int D.29075;
  struct MonoInst * D.29076;
  int D.29077;
  int D.29078;
  int D.29082;
  struct MonoInst * D.29083;
  int D.29084;
  int D.29085;
  int D.29089;
  struct MonoInst * D.29090;
  int D.29091;
  int D.29092;
  int D.29096;
  struct MonoInst * D.29097;
  int D.29098;
  int D.29099;
  int D.29100;
  unsigned int D.29104;
  unsigned int D.29105;
  int D.29106;
  unsigned int D.29107;
  unsigned int D.29108;
  int D.29109;
  int D.29110;
  struct MonoInst * D.29111;
  int D.29112;
  int D.29113;
  int D.29117;
  struct MonoInst * D.29118;
  int D.29119;
  int D.29120;
  int D.29124;
  struct MonoInst * D.29125;
  int D.29126;
  int D.29127;
  short unsigned int D.29128;
  int D.29129;
  int D.29130;
  unsigned int D.29133;
  unsigned int D.29134;
  int D.29135;
  unsigned char * D.29139;
  int D.29142;
  int D.29143;
  unsigned int D.29144;
  unsigned int D.29145;
  struct MonoBasicBlock * * D.29146;
  short unsigned int D.29151;
  short unsigned int D.29152;
  _Bool D.29153;
  short unsigned int D.29154;
  _Bool D.29155;
  _Bool D.29156;
  short unsigned int D.29162;
  _Bool D.29163;
  _Bool D.29164;
  _Bool D.29165;
  short unsigned int D.29167;
  short unsigned int D.29168;
  _Bool D.29169;
  short unsigned int D.29170;
  _Bool D.29171;
  _Bool D.29172;
  void * D.29175;
  struct MonoBasicBlock * * D.29176;
  struct MonoBasicBlock * * D.29177;
  unsigned int D.29183;
  unsigned int D.29184;
  int D.29185;
  short unsigned int D.29192;
  short unsigned int D.29193;
  _Bool D.29194;
  short unsigned int D.29195;
  _Bool D.29196;
  _Bool D.29197;
  short unsigned int D.29203;
  _Bool D.29204;
  _Bool D.29205;
  _Bool D.29206;
  short unsigned int D.29208;
  short unsigned int D.29209;
  _Bool D.29210;
  short unsigned int D.29211;
  _Bool D.29212;
  _Bool D.29213;
  int D.29216;
  struct MonoInst * D.29217;
  int D.29218;
  int D.29219;
  int D.29223;
  struct MonoInst * D.29224;
  int D.29225;
  int D.29226;
  unsigned int D.29229;
  unsigned int D.29230;
  int D.29231;
  unsigned char * D.29235;
  int D.29238;
  int D.29239;
  unsigned int D.29240;
  unsigned int D.29241;
  struct MonoBasicBlock * * D.29242;
  short unsigned int D.29247;
  short unsigned int D.29248;
  _Bool D.29249;
  short unsigned int D.29250;
  _Bool D.29251;
  _Bool D.29252;
  short unsigned int D.29258;
  _Bool D.29259;
  _Bool D.29260;
  _Bool D.29261;
  short unsigned int D.29263;
  short unsigned int D.29264;
  _Bool D.29265;
  short unsigned int D.29266;
  _Bool D.29267;
  _Bool D.29268;
  void * D.29271;
  struct MonoBasicBlock * * D.29272;
  struct MonoBasicBlock * * D.29273;
  unsigned int D.29279;
  unsigned int D.29280;
  int D.29281;
  short unsigned int D.29288;
  short unsigned int D.29289;
  _Bool D.29290;
  short unsigned int D.29291;
  _Bool D.29292;
  _Bool D.29293;
  short unsigned int D.29299;
  _Bool D.29300;
  _Bool D.29301;
  _Bool D.29302;
  short unsigned int D.29304;
  short unsigned int D.29305;
  _Bool D.29306;
  short unsigned int D.29307;
  _Bool D.29308;
  _Bool D.29309;
  int D.29312;
  struct MonoInst * D.29313;
  int D.29314;
  int D.29315;
  int D.29319;
  struct MonoInst * D.29320;
  int D.29321;
  short unsigned int D.29322;
  int D.29323;
  int D.29324;
  unsigned int D.29327;
  unsigned int D.29328;
  int D.29329;
  unsigned char * D.29333;
  int D.29336;
  int D.29337;
  unsigned int D.29338;
  unsigned int D.29339;
  struct MonoBasicBlock * * D.29340;
  short unsigned int D.29345;
  short unsigned int D.29346;
  _Bool D.29347;
  short unsigned int D.29348;
  _Bool D.29349;
  _Bool D.29350;
  short unsigned int D.29356;
  _Bool D.29357;
  _Bool D.29358;
  _Bool D.29359;
  short unsigned int D.29361;
  short unsigned int D.29362;
  _Bool D.29363;
  short unsigned int D.29364;
  _Bool D.29365;
  _Bool D.29366;
  void * D.29369;
  struct MonoBasicBlock * * D.29370;
  struct MonoBasicBlock * * D.29371;
  unsigned int D.29377;
  unsigned int D.29378;
  int D.29379;
  short unsigned int D.29386;
  short unsigned int D.29387;
  _Bool D.29388;
  short unsigned int D.29389;
  _Bool D.29390;
  _Bool D.29391;
  short unsigned int D.29397;
  _Bool D.29398;
  _Bool D.29399;
  _Bool D.29400;
  short unsigned int D.29402;
  short unsigned int D.29403;
  _Bool D.29404;
  short unsigned int D.29405;
  _Bool D.29406;
  _Bool D.29407;
  unsigned char * D.29410;
  int D.29413;
  int D.29414;
  unsigned int D.29415;
  unsigned int D.29416;
  struct MonoBasicBlock * * D.29417;
  short unsigned int D.29422;
  short unsigned int D.29423;
  _Bool D.29424;
  short unsigned int D.29425;
  _Bool D.29426;
  _Bool D.29427;
  short unsigned int D.29433;
  _Bool D.29434;
  _Bool D.29435;
  _Bool D.29436;
  short unsigned int D.29438;
  short unsigned int D.29439;
  _Bool D.29440;
  short unsigned int D.29441;
  _Bool D.29442;
  _Bool D.29443;
  int D.29445;
  struct MonoInst * D.29446;
  int D.29447;
  int D.29448;
  unsigned char * D.29452;
  int D.29455;
  int D.29456;
  unsigned int D.29457;
  unsigned int D.29458;
  struct MonoBasicBlock * * D.29459;
  short unsigned int D.29464;
  short unsigned int D.29465;
  _Bool D.29466;
  short unsigned int D.29467;
  _Bool D.29468;
  _Bool D.29469;
  short unsigned int D.29475;
  _Bool D.29476;
  _Bool D.29477;
  _Bool D.29478;
  short unsigned int D.29480;
  short unsigned int D.29481;
  _Bool D.29482;
  short unsigned int D.29483;
  _Bool D.29484;
  _Bool D.29485;
  _Bool D.29487;
  long int D.29488;
  long int D.29489;
  short unsigned int D.29492;
  int D.29493;
  unsigned int D.29494;
  unsigned int D.29495;
  int D.29496;
  struct MonoInst * D.29497;
  int D.29498;
  int D.29499;
  int low_imm.4;
  int D.29504;
  struct MonoInst * D.29505;
  int D.29506;
  int D.29507;
  int high_imm.5;
  int D.29512;
  struct MonoInst * D.29513;
  int D.29514;
  int D.29515;
  int D.29519;
  struct MonoInst * D.29520;
  int D.29521;
  int D.29522;
  int D.29526;
  struct MonoInst * D.29527;
  guint16 iftmp.6;
  int D.29532;
  int D.29533;
  void * D.29534;
  struct MonoBasicBlock * * D.29535;
  struct MonoBasicBlock * * D.29536;
  struct MonoBasicBlock * D.29537;
  struct MonoBasicBlock * * D.29538;
  struct MonoBasicBlock * D.29539;
  struct MonoBasicBlock * * D.29540;
  struct MonoBasicBlock * D.29541;
  int D.29545;
  struct MonoInst * D.29546;
  int D.29547;
  int D.29548;
  int D.29552;
  struct MonoInst * D.29553;
  int D.29554;
  int D.29555;
  short unsigned int D.29556;
  int D.29557;
  int D.29558;
  unsigned int D.29561;
  unsigned int D.29562;
  int D.29563;
  unsigned char * D.29567;
  int D.29570;
  int D.29571;
  unsigned int D.29572;
  unsigned int D.29573;
  struct MonoBasicBlock * * D.29574;
  short unsigned int D.29579;
  short unsigned int D.29580;
  _Bool D.29581;
  short unsigned int D.29582;
  _Bool D.29583;
  _Bool D.29584;
  short unsigned int D.29590;
  _Bool D.29591;
  _Bool D.29592;
  _Bool D.29593;
  short unsigned int D.29595;
  short unsigned int D.29596;
  _Bool D.29597;
  short unsigned int D.29598;
  _Bool D.29599;
  _Bool D.29600;
  void * D.29603;
  struct MonoBasicBlock * * D.29604;
  struct MonoBasicBlock * * D.29605;
  unsigned int D.29611;
  unsigned int D.29612;
  int D.29613;
  short unsigned int D.29620;
  short unsigned int D.29621;
  _Bool D.29622;
  short unsigned int D.29623;
  _Bool D.29624;
  _Bool D.29625;
  short unsigned int D.29631;
  _Bool D.29632;
  _Bool D.29633;
  _Bool D.29634;
  short unsigned int D.29636;
  short unsigned int D.29637;
  _Bool D.29638;
  short unsigned int D.29639;
  _Bool D.29640;
  _Bool D.29641;
  int D.29644;
  struct MonoInst * D.29645;
  int D.29646;
  int D.29647;
  int D.29651;
  struct MonoInst * D.29652;
  int D.29653;
  int D.29654;
  unsigned int D.29657;
  unsigned int D.29658;
  int D.29659;
  unsigned char * D.29663;
  int D.29666;
  int D.29667;
  unsigned int D.29668;
  unsigned int D.29669;
  struct MonoBasicBlock * * D.29670;
  short unsigned int D.29675;
  short unsigned int D.29676;
  _Bool D.29677;
  short unsigned int D.29678;
  _Bool D.29679;
  _Bool D.29680;
  short unsigned int D.29686;
  _Bool D.29687;
  _Bool D.29688;
  _Bool D.29689;
  short unsigned int D.29691;
  short unsigned int D.29692;
  _Bool D.29693;
  short unsigned int D.29694;
  _Bool D.29695;
  _Bool D.29696;
  void * D.29699;
  struct MonoBasicBlock * * D.29700;
  struct MonoBasicBlock * * D.29701;
  unsigned int D.29707;
  unsigned int D.29708;
  int D.29709;
  short unsigned int D.29716;
  short unsigned int D.29717;
  _Bool D.29718;
  short unsigned int D.29719;
  _Bool D.29720;
  _Bool D.29721;
  short unsigned int D.29727;
  _Bool D.29728;
  _Bool D.29729;
  _Bool D.29730;
  short unsigned int D.29732;
  short unsigned int D.29733;
  _Bool D.29734;
  short unsigned int D.29735;
  _Bool D.29736;
  _Bool D.29737;
  int D.29740;
  struct MonoInst * D.29741;
  int D.29742;
  int D.29743;
  int D.29747;
  struct MonoInst * D.29748;
  int D.29749;
  short unsigned int D.29750;
  int D.29751;
  int D.29752;
  void * D.29753;
  struct MonoBasicBlock * * D.29754;
  struct MonoBasicBlock * * D.29755;
  unsigned int D.29759;
  unsigned int D.29760;
  int D.29761;
  struct MonoInst * D.29762;
  int D.29763;
  int D.29764;
  int D.29768;
  struct MonoInst * D.29769;
  int D.29770;
  int D.29771;
  int D.29775;
  struct MonoInst * D.29776;
  int D.29777;
  int D.29778;
  int D.29782;
  struct MonoInst * D.29783;
  int D.29784;
  int D.29785;
  int D.29789;
  struct MonoInst * D.29790;
  int D.29791;
  int D.29792;
  int D.29793;
  unsigned int D.29797;
  unsigned int D.29798;
  int D.29799;
  unsigned int D.29800;
  unsigned int D.29801;
  int D.29802;
  int D.29803;
  struct MonoInst * D.29804;
  int D.29805;
  int D.29806;
  int D.29810;
  struct MonoInst * D.29811;
  int D.29812;
  int D.29813;
  int D.29817;
  struct MonoInst * D.29818;
  int D.29819;
  int D.29820;
  short unsigned int D.29821;
  int D.29822;
  int D.29823;
  unsigned int D.29826;
  unsigned int D.29827;
  int D.29828;
  unsigned char * D.29832;
  int D.29835;
  int D.29836;
  unsigned int D.29837;
  unsigned int D.29838;
  struct MonoBasicBlock * * D.29839;
  short unsigned int D.29844;
  short unsigned int D.29845;
  _Bool D.29846;
  short unsigned int D.29847;
  _Bool D.29848;
  _Bool D.29849;
  short unsigned int D.29855;
  _Bool D.29856;
  _Bool D.29857;
  _Bool D.29858;
  short unsigned int D.29860;
  short unsigned int D.29861;
  _Bool D.29862;
  short unsigned int D.29863;
  _Bool D.29864;
  _Bool D.29865;
  void * D.29868;
  struct MonoBasicBlock * * D.29869;
  struct MonoBasicBlock * * D.29870;
  unsigned int D.29876;
  unsigned int D.29877;
  int D.29878;
  short unsigned int D.29885;
  short unsigned int D.29886;
  _Bool D.29887;
  short unsigned int D.29888;
  _Bool D.29889;
  _Bool D.29890;
  short unsigned int D.29896;
  _Bool D.29897;
  _Bool D.29898;
  _Bool D.29899;
  short unsigned int D.29901;
  short unsigned int D.29902;
  _Bool D.29903;
  short unsigned int D.29904;
  _Bool D.29905;
  _Bool D.29906;
  int D.29909;
  struct MonoInst * D.29910;
  int D.29911;
  int D.29912;
  int D.29916;
  struct MonoInst * D.29917;
  int D.29918;
  int D.29919;
  unsigned int D.29922;
  unsigned int D.29923;
  int D.29924;
  unsigned char * D.29928;
  int D.29931;
  int D.29932;
  unsigned int D.29933;
  unsigned int D.29934;
  struct MonoBasicBlock * * D.29935;
  short unsigned int D.29940;
  short unsigned int D.29941;
  _Bool D.29942;
  short unsigned int D.29943;
  _Bool D.29944;
  _Bool D.29945;
  short unsigned int D.29951;
  _Bool D.29952;
  _Bool D.29953;
  _Bool D.29954;
  short unsigned int D.29956;
  short unsigned int D.29957;
  _Bool D.29958;
  short unsigned int D.29959;
  _Bool D.29960;
  _Bool D.29961;
  void * D.29964;
  struct MonoBasicBlock * * D.29965;
  struct MonoBasicBlock * * D.29966;
  unsigned int D.29972;
  unsigned int D.29973;
  int D.29974;
  short unsigned int D.29981;
  short unsigned int D.29982;
  _Bool D.29983;
  short unsigned int D.29984;
  _Bool D.29985;
  _Bool D.29986;
  short unsigned int D.29992;
  _Bool D.29993;
  _Bool D.29994;
  _Bool D.29995;
  short unsigned int D.29997;
  short unsigned int D.29998;
  _Bool D.29999;
  short unsigned int D.30000;
  _Bool D.30001;
  _Bool D.30002;
  int D.30005;
  struct MonoInst * D.30006;
  int D.30007;
  int D.30008;
  int D.30012;
  struct MonoInst * D.30013;
  int D.30014;
  short unsigned int D.30015;
  int D.30016;
  int D.30017;
  unsigned int D.30020;
  unsigned int D.30021;
  int D.30022;
  unsigned char * D.30026;
  int D.30029;
  int D.30030;
  unsigned int D.30031;
  unsigned int D.30032;
  struct MonoBasicBlock * * D.30033;
  short unsigned int D.30038;
  short unsigned int D.30039;
  _Bool D.30040;
  short unsigned int D.30041;
  _Bool D.30042;
  _Bool D.30043;
  short unsigned int D.30049;
  _Bool D.30050;
  _Bool D.30051;
  _Bool D.30052;
  short unsigned int D.30054;
  short unsigned int D.30055;
  _Bool D.30056;
  short unsigned int D.30057;
  _Bool D.30058;
  _Bool D.30059;
  void * D.30062;
  struct MonoBasicBlock * * D.30063;
  struct MonoBasicBlock * * D.30064;
  unsigned int D.30070;
  unsigned int D.30071;
  int D.30072;
  short unsigned int D.30079;
  short unsigned int D.30080;
  _Bool D.30081;
  short unsigned int D.30082;
  _Bool D.30083;
  _Bool D.30084;
  short unsigned int D.30090;
  _Bool D.30091;
  _Bool D.30092;
  _Bool D.30093;
  short unsigned int D.30095;
  short unsigned int D.30096;
  _Bool D.30097;
  short unsigned int D.30098;
  _Bool D.30099;
  _Bool D.30100;
  unsigned char * D.30103;
  int D.30106;
  int D.30107;
  unsigned int D.30108;
  unsigned int D.30109;
  struct MonoBasicBlock * * D.30110;
  short unsigned int D.30115;
  short unsigned int D.30116;
  _Bool D.30117;
  short unsigned int D.30118;
  _Bool D.30119;
  _Bool D.30120;
  short unsigned int D.30126;
  _Bool D.30127;
  _Bool D.30128;
  _Bool D.30129;
  short unsigned int D.30131;
  short unsigned int D.30132;
  _Bool D.30133;
  short unsigned int D.30134;
  _Bool D.30135;
  _Bool D.30136;
  int D.30138;
  struct MonoInst * D.30139;
  int D.30140;
  int D.30141;
  unsigned char * D.30145;
  int D.30148;
  int D.30149;
  unsigned int D.30150;
  unsigned int D.30151;
  struct MonoBasicBlock * * D.30152;
  short unsigned int D.30157;
  short unsigned int D.30158;
  _Bool D.30159;
  short unsigned int D.30160;
  _Bool D.30161;
  _Bool D.30162;
  short unsigned int D.30168;
  _Bool D.30169;
  _Bool D.30170;
  _Bool D.30171;
  short unsigned int D.30173;
  short unsigned int D.30174;
  _Bool D.30175;
  short unsigned int D.30176;
  _Bool D.30177;
  _Bool D.30178;
  struct MonoInst * D.30183;
  struct MonoInst * D.30188;
  short int D.30189;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * first_bb;

  D.27349 = cfg->mempool;
  D.27350 = mono_mempool_alloc0 (D.27349, 172);
  cfg->cbb = D.27350;
  first_bb = cfg->cbb;
  bb = cfg->bb_entry;
  goto <D.26790>;
  <D.26789>:
  {
    struct MonoInst * tree;
    struct MonoInst * prev;

    tree = bb->code;
    prev = 0B;
    tree = bb->code;
    D.27351 = cfg->cbb;
    D.27351 = cfg->cbb;
    D.27351->last_ins = 0B;
    D.27352 = D.27351->last_ins;
    D.27351->code = D.27352;
    goto <D.26787>;
    <D.26786>:
    mono_arch_decompose_long_opts (cfg, tree);
    D.27353 = tree->opcode;
    D.27354 = (int) D.27353;
    switch (D.27354) <default: <D.26784>, case 325: <D.26672>, case 328: <D.26726>, case 363: <D.26467>, case 378: <D.26478>, case 395: <D.26481>, case 425: <D.26471>, case 479: <D.26615>, case 480: <D.26618>, case 481: <D.26650>, case 486: <D.26637>, case 487: <D.26640>, case 488: <D.26643>, case 492: <D.26649>, case 493: <D.26646>, case 494: <D.26505>, case 495: <D.26509>, case 496: <D.26513>, case 497: <D.26473>, case 498: <D.26520>, case 499: <D.26518>, case 500: <D.26514>, case 501: <D.26472>, case 502: <D.26511>, case 503: <D.26507>, case 504: <D.26515>, case 505: <D.26589>, case 506: <D.26592>, case 507: <D.26621>, case 508: <D.26625>, case 511: <D.26629>, case 512: <D.26633>, case 513: <D.26541>, case 514: <D.26573>, case 515: <D.26599>, case 516: <D.26610>, case 517: <D.26550>, case 518: <D.26582>, case 519: <D.26593>, case 520: <D.26474>, case 521: <D.26598>, case 522: <D.26594>, case 523: <D.26524>, case 524: <D.26549>, case 525: <D.26556>, case 526: <D.26581>, case 527: <D.26588>, case 528: <D.26591>, case 529: <D.26475>, case 530: <D.26605>, case 536: <D.26522>, case 537: <D.26516>, case 538: <D.26651>, case 539: <D.26654>, case 541: <D.26657>, case 542: <D.26660>, case 543: <D.26663>, case 544: <D.26669>, case 546: <D.26666>, case 583: <D.26484>, case 587: <D.26490>, case 604: <D.26501>, case 608: <D.26502>, case 617: <D.26493>, case 618: <D.26496>>
    <D.26467>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27355 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27355;
      inst->prev = 0B;
      D.27356 = inst->prev;
      inst->next = D.27356;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27357 = inst->sreg3;
      inst->sreg2 = D.27357;
      D.27358 = inst->sreg2;
      inst->sreg1 = D.27358;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[0].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27363>; else goto <D.27364>;
      <D.27363>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27365>;
      <D.27364>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27365>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27366 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27366;
      inst->prev = 0B;
      D.27367 = inst->prev;
      inst->next = D.27367;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27368 = inst->sreg3;
      inst->sreg2 = D.27368;
      D.27369 = inst->sreg2;
      inst->sreg1 = D.27369;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27371 = tree->data.op[1].const_val;
      inst->data.op[0].const_val = D.27371;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27372>; else goto <D.27373>;
      <D.27372>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27374>;
      <D.27373>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27374>:
    }
    goto <D.26470>;
    <D.26471>:
    <D.26472>:
    <D.26473>:
    <D.26474>:
    <D.26475>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27375 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27375;
      inst->prev = 0B;
      D.27376 = inst->prev;
      inst->next = D.27376;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27377 = inst->sreg3;
      inst->sreg2 = D.27377;
      D.27378 = inst->sreg2;
      inst->sreg1 = D.27378;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27381>; else goto <D.27382>;
      <D.27381>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27383>;
      <D.27382>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27383>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27384 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27384;
      inst->prev = 0B;
      D.27385 = inst->prev;
      inst->next = D.27385;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27386 = inst->sreg3;
      inst->sreg2 = D.27386;
      D.27387 = inst->sreg2;
      inst->sreg1 = D.27387;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27389>; else goto <D.27390>;
      <D.27389>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27391>;
      <D.27390>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27391>:
    }
    goto <D.26470>;
    <D.26478>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27392 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27392;
      inst->prev = 0B;
      D.27393 = inst->prev;
      inst->next = D.27393;
      inst->opcode = 377;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27394 = inst->sreg3;
      inst->sreg2 = D.27394;
      D.27395 = inst->sreg2;
      inst->sreg1 = D.27395;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27362 = tree->data.op[0].const_val;
      D.27396 = D.27362 + 4;
      inst->data.op[0].const_val = D.27396;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27397>; else goto <D.27398>;
      <D.27397>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27399>;
      <D.27398>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27399>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27400 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27400;
      inst->prev = 0B;
      D.27401 = inst->prev;
      inst->next = D.27401;
      inst->opcode = 377;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27402 = inst->sreg3;
      inst->sreg2 = D.27402;
      D.27403 = inst->sreg2;
      inst->sreg1 = D.27403;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[0].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27404>; else goto <D.27405>;
      <D.27404>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27406>;
      <D.27405>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27406>:
    }
    goto <D.26470>;
    <D.26481>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27407 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27407;
      inst->prev = 0B;
      D.27408 = inst->prev;
      inst->next = D.27408;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27409 = inst->sreg3;
      inst->sreg2 = D.27409;
      D.27410 = inst->sreg2;
      inst->sreg1 = D.27410;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      D.27362 = tree->data.op[0].const_val;
      D.27396 = D.27362 + 4;
      inst->data.op[0].const_val = D.27396;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27411>; else goto <D.27412>;
      <D.27411>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27413>;
      <D.27412>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27413>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27414 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27414;
      inst->prev = 0B;
      D.27415 = inst->prev;
      inst->next = D.27415;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27416 = inst->sreg3;
      inst->sreg2 = D.27416;
      D.27417 = inst->sreg2;
      inst->sreg1 = D.27417;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[0].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27418>; else goto <D.27419>;
      <D.27418>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27420>;
      <D.27419>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27420>:
    }
    goto <D.26470>;
    <D.26484>:
    {
      guint32 tmpreg;

      tmpreg = alloc_ireg (cfg);
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27421 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27421;
        inst->prev = 0B;
        D.27422 = inst->prev;
        inst->next = D.27422;
        inst->opcode = 424;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27423 = inst->sreg3;
        inst->sreg2 = D.27423;
        D.27424 = inst->sreg2;
        inst->sreg1 = D.27424;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27360 = tree->dreg;
        D.27361 = D.27360 + 1;
        inst->dreg = D.27361;
        D.27379 = tree->sreg1;
        inst->sreg1 = D.27379;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27425>; else goto <D.27426>;
        <D.27425>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27427>;
        <D.27426>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27427>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27428 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27428;
        inst->prev = 0B;
        D.27429 = inst->prev;
        inst->next = D.27429;
        inst->opcode = 327;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27430 = inst->sreg3;
        inst->sreg2 = D.27430;
        D.27431 = inst->sreg2;
        inst->sreg1 = D.27431;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27360 = tree->dreg;
        D.27361 = D.27360 + 1;
        inst->sreg1 = D.27361;
        inst->data.op[1].const_val = -1;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27432>; else goto <D.27433>;
        <D.27432>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27434>;
        <D.27433>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27434>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27435 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27435;
        inst->prev = 0B;
        D.27436 = inst->prev;
        inst->next = D.27436;
        inst->opcode = 639;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27437 = inst->sreg3;
        inst->sreg2 = D.27437;
        D.27438 = inst->sreg2;
        inst->sreg1 = D.27438;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        tmpreg.2 = (int) tmpreg;
        inst->dreg = tmpreg.2;
        inst->sreg1 = -1;
        inst->sreg2 = -1;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27440>; else goto <D.27441>;
        <D.27440>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27442>;
        <D.27441>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27442>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27443 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27443;
        inst->prev = 0B;
        D.27444 = inst->prev;
        inst->next = D.27444;
        inst->opcode = 626;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27445 = inst->sreg3;
        inst->sreg2 = D.27445;
        D.27446 = inst->sreg2;
        inst->sreg1 = D.27446;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27360 = tree->dreg;
        D.27370 = D.27360 + 2;
        inst->dreg = D.27370;
        tmpreg.2 = (int) tmpreg;
        inst->sreg1 = tmpreg.2;
        inst->data.op[1].const_val = 1;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27447>; else goto <D.27448>;
        <D.27447>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27449>;
        <D.27448>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27449>:
      }
      goto <D.26470>;
    }
    <D.26490>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27450 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27450;
      inst->prev = 0B;
      D.27451 = inst->prev;
      inst->next = D.27451;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27452 = inst->sreg3;
      inst->sreg2 = D.27452;
      D.27453 = inst->sreg2;
      inst->sreg1 = D.27453;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27454>; else goto <D.27455>;
      <D.27454>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27456>;
      <D.27455>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27456>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27457 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27457;
      inst->prev = 0B;
      D.27458 = inst->prev;
      inst->next = D.27458;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27459 = inst->sreg3;
      inst->sreg2 = D.27459;
      D.27460 = inst->sreg2;
      inst->sreg1 = D.27460;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      inst->data.op[0].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27461>; else goto <D.27462>;
      <D.27461>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27463>;
      <D.27462>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27463>:
    }
    goto <D.26470>;
    <D.26493>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27464 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27464;
      inst->prev = 0B;
      D.27465 = inst->prev;
      inst->next = D.27465;
      inst->opcode = 440;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27466 = inst->sreg3;
      inst->sreg2 = D.27466;
      D.27467 = inst->sreg2;
      inst->sreg1 = D.27467;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      inst->data.op[1].const_val = 31;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27468>; else goto <D.27469>;
      <D.27468>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27470>;
      <D.27469>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27470>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27471 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27471;
      inst->prev = 0B;
      D.27472 = inst->prev;
      inst->next = D.27472;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27473 = inst->sreg3;
      inst->sreg2 = D.27473;
      D.27474 = inst->sreg2;
      inst->sreg1 = D.27474;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27475>; else goto <D.27476>;
      <D.27475>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27477>;
      <D.27476>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27477>:
    }
    goto <D.26470>;
    <D.26496>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27478 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27478;
      inst->prev = 0B;
      D.27479 = inst->prev;
      inst->next = D.27479;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27480 = inst->sreg3;
      inst->sreg2 = D.27480;
      D.27481 = inst->sreg2;
      inst->sreg1 = D.27481;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27482>; else goto <D.27483>;
      <D.27482>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27484>;
      <D.27483>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27484>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27485 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27485;
      inst->prev = 0B;
      D.27486 = inst->prev;
      inst->next = D.27486;
      inst->opcode = 455;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27487 = inst->sreg3;
      inst->sreg2 = D.27487;
      D.27488 = inst->sreg2;
      inst->sreg1 = D.27488;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27489>; else goto <D.27490>;
      <D.27489>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27491>;
      <D.27490>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27491>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27492 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27492;
      inst->prev = 0B;
      D.27493 = inst->prev;
      inst->next = D.27493;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27494 = inst->sreg3;
      inst->sreg2 = D.27494;
      D.27495 = inst->sreg2;
      inst->sreg1 = D.27495;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      inst->data.op[0].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27496>; else goto <D.27497>;
      <D.27496>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27498>;
      <D.27497>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27498>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27499 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27499;
      inst->prev = 0B;
      D.27500 = inst->prev;
      inst->next = D.27500;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27501 = inst->sreg3;
      inst->sreg2 = D.27501;
      D.27502 = inst->sreg2;
      inst->sreg1 = D.27502;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27503>; else goto <D.27504>;
      <D.27503>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27505>;
      <D.27504>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27505>:
    }
    goto <D.26470>;
    <D.26501>:
    <D.26502>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27506 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27506;
      inst->prev = 0B;
      D.27507 = inst->prev;
      inst->next = D.27507;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27508 = inst->sreg3;
      inst->sreg2 = D.27508;
      D.27509 = inst->sreg2;
      inst->sreg1 = D.27509;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      inst->data.op[0].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27510>; else goto <D.27511>;
      <D.27510>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27512>;
      <D.27511>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27512>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27513 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27513;
      inst->prev = 0B;
      D.27514 = inst->prev;
      inst->next = D.27514;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27515 = inst->sreg3;
      inst->sreg2 = D.27515;
      D.27516 = inst->sreg2;
      inst->sreg1 = D.27516;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      inst->sreg1 = D.27379;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27517>; else goto <D.27518>;
      <D.27517>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27519>;
      <D.27518>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27519>:
    }
    goto <D.26470>;
    <D.26505>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27520 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27520;
      inst->prev = 0B;
      D.27521 = inst->prev;
      inst->next = D.27521;
      inst->opcode = 580;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27522 = inst->sreg3;
      inst->sreg2 = D.27522;
      D.27523 = inst->sreg2;
      inst->sreg1 = D.27523;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27524>; else goto <D.27525>;
      <D.27524>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27526>;
      <D.27525>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27526>:
    }
    goto <D.26470>;
    <D.26507>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27527 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27527;
      inst->prev = 0B;
      D.27528 = inst->prev;
      inst->next = D.27528;
      inst->opcode = 591;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27529 = inst->sreg3;
      inst->sreg2 = D.27529;
      D.27530 = inst->sreg2;
      inst->sreg1 = D.27530;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27531>; else goto <D.27532>;
      <D.27531>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27533>;
      <D.27532>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27533>:
    }
    goto <D.26470>;
    <D.26509>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27534 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27534;
      inst->prev = 0B;
      D.27535 = inst->prev;
      inst->next = D.27535;
      inst->opcode = 581;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27536 = inst->sreg3;
      inst->sreg2 = D.27536;
      D.27537 = inst->sreg2;
      inst->sreg1 = D.27537;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27538>; else goto <D.27539>;
      <D.27538>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27540>;
      <D.27539>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27540>:
    }
    goto <D.26470>;
    <D.26511>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27541 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27541;
      inst->prev = 0B;
      D.27542 = inst->prev;
      inst->next = D.27542;
      inst->opcode = 590;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27543 = inst->sreg3;
      inst->sreg2 = D.27543;
      D.27544 = inst->sreg2;
      inst->sreg1 = D.27544;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27545>; else goto <D.27546>;
      <D.27545>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27547>;
      <D.27546>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27547>:
    }
    goto <D.26470>;
    <D.26513>:
    <D.26514>:
    <D.26515>:
    <D.26516>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27548 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27548;
      inst->prev = 0B;
      D.27549 = inst->prev;
      inst->next = D.27549;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27550 = inst->sreg3;
      inst->sreg2 = D.27550;
      D.27551 = inst->sreg2;
      inst->sreg1 = D.27551;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27552>; else goto <D.27553>;
      <D.27552>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27554>;
      <D.27553>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27554>:
    }
    goto <D.26470>;
    <D.26518>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27555 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27555;
      inst->prev = 0B;
      D.27556 = inst->prev;
      inst->next = D.27556;
      inst->opcode = 561;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27557 = inst->sreg3;
      inst->sreg2 = D.27557;
      D.27558 = inst->sreg2;
      inst->sreg1 = D.27558;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg2 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27559>; else goto <D.27560>;
      <D.27559>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27561>;
      <D.27560>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27561>:
    }
    goto <D.26470>;
    <D.26520>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27562 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27562;
      inst->prev = 0B;
      D.27563 = inst->prev;
      inst->next = D.27563;
      inst->opcode = 562;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27564 = inst->sreg3;
      inst->sreg2 = D.27564;
      D.27565 = inst->sreg2;
      inst->sreg1 = D.27565;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg2 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27566>; else goto <D.27567>;
      <D.27566>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27568>;
      <D.27567>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27568>:
    }
    goto <D.26470>;
    <D.26522>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27569 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27569;
      inst->prev = 0B;
      D.27570 = inst->prev;
      inst->next = D.27570;
      inst->opcode = 563;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27571 = inst->sreg3;
      inst->sreg2 = D.27571;
      D.27572 = inst->sreg2;
      inst->sreg1 = D.27572;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg2 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27573>; else goto <D.27574>;
      <D.27573>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27575>;
      <D.27574>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27575>:
    }
    goto <D.26470>;
    <D.26524>:
    {
      struct MonoBasicBlock * is_negative;
      struct MonoBasicBlock * end_label;

      D.27349 = cfg->mempool;
      is_negative = mono_mempool_alloc0 (D.27349, 172);
      D.27576 = cfg->num_bblocks;
      D.27577 = D.27576;
      D.27578 = D.27577 + 1;
      cfg->num_bblocks = D.27578;
      D.27579 = (int) D.27577;
      is_negative->block_num = D.27579;
      D.27349 = cfg->mempool;
      end_label = mono_mempool_alloc0 (D.27349, 172);
      D.27576 = cfg->num_bblocks;
      D.27580 = D.27576;
      D.27581 = D.27580 + 1;
      cfg->num_bblocks = D.27581;
      D.27582 = (int) D.27580;
      end_label->block_num = D.27582;
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27583 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27583;
        inst->prev = 0B;
        D.27584 = inst->prev;
        inst->next = D.27584;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27585 = inst->sreg3;
        inst->sreg2 = D.27585;
        D.27586 = inst->sreg2;
        inst->sreg1 = D.27586;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        inst->data.op[1].const_val = 0;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27587>; else goto <D.27588>;
        <D.27587>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27589>;
        <D.27588>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27589>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27590 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27590;
        inst->prev = 0B;
        D.27591 = inst->prev;
        inst->next = D.27591;
        inst->opcode = 453;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27592 = inst->sreg3;
        inst->sreg2 = D.27592;
        D.27593 = inst->sreg2;
        inst->sreg1 = D.27593;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27594>; else goto <D.27595>;
        <D.27594>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27596>;
        <D.27595>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27596>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27597 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27597;
        inst->prev = 0B;
        D.27598 = inst->prev;
        inst->next = D.27598;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27599 = inst->sreg3;
        inst->sreg2 = D.27599;
        D.27600 = inst->sreg2;
        inst->sreg1 = D.27600;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        inst->data.op[1].const_val = -1;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27601>; else goto <D.27602>;
        <D.27601>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27603>;
        <D.27602>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27603>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27604 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27604;
        inst->prev = 0B;
        D.27605 = inst->prev;
        inst->next = D.27605;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27606 = inst->sreg3;
        inst->sreg2 = D.27606;
        D.27607 = inst->sreg2;
        inst->sreg1 = D.27607;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27608>; else goto <D.27609>;
        <D.27608>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27610>;
        <D.27609>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27610>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27611 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27611;
        inst->prev = 0B;
        D.27612 = inst->prev;
        inst->next = D.27612;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27613 = inst->sreg3;
        inst->sreg2 = D.27613;
        D.27614 = inst->sreg2;
        inst->sreg1 = D.27614;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        inst->data.op[1].const_val = 0;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27615>; else goto <D.27616>;
        <D.27615>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27617>;
        <D.27616>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27617>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.27618 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.27618;
        ins->prev = 0B;
        D.27619 = ins->prev;
        ins->next = D.27619;
        ins->opcode = 652;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.27620 = ins->sreg3;
        ins->sreg2 = D.27620;
        D.27621 = ins->sreg2;
        ins->sreg1 = D.27621;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        if (0 != 0) goto <D.27622>; else goto <D.27623>;
        <D.27622>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.27624 = D.27576;
        D.27625 = D.27624 + 1;
        cfg->num_bblocks = D.27625;
        D.27626 = (int) D.27624;
        falsebb->block_num = D.27626;
        ins->data.op[0].target_block = is_negative;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, is_negative);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27627>; else goto <D.27628>;
        <D.27627>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.27629>;
        <D.27628>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27629>:
        D.27630 = falsebb->cil_code;
        if (D.27630 != 0B) goto <D.27631>; else goto <D.27632>;
        <D.27631>:
        D.27633 = cfg->cil_offset_to_bb;
        D.27630 = falsebb->cil_code;
        D.27634 = (int) D.27630;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.27637 = D.27634 - D.27636;
        D.27638 = (unsigned int) D.27637;
        D.27639 = D.27638 * 4;
        D.27640 = D.27633 + D.27639;
        *D.27640 = falsebb;
        <D.27632>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27645>; else goto <D.27642>;
        <D.27645>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27646 = D.27352->opcode;
        D.27647 = D.27646 + 64985;
        D.27648 = D.27647 <= 9;
        D.27649 = D.27646 + 64878;
        D.27650 = D.27649 <= 9;
        D.27651 = D.27648 | D.27650;
        if (D.27651 != 0) goto <D.27643>; else goto <D.27652>;
        <D.27652>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.27643>; else goto <D.27642>;
        <D.27643>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.27658>; else goto <D.27642>;
        <D.27658>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.27644>;
        <D.27642>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.27659>; else goto <D.27661>;
        <D.27661>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27662 = D.27352->opcode;
        D.27663 = D.27662 != 442;
        D.27664 = D.27662 != 759;
        D.27665 = D.27663 & D.27664;
        if (D.27665 != 0) goto <D.27666>; else goto <D.27660>;
        <D.27666>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27667 = D.27352->opcode;
        D.27668 = D.27667 + 64985;
        D.27669 = D.27668 > 9;
        D.27670 = D.27667 + 64878;
        D.27671 = D.27670 > 9;
        D.27672 = D.27669 & D.27671;
        if (D.27672 != 0) goto <D.27673>; else goto <D.27660>;
        <D.27673>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.27659>; else goto <D.27660>;
        <D.27659>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.27660>:
        <D.27644>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.27674>;
        <D.27623>:
        D.27349 = cfg->mempool;
        D.27675 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.27675;
        D.27676 = ins->data.op[1].many_blocks;
        *D.27676 = is_negative;
        D.27676 = ins->data.op[1].many_blocks;
        D.27677 = D.27676 + 4;
        *D.27677 = 0B;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, is_negative);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27678>; else goto <D.27679>;
        <D.27678>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.27680>;
        <D.27679>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27680>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.27683>; else goto <D.27684>;
        <D.27683>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.27685 = D.27576;
        D.27686 = D.27685 + 1;
        cfg->num_bblocks = D.27686;
        D.27687 = (int) D.27685;
        falsebb->block_num = D.27687;
        D.27676 = ins->data.op[1].many_blocks;
        D.27677 = D.27676 + 4;
        *D.27677 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.27630 = falsebb->cil_code;
        if (D.27630 != 0B) goto <D.27688>; else goto <D.27689>;
        <D.27688>:
        D.27633 = cfg->cil_offset_to_bb;
        D.27630 = falsebb->cil_code;
        D.27634 = (int) D.27630;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.27637 = D.27634 - D.27636;
        D.27638 = (unsigned int) D.27637;
        D.27639 = D.27638 * 4;
        D.27640 = D.27633 + D.27639;
        *D.27640 = falsebb;
        <D.27689>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27693>; else goto <D.27690>;
        <D.27693>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27694 = D.27352->opcode;
        D.27695 = D.27694 + 64985;
        D.27696 = D.27695 <= 9;
        D.27697 = D.27694 + 64878;
        D.27698 = D.27697 <= 9;
        D.27699 = D.27696 | D.27698;
        if (D.27699 != 0) goto <D.27691>; else goto <D.27700>;
        <D.27700>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.27691>; else goto <D.27690>;
        <D.27691>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.27701>; else goto <D.27690>;
        <D.27701>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.27692>;
        <D.27690>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.27702>; else goto <D.27704>;
        <D.27704>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27705 = D.27352->opcode;
        D.27706 = D.27705 != 442;
        D.27707 = D.27705 != 759;
        D.27708 = D.27706 & D.27707;
        if (D.27708 != 0) goto <D.27709>; else goto <D.27703>;
        <D.27709>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27710 = D.27352->opcode;
        D.27711 = D.27710 + 64985;
        D.27712 = D.27711 > 9;
        D.27713 = D.27710 + 64878;
        D.27714 = D.27713 > 9;
        D.27715 = D.27712 & D.27714;
        if (D.27715 != 0) goto <D.27716>; else goto <D.27703>;
        <D.27716>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.27702>; else goto <D.27703>;
        <D.27702>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.27703>:
        <D.27692>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.27717>;
        <D.27684>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.27717>:
        <D.27674>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27718 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27718;
        inst->prev = 0B;
        D.27719 = inst->prev;
        inst->next = D.27719;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27720 = inst->sreg3;
        inst->sreg2 = D.27720;
        D.27721 = inst->sreg2;
        inst->sreg1 = D.27721;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        inst->data.op[1].const_val = 127;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27722>; else goto <D.27723>;
        <D.27722>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27724>;
        <D.27723>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27724>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27725 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27725;
        inst->prev = 0B;
        D.27726 = inst->prev;
        inst->next = D.27726;
        inst->opcode = 458;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27727 = inst->sreg3;
        inst->sreg2 = D.27727;
        D.27728 = inst->sreg2;
        inst->sreg1 = D.27728;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27729>; else goto <D.27730>;
        <D.27729>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27731>;
        <D.27730>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27731>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.27732 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.27732;
        ins->prev = 0B;
        D.27733 = ins->prev;
        ins->next = D.27733;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.27734 = ins->sreg3;
        ins->sreg2 = D.27734;
        D.27735 = ins->sreg2;
        ins->sreg1 = D.27735;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        if (1 != 0) goto <D.27736>; else goto <D.27737>;
        <D.27736>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.27738 = D.27576;
        D.27739 = D.27738 + 1;
        cfg->num_bblocks = D.27739;
        D.27740 = (int) D.27738;
        falsebb->block_num = D.27740;
        ins->data.op[0].target_block = end_label;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, end_label);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27741>; else goto <D.27742>;
        <D.27741>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.27743>;
        <D.27742>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27743>:
        D.27744 = falsebb->cil_code;
        if (D.27744 != 0B) goto <D.27745>; else goto <D.27746>;
        <D.27745>:
        D.27633 = cfg->cil_offset_to_bb;
        D.27744 = falsebb->cil_code;
        D.27747 = (int) D.27744;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.27748 = D.27747 - D.27636;
        D.27749 = (unsigned int) D.27748;
        D.27750 = D.27749 * 4;
        D.27751 = D.27633 + D.27750;
        *D.27751 = falsebb;
        <D.27746>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27755>; else goto <D.27752>;
        <D.27755>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27756 = D.27352->opcode;
        D.27757 = D.27756 + 64985;
        D.27758 = D.27757 <= 9;
        D.27759 = D.27756 + 64878;
        D.27760 = D.27759 <= 9;
        D.27761 = D.27758 | D.27760;
        if (D.27761 != 0) goto <D.27753>; else goto <D.27762>;
        <D.27762>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.27753>; else goto <D.27752>;
        <D.27753>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.27763>; else goto <D.27752>;
        <D.27763>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.27754>;
        <D.27752>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.27764>; else goto <D.27766>;
        <D.27766>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27767 = D.27352->opcode;
        D.27768 = D.27767 != 442;
        D.27769 = D.27767 != 759;
        D.27770 = D.27768 & D.27769;
        if (D.27770 != 0) goto <D.27771>; else goto <D.27765>;
        <D.27771>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27772 = D.27352->opcode;
        D.27773 = D.27772 + 64985;
        D.27774 = D.27773 > 9;
        D.27775 = D.27772 + 64878;
        D.27776 = D.27775 > 9;
        D.27777 = D.27774 & D.27776;
        if (D.27777 != 0) goto <D.27778>; else goto <D.27765>;
        <D.27778>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.27764>; else goto <D.27765>;
        <D.27764>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.27765>:
        <D.27754>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.27779>;
        <D.27737>:
        D.27349 = cfg->mempool;
        D.27780 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.27780;
        D.27781 = ins->data.op[1].many_blocks;
        *D.27781 = end_label;
        D.27781 = ins->data.op[1].many_blocks;
        D.27782 = D.27781 + 4;
        *D.27782 = 0B;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, end_label);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27783>; else goto <D.27784>;
        <D.27783>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.27785>;
        <D.27784>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27785>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.27786>; else goto <D.27787>;
        <D.27786>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.27788 = D.27576;
        D.27789 = D.27788 + 1;
        cfg->num_bblocks = D.27789;
        D.27790 = (int) D.27788;
        falsebb->block_num = D.27790;
        D.27781 = ins->data.op[1].many_blocks;
        D.27782 = D.27781 + 4;
        *D.27782 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.27744 = falsebb->cil_code;
        if (D.27744 != 0B) goto <D.27791>; else goto <D.27792>;
        <D.27791>:
        D.27633 = cfg->cil_offset_to_bb;
        D.27744 = falsebb->cil_code;
        D.27747 = (int) D.27744;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.27748 = D.27747 - D.27636;
        D.27749 = (unsigned int) D.27748;
        D.27750 = D.27749 * 4;
        D.27751 = D.27633 + D.27750;
        *D.27751 = falsebb;
        <D.27792>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27796>; else goto <D.27793>;
        <D.27796>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27797 = D.27352->opcode;
        D.27798 = D.27797 + 64985;
        D.27799 = D.27798 <= 9;
        D.27800 = D.27797 + 64878;
        D.27801 = D.27800 <= 9;
        D.27802 = D.27799 | D.27801;
        if (D.27802 != 0) goto <D.27794>; else goto <D.27803>;
        <D.27803>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.27794>; else goto <D.27793>;
        <D.27794>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.27804>; else goto <D.27793>;
        <D.27804>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.27795>;
        <D.27793>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.27805>; else goto <D.27807>;
        <D.27807>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27808 = D.27352->opcode;
        D.27809 = D.27808 != 442;
        D.27810 = D.27808 != 759;
        D.27811 = D.27809 & D.27810;
        if (D.27811 != 0) goto <D.27812>; else goto <D.27806>;
        <D.27812>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27813 = D.27352->opcode;
        D.27814 = D.27813 + 64985;
        D.27815 = D.27814 > 9;
        D.27816 = D.27813 + 64878;
        D.27817 = D.27816 > 9;
        D.27818 = D.27815 & D.27817;
        if (D.27818 != 0) goto <D.27819>; else goto <D.27806>;
        <D.27819>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.27805>; else goto <D.27806>;
        <D.27805>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.27806>:
        <D.27795>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.27820>;
        <D.27787>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.27820>:
        <D.27779>:
      }
      D.27821 = is_negative->cil_code;
      if (D.27821 != 0B) goto <D.27822>; else goto <D.27823>;
      <D.27822>:
      D.27633 = cfg->cil_offset_to_bb;
      D.27821 = is_negative->cil_code;
      D.27824 = (int) D.27821;
      D.27635 = cfg->cil_start;
      D.27636 = (int) D.27635;
      D.27825 = D.27824 - D.27636;
      D.27826 = (unsigned int) D.27825;
      D.27827 = D.27826 * 4;
      D.27828 = D.27633 + D.27827;
      *D.27828 = is_negative;
      <D.27823>:
      D.27641 = cfg->real_offset;
      is_negative->real_offset = D.27641;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27832>; else goto <D.27829>;
      <D.27832>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27833 = D.27352->opcode;
      D.27834 = D.27833 + 64985;
      D.27835 = D.27834 <= 9;
      D.27836 = D.27833 + 64878;
      D.27837 = D.27836 <= 9;
      D.27838 = D.27835 | D.27837;
      if (D.27838 != 0) goto <D.27830>; else goto <D.27839>;
      <D.27839>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 <= 9) goto <D.27830>; else goto <D.27829>;
      <D.27830>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      D.27657 = *D.27656;
      if (D.27657 == 0B) goto <D.27840>; else goto <D.27829>;
      <D.27840>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      *D.27656 = is_negative;
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, is_negative);
      goto <D.27831>;
      <D.27829>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 == 0B) goto <D.27841>; else goto <D.27843>;
      <D.27843>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27844 = D.27352->opcode;
      D.27845 = D.27844 != 442;
      D.27846 = D.27844 != 759;
      D.27847 = D.27845 & D.27846;
      if (D.27847 != 0) goto <D.27848>; else goto <D.27842>;
      <D.27848>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27849 = D.27352->opcode;
      D.27850 = D.27849 + 64985;
      D.27851 = D.27850 > 9;
      D.27852 = D.27849 + 64878;
      D.27853 = D.27852 > 9;
      D.27854 = D.27851 & D.27853;
      if (D.27854 != 0) goto <D.27855>; else goto <D.27842>;
      <D.27855>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 > 9) goto <D.27841>; else goto <D.27842>;
      <D.27841>:
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, is_negative);
      <D.27842>:
      <D.27831>:
      D.27351 = cfg->cbb;
      D.27351->next_bb = is_negative;
      cfg->cbb = is_negative;
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27856 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27856;
        inst->prev = 0B;
        D.27857 = inst->prev;
        inst->next = D.27857;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27858 = inst->sreg3;
        inst->sreg2 = D.27858;
        D.27859 = inst->sreg2;
        inst->sreg1 = D.27859;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        inst->data.op[1].const_val = -128;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27860>; else goto <D.27861>;
        <D.27860>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27862>;
        <D.27861>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27862>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27863 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27863;
        inst->prev = 0B;
        D.27864 = inst->prev;
        inst->next = D.27864;
        inst->opcode = 460;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27865 = inst->sreg3;
        inst->sreg2 = D.27865;
        D.27866 = inst->sreg2;
        inst->sreg1 = D.27866;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27867>; else goto <D.27868>;
        <D.27867>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27869>;
        <D.27868>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27869>:
      }
      D.27870 = end_label->cil_code;
      if (D.27870 != 0B) goto <D.27871>; else goto <D.27872>;
      <D.27871>:
      D.27633 = cfg->cil_offset_to_bb;
      D.27870 = end_label->cil_code;
      D.27873 = (int) D.27870;
      D.27635 = cfg->cil_start;
      D.27636 = (int) D.27635;
      D.27874 = D.27873 - D.27636;
      D.27875 = (unsigned int) D.27874;
      D.27876 = D.27875 * 4;
      D.27877 = D.27633 + D.27876;
      *D.27877 = end_label;
      <D.27872>:
      D.27641 = cfg->real_offset;
      end_label->real_offset = D.27641;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27881>; else goto <D.27878>;
      <D.27881>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27882 = D.27352->opcode;
      D.27883 = D.27882 + 64985;
      D.27884 = D.27883 <= 9;
      D.27885 = D.27882 + 64878;
      D.27886 = D.27885 <= 9;
      D.27887 = D.27884 | D.27886;
      if (D.27887 != 0) goto <D.27879>; else goto <D.27888>;
      <D.27888>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 <= 9) goto <D.27879>; else goto <D.27878>;
      <D.27879>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      D.27657 = *D.27656;
      if (D.27657 == 0B) goto <D.27889>; else goto <D.27878>;
      <D.27889>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      *D.27656 = end_label;
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, end_label);
      goto <D.27880>;
      <D.27878>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 == 0B) goto <D.27890>; else goto <D.27892>;
      <D.27892>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27893 = D.27352->opcode;
      D.27894 = D.27893 != 442;
      D.27895 = D.27893 != 759;
      D.27896 = D.27894 & D.27895;
      if (D.27896 != 0) goto <D.27897>; else goto <D.27891>;
      <D.27897>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27898 = D.27352->opcode;
      D.27899 = D.27898 + 64985;
      D.27900 = D.27899 > 9;
      D.27901 = D.27898 + 64878;
      D.27902 = D.27901 > 9;
      D.27903 = D.27900 & D.27902;
      if (D.27903 != 0) goto <D.27904>; else goto <D.27891>;
      <D.27904>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 > 9) goto <D.27890>; else goto <D.27891>;
      <D.27890>:
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, end_label);
      <D.27891>:
      <D.27880>:
      D.27351 = cfg->cbb;
      D.27351->next_bb = end_label;
      cfg->cbb = end_label;
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.27905 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.27905;
        inst->prev = 0B;
        D.27906 = inst->prev;
        inst->next = D.27906;
        inst->opcode = 580;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.27907 = inst->sreg3;
        inst->sreg2 = D.27907;
        D.27908 = inst->sreg2;
        inst->sreg1 = D.27908;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27360 = tree->dreg;
        inst->dreg = D.27360;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.27909>; else goto <D.27910>;
        <D.27909>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.27911>;
        <D.27910>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.27911>:
      }
      goto <D.26470>;
    }
    <D.26541>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27912 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27912;
      inst->prev = 0B;
      D.27913 = inst->prev;
      inst->next = D.27913;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27914 = inst->sreg3;
      inst->sreg2 = D.27914;
      D.27915 = inst->sreg2;
      inst->sreg1 = D.27915;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27916>; else goto <D.27917>;
      <D.27916>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27918>;
      <D.27917>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27918>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27919 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27919;
      inst->prev = 0B;
      D.27920 = inst->prev;
      inst->next = D.27920;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27921 = inst->sreg3;
      inst->sreg2 = D.27921;
      D.27922 = inst->sreg2;
      inst->sreg1 = D.27922;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27923>; else goto <D.27924>;
      <D.27923>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27925>;
      <D.27924>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27925>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27926 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27926;
      inst->prev = 0B;
      D.27927 = inst->prev;
      inst->next = D.27927;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27928 = inst->sreg3;
      inst->sreg2 = D.27928;
      D.27929 = inst->sreg2;
      inst->sreg1 = D.27929;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 127;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27930>; else goto <D.27931>;
      <D.27930>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27932>;
      <D.27931>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27932>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27933 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27933;
      inst->prev = 0B;
      D.27934 = inst->prev;
      inst->next = D.27934;
      inst->opcode = 453;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27935 = inst->sreg3;
      inst->sreg2 = D.27935;
      D.27936 = inst->sreg2;
      inst->sreg1 = D.27936;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27937>; else goto <D.27938>;
      <D.27937>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27939>;
      <D.27938>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27939>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27940 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27940;
      inst->prev = 0B;
      D.27941 = inst->prev;
      inst->next = D.27941;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27942 = inst->sreg3;
      inst->sreg2 = D.27942;
      D.27943 = inst->sreg2;
      inst->sreg1 = D.27943;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = -128;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27944>; else goto <D.27945>;
      <D.27944>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27946>;
      <D.27945>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27946>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27947 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27947;
      inst->prev = 0B;
      D.27948 = inst->prev;
      inst->next = D.27948;
      inst->opcode = 455;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27949 = inst->sreg3;
      inst->sreg2 = D.27949;
      D.27950 = inst->sreg2;
      inst->sreg1 = D.27950;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27951>; else goto <D.27952>;
      <D.27951>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27953>;
      <D.27952>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27953>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27954 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27954;
      inst->prev = 0B;
      D.27955 = inst->prev;
      inst->next = D.27955;
      inst->opcode = 580;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27956 = inst->sreg3;
      inst->sreg2 = D.27956;
      D.27957 = inst->sreg2;
      inst->sreg1 = D.27957;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27958>; else goto <D.27959>;
      <D.27958>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27960>;
      <D.27959>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27960>:
    }
    goto <D.26470>;
    <D.26549>:
    <D.26550>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27961 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27961;
      inst->prev = 0B;
      D.27962 = inst->prev;
      inst->next = D.27962;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27963 = inst->sreg3;
      inst->sreg2 = D.27963;
      D.27964 = inst->sreg2;
      inst->sreg1 = D.27964;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27965>; else goto <D.27966>;
      <D.27965>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27967>;
      <D.27966>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27967>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27968 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27968;
      inst->prev = 0B;
      D.27969 = inst->prev;
      inst->next = D.27969;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27970 = inst->sreg3;
      inst->sreg2 = D.27970;
      D.27971 = inst->sreg2;
      inst->sreg1 = D.27971;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27972>; else goto <D.27973>;
      <D.27972>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27974>;
      <D.27973>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27974>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27975 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27975;
      inst->prev = 0B;
      D.27976 = inst->prev;
      inst->next = D.27976;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27977 = inst->sreg3;
      inst->sreg2 = D.27977;
      D.27978 = inst->sreg2;
      inst->sreg1 = D.27978;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 255;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27979>; else goto <D.27980>;
      <D.27979>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27981>;
      <D.27980>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27981>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27982 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27982;
      inst->prev = 0B;
      D.27983 = inst->prev;
      inst->next = D.27983;
      inst->opcode = 458;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27984 = inst->sreg3;
      inst->sreg2 = D.27984;
      D.27985 = inst->sreg2;
      inst->sreg1 = D.27985;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27986>; else goto <D.27987>;
      <D.27986>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27988>;
      <D.27987>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27988>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.27989 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.27989;
      inst->prev = 0B;
      D.27990 = inst->prev;
      inst->next = D.27990;
      inst->opcode = 436;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.27991 = inst->sreg3;
      inst->sreg2 = D.27991;
      D.27992 = inst->sreg2;
      inst->sreg1 = D.27992;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 255;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.27993>; else goto <D.27994>;
      <D.27993>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.27995>;
      <D.27994>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.27995>:
    }
    goto <D.26470>;
    <D.26556>:
    {
      struct MonoBasicBlock * is_negative;
      struct MonoBasicBlock * end_label;

      D.27349 = cfg->mempool;
      is_negative = mono_mempool_alloc0 (D.27349, 172);
      D.27576 = cfg->num_bblocks;
      D.27996 = D.27576;
      D.27997 = D.27996 + 1;
      cfg->num_bblocks = D.27997;
      D.27998 = (int) D.27996;
      is_negative->block_num = D.27998;
      D.27349 = cfg->mempool;
      end_label = mono_mempool_alloc0 (D.27349, 172);
      D.27576 = cfg->num_bblocks;
      D.27999 = D.27576;
      D.28000 = D.27999 + 1;
      cfg->num_bblocks = D.28000;
      D.28001 = (int) D.27999;
      end_label->block_num = D.28001;
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28002 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28002;
        inst->prev = 0B;
        D.28003 = inst->prev;
        inst->next = D.28003;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28004 = inst->sreg3;
        inst->sreg2 = D.28004;
        D.28005 = inst->sreg2;
        inst->sreg1 = D.28005;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        inst->data.op[1].const_val = 0;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28006>; else goto <D.28007>;
        <D.28006>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28008>;
        <D.28007>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28008>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28009 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28009;
        inst->prev = 0B;
        D.28010 = inst->prev;
        inst->next = D.28010;
        inst->opcode = 453;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28011 = inst->sreg3;
        inst->sreg2 = D.28011;
        D.28012 = inst->sreg2;
        inst->sreg1 = D.28012;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28013>; else goto <D.28014>;
        <D.28013>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28015>;
        <D.28014>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28015>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28016 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28016;
        inst->prev = 0B;
        D.28017 = inst->prev;
        inst->next = D.28017;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28018 = inst->sreg3;
        inst->sreg2 = D.28018;
        D.28019 = inst->sreg2;
        inst->sreg1 = D.28019;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        inst->data.op[1].const_val = -1;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28020>; else goto <D.28021>;
        <D.28020>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28022>;
        <D.28021>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28022>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28023 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28023;
        inst->prev = 0B;
        D.28024 = inst->prev;
        inst->next = D.28024;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28025 = inst->sreg3;
        inst->sreg2 = D.28025;
        D.28026 = inst->sreg2;
        inst->sreg1 = D.28026;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28027>; else goto <D.28028>;
        <D.28027>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28029>;
        <D.28028>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28029>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28030 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28030;
        inst->prev = 0B;
        D.28031 = inst->prev;
        inst->next = D.28031;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28032 = inst->sreg3;
        inst->sreg2 = D.28032;
        D.28033 = inst->sreg2;
        inst->sreg1 = D.28033;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        inst->data.op[1].const_val = 0;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28034>; else goto <D.28035>;
        <D.28034>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28036>;
        <D.28035>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28036>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.28037 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.28037;
        ins->prev = 0B;
        D.28038 = ins->prev;
        ins->next = D.28038;
        ins->opcode = 652;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.28039 = ins->sreg3;
        ins->sreg2 = D.28039;
        D.28040 = ins->sreg2;
        ins->sreg1 = D.28040;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        if (0 != 0) goto <D.28041>; else goto <D.28042>;
        <D.28041>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28043 = D.27576;
        D.28044 = D.28043 + 1;
        cfg->num_bblocks = D.28044;
        D.28045 = (int) D.28043;
        falsebb->block_num = D.28045;
        ins->data.op[0].target_block = is_negative;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, is_negative);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28046>; else goto <D.28047>;
        <D.28046>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28048>;
        <D.28047>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28048>:
        D.28049 = falsebb->cil_code;
        if (D.28049 != 0B) goto <D.28050>; else goto <D.28051>;
        <D.28050>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28049 = falsebb->cil_code;
        D.28052 = (int) D.28049;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28053 = D.28052 - D.27636;
        D.28054 = (unsigned int) D.28053;
        D.28055 = D.28054 * 4;
        D.28056 = D.27633 + D.28055;
        *D.28056 = falsebb;
        <D.28051>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28060>; else goto <D.28057>;
        <D.28060>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28061 = D.27352->opcode;
        D.28062 = D.28061 + 64985;
        D.28063 = D.28062 <= 9;
        D.28064 = D.28061 + 64878;
        D.28065 = D.28064 <= 9;
        D.28066 = D.28063 | D.28065;
        if (D.28066 != 0) goto <D.28058>; else goto <D.28067>;
        <D.28067>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28058>; else goto <D.28057>;
        <D.28058>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28068>; else goto <D.28057>;
        <D.28068>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28059>;
        <D.28057>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28069>; else goto <D.28071>;
        <D.28071>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28072 = D.27352->opcode;
        D.28073 = D.28072 != 442;
        D.28074 = D.28072 != 759;
        D.28075 = D.28073 & D.28074;
        if (D.28075 != 0) goto <D.28076>; else goto <D.28070>;
        <D.28076>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28077 = D.27352->opcode;
        D.28078 = D.28077 + 64985;
        D.28079 = D.28078 > 9;
        D.28080 = D.28077 + 64878;
        D.28081 = D.28080 > 9;
        D.28082 = D.28079 & D.28081;
        if (D.28082 != 0) goto <D.28083>; else goto <D.28070>;
        <D.28083>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28069>; else goto <D.28070>;
        <D.28069>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28070>:
        <D.28059>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.28084>;
        <D.28042>:
        D.27349 = cfg->mempool;
        D.28085 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.28085;
        D.28086 = ins->data.op[1].many_blocks;
        *D.28086 = is_negative;
        D.28086 = ins->data.op[1].many_blocks;
        D.28087 = D.28086 + 4;
        *D.28087 = 0B;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, is_negative);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28088>; else goto <D.28089>;
        <D.28088>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28090>;
        <D.28089>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28090>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.28091>; else goto <D.28092>;
        <D.28091>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28093 = D.27576;
        D.28094 = D.28093 + 1;
        cfg->num_bblocks = D.28094;
        D.28095 = (int) D.28093;
        falsebb->block_num = D.28095;
        D.28086 = ins->data.op[1].many_blocks;
        D.28087 = D.28086 + 4;
        *D.28087 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.28049 = falsebb->cil_code;
        if (D.28049 != 0B) goto <D.28096>; else goto <D.28097>;
        <D.28096>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28049 = falsebb->cil_code;
        D.28052 = (int) D.28049;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28053 = D.28052 - D.27636;
        D.28054 = (unsigned int) D.28053;
        D.28055 = D.28054 * 4;
        D.28056 = D.27633 + D.28055;
        *D.28056 = falsebb;
        <D.28097>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28101>; else goto <D.28098>;
        <D.28101>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28102 = D.27352->opcode;
        D.28103 = D.28102 + 64985;
        D.28104 = D.28103 <= 9;
        D.28105 = D.28102 + 64878;
        D.28106 = D.28105 <= 9;
        D.28107 = D.28104 | D.28106;
        if (D.28107 != 0) goto <D.28099>; else goto <D.28108>;
        <D.28108>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28099>; else goto <D.28098>;
        <D.28099>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28109>; else goto <D.28098>;
        <D.28109>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28100>;
        <D.28098>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28110>; else goto <D.28112>;
        <D.28112>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28113 = D.27352->opcode;
        D.28114 = D.28113 != 442;
        D.28115 = D.28113 != 759;
        D.28116 = D.28114 & D.28115;
        if (D.28116 != 0) goto <D.28117>; else goto <D.28111>;
        <D.28117>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28118 = D.27352->opcode;
        D.28119 = D.28118 + 64985;
        D.28120 = D.28119 > 9;
        D.28121 = D.28118 + 64878;
        D.28122 = D.28121 > 9;
        D.28123 = D.28120 & D.28122;
        if (D.28123 != 0) goto <D.28124>; else goto <D.28111>;
        <D.28124>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28110>; else goto <D.28111>;
        <D.28110>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28111>:
        <D.28100>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.28125>;
        <D.28092>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.28125>:
        <D.28084>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28126 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28126;
        inst->prev = 0B;
        D.28127 = inst->prev;
        inst->next = D.28127;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28128 = inst->sreg3;
        inst->sreg2 = D.28128;
        D.28129 = inst->sreg2;
        inst->sreg1 = D.28129;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        inst->data.op[1].const_val = 32767;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28130>; else goto <D.28131>;
        <D.28130>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28132>;
        <D.28131>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28132>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28133 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28133;
        inst->prev = 0B;
        D.28134 = inst->prev;
        inst->next = D.28134;
        inst->opcode = 458;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28135 = inst->sreg3;
        inst->sreg2 = D.28135;
        D.28136 = inst->sreg2;
        inst->sreg1 = D.28136;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28137>; else goto <D.28138>;
        <D.28137>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28139>;
        <D.28138>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28139>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.28140 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.28140;
        ins->prev = 0B;
        D.28141 = ins->prev;
        ins->next = D.28141;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.28142 = ins->sreg3;
        ins->sreg2 = D.28142;
        D.28143 = ins->sreg2;
        ins->sreg1 = D.28143;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        if (1 != 0) goto <D.28144>; else goto <D.28145>;
        <D.28144>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28146 = D.27576;
        D.28147 = D.28146 + 1;
        cfg->num_bblocks = D.28147;
        D.28148 = (int) D.28146;
        falsebb->block_num = D.28148;
        ins->data.op[0].target_block = end_label;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, end_label);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28149>; else goto <D.28150>;
        <D.28149>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28151>;
        <D.28150>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28151>:
        D.28152 = falsebb->cil_code;
        if (D.28152 != 0B) goto <D.28153>; else goto <D.28154>;
        <D.28153>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28152 = falsebb->cil_code;
        D.28155 = (int) D.28152;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28156 = D.28155 - D.27636;
        D.28157 = (unsigned int) D.28156;
        D.28158 = D.28157 * 4;
        D.28159 = D.27633 + D.28158;
        *D.28159 = falsebb;
        <D.28154>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28163>; else goto <D.28160>;
        <D.28163>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28164 = D.27352->opcode;
        D.28165 = D.28164 + 64985;
        D.28166 = D.28165 <= 9;
        D.28167 = D.28164 + 64878;
        D.28168 = D.28167 <= 9;
        D.28169 = D.28166 | D.28168;
        if (D.28169 != 0) goto <D.28161>; else goto <D.28170>;
        <D.28170>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28161>; else goto <D.28160>;
        <D.28161>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28171>; else goto <D.28160>;
        <D.28171>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28162>;
        <D.28160>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28172>; else goto <D.28174>;
        <D.28174>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28175 = D.27352->opcode;
        D.28176 = D.28175 != 442;
        D.28177 = D.28175 != 759;
        D.28178 = D.28176 & D.28177;
        if (D.28178 != 0) goto <D.28179>; else goto <D.28173>;
        <D.28179>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28180 = D.27352->opcode;
        D.28181 = D.28180 + 64985;
        D.28182 = D.28181 > 9;
        D.28183 = D.28180 + 64878;
        D.28184 = D.28183 > 9;
        D.28185 = D.28182 & D.28184;
        if (D.28185 != 0) goto <D.28186>; else goto <D.28173>;
        <D.28186>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28172>; else goto <D.28173>;
        <D.28172>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28173>:
        <D.28162>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.28187>;
        <D.28145>:
        D.27349 = cfg->mempool;
        D.28188 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.28188;
        D.28189 = ins->data.op[1].many_blocks;
        *D.28189 = end_label;
        D.28189 = ins->data.op[1].many_blocks;
        D.28190 = D.28189 + 4;
        *D.28190 = 0B;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, end_label);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28191>; else goto <D.28192>;
        <D.28191>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28193>;
        <D.28192>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28193>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.28194>; else goto <D.28195>;
        <D.28194>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28196 = D.27576;
        D.28197 = D.28196 + 1;
        cfg->num_bblocks = D.28197;
        D.28198 = (int) D.28196;
        falsebb->block_num = D.28198;
        D.28189 = ins->data.op[1].many_blocks;
        D.28190 = D.28189 + 4;
        *D.28190 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.28152 = falsebb->cil_code;
        if (D.28152 != 0B) goto <D.28199>; else goto <D.28200>;
        <D.28199>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28152 = falsebb->cil_code;
        D.28155 = (int) D.28152;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28156 = D.28155 - D.27636;
        D.28157 = (unsigned int) D.28156;
        D.28158 = D.28157 * 4;
        D.28159 = D.27633 + D.28158;
        *D.28159 = falsebb;
        <D.28200>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28204>; else goto <D.28201>;
        <D.28204>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28205 = D.27352->opcode;
        D.28206 = D.28205 + 64985;
        D.28207 = D.28206 <= 9;
        D.28208 = D.28205 + 64878;
        D.28209 = D.28208 <= 9;
        D.28210 = D.28207 | D.28209;
        if (D.28210 != 0) goto <D.28202>; else goto <D.28211>;
        <D.28211>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28202>; else goto <D.28201>;
        <D.28202>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28212>; else goto <D.28201>;
        <D.28212>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28203>;
        <D.28201>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28213>; else goto <D.28215>;
        <D.28215>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28216 = D.27352->opcode;
        D.28217 = D.28216 != 442;
        D.28218 = D.28216 != 759;
        D.28219 = D.28217 & D.28218;
        if (D.28219 != 0) goto <D.28220>; else goto <D.28214>;
        <D.28220>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28221 = D.27352->opcode;
        D.28222 = D.28221 + 64985;
        D.28223 = D.28222 > 9;
        D.28224 = D.28221 + 64878;
        D.28225 = D.28224 > 9;
        D.28226 = D.28223 & D.28225;
        if (D.28226 != 0) goto <D.28227>; else goto <D.28214>;
        <D.28227>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28213>; else goto <D.28214>;
        <D.28213>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28214>:
        <D.28203>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.28228>;
        <D.28195>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.28228>:
        <D.28187>:
      }
      D.28229 = is_negative->cil_code;
      if (D.28229 != 0B) goto <D.28230>; else goto <D.28231>;
      <D.28230>:
      D.27633 = cfg->cil_offset_to_bb;
      D.28229 = is_negative->cil_code;
      D.28232 = (int) D.28229;
      D.27635 = cfg->cil_start;
      D.27636 = (int) D.27635;
      D.28233 = D.28232 - D.27636;
      D.28234 = (unsigned int) D.28233;
      D.28235 = D.28234 * 4;
      D.28236 = D.27633 + D.28235;
      *D.28236 = is_negative;
      <D.28231>:
      D.27641 = cfg->real_offset;
      is_negative->real_offset = D.27641;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28240>; else goto <D.28237>;
      <D.28240>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.28241 = D.27352->opcode;
      D.28242 = D.28241 + 64985;
      D.28243 = D.28242 <= 9;
      D.28244 = D.28241 + 64878;
      D.28245 = D.28244 <= 9;
      D.28246 = D.28243 | D.28245;
      if (D.28246 != 0) goto <D.28238>; else goto <D.28247>;
      <D.28247>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 <= 9) goto <D.28238>; else goto <D.28237>;
      <D.28238>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      D.27657 = *D.27656;
      if (D.27657 == 0B) goto <D.28248>; else goto <D.28237>;
      <D.28248>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      *D.27656 = is_negative;
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, is_negative);
      goto <D.28239>;
      <D.28237>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 == 0B) goto <D.28249>; else goto <D.28251>;
      <D.28251>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.28252 = D.27352->opcode;
      D.28253 = D.28252 != 442;
      D.28254 = D.28252 != 759;
      D.28255 = D.28253 & D.28254;
      if (D.28255 != 0) goto <D.28256>; else goto <D.28250>;
      <D.28256>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.28257 = D.27352->opcode;
      D.28258 = D.28257 + 64985;
      D.28259 = D.28258 > 9;
      D.28260 = D.28257 + 64878;
      D.28261 = D.28260 > 9;
      D.28262 = D.28259 & D.28261;
      if (D.28262 != 0) goto <D.28263>; else goto <D.28250>;
      <D.28263>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 > 9) goto <D.28249>; else goto <D.28250>;
      <D.28249>:
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, is_negative);
      <D.28250>:
      <D.28239>:
      D.27351 = cfg->cbb;
      D.27351->next_bb = is_negative;
      cfg->cbb = is_negative;
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28264 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28264;
        inst->prev = 0B;
        D.28265 = inst->prev;
        inst->next = D.28265;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28266 = inst->sreg3;
        inst->sreg2 = D.28266;
        D.28267 = inst->sreg2;
        inst->sreg1 = D.28267;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        inst->data.op[1].const_val = -32768;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28268>; else goto <D.28269>;
        <D.28268>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28270>;
        <D.28269>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28270>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28271 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28271;
        inst->prev = 0B;
        D.28272 = inst->prev;
        inst->next = D.28272;
        inst->opcode = 460;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28273 = inst->sreg3;
        inst->sreg2 = D.28273;
        D.28274 = inst->sreg2;
        inst->sreg1 = D.28274;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->data.op[1].p = "OverflowException";
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28275>; else goto <D.28276>;
        <D.28275>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28277>;
        <D.28276>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28277>:
      }
      D.28278 = end_label->cil_code;
      if (D.28278 != 0B) goto <D.28279>; else goto <D.28280>;
      <D.28279>:
      D.27633 = cfg->cil_offset_to_bb;
      D.28278 = end_label->cil_code;
      D.28281 = (int) D.28278;
      D.27635 = cfg->cil_start;
      D.27636 = (int) D.27635;
      D.28282 = D.28281 - D.27636;
      D.28283 = (unsigned int) D.28282;
      D.28284 = D.28283 * 4;
      D.28285 = D.27633 + D.28284;
      *D.28285 = end_label;
      <D.28280>:
      D.27641 = cfg->real_offset;
      end_label->real_offset = D.27641;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28289>; else goto <D.28286>;
      <D.28289>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.28290 = D.27352->opcode;
      D.28291 = D.28290 + 64985;
      D.28292 = D.28291 <= 9;
      D.28293 = D.28290 + 64878;
      D.28294 = D.28293 <= 9;
      D.28295 = D.28292 | D.28294;
      if (D.28295 != 0) goto <D.28287>; else goto <D.28296>;
      <D.28296>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 <= 9) goto <D.28287>; else goto <D.28286>;
      <D.28287>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      D.27657 = *D.27656;
      if (D.27657 == 0B) goto <D.28297>; else goto <D.28286>;
      <D.28297>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27655 = D.27352->data.op[1].many_blocks;
      D.27656 = D.27655 + 4;
      *D.27656 = end_label;
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, end_label);
      goto <D.28288>;
      <D.28286>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 == 0B) goto <D.28298>; else goto <D.28300>;
      <D.28300>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.28301 = D.27352->opcode;
      D.28302 = D.28301 != 442;
      D.28303 = D.28301 != 759;
      D.28304 = D.28302 & D.28303;
      if (D.28304 != 0) goto <D.28305>; else goto <D.28299>;
      <D.28305>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.28306 = D.27352->opcode;
      D.28307 = D.28306 + 64985;
      D.28308 = D.28307 > 9;
      D.28309 = D.28306 + 64878;
      D.28310 = D.28309 > 9;
      D.28311 = D.28308 & D.28310;
      if (D.28311 != 0) goto <D.28312>; else goto <D.28299>;
      <D.28312>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27653 = D.27352->opcode;
      D.27654 = D.27653 + 64888;
      if (D.27654 > 9) goto <D.28298>; else goto <D.28299>;
      <D.28298>:
      D.27351 = cfg->cbb;
      mono_link_bblock (cfg, D.27351, end_label);
      <D.28299>:
      <D.28288>:
      D.27351 = cfg->cbb;
      D.27351->next_bb = end_label;
      cfg->cbb = end_label;
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28313 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28313;
        inst->prev = 0B;
        D.28314 = inst->prev;
        inst->next = D.28314;
        inst->opcode = 581;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28315 = inst->sreg3;
        inst->sreg2 = D.28315;
        D.28316 = inst->sreg2;
        inst->sreg1 = D.28316;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        D.27360 = tree->dreg;
        inst->dreg = D.27360;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28317>; else goto <D.28318>;
        <D.28317>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28319>;
        <D.28318>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28319>:
      }
      goto <D.26470>;
    }
    <D.26573>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28320 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28320;
      inst->prev = 0B;
      D.28321 = inst->prev;
      inst->next = D.28321;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28322 = inst->sreg3;
      inst->sreg2 = D.28322;
      D.28323 = inst->sreg2;
      inst->sreg1 = D.28323;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28324>; else goto <D.28325>;
      <D.28324>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28326>;
      <D.28325>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28326>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28327 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28327;
      inst->prev = 0B;
      D.28328 = inst->prev;
      inst->next = D.28328;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28329 = inst->sreg3;
      inst->sreg2 = D.28329;
      D.28330 = inst->sreg2;
      inst->sreg1 = D.28330;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28331>; else goto <D.28332>;
      <D.28331>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28333>;
      <D.28332>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28333>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28334 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28334;
      inst->prev = 0B;
      D.28335 = inst->prev;
      inst->next = D.28335;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28336 = inst->sreg3;
      inst->sreg2 = D.28336;
      D.28337 = inst->sreg2;
      inst->sreg1 = D.28337;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 32767;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28338>; else goto <D.28339>;
      <D.28338>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28340>;
      <D.28339>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28340>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28341 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28341;
      inst->prev = 0B;
      D.28342 = inst->prev;
      inst->next = D.28342;
      inst->opcode = 453;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28343 = inst->sreg3;
      inst->sreg2 = D.28343;
      D.28344 = inst->sreg2;
      inst->sreg1 = D.28344;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28345>; else goto <D.28346>;
      <D.28345>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28347>;
      <D.28346>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28347>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28348 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28348;
      inst->prev = 0B;
      D.28349 = inst->prev;
      inst->next = D.28349;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28350 = inst->sreg3;
      inst->sreg2 = D.28350;
      D.28351 = inst->sreg2;
      inst->sreg1 = D.28351;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = -32768;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28352>; else goto <D.28353>;
      <D.28352>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28354>;
      <D.28353>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28354>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28355 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28355;
      inst->prev = 0B;
      D.28356 = inst->prev;
      inst->next = D.28356;
      inst->opcode = 455;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28357 = inst->sreg3;
      inst->sreg2 = D.28357;
      D.28358 = inst->sreg2;
      inst->sreg1 = D.28358;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28359>; else goto <D.28360>;
      <D.28359>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28361>;
      <D.28360>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28361>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28362 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28362;
      inst->prev = 0B;
      D.28363 = inst->prev;
      inst->next = D.28363;
      inst->opcode = 581;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28364 = inst->sreg3;
      inst->sreg2 = D.28364;
      D.28365 = inst->sreg2;
      inst->sreg1 = D.28365;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28366>; else goto <D.28367>;
      <D.28366>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28368>;
      <D.28367>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28368>:
    }
    goto <D.26470>;
    <D.26581>:
    <D.26582>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28369 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28369;
      inst->prev = 0B;
      D.28370 = inst->prev;
      inst->next = D.28370;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28371 = inst->sreg3;
      inst->sreg2 = D.28371;
      D.28372 = inst->sreg2;
      inst->sreg1 = D.28372;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28373>; else goto <D.28374>;
      <D.28373>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28375>;
      <D.28374>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28375>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28376 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28376;
      inst->prev = 0B;
      D.28377 = inst->prev;
      inst->next = D.28377;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28378 = inst->sreg3;
      inst->sreg2 = D.28378;
      D.28379 = inst->sreg2;
      inst->sreg1 = D.28379;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28380>; else goto <D.28381>;
      <D.28380>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28382>;
      <D.28381>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28382>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28383 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28383;
      inst->prev = 0B;
      D.28384 = inst->prev;
      inst->next = D.28384;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28385 = inst->sreg3;
      inst->sreg2 = D.28385;
      D.28386 = inst->sreg2;
      inst->sreg1 = D.28386;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 65535;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28387>; else goto <D.28388>;
      <D.28387>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28389>;
      <D.28388>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28389>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28390 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28390;
      inst->prev = 0B;
      D.28391 = inst->prev;
      inst->next = D.28391;
      inst->opcode = 458;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28392 = inst->sreg3;
      inst->sreg2 = D.28392;
      D.28393 = inst->sreg2;
      inst->sreg1 = D.28393;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28394>; else goto <D.28395>;
      <D.28394>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28396>;
      <D.28395>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28396>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28397 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28397;
      inst->prev = 0B;
      D.28398 = inst->prev;
      inst->next = D.28398;
      inst->opcode = 436;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28399 = inst->sreg3;
      inst->sreg2 = D.28399;
      D.28400 = inst->sreg2;
      inst->sreg1 = D.28400;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 65535;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28401>; else goto <D.28402>;
      <D.28401>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28403>;
      <D.28402>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28403>:
    }
    goto <D.26470>;
    <D.26588>:
    <D.26589>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28404 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28404;
      inst->prev = 0B;
      D.28405 = inst->prev;
      inst->next = D.28405;
      inst->opcode = 564;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28406 = inst->sreg3;
      inst->sreg2 = D.28406;
      D.28407 = inst->sreg2;
      inst->sreg1 = D.28407;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg2 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28408>; else goto <D.28409>;
      <D.28408>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28410>;
      <D.28409>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28410>:
    }
    goto <D.26470>;
    <D.26591>:
    <D.26592>:
    <D.26593>:
    <D.26594>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28411 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28411;
      inst->prev = 0B;
      D.28412 = inst->prev;
      inst->next = D.28412;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28413 = inst->sreg3;
      inst->sreg2 = D.28413;
      D.28414 = inst->sreg2;
      inst->sreg1 = D.28414;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28415>; else goto <D.28416>;
      <D.28415>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28417>;
      <D.28416>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28417>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28418 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28418;
      inst->prev = 0B;
      D.28419 = inst->prev;
      inst->next = D.28419;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28420 = inst->sreg3;
      inst->sreg2 = D.28420;
      D.28421 = inst->sreg2;
      inst->sreg1 = D.28421;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28422>; else goto <D.28423>;
      <D.28422>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28424>;
      <D.28423>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28424>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28425 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28425;
      inst->prev = 0B;
      D.28426 = inst->prev;
      inst->next = D.28426;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28427 = inst->sreg3;
      inst->sreg2 = D.28427;
      D.28428 = inst->sreg2;
      inst->sreg1 = D.28428;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28429>; else goto <D.28430>;
      <D.28429>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28431>;
      <D.28430>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28431>:
    }
    goto <D.26470>;
    <D.26598>:
    <D.26599>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28432 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28432;
      inst->prev = 0B;
      D.28433 = inst->prev;
      inst->next = D.28433;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28434 = inst->sreg3;
      inst->sreg2 = D.28434;
      D.28435 = inst->sreg2;
      inst->sreg1 = D.28435;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28436>; else goto <D.28437>;
      <D.28436>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28438>;
      <D.28437>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28438>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28439 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28439;
      inst->prev = 0B;
      D.28440 = inst->prev;
      inst->next = D.28440;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28441 = inst->sreg3;
      inst->sreg2 = D.28441;
      D.28442 = inst->sreg2;
      inst->sreg1 = D.28442;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28443>; else goto <D.28444>;
      <D.28443>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28445>;
      <D.28444>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28445>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28446 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28446;
      inst->prev = 0B;
      D.28447 = inst->prev;
      inst->next = D.28447;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28448 = inst->sreg3;
      inst->sreg2 = D.28448;
      D.28449 = inst->sreg2;
      inst->sreg1 = D.28449;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28450>; else goto <D.28451>;
      <D.28450>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28452>;
      <D.28451>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28452>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28453 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28453;
      inst->prev = 0B;
      D.28454 = inst->prev;
      inst->next = D.28454;
      inst->opcode = 455;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28455 = inst->sreg3;
      inst->sreg2 = D.28455;
      D.28456 = inst->sreg2;
      inst->sreg1 = D.28456;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28457>; else goto <D.28458>;
      <D.28457>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28459>;
      <D.28458>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28459>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28460 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28460;
      inst->prev = 0B;
      D.28461 = inst->prev;
      inst->next = D.28461;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28462 = inst->sreg3;
      inst->sreg2 = D.28462;
      D.28463 = inst->sreg2;
      inst->sreg1 = D.28463;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      inst->dreg = D.27360;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28464>; else goto <D.28465>;
      <D.28464>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28466>;
      <D.28465>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28466>:
    }
    goto <D.26470>;
    <D.26605>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28467 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28467;
      inst->prev = 0B;
      D.28468 = inst->prev;
      inst->next = D.28468;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28469 = inst->sreg3;
      inst->sreg2 = D.28469;
      D.28470 = inst->sreg2;
      inst->sreg1 = D.28470;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28471>; else goto <D.28472>;
      <D.28471>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28473>;
      <D.28472>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28473>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28474 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28474;
      inst->prev = 0B;
      D.28475 = inst->prev;
      inst->next = D.28475;
      inst->opcode = 455;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28476 = inst->sreg3;
      inst->sreg2 = D.28476;
      D.28477 = inst->sreg2;
      inst->sreg1 = D.28477;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28478>; else goto <D.28479>;
      <D.28478>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28480>;
      <D.28479>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28480>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28481 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28481;
      inst->prev = 0B;
      D.28482 = inst->prev;
      inst->next = D.28482;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28483 = inst->sreg3;
      inst->sreg2 = D.28483;
      D.28484 = inst->sreg2;
      inst->sreg1 = D.28484;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28485>; else goto <D.28486>;
      <D.28485>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28487>;
      <D.28486>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28487>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28488 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28488;
      inst->prev = 0B;
      D.28489 = inst->prev;
      inst->next = D.28489;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28490 = inst->sreg3;
      inst->sreg2 = D.28490;
      D.28491 = inst->sreg2;
      inst->sreg1 = D.28491;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28492>; else goto <D.28493>;
      <D.28492>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28494>;
      <D.28493>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28494>:
    }
    goto <D.26470>;
    <D.26610>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28495 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28495;
      inst->prev = 0B;
      D.28496 = inst->prev;
      inst->next = D.28496;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28497 = inst->sreg3;
      inst->sreg2 = D.28497;
      D.28498 = inst->sreg2;
      inst->sreg1 = D.28498;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->dreg = -1;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      inst->data.op[1].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28499>; else goto <D.28500>;
      <D.28499>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28501>;
      <D.28500>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28501>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28502 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28502;
      inst->prev = 0B;
      D.28503 = inst->prev;
      inst->next = D.28503;
      inst->opcode = 455;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28504 = inst->sreg3;
      inst->sreg2 = D.28504;
      D.28505 = inst->sreg2;
      inst->sreg1 = D.28505;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28506>; else goto <D.28507>;
      <D.28506>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28508>;
      <D.28507>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28508>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28509 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28509;
      inst->prev = 0B;
      D.28510 = inst->prev;
      inst->next = D.28510;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28511 = inst->sreg3;
      inst->sreg2 = D.28511;
      D.28512 = inst->sreg2;
      inst->sreg1 = D.28512;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28513>; else goto <D.28514>;
      <D.28513>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28515>;
      <D.28514>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28515>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28516 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28516;
      inst->prev = 0B;
      D.28517 = inst->prev;
      inst->next = D.28517;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28518 = inst->sreg3;
      inst->sreg2 = D.28518;
      D.28519 = inst->sreg2;
      inst->sreg1 = D.28519;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28520>; else goto <D.28521>;
      <D.28520>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28522>;
      <D.28521>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28522>:
    }
    goto <D.26470>;
    <D.26615>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28523 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28523;
      inst->prev = 0B;
      D.28524 = inst->prev;
      inst->next = D.28524;
      inst->opcode = 623;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28525 = inst->sreg3;
      inst->sreg2 = D.28525;
      D.28526 = inst->sreg2;
      inst->sreg1 = D.28526;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28529>; else goto <D.28530>;
      <D.28529>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28531>;
      <D.28530>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28531>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28532 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28532;
      inst->prev = 0B;
      D.28533 = inst->prev;
      inst->next = D.28533;
      inst->opcode = 619;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28534 = inst->sreg3;
      inst->sreg2 = D.28534;
      D.28535 = inst->sreg2;
      inst->sreg1 = D.28535;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28537>; else goto <D.28538>;
      <D.28537>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28539>;
      <D.28538>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28539>:
    }
    goto <D.26470>;
    <D.26618>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28540 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28540;
      inst->prev = 0B;
      D.28541 = inst->prev;
      inst->next = D.28541;
      inst->opcode = 624;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28542 = inst->sreg3;
      inst->sreg2 = D.28542;
      D.28543 = inst->sreg2;
      inst->sreg1 = D.28543;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28544>; else goto <D.28545>;
      <D.28544>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28546>;
      <D.28545>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28546>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28547 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28547;
      inst->prev = 0B;
      D.28548 = inst->prev;
      inst->next = D.28548;
      inst->opcode = 621;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28549 = inst->sreg3;
      inst->sreg2 = D.28549;
      D.28550 = inst->sreg2;
      inst->sreg1 = D.28550;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28551>; else goto <D.28552>;
      <D.28551>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28553>;
      <D.28552>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28553>:
    }
    goto <D.26470>;
    <D.26621>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28554 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28554;
      inst->prev = 0B;
      D.28555 = inst->prev;
      inst->next = D.28555;
      inst->opcode = 623;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28556 = inst->sreg3;
      inst->sreg2 = D.28556;
      D.28557 = inst->sreg2;
      inst->sreg1 = D.28557;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28558>; else goto <D.28559>;
      <D.28558>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28560>;
      <D.28559>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28560>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28561 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28561;
      inst->prev = 0B;
      D.28562 = inst->prev;
      inst->next = D.28562;
      inst->opcode = 619;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28563 = inst->sreg3;
      inst->sreg2 = D.28563;
      D.28564 = inst->sreg2;
      inst->sreg1 = D.28564;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28565>; else goto <D.28566>;
      <D.28565>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28567>;
      <D.28566>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28567>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28568 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28568;
      inst->prev = 0B;
      D.28569 = inst->prev;
      inst->next = D.28569;
      inst->opcode = 461;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28570 = inst->sreg3;
      inst->sreg2 = D.28570;
      D.28571 = inst->sreg2;
      inst->sreg1 = D.28571;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28572>; else goto <D.28573>;
      <D.28572>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28574>;
      <D.28573>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28574>:
    }
    goto <D.26470>;
    <D.26625>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28575 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28575;
      inst->prev = 0B;
      D.28576 = inst->prev;
      inst->next = D.28576;
      inst->opcode = 623;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28577 = inst->sreg3;
      inst->sreg2 = D.28577;
      D.28578 = inst->sreg2;
      inst->sreg1 = D.28578;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28579>; else goto <D.28580>;
      <D.28579>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28581>;
      <D.28580>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28581>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28582 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28582;
      inst->prev = 0B;
      D.28583 = inst->prev;
      inst->next = D.28583;
      inst->opcode = 619;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28584 = inst->sreg3;
      inst->sreg2 = D.28584;
      D.28585 = inst->sreg2;
      inst->sreg1 = D.28585;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28586>; else goto <D.28587>;
      <D.28586>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28588>;
      <D.28587>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28588>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28589 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28589;
      inst->prev = 0B;
      D.28590 = inst->prev;
      inst->next = D.28590;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28591 = inst->sreg3;
      inst->sreg2 = D.28591;
      D.28592 = inst->sreg2;
      inst->sreg1 = D.28592;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28593>; else goto <D.28594>;
      <D.28593>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28595>;
      <D.28594>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28595>:
    }
    goto <D.26470>;
    <D.26629>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28596 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28596;
      inst->prev = 0B;
      D.28597 = inst->prev;
      inst->next = D.28597;
      inst->opcode = 624;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28598 = inst->sreg3;
      inst->sreg2 = D.28598;
      D.28599 = inst->sreg2;
      inst->sreg1 = D.28599;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28600>; else goto <D.28601>;
      <D.28600>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28602>;
      <D.28601>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28602>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28603 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28603;
      inst->prev = 0B;
      D.28604 = inst->prev;
      inst->next = D.28604;
      inst->opcode = 621;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28605 = inst->sreg3;
      inst->sreg2 = D.28605;
      D.28606 = inst->sreg2;
      inst->sreg1 = D.28606;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28607>; else goto <D.28608>;
      <D.28607>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28609>;
      <D.28608>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28609>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28610 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28610;
      inst->prev = 0B;
      D.28611 = inst->prev;
      inst->next = D.28611;
      inst->opcode = 461;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28612 = inst->sreg3;
      inst->sreg2 = D.28612;
      D.28613 = inst->sreg2;
      inst->sreg1 = D.28613;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28614>; else goto <D.28615>;
      <D.28614>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28616>;
      <D.28615>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28616>:
    }
    goto <D.26470>;
    <D.26633>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28617 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28617;
      inst->prev = 0B;
      D.28618 = inst->prev;
      inst->next = D.28618;
      inst->opcode = 624;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28619 = inst->sreg3;
      inst->sreg2 = D.28619;
      D.28620 = inst->sreg2;
      inst->sreg1 = D.28620;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28621>; else goto <D.28622>;
      <D.28621>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28623>;
      <D.28622>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28623>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28624 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28624;
      inst->prev = 0B;
      D.28625 = inst->prev;
      inst->next = D.28625;
      inst->opcode = 621;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28626 = inst->sreg3;
      inst->sreg2 = D.28626;
      D.28627 = inst->sreg2;
      inst->sreg1 = D.28627;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28628>; else goto <D.28629>;
      <D.28628>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28630>;
      <D.28629>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28630>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28631 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28631;
      inst->prev = 0B;
      D.28632 = inst->prev;
      inst->next = D.28632;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28633 = inst->sreg3;
      inst->sreg2 = D.28633;
      D.28634 = inst->sreg2;
      inst->sreg1 = D.28634;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      inst->data.op[1].p = "OverflowException";
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28635>; else goto <D.28636>;
      <D.28635>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28637>;
      <D.28636>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28637>:
    }
    goto <D.26470>;
    <D.26637>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28638 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28638;
      inst->prev = 0B;
      D.28639 = inst->prev;
      inst->next = D.28639;
      inst->opcode = 572;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28640 = inst->sreg3;
      inst->sreg2 = D.28640;
      D.28641 = inst->sreg2;
      inst->sreg1 = D.28641;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28642>; else goto <D.28643>;
      <D.28642>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28644>;
      <D.28643>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28644>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28645 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28645;
      inst->prev = 0B;
      D.28646 = inst->prev;
      inst->next = D.28646;
      inst->opcode = 572;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28647 = inst->sreg3;
      inst->sreg2 = D.28647;
      D.28648 = inst->sreg2;
      inst->sreg1 = D.28648;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28649>; else goto <D.28650>;
      <D.28649>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28651>;
      <D.28650>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28651>:
    }
    goto <D.26470>;
    <D.26640>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28652 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28652;
      inst->prev = 0B;
      D.28653 = inst->prev;
      inst->next = D.28653;
      inst->opcode = 573;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28654 = inst->sreg3;
      inst->sreg2 = D.28654;
      D.28655 = inst->sreg2;
      inst->sreg1 = D.28655;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28656>; else goto <D.28657>;
      <D.28656>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28658>;
      <D.28657>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28658>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28659 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28659;
      inst->prev = 0B;
      D.28660 = inst->prev;
      inst->next = D.28660;
      inst->opcode = 573;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28661 = inst->sreg3;
      inst->sreg2 = D.28661;
      D.28662 = inst->sreg2;
      inst->sreg1 = D.28662;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28663>; else goto <D.28664>;
      <D.28663>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28665>;
      <D.28664>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28665>:
    }
    goto <D.26470>;
    <D.26643>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28666 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28666;
      inst->prev = 0B;
      D.28667 = inst->prev;
      inst->next = D.28667;
      inst->opcode = 574;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28668 = inst->sreg3;
      inst->sreg2 = D.28668;
      D.28669 = inst->sreg2;
      inst->sreg1 = D.28669;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.28527 = tree->sreg2;
      D.28528 = D.28527 + 1;
      inst->sreg2 = D.28528;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28670>; else goto <D.28671>;
      <D.28670>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28672>;
      <D.28671>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28672>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28673 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28673;
      inst->prev = 0B;
      D.28674 = inst->prev;
      inst->next = D.28674;
      inst->opcode = 574;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28675 = inst->sreg3;
      inst->sreg2 = D.28675;
      D.28676 = inst->sreg2;
      inst->sreg1 = D.28676;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.28527 = tree->sreg2;
      D.28536 = D.28527 + 2;
      inst->sreg2 = D.28536;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28677>; else goto <D.28678>;
      <D.28677>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28679>;
      <D.28678>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28679>:
    }
    goto <D.26470>;
    <D.26646>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28680 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28680;
      inst->prev = 0B;
      D.28681 = inst->prev;
      inst->next = D.28681;
      inst->opcode = 579;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28682 = inst->sreg3;
      inst->sreg2 = D.28682;
      D.28683 = inst->sreg2;
      inst->sreg1 = D.28683;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28684>; else goto <D.28685>;
      <D.28684>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28686>;
      <D.28685>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28686>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28687 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28687;
      inst->prev = 0B;
      D.28688 = inst->prev;
      inst->next = D.28688;
      inst->opcode = 579;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28689 = inst->sreg3;
      inst->sreg2 = D.28689;
      D.28690 = inst->sreg2;
      inst->sreg1 = D.28690;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28691>; else goto <D.28692>;
      <D.28691>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28693>;
      <D.28692>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28693>:
    }
    goto <D.26470>;
    <D.26649>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "decompose.c", 840);
    <D.26650>:
    goto <D.26470>;
    <D.26651>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28694 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28694;
      inst->prev = 0B;
      D.28695 = inst->prev;
      inst->next = D.28695;
      inst->opcode = 756;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28696 = inst->sreg3;
      inst->sreg2 = D.28696;
      D.28697 = inst->sreg2;
      inst->sreg1 = D.28697;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[1].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28698>; else goto <D.28699>;
      <D.28698>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28700>;
      <D.28699>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28700>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28701 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28701;
      inst->prev = 0B;
      D.28702 = inst->prev;
      inst->next = D.28702;
      inst->opcode = 752;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28703 = inst->sreg3;
      inst->sreg2 = D.28703;
      D.28704 = inst->sreg2;
      inst->sreg1 = D.28704;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27371 = tree->data.op[1].const_val;
      inst->data.op[1].const_val = D.27371;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28705>; else goto <D.28706>;
      <D.28705>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28707>;
      <D.28706>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28707>:
    }
    goto <D.26470>;
    <D.26654>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28708 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28708;
      inst->prev = 0B;
      D.28709 = inst->prev;
      inst->next = D.28709;
      inst->opcode = 758;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28710 = inst->sreg3;
      inst->sreg2 = D.28710;
      D.28711 = inst->sreg2;
      inst->sreg1 = D.28711;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[1].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28712>; else goto <D.28713>;
      <D.28712>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28714>;
      <D.28713>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28714>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28715 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28715;
      inst->prev = 0B;
      D.28716 = inst->prev;
      inst->next = D.28716;
      inst->opcode = 754;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28717 = inst->sreg3;
      inst->sreg2 = D.28717;
      D.28718 = inst->sreg2;
      inst->sreg1 = D.28718;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27371 = tree->data.op[1].const_val;
      inst->data.op[1].const_val = D.27371;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28719>; else goto <D.28720>;
      <D.28719>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28721>;
      <D.28720>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28721>:
    }
    goto <D.26470>;
    <D.26657>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28722 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28722;
      inst->prev = 0B;
      D.28723 = inst->prev;
      inst->next = D.28723;
      inst->opcode = 436;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28724 = inst->sreg3;
      inst->sreg2 = D.28724;
      D.28725 = inst->sreg2;
      inst->sreg1 = D.28725;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[1].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28726>; else goto <D.28727>;
      <D.28726>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28728>;
      <D.28727>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28728>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28729 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28729;
      inst->prev = 0B;
      D.28730 = inst->prev;
      inst->next = D.28730;
      inst->opcode = 436;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28731 = inst->sreg3;
      inst->sreg2 = D.28731;
      D.28732 = inst->sreg2;
      inst->sreg1 = D.28732;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27371 = tree->data.op[1].const_val;
      inst->data.op[1].const_val = D.27371;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28733>; else goto <D.28734>;
      <D.28733>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28735>;
      <D.28734>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28735>:
    }
    goto <D.26470>;
    <D.26660>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28736 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28736;
      inst->prev = 0B;
      D.28737 = inst->prev;
      inst->next = D.28737;
      inst->opcode = 437;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28738 = inst->sreg3;
      inst->sreg2 = D.28738;
      D.28739 = inst->sreg2;
      inst->sreg1 = D.28739;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[1].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28740>; else goto <D.28741>;
      <D.28740>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28742>;
      <D.28741>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28742>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28743 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28743;
      inst->prev = 0B;
      D.28744 = inst->prev;
      inst->next = D.28744;
      inst->opcode = 437;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28745 = inst->sreg3;
      inst->sreg2 = D.28745;
      D.28746 = inst->sreg2;
      inst->sreg1 = D.28746;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27371 = tree->data.op[1].const_val;
      inst->data.op[1].const_val = D.27371;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28747>; else goto <D.28748>;
      <D.28747>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28749>;
      <D.28748>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28749>:
    }
    goto <D.26470>;
    <D.26663>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28750 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28750;
      inst->prev = 0B;
      D.28751 = inst->prev;
      inst->next = D.28751;
      inst->opcode = 438;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28752 = inst->sreg3;
      inst->sreg2 = D.28752;
      D.28753 = inst->sreg2;
      inst->sreg1 = D.28753;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27362 = tree->data.op[0].const_val;
      inst->data.op[1].const_val = D.27362;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28754>; else goto <D.28755>;
      <D.28754>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28756>;
      <D.28755>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28756>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28757 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28757;
      inst->prev = 0B;
      D.28758 = inst->prev;
      inst->next = D.28758;
      inst->opcode = 438;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28759 = inst->sreg3;
      inst->sreg2 = D.28759;
      D.28760 = inst->sreg2;
      inst->sreg1 = D.28760;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27371 = tree->data.op[1].const_val;
      inst->data.op[1].const_val = D.27371;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28761>; else goto <D.28762>;
      <D.28761>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28763>;
      <D.28762>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28763>:
    }
    goto <D.26470>;
    <D.26666>:
    D.27371 = tree->data.op[1].const_val;
    if (D.27371 == 32) goto <D.28764>; else goto <D.28765>;
    <D.28764>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28766 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28766;
      inst->prev = 0B;
      D.28767 = inst->prev;
      inst->next = D.28767;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28768 = inst->sreg3;
      inst->sreg2 = D.28768;
      D.28769 = inst->sreg2;
      inst->sreg1 = D.28769;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      D.27379 = tree->sreg1;
      D.27388 = D.27379 + 2;
      inst->sreg1 = D.27388;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28770>; else goto <D.28771>;
      <D.28770>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28772>;
      <D.28771>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28772>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28773 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28773;
      inst->prev = 0B;
      D.28774 = inst->prev;
      inst->next = D.28774;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28775 = inst->sreg3;
      inst->sreg2 = D.28775;
      D.28776 = inst->sreg2;
      inst->sreg1 = D.28776;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      inst->data.op[0].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28777>; else goto <D.28778>;
      <D.28777>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28779>;
      <D.28778>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28779>:
    }
    <D.28765>:
    goto <D.26470>;
    <D.26669>:
    D.27371 = tree->data.op[1].const_val;
    if (D.27371 == 32) goto <D.28780>; else goto <D.28781>;
    <D.28780>:
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28782 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28782;
      inst->prev = 0B;
      D.28783 = inst->prev;
      inst->next = D.28783;
      inst->opcode = 424;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28784 = inst->sreg3;
      inst->sreg2 = D.28784;
      D.28785 = inst->sreg2;
      inst->sreg1 = D.28785;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27370 = D.27360 + 2;
      inst->dreg = D.27370;
      D.27379 = tree->sreg1;
      D.27380 = D.27379 + 1;
      inst->sreg1 = D.27380;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28786>; else goto <D.28787>;
      <D.28786>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28788>;
      <D.28787>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28788>:
    }
    {
      struct MonoInst * inst;

      D.27349 = cfg->mempool;
      inst = mono_mempool_alloc (D.27349, 56);
      inst->data.op[1].const_val = 0;
      D.28789 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28789;
      inst->prev = 0B;
      D.28790 = inst->prev;
      inst->next = D.28790;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28791 = inst->sreg3;
      inst->sreg2 = D.28791;
      D.28792 = inst->sreg2;
      inst->sreg1 = D.28792;
      D.27359 = cfg->ip;
      inst->cil_code = D.27359;
      D.27360 = tree->dreg;
      D.27361 = D.27360 + 1;
      inst->dreg = D.27361;
      inst->data.op[0].const_val = 0;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      if (D.27352 != 0B) goto <D.28793>; else goto <D.28794>;
      <D.28793>:
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      D.27352->next = inst;
      D.27351 = cfg->cbb;
      D.27352 = D.27351->last_ins;
      inst->prev = D.27352;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      goto <D.28795>;
      <D.28794>:
      D.27351 = cfg->cbb;
      D.27351 = cfg->cbb;
      D.27351->last_ins = inst;
      D.27352 = D.27351->last_ins;
      D.27351->code = D.27352;
      <D.28795>:
    }
    <D.28781>:
    goto <D.26470>;
    <D.26672>:
    {
      struct MonoInst * next;

      next = tree->next;
      D.28796 = next == 0B;
      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", "decompose.c", 892, "next");
      <D.28800>:
      D.28801 = next->opcode;
      D.28802 = (int) D.28801;
      switch (D.28802) <default: <D.26725>, case 531: <D.26700>, case 532: <D.26710>, case 533: <D.26711>, case 534: <D.26708>, case 535: <D.26709>, case 551: <D.26674>, case 552: <D.26684>, case 553: <D.26685>, case 554: <D.26686>, case 555: <D.26687>, case 556: <D.26675>, case 557: <D.26688>, case 558: <D.26689>, case 559: <D.26690>, case 560: <D.26691>>
      <D.26674>:
      <D.26675>:
      {
        int d1;
        int d2;

        D.28803 = alloc_ireg (cfg);
        d1 = (int) D.28803;
        D.28804 = alloc_ireg (cfg);
        d2 = (int) D.28804;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.28805 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.28805;
          inst->prev = 0B;
          D.28806 = inst->prev;
          inst->next = D.28806;
          inst->opcode = 574;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.28807 = inst->sreg3;
          inst->sreg2 = D.28807;
          D.28808 = inst->sreg2;
          inst->sreg1 = D.28808;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          D.27379 = tree->sreg1;
          D.27380 = D.27379 + 1;
          inst->sreg1 = D.27380;
          D.28527 = tree->sreg2;
          D.28528 = D.28527 + 1;
          inst->sreg2 = D.28528;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.28809>; else goto <D.28810>;
          <D.28809>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.28811>;
          <D.28810>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.28811>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.28812 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.28812;
          inst->prev = 0B;
          D.28813 = inst->prev;
          inst->next = D.28813;
          inst->opcode = 574;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.28814 = inst->sreg3;
          inst->sreg2 = D.28814;
          D.28815 = inst->sreg2;
          inst->sreg1 = D.28815;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d2;
          D.27379 = tree->sreg1;
          D.27388 = D.27379 + 2;
          inst->sreg1 = D.27388;
          D.28527 = tree->sreg2;
          D.28536 = D.28527 + 2;
          inst->sreg2 = D.28536;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.28816>; else goto <D.28817>;
          <D.28816>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.28818>;
          <D.28817>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.28818>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.28819 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.28819;
          inst->prev = 0B;
          D.28820 = inst->prev;
          inst->next = D.28820;
          inst->opcode = 573;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.28821 = inst->sreg3;
          inst->sreg2 = D.28821;
          D.28822 = inst->sreg2;
          inst->sreg1 = D.28822;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          inst->sreg1 = d1;
          inst->sreg2 = d2;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.28823>; else goto <D.28824>;
          <D.28823>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.28825>;
          <D.28824>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.28825>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.28826 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.28826;
          inst->prev = 0B;
          D.28827 = inst->prev;
          inst->next = D.28827;
          inst->opcode = 327;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.28828 = inst->sreg3;
          inst->sreg2 = D.28828;
          D.28829 = inst->sreg2;
          inst->sreg1 = D.28829;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = d1;
          inst->data.op[1].const_val = 0;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.28830>; else goto <D.28831>;
          <D.28830>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.28832>;
          <D.28831>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.28832>:
        }
        {
          struct MonoInst * ins;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.28833 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.28833;
          ins->prev = 0B;
          D.28834 = ins->prev;
          ins->next = D.28834;
          D.28801 = next->opcode;
          if (D.28801 == 551) goto <D.28836>; else goto <D.28837>;
          <D.28836>:
          iftmp.3 = 648;
          goto <D.28838>;
          <D.28837>:
          iftmp.3 = 653;
          <D.28838>:
          ins->opcode = iftmp.3;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.28839 = ins->sreg3;
          ins->sreg2 = D.28839;
          D.28840 = ins->sreg2;
          ins->sreg1 = D.28840;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          D.27349 = cfg->mempool;
          D.28841 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.28841;
          D.28842 = ins->data.op[1].many_blocks;
          D.28843 = next->data.op[1].many_blocks;
          D.28844 = *D.28843;
          *D.28842 = D.28844;
          D.28842 = ins->data.op[1].many_blocks;
          D.28845 = D.28842 + 4;
          D.28843 = next->data.op[1].many_blocks;
          D.28846 = MEM[(struct MonoBasicBlock * *)D.28843 + 4B];
          *D.28845 = D.28846;
          D.27351 = cfg->cbb;
          D.28843 = next->data.op[1].many_blocks;
          D.28844 = *D.28843;
          mono_link_bblock (cfg, D.27351, D.28844);
          D.27351 = cfg->cbb;
          D.28843 = next->data.op[1].many_blocks;
          D.28847 = D.28843 + 4;
          D.28848 = *D.28847;
          mono_link_bblock (cfg, D.27351, D.28848);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.28849>; else goto <D.28850>;
          <D.28849>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.28851>;
          <D.28850>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.28851>:
        }
        next->opcode = 316;
        goto <D.26683>;
      }
      <D.26684>:
      <D.26685>:
      <D.26686>:
      <D.26687>:
      <D.26688>:
      <D.26689>:
      <D.26690>:
      <D.26691>:
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28852 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28852;
        inst->prev = 0B;
        D.28853 = inst->prev;
        inst->next = D.28853;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28854 = inst->sreg3;
        inst->sreg2 = D.28854;
        D.28855 = inst->sreg2;
        inst->sreg1 = D.28855;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        D.28527 = tree->sreg2;
        D.28536 = D.28527 + 2;
        inst->sreg2 = D.28536;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28856>; else goto <D.28857>;
        <D.28856>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28858>;
        <D.28857>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28858>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.28859 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.28859;
        ins->prev = 0B;
        D.28860 = ins->prev;
        ins->next = D.28860;
        D.28801 = next->opcode;
        D.28802 = (int) D.28801;
        D.28861 = D.28802 + -551;
        D.28862 = lbr_decomp[D.28861][0];
        D.28863 = (short unsigned int) D.28862;
        ins->opcode = D.28863;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.28864 = ins->sreg3;
        ins->sreg2 = D.28864;
        D.28865 = ins->sreg2;
        ins->sreg1 = D.28865;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        D.28801 = next->opcode;
        D.28802 = (int) D.28801;
        D.28861 = D.28802 + -551;
        D.28862 = lbr_decomp[D.28861][0];
        if (D.28862 == 442) goto <D.28866>; else goto <D.28867>;
        <D.28866>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28868 = D.27576;
        D.28869 = D.28868 + 1;
        cfg->num_bblocks = D.28869;
        D.28870 = (int) D.28868;
        falsebb->block_num = D.28870;
        D.28843 = next->data.op[1].many_blocks;
        D.28844 = *D.28843;
        ins->data.op[0].target_block = D.28844;
        D.27351 = cfg->cbb;
        D.28843 = next->data.op[1].many_blocks;
        D.28844 = *D.28843;
        mono_link_bblock (cfg, D.27351, D.28844);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28871>; else goto <D.28872>;
        <D.28871>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28873>;
        <D.28872>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28873>:
        D.28874 = falsebb->cil_code;
        if (D.28874 != 0B) goto <D.28875>; else goto <D.28876>;
        <D.28875>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28874 = falsebb->cil_code;
        D.28877 = (int) D.28874;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28878 = D.28877 - D.27636;
        D.28879 = (unsigned int) D.28878;
        D.28880 = D.28879 * 4;
        D.28881 = D.27633 + D.28880;
        *D.28881 = falsebb;
        <D.28876>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28885>; else goto <D.28882>;
        <D.28885>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28886 = D.27352->opcode;
        D.28887 = D.28886 + 64985;
        D.28888 = D.28887 <= 9;
        D.28889 = D.28886 + 64878;
        D.28890 = D.28889 <= 9;
        D.28891 = D.28888 | D.28890;
        if (D.28891 != 0) goto <D.28883>; else goto <D.28892>;
        <D.28892>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28883>; else goto <D.28882>;
        <D.28883>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28893>; else goto <D.28882>;
        <D.28893>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28884>;
        <D.28882>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28894>; else goto <D.28896>;
        <D.28896>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28897 = D.27352->opcode;
        D.28898 = D.28897 != 442;
        D.28899 = D.28897 != 759;
        D.28900 = D.28898 & D.28899;
        if (D.28900 != 0) goto <D.28901>; else goto <D.28895>;
        <D.28901>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28902 = D.27352->opcode;
        D.28903 = D.28902 + 64985;
        D.28904 = D.28903 > 9;
        D.28905 = D.28902 + 64878;
        D.28906 = D.28905 > 9;
        D.28907 = D.28904 & D.28906;
        if (D.28907 != 0) goto <D.28908>; else goto <D.28895>;
        <D.28908>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28894>; else goto <D.28895>;
        <D.28894>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28895>:
        <D.28884>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.28909>;
        <D.28867>:
        D.27349 = cfg->mempool;
        D.28910 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.28910;
        D.28911 = ins->data.op[1].many_blocks;
        D.28843 = next->data.op[1].many_blocks;
        D.28844 = *D.28843;
        *D.28911 = D.28844;
        D.28911 = ins->data.op[1].many_blocks;
        D.28912 = D.28911 + 4;
        *D.28912 = 0B;
        D.27351 = cfg->cbb;
        D.28843 = next->data.op[1].many_blocks;
        D.28844 = *D.28843;
        mono_link_bblock (cfg, D.27351, D.28844);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28913>; else goto <D.28914>;
        <D.28913>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28915>;
        <D.28914>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28915>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.28916>; else goto <D.28917>;
        <D.28916>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28918 = D.27576;
        D.28919 = D.28918 + 1;
        cfg->num_bblocks = D.28919;
        D.28920 = (int) D.28918;
        falsebb->block_num = D.28920;
        D.28911 = ins->data.op[1].many_blocks;
        D.28912 = D.28911 + 4;
        *D.28912 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.28874 = falsebb->cil_code;
        if (D.28874 != 0B) goto <D.28921>; else goto <D.28922>;
        <D.28921>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28874 = falsebb->cil_code;
        D.28877 = (int) D.28874;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28878 = D.28877 - D.27636;
        D.28879 = (unsigned int) D.28878;
        D.28880 = D.28879 * 4;
        D.28881 = D.27633 + D.28880;
        *D.28881 = falsebb;
        <D.28922>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28926>; else goto <D.28923>;
        <D.28926>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28927 = D.27352->opcode;
        D.28928 = D.28927 + 64985;
        D.28929 = D.28928 <= 9;
        D.28930 = D.28927 + 64878;
        D.28931 = D.28930 <= 9;
        D.28932 = D.28929 | D.28931;
        if (D.28932 != 0) goto <D.28924>; else goto <D.28933>;
        <D.28933>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28924>; else goto <D.28923>;
        <D.28924>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28934>; else goto <D.28923>;
        <D.28934>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28925>;
        <D.28923>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28935>; else goto <D.28937>;
        <D.28937>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28938 = D.27352->opcode;
        D.28939 = D.28938 != 442;
        D.28940 = D.28938 != 759;
        D.28941 = D.28939 & D.28940;
        if (D.28941 != 0) goto <D.28942>; else goto <D.28936>;
        <D.28942>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28943 = D.27352->opcode;
        D.28944 = D.28943 + 64985;
        D.28945 = D.28944 > 9;
        D.28946 = D.28943 + 64878;
        D.28947 = D.28946 > 9;
        D.28948 = D.28945 & D.28947;
        if (D.28948 != 0) goto <D.28949>; else goto <D.28936>;
        <D.28949>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28935>; else goto <D.28936>;
        <D.28935>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28936>:
        <D.28925>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.28950>;
        <D.28917>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.28950>:
        <D.28909>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.28951 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28951;
        inst->prev = 0B;
        D.28952 = inst->prev;
        inst->next = D.28952;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28953 = inst->sreg3;
        inst->sreg2 = D.28953;
        D.28954 = inst->sreg2;
        inst->sreg1 = D.28954;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27388 = D.27379 + 2;
        inst->sreg1 = D.27388;
        D.28527 = tree->sreg2;
        D.28536 = D.28527 + 2;
        inst->sreg2 = D.28536;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28955>; else goto <D.28956>;
        <D.28955>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.28957>;
        <D.28956>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28957>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.28958 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.28958;
        ins->prev = 0B;
        D.28959 = ins->prev;
        ins->next = D.28959;
        ins->opcode = 653;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.28960 = ins->sreg3;
        ins->sreg2 = D.28960;
        D.28961 = ins->sreg2;
        ins->sreg1 = D.28961;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        if (0 != 0) goto <D.28962>; else goto <D.28963>;
        <D.28962>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.28964 = D.27576;
        D.28965 = D.28964 + 1;
        cfg->num_bblocks = D.28965;
        D.28966 = (int) D.28964;
        falsebb->block_num = D.28966;
        D.28843 = next->data.op[1].many_blocks;
        D.28846 = MEM[(struct MonoBasicBlock * *)D.28843 + 4B];
        ins->data.op[0].target_block = D.28846;
        D.27351 = cfg->cbb;
        D.28843 = next->data.op[1].many_blocks;
        D.28847 = D.28843 + 4;
        D.28848 = *D.28847;
        mono_link_bblock (cfg, D.27351, D.28848);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28967>; else goto <D.28968>;
        <D.28967>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.28969>;
        <D.28968>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.28969>:
        D.28970 = falsebb->cil_code;
        if (D.28970 != 0B) goto <D.28971>; else goto <D.28972>;
        <D.28971>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28970 = falsebb->cil_code;
        D.28973 = (int) D.28970;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28974 = D.28973 - D.27636;
        D.28975 = (unsigned int) D.28974;
        D.28976 = D.28975 * 4;
        D.28977 = D.27633 + D.28976;
        *D.28977 = falsebb;
        <D.28972>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.28981>; else goto <D.28978>;
        <D.28981>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28982 = D.27352->opcode;
        D.28983 = D.28982 + 64985;
        D.28984 = D.28983 <= 9;
        D.28985 = D.28982 + 64878;
        D.28986 = D.28985 <= 9;
        D.28987 = D.28984 | D.28986;
        if (D.28987 != 0) goto <D.28979>; else goto <D.28988>;
        <D.28988>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.28979>; else goto <D.28978>;
        <D.28979>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.28989>; else goto <D.28978>;
        <D.28989>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.28980>;
        <D.28978>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.28990>; else goto <D.28992>;
        <D.28992>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28993 = D.27352->opcode;
        D.28994 = D.28993 != 442;
        D.28995 = D.28993 != 759;
        D.28996 = D.28994 & D.28995;
        if (D.28996 != 0) goto <D.28997>; else goto <D.28991>;
        <D.28997>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.28998 = D.27352->opcode;
        D.28999 = D.28998 + 64985;
        D.29000 = D.28999 > 9;
        D.29001 = D.28998 + 64878;
        D.29002 = D.29001 > 9;
        D.29003 = D.29000 & D.29002;
        if (D.29003 != 0) goto <D.29004>; else goto <D.28991>;
        <D.29004>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.28990>; else goto <D.28991>;
        <D.28990>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.28991>:
        <D.28980>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.29005>;
        <D.28963>:
        D.27349 = cfg->mempool;
        D.29006 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.29006;
        D.29007 = ins->data.op[1].many_blocks;
        D.28843 = next->data.op[1].many_blocks;
        D.28846 = MEM[(struct MonoBasicBlock * *)D.28843 + 4B];
        *D.29007 = D.28846;
        D.29007 = ins->data.op[1].many_blocks;
        D.29008 = D.29007 + 4;
        *D.29008 = 0B;
        D.27351 = cfg->cbb;
        D.28843 = next->data.op[1].many_blocks;
        D.28847 = D.28843 + 4;
        D.28848 = *D.28847;
        mono_link_bblock (cfg, D.27351, D.28848);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29009>; else goto <D.29010>;
        <D.29009>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29011>;
        <D.29010>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29011>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.29012>; else goto <D.29013>;
        <D.29012>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29014 = D.27576;
        D.29015 = D.29014 + 1;
        cfg->num_bblocks = D.29015;
        D.29016 = (int) D.29014;
        falsebb->block_num = D.29016;
        D.29007 = ins->data.op[1].many_blocks;
        D.29008 = D.29007 + 4;
        *D.29008 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.28970 = falsebb->cil_code;
        if (D.28970 != 0B) goto <D.29017>; else goto <D.29018>;
        <D.29017>:
        D.27633 = cfg->cil_offset_to_bb;
        D.28970 = falsebb->cil_code;
        D.28973 = (int) D.28970;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.28974 = D.28973 - D.27636;
        D.28975 = (unsigned int) D.28974;
        D.28976 = D.28975 * 4;
        D.28977 = D.27633 + D.28976;
        *D.28977 = falsebb;
        <D.29018>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29022>; else goto <D.29019>;
        <D.29022>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29023 = D.27352->opcode;
        D.29024 = D.29023 + 64985;
        D.29025 = D.29024 <= 9;
        D.29026 = D.29023 + 64878;
        D.29027 = D.29026 <= 9;
        D.29028 = D.29025 | D.29027;
        if (D.29028 != 0) goto <D.29020>; else goto <D.29029>;
        <D.29029>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29020>; else goto <D.29019>;
        <D.29020>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29030>; else goto <D.29019>;
        <D.29030>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.29021>;
        <D.29019>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29031>; else goto <D.29033>;
        <D.29033>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29034 = D.27352->opcode;
        D.29035 = D.29034 != 442;
        D.29036 = D.29034 != 759;
        D.29037 = D.29035 & D.29036;
        if (D.29037 != 0) goto <D.29038>; else goto <D.29032>;
        <D.29038>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29039 = D.27352->opcode;
        D.29040 = D.29039 + 64985;
        D.29041 = D.29040 > 9;
        D.29042 = D.29039 + 64878;
        D.29043 = D.29042 > 9;
        D.29044 = D.29041 & D.29043;
        if (D.29044 != 0) goto <D.29045>; else goto <D.29032>;
        <D.29045>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29031>; else goto <D.29032>;
        <D.29031>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.29032>:
        <D.29021>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.29046>;
        <D.29013>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.29046>:
        <D.29005>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.29047 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29047;
        inst->prev = 0B;
        D.29048 = inst->prev;
        inst->next = D.29048;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29049 = inst->sreg3;
        inst->sreg2 = D.29049;
        D.29050 = inst->sreg2;
        inst->sreg1 = D.29050;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        D.27379 = tree->sreg1;
        D.27380 = D.27379 + 1;
        inst->sreg1 = D.27380;
        D.28527 = tree->sreg2;
        D.28528 = D.28527 + 1;
        inst->sreg2 = D.28528;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29051>; else goto <D.29052>;
        <D.29051>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.29053>;
        <D.29052>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29053>:
      }
      {
        struct MonoInst * ins;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.29054 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29054;
        ins->prev = 0B;
        D.29055 = ins->prev;
        ins->next = D.29055;
        D.28801 = next->opcode;
        D.28802 = (int) D.28801;
        D.28861 = D.28802 + -551;
        D.29056 = lbr_decomp[D.28861][1];
        D.29057 = (short unsigned int) D.29056;
        ins->opcode = D.29057;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29058 = ins->sreg3;
        ins->sreg2 = D.29058;
        D.29059 = ins->sreg2;
        ins->sreg1 = D.29059;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        D.27349 = cfg->mempool;
        D.29060 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.29060;
        D.29061 = ins->data.op[1].many_blocks;
        D.28843 = next->data.op[1].many_blocks;
        D.28844 = *D.28843;
        *D.29061 = D.28844;
        D.29061 = ins->data.op[1].many_blocks;
        D.29062 = D.29061 + 4;
        D.28843 = next->data.op[1].many_blocks;
        D.28846 = MEM[(struct MonoBasicBlock * *)D.28843 + 4B];
        *D.29062 = D.28846;
        D.27351 = cfg->cbb;
        D.28843 = next->data.op[1].many_blocks;
        D.28844 = *D.28843;
        mono_link_bblock (cfg, D.27351, D.28844);
        D.27351 = cfg->cbb;
        D.28843 = next->data.op[1].many_blocks;
        D.28847 = D.28843 + 4;
        D.28848 = *D.28847;
        mono_link_bblock (cfg, D.27351, D.28848);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29063>; else goto <D.29064>;
        <D.29063>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29065>;
        <D.29064>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29065>:
      }
      next->opcode = 316;
      goto <D.26683>;
      <D.26700>:
      {
        int d1;
        int d2;

        D.29066 = alloc_ireg (cfg);
        d1 = (int) D.29066;
        D.29067 = alloc_ireg (cfg);
        d2 = (int) D.29067;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29068 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29068;
          inst->prev = 0B;
          D.29069 = inst->prev;
          inst->next = D.29069;
          inst->opcode = 574;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29070 = inst->sreg3;
          inst->sreg2 = D.29070;
          D.29071 = inst->sreg2;
          inst->sreg1 = D.29071;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          D.27379 = tree->sreg1;
          D.27380 = D.27379 + 1;
          inst->sreg1 = D.27380;
          D.28527 = tree->sreg2;
          D.28528 = D.28527 + 1;
          inst->sreg2 = D.28528;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29072>; else goto <D.29073>;
          <D.29072>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29074>;
          <D.29073>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29074>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29075 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29075;
          inst->prev = 0B;
          D.29076 = inst->prev;
          inst->next = D.29076;
          inst->opcode = 574;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29077 = inst->sreg3;
          inst->sreg2 = D.29077;
          D.29078 = inst->sreg2;
          inst->sreg1 = D.29078;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d2;
          D.27379 = tree->sreg1;
          D.27388 = D.27379 + 2;
          inst->sreg1 = D.27388;
          D.28527 = tree->sreg2;
          D.28536 = D.28527 + 2;
          inst->sreg2 = D.28536;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29079>; else goto <D.29080>;
          <D.29079>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29081>;
          <D.29080>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29081>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29082 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29082;
          inst->prev = 0B;
          D.29083 = inst->prev;
          inst->next = D.29083;
          inst->opcode = 573;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29084 = inst->sreg3;
          inst->sreg2 = D.29084;
          D.29085 = inst->sreg2;
          inst->sreg1 = D.29085;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          inst->sreg1 = d1;
          inst->sreg2 = d2;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29086>; else goto <D.29087>;
          <D.29086>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29088>;
          <D.29087>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29088>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29089 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29089;
          inst->prev = 0B;
          D.29090 = inst->prev;
          inst->next = D.29090;
          inst->opcode = 327;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29091 = inst->sreg3;
          inst->sreg2 = D.29091;
          D.29092 = inst->sreg2;
          inst->sreg1 = D.29092;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = d1;
          inst->data.op[1].const_val = 0;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29093>; else goto <D.29094>;
          <D.29093>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29095>;
          <D.29094>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29095>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29096 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29096;
          inst->prev = 0B;
          D.29097 = inst->prev;
          inst->next = D.29097;
          inst->opcode = 638;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29098 = inst->sreg3;
          inst->sreg2 = D.29098;
          D.29099 = inst->sreg2;
          inst->sreg1 = D.29099;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          D.29100 = next->dreg;
          inst->dreg = D.29100;
          inst->sreg1 = -1;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29101>; else goto <D.29102>;
          <D.29101>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29103>;
          <D.29102>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29103>:
        }
        next->opcode = 316;
        goto <D.26683>;
      }
      <D.26708>:
      <D.26709>:
      <D.26710>:
      <D.26711>:
      {
        struct MonoBasicBlock * set_to_0;
        struct MonoBasicBlock * set_to_1;

        D.27349 = cfg->mempool;
        set_to_0 = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29104 = D.27576;
        D.29105 = D.29104 + 1;
        cfg->num_bblocks = D.29105;
        D.29106 = (int) D.29104;
        set_to_0->block_num = D.29106;
        D.27349 = cfg->mempool;
        set_to_1 = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29107 = D.27576;
        D.29108 = D.29107 + 1;
        cfg->num_bblocks = D.29108;
        D.29109 = (int) D.29107;
        set_to_1->block_num = D.29109;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29110 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29110;
          inst->prev = 0B;
          D.29111 = inst->prev;
          inst->next = D.29111;
          inst->opcode = 362;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29112 = inst->sreg3;
          inst->sreg2 = D.29112;
          D.29113 = inst->sreg2;
          inst->sreg1 = D.29113;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          D.29100 = next->dreg;
          inst->dreg = D.29100;
          inst->data.op[0].const_val = 0;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29114>; else goto <D.29115>;
          <D.29114>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29116>;
          <D.29115>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29116>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29117 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29117;
          inst->prev = 0B;
          D.29118 = inst->prev;
          inst->next = D.29118;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29119 = inst->sreg3;
          inst->sreg2 = D.29119;
          D.29120 = inst->sreg2;
          inst->sreg1 = D.29120;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          D.27379 = tree->sreg1;
          D.27388 = D.27379 + 2;
          inst->sreg1 = D.27388;
          D.28527 = tree->sreg2;
          D.28536 = D.28527 + 2;
          inst->sreg2 = D.28536;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29121>; else goto <D.29122>;
          <D.29121>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29123>;
          <D.29122>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29123>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.29124 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.29124;
          ins->prev = 0B;
          D.29125 = ins->prev;
          ins->next = D.29125;
          D.28801 = next->opcode;
          D.28802 = (int) D.28801;
          D.29126 = D.28802 + -531;
          D.29127 = lcset_decomp[D.29126][0];
          D.29128 = (short unsigned int) D.29127;
          ins->opcode = D.29128;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.29129 = ins->sreg3;
          ins->sreg2 = D.29129;
          D.29130 = ins->sreg2;
          ins->sreg1 = D.29130;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          D.28801 = next->opcode;
          D.28802 = (int) D.28801;
          D.29126 = D.28802 + -531;
          D.29127 = lcset_decomp[D.29126][0];
          if (D.29127 == 442) goto <D.29131>; else goto <D.29132>;
          <D.29131>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29133 = D.27576;
          D.29134 = D.29133 + 1;
          cfg->num_bblocks = D.29134;
          D.29135 = (int) D.29133;
          falsebb->block_num = D.29135;
          ins->data.op[0].target_block = set_to_0;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29136>; else goto <D.29137>;
          <D.29136>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29138>;
          <D.29137>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29138>:
          D.29139 = falsebb->cil_code;
          if (D.29139 != 0B) goto <D.29140>; else goto <D.29141>;
          <D.29140>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29139 = falsebb->cil_code;
          D.29142 = (int) D.29139;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29143 = D.29142 - D.27636;
          D.29144 = (unsigned int) D.29143;
          D.29145 = D.29144 * 4;
          D.29146 = D.27633 + D.29145;
          *D.29146 = falsebb;
          <D.29141>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29150>; else goto <D.29147>;
          <D.29150>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29151 = D.27352->opcode;
          D.29152 = D.29151 + 64985;
          D.29153 = D.29152 <= 9;
          D.29154 = D.29151 + 64878;
          D.29155 = D.29154 <= 9;
          D.29156 = D.29153 | D.29155;
          if (D.29156 != 0) goto <D.29148>; else goto <D.29157>;
          <D.29157>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29148>; else goto <D.29147>;
          <D.29148>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29158>; else goto <D.29147>;
          <D.29158>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29149>;
          <D.29147>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29159>; else goto <D.29161>;
          <D.29161>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29162 = D.27352->opcode;
          D.29163 = D.29162 != 442;
          D.29164 = D.29162 != 759;
          D.29165 = D.29163 & D.29164;
          if (D.29165 != 0) goto <D.29166>; else goto <D.29160>;
          <D.29166>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29167 = D.27352->opcode;
          D.29168 = D.29167 + 64985;
          D.29169 = D.29168 > 9;
          D.29170 = D.29167 + 64878;
          D.29171 = D.29170 > 9;
          D.29172 = D.29169 & D.29171;
          if (D.29172 != 0) goto <D.29173>; else goto <D.29160>;
          <D.29173>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29159>; else goto <D.29160>;
          <D.29159>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29160>:
          <D.29149>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29174>;
          <D.29132>:
          D.27349 = cfg->mempool;
          D.29175 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.29175;
          D.29176 = ins->data.op[1].many_blocks;
          *D.29176 = set_to_0;
          D.29176 = ins->data.op[1].many_blocks;
          D.29177 = D.29176 + 4;
          *D.29177 = 0B;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29178>; else goto <D.29179>;
          <D.29178>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29180>;
          <D.29179>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29180>:
          D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.27682 = D.27681 & 8;
          if (D.27682 == 0) goto <D.29181>; else goto <D.29182>;
          <D.29181>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29183 = D.27576;
          D.29184 = D.29183 + 1;
          cfg->num_bblocks = D.29184;
          D.29185 = (int) D.29183;
          falsebb->block_num = D.29185;
          D.29176 = ins->data.op[1].many_blocks;
          D.29177 = D.29176 + 4;
          *D.29177 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          D.29139 = falsebb->cil_code;
          if (D.29139 != 0B) goto <D.29186>; else goto <D.29187>;
          <D.29186>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29139 = falsebb->cil_code;
          D.29142 = (int) D.29139;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29143 = D.29142 - D.27636;
          D.29144 = (unsigned int) D.29143;
          D.29145 = D.29144 * 4;
          D.29146 = D.27633 + D.29145;
          *D.29146 = falsebb;
          <D.29187>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29191>; else goto <D.29188>;
          <D.29191>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29192 = D.27352->opcode;
          D.29193 = D.29192 + 64985;
          D.29194 = D.29193 <= 9;
          D.29195 = D.29192 + 64878;
          D.29196 = D.29195 <= 9;
          D.29197 = D.29194 | D.29196;
          if (D.29197 != 0) goto <D.29189>; else goto <D.29198>;
          <D.29198>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29189>; else goto <D.29188>;
          <D.29189>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29199>; else goto <D.29188>;
          <D.29199>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29190>;
          <D.29188>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29200>; else goto <D.29202>;
          <D.29202>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29203 = D.27352->opcode;
          D.29204 = D.29203 != 442;
          D.29205 = D.29203 != 759;
          D.29206 = D.29204 & D.29205;
          if (D.29206 != 0) goto <D.29207>; else goto <D.29201>;
          <D.29207>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29208 = D.27352->opcode;
          D.29209 = D.29208 + 64985;
          D.29210 = D.29209 > 9;
          D.29211 = D.29208 + 64878;
          D.29212 = D.29211 > 9;
          D.29213 = D.29210 & D.29212;
          if (D.29213 != 0) goto <D.29214>; else goto <D.29201>;
          <D.29214>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29200>; else goto <D.29201>;
          <D.29200>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29201>:
          <D.29190>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29215>;
          <D.29182>:
          D.27351 = cfg->cbb;
          D.27351->extended = 1;
          <D.29215>:
          <D.29174>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29216 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29216;
          inst->prev = 0B;
          D.29217 = inst->prev;
          inst->next = D.29217;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29218 = inst->sreg3;
          inst->sreg2 = D.29218;
          D.29219 = inst->sreg2;
          inst->sreg1 = D.29219;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          D.27379 = tree->sreg1;
          D.27388 = D.27379 + 2;
          inst->sreg1 = D.27388;
          D.28527 = tree->sreg2;
          D.28536 = D.28527 + 2;
          inst->sreg2 = D.28536;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29220>; else goto <D.29221>;
          <D.29220>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29222>;
          <D.29221>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29222>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.29223 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.29223;
          ins->prev = 0B;
          D.29224 = ins->prev;
          ins->next = D.29224;
          ins->opcode = 653;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.29225 = ins->sreg3;
          ins->sreg2 = D.29225;
          D.29226 = ins->sreg2;
          ins->sreg1 = D.29226;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          if (0 != 0) goto <D.29227>; else goto <D.29228>;
          <D.29227>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29229 = D.27576;
          D.29230 = D.29229 + 1;
          cfg->num_bblocks = D.29230;
          D.29231 = (int) D.29229;
          falsebb->block_num = D.29231;
          ins->data.op[0].target_block = set_to_1;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_1);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29232>; else goto <D.29233>;
          <D.29232>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29234>;
          <D.29233>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29234>:
          D.29235 = falsebb->cil_code;
          if (D.29235 != 0B) goto <D.29236>; else goto <D.29237>;
          <D.29236>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29235 = falsebb->cil_code;
          D.29238 = (int) D.29235;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29239 = D.29238 - D.27636;
          D.29240 = (unsigned int) D.29239;
          D.29241 = D.29240 * 4;
          D.29242 = D.27633 + D.29241;
          *D.29242 = falsebb;
          <D.29237>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29246>; else goto <D.29243>;
          <D.29246>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29247 = D.27352->opcode;
          D.29248 = D.29247 + 64985;
          D.29249 = D.29248 <= 9;
          D.29250 = D.29247 + 64878;
          D.29251 = D.29250 <= 9;
          D.29252 = D.29249 | D.29251;
          if (D.29252 != 0) goto <D.29244>; else goto <D.29253>;
          <D.29253>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29244>; else goto <D.29243>;
          <D.29244>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29254>; else goto <D.29243>;
          <D.29254>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29245>;
          <D.29243>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29255>; else goto <D.29257>;
          <D.29257>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29258 = D.27352->opcode;
          D.29259 = D.29258 != 442;
          D.29260 = D.29258 != 759;
          D.29261 = D.29259 & D.29260;
          if (D.29261 != 0) goto <D.29262>; else goto <D.29256>;
          <D.29262>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29263 = D.27352->opcode;
          D.29264 = D.29263 + 64985;
          D.29265 = D.29264 > 9;
          D.29266 = D.29263 + 64878;
          D.29267 = D.29266 > 9;
          D.29268 = D.29265 & D.29267;
          if (D.29268 != 0) goto <D.29269>; else goto <D.29256>;
          <D.29269>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29255>; else goto <D.29256>;
          <D.29255>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29256>:
          <D.29245>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29270>;
          <D.29228>:
          D.27349 = cfg->mempool;
          D.29271 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.29271;
          D.29272 = ins->data.op[1].many_blocks;
          *D.29272 = set_to_1;
          D.29272 = ins->data.op[1].many_blocks;
          D.29273 = D.29272 + 4;
          *D.29273 = 0B;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_1);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29274>; else goto <D.29275>;
          <D.29274>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29276>;
          <D.29275>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29276>:
          D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.27682 = D.27681 & 8;
          if (D.27682 == 0) goto <D.29277>; else goto <D.29278>;
          <D.29277>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29279 = D.27576;
          D.29280 = D.29279 + 1;
          cfg->num_bblocks = D.29280;
          D.29281 = (int) D.29279;
          falsebb->block_num = D.29281;
          D.29272 = ins->data.op[1].many_blocks;
          D.29273 = D.29272 + 4;
          *D.29273 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          D.29235 = falsebb->cil_code;
          if (D.29235 != 0B) goto <D.29282>; else goto <D.29283>;
          <D.29282>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29235 = falsebb->cil_code;
          D.29238 = (int) D.29235;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29239 = D.29238 - D.27636;
          D.29240 = (unsigned int) D.29239;
          D.29241 = D.29240 * 4;
          D.29242 = D.27633 + D.29241;
          *D.29242 = falsebb;
          <D.29283>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29287>; else goto <D.29284>;
          <D.29287>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29288 = D.27352->opcode;
          D.29289 = D.29288 + 64985;
          D.29290 = D.29289 <= 9;
          D.29291 = D.29288 + 64878;
          D.29292 = D.29291 <= 9;
          D.29293 = D.29290 | D.29292;
          if (D.29293 != 0) goto <D.29285>; else goto <D.29294>;
          <D.29294>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29285>; else goto <D.29284>;
          <D.29285>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29295>; else goto <D.29284>;
          <D.29295>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29286>;
          <D.29284>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29296>; else goto <D.29298>;
          <D.29298>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29299 = D.27352->opcode;
          D.29300 = D.29299 != 442;
          D.29301 = D.29299 != 759;
          D.29302 = D.29300 & D.29301;
          if (D.29302 != 0) goto <D.29303>; else goto <D.29297>;
          <D.29303>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29304 = D.27352->opcode;
          D.29305 = D.29304 + 64985;
          D.29306 = D.29305 > 9;
          D.29307 = D.29304 + 64878;
          D.29308 = D.29307 > 9;
          D.29309 = D.29306 & D.29308;
          if (D.29309 != 0) goto <D.29310>; else goto <D.29297>;
          <D.29310>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29296>; else goto <D.29297>;
          <D.29296>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29297>:
          <D.29286>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29311>;
          <D.29278>:
          D.27351 = cfg->cbb;
          D.27351->extended = 1;
          <D.29311>:
          <D.29270>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29312 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29312;
          inst->prev = 0B;
          D.29313 = inst->prev;
          inst->next = D.29313;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29314 = inst->sreg3;
          inst->sreg2 = D.29314;
          D.29315 = inst->sreg2;
          inst->sreg1 = D.29315;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          D.27379 = tree->sreg1;
          D.27380 = D.27379 + 1;
          inst->sreg1 = D.27380;
          D.28527 = tree->sreg2;
          D.28528 = D.28527 + 1;
          inst->sreg2 = D.28528;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29316>; else goto <D.29317>;
          <D.29316>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29318>;
          <D.29317>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29318>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.29319 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.29319;
          ins->prev = 0B;
          D.29320 = ins->prev;
          ins->next = D.29320;
          D.28801 = next->opcode;
          D.28802 = (int) D.28801;
          D.29126 = D.28802 + -531;
          D.29321 = lcset_decomp[D.29126][1];
          D.29322 = (short unsigned int) D.29321;
          ins->opcode = D.29322;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.29323 = ins->sreg3;
          ins->sreg2 = D.29323;
          D.29324 = ins->sreg2;
          ins->sreg1 = D.29324;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          D.28801 = next->opcode;
          D.28802 = (int) D.28801;
          D.29126 = D.28802 + -531;
          D.29321 = lcset_decomp[D.29126][1];
          if (D.29321 == 442) goto <D.29325>; else goto <D.29326>;
          <D.29325>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29327 = D.27576;
          D.29328 = D.29327 + 1;
          cfg->num_bblocks = D.29328;
          D.29329 = (int) D.29327;
          falsebb->block_num = D.29329;
          ins->data.op[0].target_block = set_to_0;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29330>; else goto <D.29331>;
          <D.29330>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29332>;
          <D.29331>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29332>:
          D.29333 = falsebb->cil_code;
          if (D.29333 != 0B) goto <D.29334>; else goto <D.29335>;
          <D.29334>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29333 = falsebb->cil_code;
          D.29336 = (int) D.29333;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29337 = D.29336 - D.27636;
          D.29338 = (unsigned int) D.29337;
          D.29339 = D.29338 * 4;
          D.29340 = D.27633 + D.29339;
          *D.29340 = falsebb;
          <D.29335>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29344>; else goto <D.29341>;
          <D.29344>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29345 = D.27352->opcode;
          D.29346 = D.29345 + 64985;
          D.29347 = D.29346 <= 9;
          D.29348 = D.29345 + 64878;
          D.29349 = D.29348 <= 9;
          D.29350 = D.29347 | D.29349;
          if (D.29350 != 0) goto <D.29342>; else goto <D.29351>;
          <D.29351>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29342>; else goto <D.29341>;
          <D.29342>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29352>; else goto <D.29341>;
          <D.29352>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29343>;
          <D.29341>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29353>; else goto <D.29355>;
          <D.29355>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29356 = D.27352->opcode;
          D.29357 = D.29356 != 442;
          D.29358 = D.29356 != 759;
          D.29359 = D.29357 & D.29358;
          if (D.29359 != 0) goto <D.29360>; else goto <D.29354>;
          <D.29360>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29361 = D.27352->opcode;
          D.29362 = D.29361 + 64985;
          D.29363 = D.29362 > 9;
          D.29364 = D.29361 + 64878;
          D.29365 = D.29364 > 9;
          D.29366 = D.29363 & D.29365;
          if (D.29366 != 0) goto <D.29367>; else goto <D.29354>;
          <D.29367>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29353>; else goto <D.29354>;
          <D.29353>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29354>:
          <D.29343>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29368>;
          <D.29326>:
          D.27349 = cfg->mempool;
          D.29369 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.29369;
          D.29370 = ins->data.op[1].many_blocks;
          *D.29370 = set_to_0;
          D.29370 = ins->data.op[1].many_blocks;
          D.29371 = D.29370 + 4;
          *D.29371 = 0B;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29372>; else goto <D.29373>;
          <D.29372>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29374>;
          <D.29373>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29374>:
          D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.27682 = D.27681 & 8;
          if (D.27682 == 0) goto <D.29375>; else goto <D.29376>;
          <D.29375>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29377 = D.27576;
          D.29378 = D.29377 + 1;
          cfg->num_bblocks = D.29378;
          D.29379 = (int) D.29377;
          falsebb->block_num = D.29379;
          D.29370 = ins->data.op[1].many_blocks;
          D.29371 = D.29370 + 4;
          *D.29371 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          D.29333 = falsebb->cil_code;
          if (D.29333 != 0B) goto <D.29380>; else goto <D.29381>;
          <D.29380>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29333 = falsebb->cil_code;
          D.29336 = (int) D.29333;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29337 = D.29336 - D.27636;
          D.29338 = (unsigned int) D.29337;
          D.29339 = D.29338 * 4;
          D.29340 = D.27633 + D.29339;
          *D.29340 = falsebb;
          <D.29381>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29385>; else goto <D.29382>;
          <D.29385>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29386 = D.27352->opcode;
          D.29387 = D.29386 + 64985;
          D.29388 = D.29387 <= 9;
          D.29389 = D.29386 + 64878;
          D.29390 = D.29389 <= 9;
          D.29391 = D.29388 | D.29390;
          if (D.29391 != 0) goto <D.29383>; else goto <D.29392>;
          <D.29392>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29383>; else goto <D.29382>;
          <D.29383>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29393>; else goto <D.29382>;
          <D.29393>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29384>;
          <D.29382>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29394>; else goto <D.29396>;
          <D.29396>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29397 = D.27352->opcode;
          D.29398 = D.29397 != 442;
          D.29399 = D.29397 != 759;
          D.29400 = D.29398 & D.29399;
          if (D.29400 != 0) goto <D.29401>; else goto <D.29395>;
          <D.29401>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29402 = D.27352->opcode;
          D.29403 = D.29402 + 64985;
          D.29404 = D.29403 > 9;
          D.29405 = D.29402 + 64878;
          D.29406 = D.29405 > 9;
          D.29407 = D.29404 & D.29406;
          if (D.29407 != 0) goto <D.29408>; else goto <D.29395>;
          <D.29408>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29394>; else goto <D.29395>;
          <D.29394>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29395>:
          <D.29384>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29409>;
          <D.29376>:
          D.27351 = cfg->cbb;
          D.27351->extended = 1;
          <D.29409>:
          <D.29368>:
        }
        D.29410 = set_to_1->cil_code;
        if (D.29410 != 0B) goto <D.29411>; else goto <D.29412>;
        <D.29411>:
        D.27633 = cfg->cil_offset_to_bb;
        D.29410 = set_to_1->cil_code;
        D.29413 = (int) D.29410;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.29414 = D.29413 - D.27636;
        D.29415 = (unsigned int) D.29414;
        D.29416 = D.29415 * 4;
        D.29417 = D.27633 + D.29416;
        *D.29417 = set_to_1;
        <D.29412>:
        D.27641 = cfg->real_offset;
        set_to_1->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29421>; else goto <D.29418>;
        <D.29421>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29422 = D.27352->opcode;
        D.29423 = D.29422 + 64985;
        D.29424 = D.29423 <= 9;
        D.29425 = D.29422 + 64878;
        D.29426 = D.29425 <= 9;
        D.29427 = D.29424 | D.29426;
        if (D.29427 != 0) goto <D.29419>; else goto <D.29428>;
        <D.29428>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29419>; else goto <D.29418>;
        <D.29419>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29429>; else goto <D.29418>;
        <D.29429>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = set_to_1;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_1);
        goto <D.29420>;
        <D.29418>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29430>; else goto <D.29432>;
        <D.29432>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29433 = D.27352->opcode;
        D.29434 = D.29433 != 442;
        D.29435 = D.29433 != 759;
        D.29436 = D.29434 & D.29435;
        if (D.29436 != 0) goto <D.29437>; else goto <D.29431>;
        <D.29437>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29438 = D.27352->opcode;
        D.29439 = D.29438 + 64985;
        D.29440 = D.29439 > 9;
        D.29441 = D.29438 + 64878;
        D.29442 = D.29441 > 9;
        D.29443 = D.29440 & D.29442;
        if (D.29443 != 0) goto <D.29444>; else goto <D.29431>;
        <D.29444>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29430>; else goto <D.29431>;
        <D.29430>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_1);
        <D.29431>:
        <D.29420>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = set_to_1;
        cfg->cbb = set_to_1;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29445 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29445;
          inst->prev = 0B;
          D.29446 = inst->prev;
          inst->next = D.29446;
          inst->opcode = 362;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29447 = inst->sreg3;
          inst->sreg2 = D.29447;
          D.29448 = inst->sreg2;
          inst->sreg1 = D.29448;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          D.29100 = next->dreg;
          inst->dreg = D.29100;
          inst->data.op[0].const_val = 1;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29449>; else goto <D.29450>;
          <D.29449>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29451>;
          <D.29450>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29451>:
        }
        D.29452 = set_to_0->cil_code;
        if (D.29452 != 0B) goto <D.29453>; else goto <D.29454>;
        <D.29453>:
        D.27633 = cfg->cil_offset_to_bb;
        D.29452 = set_to_0->cil_code;
        D.29455 = (int) D.29452;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.29456 = D.29455 - D.27636;
        D.29457 = (unsigned int) D.29456;
        D.29458 = D.29457 * 4;
        D.29459 = D.27633 + D.29458;
        *D.29459 = set_to_0;
        <D.29454>:
        D.27641 = cfg->real_offset;
        set_to_0->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29463>; else goto <D.29460>;
        <D.29463>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29464 = D.27352->opcode;
        D.29465 = D.29464 + 64985;
        D.29466 = D.29465 <= 9;
        D.29467 = D.29464 + 64878;
        D.29468 = D.29467 <= 9;
        D.29469 = D.29466 | D.29468;
        if (D.29469 != 0) goto <D.29461>; else goto <D.29470>;
        <D.29470>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29461>; else goto <D.29460>;
        <D.29461>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29471>; else goto <D.29460>;
        <D.29471>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = set_to_0;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_0);
        goto <D.29462>;
        <D.29460>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29472>; else goto <D.29474>;
        <D.29474>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29475 = D.27352->opcode;
        D.29476 = D.29475 != 442;
        D.29477 = D.29475 != 759;
        D.29478 = D.29476 & D.29477;
        if (D.29478 != 0) goto <D.29479>; else goto <D.29473>;
        <D.29479>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29480 = D.27352->opcode;
        D.29481 = D.29480 + 64985;
        D.29482 = D.29481 > 9;
        D.29483 = D.29480 + 64878;
        D.29484 = D.29483 > 9;
        D.29485 = D.29482 & D.29484;
        if (D.29485 != 0) goto <D.29486>; else goto <D.29473>;
        <D.29486>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29472>; else goto <D.29473>;
        <D.29472>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_0);
        <D.29473>:
        <D.29462>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = set_to_0;
        cfg->cbb = set_to_0;
        next->opcode = 316;
        goto <D.26683>;
      }
      <D.26725>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "decompose.c", 965);
      <D.26683>:
      goto <D.26470>;
    }
    <D.26726>:
    {
      struct MonoInst * next;
      guint32 low_imm;
      guint32 high_imm;
      int low_reg;
      int high_reg;

      next = tree->next;
      D.27362 = tree->data.op[0].const_val;
      low_imm = (guint32) D.27362;
      D.27371 = tree->data.op[1].const_val;
      high_imm = (guint32) D.27371;
      D.27379 = tree->sreg1;
      low_reg = D.27379 + 1;
      D.27379 = tree->sreg1;
      high_reg = D.27379 + 2;
      D.29487 = next == 0B;
      D.29488 = (long int) D.29487;
      D.29489 = __builtin_expect (D.29488, 0);
      if (D.29489 != 0) goto <D.29490>; else goto <D.29491>;
      <D.29490>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 978, "next");
      <D.29491>:
      D.29492 = next->opcode;
      D.29493 = (int) D.29492;
      switch (D.29493) <default: <D.26783>, case 531: <D.26758>, case 532: <D.26768>, case 533: <D.26769>, case 534: <D.26766>, case 535: <D.26767>, case 551: <D.26732>, case 552: <D.26742>, case 553: <D.26743>, case 554: <D.26744>, case 555: <D.26745>, case 556: <D.26733>, case 557: <D.26746>, case 558: <D.26747>, case 559: <D.26748>, case 560: <D.26749>>
      <D.26732>:
      <D.26733>:
      {
        int d1;
        int d2;

        D.29494 = alloc_ireg (cfg);
        d1 = (int) D.29494;
        D.29495 = alloc_ireg (cfg);
        d2 = (int) D.29495;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29496 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29496;
          inst->prev = 0B;
          D.29497 = inst->prev;
          inst->next = D.29497;
          inst->opcode = 634;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29498 = inst->sreg3;
          inst->sreg2 = D.29498;
          D.29499 = inst->sreg2;
          inst->sreg1 = D.29499;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          inst->sreg1 = low_reg;
          low_imm.4 = (int) low_imm;
          inst->data.op[1].const_val = low_imm.4;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29501>; else goto <D.29502>;
          <D.29501>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29503>;
          <D.29502>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29503>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29504 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29504;
          inst->prev = 0B;
          D.29505 = inst->prev;
          inst->next = D.29505;
          inst->opcode = 634;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29506 = inst->sreg3;
          inst->sreg2 = D.29506;
          D.29507 = inst->sreg2;
          inst->sreg1 = D.29507;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d2;
          inst->sreg1 = high_reg;
          high_imm.5 = (int) high_imm;
          inst->data.op[1].const_val = high_imm.5;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29509>; else goto <D.29510>;
          <D.29509>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29511>;
          <D.29510>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29511>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29512 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29512;
          inst->prev = 0B;
          D.29513 = inst->prev;
          inst->next = D.29513;
          inst->opcode = 573;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29514 = inst->sreg3;
          inst->sreg2 = D.29514;
          D.29515 = inst->sreg2;
          inst->sreg1 = D.29515;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          inst->sreg1 = d1;
          inst->sreg2 = d2;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29516>; else goto <D.29517>;
          <D.29516>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29518>;
          <D.29517>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29518>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29519 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29519;
          inst->prev = 0B;
          D.29520 = inst->prev;
          inst->next = D.29520;
          inst->opcode = 327;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29521 = inst->sreg3;
          inst->sreg2 = D.29521;
          D.29522 = inst->sreg2;
          inst->sreg1 = D.29522;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = d1;
          inst->data.op[1].const_val = 0;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29523>; else goto <D.29524>;
          <D.29523>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29525>;
          <D.29524>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29525>:
        }
        {
          struct MonoInst * ins;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.29526 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.29526;
          ins->prev = 0B;
          D.29527 = ins->prev;
          ins->next = D.29527;
          D.29492 = next->opcode;
          if (D.29492 == 551) goto <D.29529>; else goto <D.29530>;
          <D.29529>:
          iftmp.6 = 648;
          goto <D.29531>;
          <D.29530>:
          iftmp.6 = 653;
          <D.29531>:
          ins->opcode = iftmp.6;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.29532 = ins->sreg3;
          ins->sreg2 = D.29532;
          D.29533 = ins->sreg2;
          ins->sreg1 = D.29533;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          D.27349 = cfg->mempool;
          D.29534 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.29534;
          D.29535 = ins->data.op[1].many_blocks;
          D.29536 = next->data.op[1].many_blocks;
          D.29537 = *D.29536;
          *D.29535 = D.29537;
          D.29535 = ins->data.op[1].many_blocks;
          D.29538 = D.29535 + 4;
          D.29536 = next->data.op[1].many_blocks;
          D.29539 = MEM[(struct MonoBasicBlock * *)D.29536 + 4B];
          *D.29538 = D.29539;
          D.27351 = cfg->cbb;
          D.29536 = next->data.op[1].many_blocks;
          D.29537 = *D.29536;
          mono_link_bblock (cfg, D.27351, D.29537);
          D.27351 = cfg->cbb;
          D.29536 = next->data.op[1].many_blocks;
          D.29540 = D.29536 + 4;
          D.29541 = *D.29540;
          mono_link_bblock (cfg, D.27351, D.29541);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29542>; else goto <D.29543>;
          <D.29542>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29544>;
          <D.29543>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29544>:
        }
        next->opcode = 316;
        goto <D.26741>;
      }
      <D.26742>:
      <D.26743>:
      <D.26744>:
      <D.26745>:
      <D.26746>:
      <D.26747>:
      <D.26748>:
      <D.26749>:
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.29545 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29545;
        inst->prev = 0B;
        D.29546 = inst->prev;
        inst->next = D.29546;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29547 = inst->sreg3;
        inst->sreg2 = D.29547;
        D.29548 = inst->sreg2;
        inst->sreg1 = D.29548;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        inst->sreg1 = high_reg;
        high_imm.5 = (int) high_imm;
        inst->data.op[1].const_val = high_imm.5;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29549>; else goto <D.29550>;
        <D.29549>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.29551>;
        <D.29550>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29551>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.29552 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29552;
        ins->prev = 0B;
        D.29553 = ins->prev;
        ins->next = D.29553;
        D.29492 = next->opcode;
        D.29493 = (int) D.29492;
        D.29554 = D.29493 + -551;
        D.29555 = lbr_decomp[D.29554][0];
        D.29556 = (short unsigned int) D.29555;
        ins->opcode = D.29556;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29557 = ins->sreg3;
        ins->sreg2 = D.29557;
        D.29558 = ins->sreg2;
        ins->sreg1 = D.29558;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        D.29492 = next->opcode;
        D.29493 = (int) D.29492;
        D.29554 = D.29493 + -551;
        D.29555 = lbr_decomp[D.29554][0];
        if (D.29555 == 442) goto <D.29559>; else goto <D.29560>;
        <D.29559>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29561 = D.27576;
        D.29562 = D.29561 + 1;
        cfg->num_bblocks = D.29562;
        D.29563 = (int) D.29561;
        falsebb->block_num = D.29563;
        D.29536 = next->data.op[1].many_blocks;
        D.29537 = *D.29536;
        ins->data.op[0].target_block = D.29537;
        D.27351 = cfg->cbb;
        D.29536 = next->data.op[1].many_blocks;
        D.29537 = *D.29536;
        mono_link_bblock (cfg, D.27351, D.29537);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29564>; else goto <D.29565>;
        <D.29564>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29566>;
        <D.29565>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29566>:
        D.29567 = falsebb->cil_code;
        if (D.29567 != 0B) goto <D.29568>; else goto <D.29569>;
        <D.29568>:
        D.27633 = cfg->cil_offset_to_bb;
        D.29567 = falsebb->cil_code;
        D.29570 = (int) D.29567;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.29571 = D.29570 - D.27636;
        D.29572 = (unsigned int) D.29571;
        D.29573 = D.29572 * 4;
        D.29574 = D.27633 + D.29573;
        *D.29574 = falsebb;
        <D.29569>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29578>; else goto <D.29575>;
        <D.29578>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29579 = D.27352->opcode;
        D.29580 = D.29579 + 64985;
        D.29581 = D.29580 <= 9;
        D.29582 = D.29579 + 64878;
        D.29583 = D.29582 <= 9;
        D.29584 = D.29581 | D.29583;
        if (D.29584 != 0) goto <D.29576>; else goto <D.29585>;
        <D.29585>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29576>; else goto <D.29575>;
        <D.29576>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29586>; else goto <D.29575>;
        <D.29586>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.29577>;
        <D.29575>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29587>; else goto <D.29589>;
        <D.29589>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29590 = D.27352->opcode;
        D.29591 = D.29590 != 442;
        D.29592 = D.29590 != 759;
        D.29593 = D.29591 & D.29592;
        if (D.29593 != 0) goto <D.29594>; else goto <D.29588>;
        <D.29594>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29595 = D.27352->opcode;
        D.29596 = D.29595 + 64985;
        D.29597 = D.29596 > 9;
        D.29598 = D.29595 + 64878;
        D.29599 = D.29598 > 9;
        D.29600 = D.29597 & D.29599;
        if (D.29600 != 0) goto <D.29601>; else goto <D.29588>;
        <D.29601>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29587>; else goto <D.29588>;
        <D.29587>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.29588>:
        <D.29577>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.29602>;
        <D.29560>:
        D.27349 = cfg->mempool;
        D.29603 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.29603;
        D.29604 = ins->data.op[1].many_blocks;
        D.29536 = next->data.op[1].many_blocks;
        D.29537 = *D.29536;
        *D.29604 = D.29537;
        D.29604 = ins->data.op[1].many_blocks;
        D.29605 = D.29604 + 4;
        *D.29605 = 0B;
        D.27351 = cfg->cbb;
        D.29536 = next->data.op[1].many_blocks;
        D.29537 = *D.29536;
        mono_link_bblock (cfg, D.27351, D.29537);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29606>; else goto <D.29607>;
        <D.29606>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29608>;
        <D.29607>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29608>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.29609>; else goto <D.29610>;
        <D.29609>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29611 = D.27576;
        D.29612 = D.29611 + 1;
        cfg->num_bblocks = D.29612;
        D.29613 = (int) D.29611;
        falsebb->block_num = D.29613;
        D.29604 = ins->data.op[1].many_blocks;
        D.29605 = D.29604 + 4;
        *D.29605 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.29567 = falsebb->cil_code;
        if (D.29567 != 0B) goto <D.29614>; else goto <D.29615>;
        <D.29614>:
        D.27633 = cfg->cil_offset_to_bb;
        D.29567 = falsebb->cil_code;
        D.29570 = (int) D.29567;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.29571 = D.29570 - D.27636;
        D.29572 = (unsigned int) D.29571;
        D.29573 = D.29572 * 4;
        D.29574 = D.27633 + D.29573;
        *D.29574 = falsebb;
        <D.29615>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29619>; else goto <D.29616>;
        <D.29619>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29620 = D.27352->opcode;
        D.29621 = D.29620 + 64985;
        D.29622 = D.29621 <= 9;
        D.29623 = D.29620 + 64878;
        D.29624 = D.29623 <= 9;
        D.29625 = D.29622 | D.29624;
        if (D.29625 != 0) goto <D.29617>; else goto <D.29626>;
        <D.29626>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29617>; else goto <D.29616>;
        <D.29617>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29627>; else goto <D.29616>;
        <D.29627>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.29618>;
        <D.29616>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29628>; else goto <D.29630>;
        <D.29630>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29631 = D.27352->opcode;
        D.29632 = D.29631 != 442;
        D.29633 = D.29631 != 759;
        D.29634 = D.29632 & D.29633;
        if (D.29634 != 0) goto <D.29635>; else goto <D.29629>;
        <D.29635>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29636 = D.27352->opcode;
        D.29637 = D.29636 + 64985;
        D.29638 = D.29637 > 9;
        D.29639 = D.29636 + 64878;
        D.29640 = D.29639 > 9;
        D.29641 = D.29638 & D.29640;
        if (D.29641 != 0) goto <D.29642>; else goto <D.29629>;
        <D.29642>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29628>; else goto <D.29629>;
        <D.29628>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.29629>:
        <D.29618>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.29643>;
        <D.29610>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.29643>:
        <D.29602>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.29644 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29644;
        inst->prev = 0B;
        D.29645 = inst->prev;
        inst->next = D.29645;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29646 = inst->sreg3;
        inst->sreg2 = D.29646;
        D.29647 = inst->sreg2;
        inst->sreg1 = D.29647;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        inst->sreg1 = high_reg;
        high_imm.5 = (int) high_imm;
        inst->data.op[1].const_val = high_imm.5;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29648>; else goto <D.29649>;
        <D.29648>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.29650>;
        <D.29649>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29650>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.29651 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29651;
        ins->prev = 0B;
        D.29652 = ins->prev;
        ins->next = D.29652;
        ins->opcode = 653;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29653 = ins->sreg3;
        ins->sreg2 = D.29653;
        D.29654 = ins->sreg2;
        ins->sreg1 = D.29654;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        if (0 != 0) goto <D.29655>; else goto <D.29656>;
        <D.29655>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29657 = D.27576;
        D.29658 = D.29657 + 1;
        cfg->num_bblocks = D.29658;
        D.29659 = (int) D.29657;
        falsebb->block_num = D.29659;
        D.29536 = next->data.op[1].many_blocks;
        D.29539 = MEM[(struct MonoBasicBlock * *)D.29536 + 4B];
        ins->data.op[0].target_block = D.29539;
        D.27351 = cfg->cbb;
        D.29536 = next->data.op[1].many_blocks;
        D.29540 = D.29536 + 4;
        D.29541 = *D.29540;
        mono_link_bblock (cfg, D.27351, D.29541);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29660>; else goto <D.29661>;
        <D.29660>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29662>;
        <D.29661>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29662>:
        D.29663 = falsebb->cil_code;
        if (D.29663 != 0B) goto <D.29664>; else goto <D.29665>;
        <D.29664>:
        D.27633 = cfg->cil_offset_to_bb;
        D.29663 = falsebb->cil_code;
        D.29666 = (int) D.29663;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.29667 = D.29666 - D.27636;
        D.29668 = (unsigned int) D.29667;
        D.29669 = D.29668 * 4;
        D.29670 = D.27633 + D.29669;
        *D.29670 = falsebb;
        <D.29665>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29674>; else goto <D.29671>;
        <D.29674>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29675 = D.27352->opcode;
        D.29676 = D.29675 + 64985;
        D.29677 = D.29676 <= 9;
        D.29678 = D.29675 + 64878;
        D.29679 = D.29678 <= 9;
        D.29680 = D.29677 | D.29679;
        if (D.29680 != 0) goto <D.29672>; else goto <D.29681>;
        <D.29681>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29672>; else goto <D.29671>;
        <D.29672>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29682>; else goto <D.29671>;
        <D.29682>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.29673>;
        <D.29671>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29683>; else goto <D.29685>;
        <D.29685>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29686 = D.27352->opcode;
        D.29687 = D.29686 != 442;
        D.29688 = D.29686 != 759;
        D.29689 = D.29687 & D.29688;
        if (D.29689 != 0) goto <D.29690>; else goto <D.29684>;
        <D.29690>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29691 = D.27352->opcode;
        D.29692 = D.29691 + 64985;
        D.29693 = D.29692 > 9;
        D.29694 = D.29691 + 64878;
        D.29695 = D.29694 > 9;
        D.29696 = D.29693 & D.29695;
        if (D.29696 != 0) goto <D.29697>; else goto <D.29684>;
        <D.29697>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29683>; else goto <D.29684>;
        <D.29683>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.29684>:
        <D.29673>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.29698>;
        <D.29656>:
        D.27349 = cfg->mempool;
        D.29699 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.29699;
        D.29700 = ins->data.op[1].many_blocks;
        D.29536 = next->data.op[1].many_blocks;
        D.29539 = MEM[(struct MonoBasicBlock * *)D.29536 + 4B];
        *D.29700 = D.29539;
        D.29700 = ins->data.op[1].many_blocks;
        D.29701 = D.29700 + 4;
        *D.29701 = 0B;
        D.27351 = cfg->cbb;
        D.29536 = next->data.op[1].many_blocks;
        D.29540 = D.29536 + 4;
        D.29541 = *D.29540;
        mono_link_bblock (cfg, D.27351, D.29541);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29702>; else goto <D.29703>;
        <D.29702>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29704>;
        <D.29703>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29704>:
        D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.27682 = D.27681 & 8;
        if (D.27682 == 0) goto <D.29705>; else goto <D.29706>;
        <D.29705>:
        D.27349 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29707 = D.27576;
        D.29708 = D.29707 + 1;
        cfg->num_bblocks = D.29708;
        D.29709 = (int) D.29707;
        falsebb->block_num = D.29709;
        D.29700 = ins->data.op[1].many_blocks;
        D.29701 = D.29700 + 4;
        *D.29701 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        D.29663 = falsebb->cil_code;
        if (D.29663 != 0B) goto <D.29710>; else goto <D.29711>;
        <D.29710>:
        D.27633 = cfg->cil_offset_to_bb;
        D.29663 = falsebb->cil_code;
        D.29666 = (int) D.29663;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.29667 = D.29666 - D.27636;
        D.29668 = (unsigned int) D.29667;
        D.29669 = D.29668 * 4;
        D.29670 = D.27633 + D.29669;
        *D.29670 = falsebb;
        <D.29711>:
        D.27641 = cfg->real_offset;
        falsebb->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29715>; else goto <D.29712>;
        <D.29715>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29716 = D.27352->opcode;
        D.29717 = D.29716 + 64985;
        D.29718 = D.29717 <= 9;
        D.29719 = D.29716 + 64878;
        D.29720 = D.29719 <= 9;
        D.29721 = D.29718 | D.29720;
        if (D.29721 != 0) goto <D.29713>; else goto <D.29722>;
        <D.29722>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.29713>; else goto <D.29712>;
        <D.29713>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.29723>; else goto <D.29712>;
        <D.29723>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = falsebb;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        goto <D.29714>;
        <D.29712>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.29724>; else goto <D.29726>;
        <D.29726>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29727 = D.27352->opcode;
        D.29728 = D.29727 != 442;
        D.29729 = D.29727 != 759;
        D.29730 = D.29728 & D.29729;
        if (D.29730 != 0) goto <D.29731>; else goto <D.29725>;
        <D.29731>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.29732 = D.27352->opcode;
        D.29733 = D.29732 + 64985;
        D.29734 = D.29733 > 9;
        D.29735 = D.29732 + 64878;
        D.29736 = D.29735 > 9;
        D.29737 = D.29734 & D.29736;
        if (D.29737 != 0) goto <D.29738>; else goto <D.29725>;
        <D.29738>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.29724>; else goto <D.29725>;
        <D.29724>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, falsebb);
        <D.29725>:
        <D.29714>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.29739>;
        <D.29706>:
        D.27351 = cfg->cbb;
        D.27351->extended = 1;
        <D.29739>:
        <D.29698>:
      }
      {
        struct MonoInst * inst;

        D.27349 = cfg->mempool;
        inst = mono_mempool_alloc (D.27349, 56);
        inst->data.op[1].const_val = 0;
        D.29740 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29740;
        inst->prev = 0B;
        D.29741 = inst->prev;
        inst->next = D.29741;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29742 = inst->sreg3;
        inst->sreg2 = D.29742;
        D.29743 = inst->sreg2;
        inst->sreg1 = D.29743;
        D.27359 = cfg->ip;
        inst->cil_code = D.27359;
        inst->dreg = -1;
        inst->sreg1 = low_reg;
        low_imm.4 = (int) low_imm;
        inst->data.op[1].const_val = low_imm.4;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29744>; else goto <D.29745>;
        <D.29744>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = inst;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        inst->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        goto <D.29746>;
        <D.29745>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = inst;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29746>:
      }
      {
        struct MonoInst * ins;

        D.27349 = cfg->mempool;
        ins = mono_mempool_alloc (D.27349, 56);
        ins->data.op[1].const_val = 0;
        D.29747 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29747;
        ins->prev = 0B;
        D.29748 = ins->prev;
        ins->next = D.29748;
        D.29492 = next->opcode;
        D.29493 = (int) D.29492;
        D.29554 = D.29493 + -551;
        D.29749 = lbr_decomp[D.29554][1];
        D.29750 = (short unsigned int) D.29749;
        ins->opcode = D.29750;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29751 = ins->sreg3;
        ins->sreg2 = D.29751;
        D.29752 = ins->sreg2;
        ins->sreg1 = D.29752;
        D.27359 = cfg->ip;
        ins->cil_code = D.27359;
        D.27349 = cfg->mempool;
        D.29753 = mono_mempool_alloc (D.27349, 8);
        ins->data.op[1].many_blocks = D.29753;
        D.29754 = ins->data.op[1].many_blocks;
        D.29536 = next->data.op[1].many_blocks;
        D.29537 = *D.29536;
        *D.29754 = D.29537;
        D.29754 = ins->data.op[1].many_blocks;
        D.29755 = D.29754 + 4;
        D.29536 = next->data.op[1].many_blocks;
        D.29539 = MEM[(struct MonoBasicBlock * *)D.29536 + 4B];
        *D.29755 = D.29539;
        D.27351 = cfg->cbb;
        D.29536 = next->data.op[1].many_blocks;
        D.29537 = *D.29536;
        mono_link_bblock (cfg, D.27351, D.29537);
        D.27351 = cfg->cbb;
        D.29536 = next->data.op[1].many_blocks;
        D.29540 = D.29536 + 4;
        D.29541 = *D.29540;
        mono_link_bblock (cfg, D.27351, D.29541);
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.29756>; else goto <D.29757>;
        <D.29756>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27352->next = ins;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        ins->prev = D.27352;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        goto <D.29758>;
        <D.29757>:
        D.27351 = cfg->cbb;
        D.27351 = cfg->cbb;
        D.27351->last_ins = ins;
        D.27352 = D.27351->last_ins;
        D.27351->code = D.27352;
        <D.29758>:
      }
      next->opcode = 316;
      goto <D.26741>;
      <D.26758>:
      {
        int d1;
        int d2;

        D.29759 = alloc_ireg (cfg);
        d1 = (int) D.29759;
        D.29760 = alloc_ireg (cfg);
        d2 = (int) D.29760;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29761 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29761;
          inst->prev = 0B;
          D.29762 = inst->prev;
          inst->next = D.29762;
          inst->opcode = 634;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29763 = inst->sreg3;
          inst->sreg2 = D.29763;
          D.29764 = inst->sreg2;
          inst->sreg1 = D.29764;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          inst->sreg1 = low_reg;
          low_imm.4 = (int) low_imm;
          inst->data.op[1].const_val = low_imm.4;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29765>; else goto <D.29766>;
          <D.29765>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29767>;
          <D.29766>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29767>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29768 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29768;
          inst->prev = 0B;
          D.29769 = inst->prev;
          inst->next = D.29769;
          inst->opcode = 634;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29770 = inst->sreg3;
          inst->sreg2 = D.29770;
          D.29771 = inst->sreg2;
          inst->sreg1 = D.29771;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d2;
          inst->sreg1 = high_reg;
          high_imm.5 = (int) high_imm;
          inst->data.op[1].const_val = high_imm.5;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29772>; else goto <D.29773>;
          <D.29772>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29774>;
          <D.29773>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29774>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29775 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29775;
          inst->prev = 0B;
          D.29776 = inst->prev;
          inst->next = D.29776;
          inst->opcode = 573;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29777 = inst->sreg3;
          inst->sreg2 = D.29777;
          D.29778 = inst->sreg2;
          inst->sreg1 = D.29778;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = d1;
          inst->sreg1 = d1;
          inst->sreg2 = d2;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29779>; else goto <D.29780>;
          <D.29779>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29781>;
          <D.29780>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29781>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29782 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29782;
          inst->prev = 0B;
          D.29783 = inst->prev;
          inst->next = D.29783;
          inst->opcode = 327;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29784 = inst->sreg3;
          inst->sreg2 = D.29784;
          D.29785 = inst->sreg2;
          inst->sreg1 = D.29785;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = d1;
          inst->data.op[1].const_val = 0;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29786>; else goto <D.29787>;
          <D.29786>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29788>;
          <D.29787>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29788>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29789 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29789;
          inst->prev = 0B;
          D.29790 = inst->prev;
          inst->next = D.29790;
          inst->opcode = 638;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29791 = inst->sreg3;
          inst->sreg2 = D.29791;
          D.29792 = inst->sreg2;
          inst->sreg1 = D.29792;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          D.29793 = next->dreg;
          inst->dreg = D.29793;
          inst->sreg1 = -1;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29794>; else goto <D.29795>;
          <D.29794>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29796>;
          <D.29795>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29796>:
        }
        next->opcode = 316;
        goto <D.26741>;
      }
      <D.26766>:
      <D.26767>:
      <D.26768>:
      <D.26769>:
      {
        struct MonoBasicBlock * set_to_0;
        struct MonoBasicBlock * set_to_1;

        D.27349 = cfg->mempool;
        set_to_0 = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29797 = D.27576;
        D.29798 = D.29797 + 1;
        cfg->num_bblocks = D.29798;
        D.29799 = (int) D.29797;
        set_to_0->block_num = D.29799;
        D.27349 = cfg->mempool;
        set_to_1 = mono_mempool_alloc0 (D.27349, 172);
        D.27576 = cfg->num_bblocks;
        D.29800 = D.27576;
        D.29801 = D.29800 + 1;
        cfg->num_bblocks = D.29801;
        D.29802 = (int) D.29800;
        set_to_1->block_num = D.29802;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29803 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29803;
          inst->prev = 0B;
          D.29804 = inst->prev;
          inst->next = D.29804;
          inst->opcode = 362;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29805 = inst->sreg3;
          inst->sreg2 = D.29805;
          D.29806 = inst->sreg2;
          inst->sreg1 = D.29806;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          D.29793 = next->dreg;
          inst->dreg = D.29793;
          inst->data.op[0].const_val = 0;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29807>; else goto <D.29808>;
          <D.29807>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29809>;
          <D.29808>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29809>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29810 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29810;
          inst->prev = 0B;
          D.29811 = inst->prev;
          inst->next = D.29811;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29812 = inst->sreg3;
          inst->sreg2 = D.29812;
          D.29813 = inst->sreg2;
          inst->sreg1 = D.29813;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = high_reg;
          high_imm.5 = (int) high_imm;
          inst->data.op[1].const_val = high_imm.5;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29814>; else goto <D.29815>;
          <D.29814>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29816>;
          <D.29815>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29816>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.29817 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.29817;
          ins->prev = 0B;
          D.29818 = ins->prev;
          ins->next = D.29818;
          D.29492 = next->opcode;
          D.29493 = (int) D.29492;
          D.29819 = D.29493 + -531;
          D.29820 = lcset_decomp[D.29819][0];
          D.29821 = (short unsigned int) D.29820;
          ins->opcode = D.29821;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.29822 = ins->sreg3;
          ins->sreg2 = D.29822;
          D.29823 = ins->sreg2;
          ins->sreg1 = D.29823;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          D.29492 = next->opcode;
          D.29493 = (int) D.29492;
          D.29819 = D.29493 + -531;
          D.29820 = lcset_decomp[D.29819][0];
          if (D.29820 == 442) goto <D.29824>; else goto <D.29825>;
          <D.29824>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29826 = D.27576;
          D.29827 = D.29826 + 1;
          cfg->num_bblocks = D.29827;
          D.29828 = (int) D.29826;
          falsebb->block_num = D.29828;
          ins->data.op[0].target_block = set_to_0;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29829>; else goto <D.29830>;
          <D.29829>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29831>;
          <D.29830>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29831>:
          D.29832 = falsebb->cil_code;
          if (D.29832 != 0B) goto <D.29833>; else goto <D.29834>;
          <D.29833>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29832 = falsebb->cil_code;
          D.29835 = (int) D.29832;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29836 = D.29835 - D.27636;
          D.29837 = (unsigned int) D.29836;
          D.29838 = D.29837 * 4;
          D.29839 = D.27633 + D.29838;
          *D.29839 = falsebb;
          <D.29834>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29843>; else goto <D.29840>;
          <D.29843>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29844 = D.27352->opcode;
          D.29845 = D.29844 + 64985;
          D.29846 = D.29845 <= 9;
          D.29847 = D.29844 + 64878;
          D.29848 = D.29847 <= 9;
          D.29849 = D.29846 | D.29848;
          if (D.29849 != 0) goto <D.29841>; else goto <D.29850>;
          <D.29850>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29841>; else goto <D.29840>;
          <D.29841>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29851>; else goto <D.29840>;
          <D.29851>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29842>;
          <D.29840>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29852>; else goto <D.29854>;
          <D.29854>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29855 = D.27352->opcode;
          D.29856 = D.29855 != 442;
          D.29857 = D.29855 != 759;
          D.29858 = D.29856 & D.29857;
          if (D.29858 != 0) goto <D.29859>; else goto <D.29853>;
          <D.29859>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29860 = D.27352->opcode;
          D.29861 = D.29860 + 64985;
          D.29862 = D.29861 > 9;
          D.29863 = D.29860 + 64878;
          D.29864 = D.29863 > 9;
          D.29865 = D.29862 & D.29864;
          if (D.29865 != 0) goto <D.29866>; else goto <D.29853>;
          <D.29866>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29852>; else goto <D.29853>;
          <D.29852>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29853>:
          <D.29842>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29867>;
          <D.29825>:
          D.27349 = cfg->mempool;
          D.29868 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.29868;
          D.29869 = ins->data.op[1].many_blocks;
          *D.29869 = set_to_0;
          D.29869 = ins->data.op[1].many_blocks;
          D.29870 = D.29869 + 4;
          *D.29870 = 0B;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29871>; else goto <D.29872>;
          <D.29871>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29873>;
          <D.29872>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29873>:
          D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.27682 = D.27681 & 8;
          if (D.27682 == 0) goto <D.29874>; else goto <D.29875>;
          <D.29874>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29876 = D.27576;
          D.29877 = D.29876 + 1;
          cfg->num_bblocks = D.29877;
          D.29878 = (int) D.29876;
          falsebb->block_num = D.29878;
          D.29869 = ins->data.op[1].many_blocks;
          D.29870 = D.29869 + 4;
          *D.29870 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          D.29832 = falsebb->cil_code;
          if (D.29832 != 0B) goto <D.29879>; else goto <D.29880>;
          <D.29879>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29832 = falsebb->cil_code;
          D.29835 = (int) D.29832;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29836 = D.29835 - D.27636;
          D.29837 = (unsigned int) D.29836;
          D.29838 = D.29837 * 4;
          D.29839 = D.27633 + D.29838;
          *D.29839 = falsebb;
          <D.29880>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29884>; else goto <D.29881>;
          <D.29884>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29885 = D.27352->opcode;
          D.29886 = D.29885 + 64985;
          D.29887 = D.29886 <= 9;
          D.29888 = D.29885 + 64878;
          D.29889 = D.29888 <= 9;
          D.29890 = D.29887 | D.29889;
          if (D.29890 != 0) goto <D.29882>; else goto <D.29891>;
          <D.29891>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29882>; else goto <D.29881>;
          <D.29882>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29892>; else goto <D.29881>;
          <D.29892>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29883>;
          <D.29881>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29893>; else goto <D.29895>;
          <D.29895>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29896 = D.27352->opcode;
          D.29897 = D.29896 != 442;
          D.29898 = D.29896 != 759;
          D.29899 = D.29897 & D.29898;
          if (D.29899 != 0) goto <D.29900>; else goto <D.29894>;
          <D.29900>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29901 = D.27352->opcode;
          D.29902 = D.29901 + 64985;
          D.29903 = D.29902 > 9;
          D.29904 = D.29901 + 64878;
          D.29905 = D.29904 > 9;
          D.29906 = D.29903 & D.29905;
          if (D.29906 != 0) goto <D.29907>; else goto <D.29894>;
          <D.29907>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29893>; else goto <D.29894>;
          <D.29893>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29894>:
          <D.29883>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29908>;
          <D.29875>:
          D.27351 = cfg->cbb;
          D.27351->extended = 1;
          <D.29908>:
          <D.29867>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.29909 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29909;
          inst->prev = 0B;
          D.29910 = inst->prev;
          inst->next = D.29910;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29911 = inst->sreg3;
          inst->sreg2 = D.29911;
          D.29912 = inst->sreg2;
          inst->sreg1 = D.29912;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = high_reg;
          high_imm.5 = (int) high_imm;
          inst->data.op[1].const_val = high_imm.5;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29913>; else goto <D.29914>;
          <D.29913>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.29915>;
          <D.29914>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29915>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.29916 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.29916;
          ins->prev = 0B;
          D.29917 = ins->prev;
          ins->next = D.29917;
          ins->opcode = 653;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.29918 = ins->sreg3;
          ins->sreg2 = D.29918;
          D.29919 = ins->sreg2;
          ins->sreg1 = D.29919;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          if (0 != 0) goto <D.29920>; else goto <D.29921>;
          <D.29920>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29922 = D.27576;
          D.29923 = D.29922 + 1;
          cfg->num_bblocks = D.29923;
          D.29924 = (int) D.29922;
          falsebb->block_num = D.29924;
          ins->data.op[0].target_block = set_to_1;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_1);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29925>; else goto <D.29926>;
          <D.29925>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29927>;
          <D.29926>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29927>:
          D.29928 = falsebb->cil_code;
          if (D.29928 != 0B) goto <D.29929>; else goto <D.29930>;
          <D.29929>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29928 = falsebb->cil_code;
          D.29931 = (int) D.29928;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29932 = D.29931 - D.27636;
          D.29933 = (unsigned int) D.29932;
          D.29934 = D.29933 * 4;
          D.29935 = D.27633 + D.29934;
          *D.29935 = falsebb;
          <D.29930>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29939>; else goto <D.29936>;
          <D.29939>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29940 = D.27352->opcode;
          D.29941 = D.29940 + 64985;
          D.29942 = D.29941 <= 9;
          D.29943 = D.29940 + 64878;
          D.29944 = D.29943 <= 9;
          D.29945 = D.29942 | D.29944;
          if (D.29945 != 0) goto <D.29937>; else goto <D.29946>;
          <D.29946>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29937>; else goto <D.29936>;
          <D.29937>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29947>; else goto <D.29936>;
          <D.29947>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29938>;
          <D.29936>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29948>; else goto <D.29950>;
          <D.29950>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29951 = D.27352->opcode;
          D.29952 = D.29951 != 442;
          D.29953 = D.29951 != 759;
          D.29954 = D.29952 & D.29953;
          if (D.29954 != 0) goto <D.29955>; else goto <D.29949>;
          <D.29955>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29956 = D.27352->opcode;
          D.29957 = D.29956 + 64985;
          D.29958 = D.29957 > 9;
          D.29959 = D.29956 + 64878;
          D.29960 = D.29959 > 9;
          D.29961 = D.29958 & D.29960;
          if (D.29961 != 0) goto <D.29962>; else goto <D.29949>;
          <D.29962>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29948>; else goto <D.29949>;
          <D.29948>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29949>:
          <D.29938>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.29963>;
          <D.29921>:
          D.27349 = cfg->mempool;
          D.29964 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.29964;
          D.29965 = ins->data.op[1].many_blocks;
          *D.29965 = set_to_1;
          D.29965 = ins->data.op[1].many_blocks;
          D.29966 = D.29965 + 4;
          *D.29966 = 0B;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_1);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29967>; else goto <D.29968>;
          <D.29967>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.29969>;
          <D.29968>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.29969>:
          D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.27682 = D.27681 & 8;
          if (D.27682 == 0) goto <D.29970>; else goto <D.29971>;
          <D.29970>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.29972 = D.27576;
          D.29973 = D.29972 + 1;
          cfg->num_bblocks = D.29973;
          D.29974 = (int) D.29972;
          falsebb->block_num = D.29974;
          D.29965 = ins->data.op[1].many_blocks;
          D.29966 = D.29965 + 4;
          *D.29966 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          D.29928 = falsebb->cil_code;
          if (D.29928 != 0B) goto <D.29975>; else goto <D.29976>;
          <D.29975>:
          D.27633 = cfg->cil_offset_to_bb;
          D.29928 = falsebb->cil_code;
          D.29931 = (int) D.29928;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.29932 = D.29931 - D.27636;
          D.29933 = (unsigned int) D.29932;
          D.29934 = D.29933 * 4;
          D.29935 = D.27633 + D.29934;
          *D.29935 = falsebb;
          <D.29976>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.29980>; else goto <D.29977>;
          <D.29980>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29981 = D.27352->opcode;
          D.29982 = D.29981 + 64985;
          D.29983 = D.29982 <= 9;
          D.29984 = D.29981 + 64878;
          D.29985 = D.29984 <= 9;
          D.29986 = D.29983 | D.29985;
          if (D.29986 != 0) goto <D.29978>; else goto <D.29987>;
          <D.29987>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.29978>; else goto <D.29977>;
          <D.29978>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.29988>; else goto <D.29977>;
          <D.29988>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.29979>;
          <D.29977>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.29989>; else goto <D.29991>;
          <D.29991>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29992 = D.27352->opcode;
          D.29993 = D.29992 != 442;
          D.29994 = D.29992 != 759;
          D.29995 = D.29993 & D.29994;
          if (D.29995 != 0) goto <D.29996>; else goto <D.29990>;
          <D.29996>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.29997 = D.27352->opcode;
          D.29998 = D.29997 + 64985;
          D.29999 = D.29998 > 9;
          D.30000 = D.29997 + 64878;
          D.30001 = D.30000 > 9;
          D.30002 = D.29999 & D.30001;
          if (D.30002 != 0) goto <D.30003>; else goto <D.29990>;
          <D.30003>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.29989>; else goto <D.29990>;
          <D.29989>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.29990>:
          <D.29979>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.30004>;
          <D.29971>:
          D.27351 = cfg->cbb;
          D.27351->extended = 1;
          <D.30004>:
          <D.29963>:
        }
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.30005 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30005;
          inst->prev = 0B;
          D.30006 = inst->prev;
          inst->next = D.30006;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30007 = inst->sreg3;
          inst->sreg2 = D.30007;
          D.30008 = inst->sreg2;
          inst->sreg1 = D.30008;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          inst->dreg = -1;
          inst->sreg1 = low_reg;
          low_imm.4 = (int) low_imm;
          inst->data.op[1].const_val = low_imm.4;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.30009>; else goto <D.30010>;
          <D.30009>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.30011>;
          <D.30010>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.30011>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.27349 = cfg->mempool;
          ins = mono_mempool_alloc (D.27349, 56);
          ins->data.op[1].const_val = 0;
          D.30012 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30012;
          ins->prev = 0B;
          D.30013 = ins->prev;
          ins->next = D.30013;
          D.29492 = next->opcode;
          D.29493 = (int) D.29492;
          D.29819 = D.29493 + -531;
          D.30014 = lcset_decomp[D.29819][1];
          D.30015 = (short unsigned int) D.30014;
          ins->opcode = D.30015;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30016 = ins->sreg3;
          ins->sreg2 = D.30016;
          D.30017 = ins->sreg2;
          ins->sreg1 = D.30017;
          D.27359 = cfg->ip;
          ins->cil_code = D.27359;
          D.29492 = next->opcode;
          D.29493 = (int) D.29492;
          D.29819 = D.29493 + -531;
          D.30014 = lcset_decomp[D.29819][1];
          if (D.30014 == 442) goto <D.30018>; else goto <D.30019>;
          <D.30018>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.30020 = D.27576;
          D.30021 = D.30020 + 1;
          cfg->num_bblocks = D.30021;
          D.30022 = (int) D.30020;
          falsebb->block_num = D.30022;
          ins->data.op[0].target_block = set_to_0;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.30023>; else goto <D.30024>;
          <D.30023>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.30025>;
          <D.30024>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.30025>:
          D.30026 = falsebb->cil_code;
          if (D.30026 != 0B) goto <D.30027>; else goto <D.30028>;
          <D.30027>:
          D.27633 = cfg->cil_offset_to_bb;
          D.30026 = falsebb->cil_code;
          D.30029 = (int) D.30026;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.30030 = D.30029 - D.27636;
          D.30031 = (unsigned int) D.30030;
          D.30032 = D.30031 * 4;
          D.30033 = D.27633 + D.30032;
          *D.30033 = falsebb;
          <D.30028>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.30037>; else goto <D.30034>;
          <D.30037>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.30038 = D.27352->opcode;
          D.30039 = D.30038 + 64985;
          D.30040 = D.30039 <= 9;
          D.30041 = D.30038 + 64878;
          D.30042 = D.30041 <= 9;
          D.30043 = D.30040 | D.30042;
          if (D.30043 != 0) goto <D.30035>; else goto <D.30044>;
          <D.30044>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.30035>; else goto <D.30034>;
          <D.30035>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.30045>; else goto <D.30034>;
          <D.30045>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.30036>;
          <D.30034>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.30046>; else goto <D.30048>;
          <D.30048>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.30049 = D.27352->opcode;
          D.30050 = D.30049 != 442;
          D.30051 = D.30049 != 759;
          D.30052 = D.30050 & D.30051;
          if (D.30052 != 0) goto <D.30053>; else goto <D.30047>;
          <D.30053>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.30054 = D.27352->opcode;
          D.30055 = D.30054 + 64985;
          D.30056 = D.30055 > 9;
          D.30057 = D.30054 + 64878;
          D.30058 = D.30057 > 9;
          D.30059 = D.30056 & D.30058;
          if (D.30059 != 0) goto <D.30060>; else goto <D.30047>;
          <D.30060>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.30046>; else goto <D.30047>;
          <D.30046>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.30047>:
          <D.30036>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.30061>;
          <D.30019>:
          D.27349 = cfg->mempool;
          D.30062 = mono_mempool_alloc (D.27349, 8);
          ins->data.op[1].many_blocks = D.30062;
          D.30063 = ins->data.op[1].many_blocks;
          *D.30063 = set_to_0;
          D.30063 = ins->data.op[1].many_blocks;
          D.30064 = D.30063 + 4;
          *D.30064 = 0B;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, set_to_0);
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.30065>; else goto <D.30066>;
          <D.30065>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = ins;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          ins->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          goto <D.30067>;
          <D.30066>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = ins;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.30067>:
          D.27681 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.27682 = D.27681 & 8;
          if (D.27682 == 0) goto <D.30068>; else goto <D.30069>;
          <D.30068>:
          D.27349 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.27349, 172);
          D.27576 = cfg->num_bblocks;
          D.30070 = D.27576;
          D.30071 = D.30070 + 1;
          cfg->num_bblocks = D.30071;
          D.30072 = (int) D.30070;
          falsebb->block_num = D.30072;
          D.30063 = ins->data.op[1].many_blocks;
          D.30064 = D.30063 + 4;
          *D.30064 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          D.30026 = falsebb->cil_code;
          if (D.30026 != 0B) goto <D.30073>; else goto <D.30074>;
          <D.30073>:
          D.27633 = cfg->cil_offset_to_bb;
          D.30026 = falsebb->cil_code;
          D.30029 = (int) D.30026;
          D.27635 = cfg->cil_start;
          D.27636 = (int) D.27635;
          D.30030 = D.30029 - D.27636;
          D.30031 = (unsigned int) D.30030;
          D.30032 = D.30031 * 4;
          D.30033 = D.27633 + D.30032;
          *D.30033 = falsebb;
          <D.30074>:
          D.27641 = cfg->real_offset;
          falsebb->real_offset = D.27641;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.30078>; else goto <D.30075>;
          <D.30078>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.30079 = D.27352->opcode;
          D.30080 = D.30079 + 64985;
          D.30081 = D.30080 <= 9;
          D.30082 = D.30079 + 64878;
          D.30083 = D.30082 <= 9;
          D.30084 = D.30081 | D.30083;
          if (D.30084 != 0) goto <D.30076>; else goto <D.30085>;
          <D.30085>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 <= 9) goto <D.30076>; else goto <D.30075>;
          <D.30076>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          D.27657 = *D.27656;
          if (D.27657 == 0B) goto <D.30086>; else goto <D.30075>;
          <D.30086>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27655 = D.27352->data.op[1].many_blocks;
          D.27656 = D.27655 + 4;
          *D.27656 = falsebb;
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          goto <D.30077>;
          <D.30075>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 == 0B) goto <D.30087>; else goto <D.30089>;
          <D.30089>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.30090 = D.27352->opcode;
          D.30091 = D.30090 != 442;
          D.30092 = D.30090 != 759;
          D.30093 = D.30091 & D.30092;
          if (D.30093 != 0) goto <D.30094>; else goto <D.30088>;
          <D.30094>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.30095 = D.27352->opcode;
          D.30096 = D.30095 + 64985;
          D.30097 = D.30096 > 9;
          D.30098 = D.30095 + 64878;
          D.30099 = D.30098 > 9;
          D.30100 = D.30097 & D.30099;
          if (D.30100 != 0) goto <D.30101>; else goto <D.30088>;
          <D.30101>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27653 = D.27352->opcode;
          D.27654 = D.27653 + 64888;
          if (D.27654 > 9) goto <D.30087>; else goto <D.30088>;
          <D.30087>:
          D.27351 = cfg->cbb;
          mono_link_bblock (cfg, D.27351, falsebb);
          <D.30088>:
          <D.30077>:
          D.27351 = cfg->cbb;
          D.27351->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.30102>;
          <D.30069>:
          D.27351 = cfg->cbb;
          D.27351->extended = 1;
          <D.30102>:
          <D.30061>:
        }
        D.30103 = set_to_1->cil_code;
        if (D.30103 != 0B) goto <D.30104>; else goto <D.30105>;
        <D.30104>:
        D.27633 = cfg->cil_offset_to_bb;
        D.30103 = set_to_1->cil_code;
        D.30106 = (int) D.30103;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.30107 = D.30106 - D.27636;
        D.30108 = (unsigned int) D.30107;
        D.30109 = D.30108 * 4;
        D.30110 = D.27633 + D.30109;
        *D.30110 = set_to_1;
        <D.30105>:
        D.27641 = cfg->real_offset;
        set_to_1->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.30114>; else goto <D.30111>;
        <D.30114>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.30115 = D.27352->opcode;
        D.30116 = D.30115 + 64985;
        D.30117 = D.30116 <= 9;
        D.30118 = D.30115 + 64878;
        D.30119 = D.30118 <= 9;
        D.30120 = D.30117 | D.30119;
        if (D.30120 != 0) goto <D.30112>; else goto <D.30121>;
        <D.30121>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.30112>; else goto <D.30111>;
        <D.30112>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.30122>; else goto <D.30111>;
        <D.30122>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = set_to_1;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_1);
        goto <D.30113>;
        <D.30111>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.30123>; else goto <D.30125>;
        <D.30125>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.30126 = D.27352->opcode;
        D.30127 = D.30126 != 442;
        D.30128 = D.30126 != 759;
        D.30129 = D.30127 & D.30128;
        if (D.30129 != 0) goto <D.30130>; else goto <D.30124>;
        <D.30130>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.30131 = D.27352->opcode;
        D.30132 = D.30131 + 64985;
        D.30133 = D.30132 > 9;
        D.30134 = D.30131 + 64878;
        D.30135 = D.30134 > 9;
        D.30136 = D.30133 & D.30135;
        if (D.30136 != 0) goto <D.30137>; else goto <D.30124>;
        <D.30137>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.30123>; else goto <D.30124>;
        <D.30123>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_1);
        <D.30124>:
        <D.30113>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = set_to_1;
        cfg->cbb = set_to_1;
        {
          struct MonoInst * inst;

          D.27349 = cfg->mempool;
          inst = mono_mempool_alloc (D.27349, 56);
          inst->data.op[1].const_val = 0;
          D.30138 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30138;
          inst->prev = 0B;
          D.30139 = inst->prev;
          inst->next = D.30139;
          inst->opcode = 362;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30140 = inst->sreg3;
          inst->sreg2 = D.30140;
          D.30141 = inst->sreg2;
          inst->sreg1 = D.30141;
          D.27359 = cfg->ip;
          inst->cil_code = D.27359;
          D.29793 = next->dreg;
          inst->dreg = D.29793;
          inst->data.op[0].const_val = 1;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          if (D.27352 != 0B) goto <D.30142>; else goto <D.30143>;
          <D.30142>:
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          D.27352->next = inst;
          D.27351 = cfg->cbb;
          D.27352 = D.27351->last_ins;
          inst->prev = D.27352;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          goto <D.30144>;
          <D.30143>:
          D.27351 = cfg->cbb;
          D.27351 = cfg->cbb;
          D.27351->last_ins = inst;
          D.27352 = D.27351->last_ins;
          D.27351->code = D.27352;
          <D.30144>:
        }
        D.30145 = set_to_0->cil_code;
        if (D.30145 != 0B) goto <D.30146>; else goto <D.30147>;
        <D.30146>:
        D.27633 = cfg->cil_offset_to_bb;
        D.30145 = set_to_0->cil_code;
        D.30148 = (int) D.30145;
        D.27635 = cfg->cil_start;
        D.27636 = (int) D.27635;
        D.30149 = D.30148 - D.27636;
        D.30150 = (unsigned int) D.30149;
        D.30151 = D.30150 * 4;
        D.30152 = D.27633 + D.30151;
        *D.30152 = set_to_0;
        <D.30147>:
        D.27641 = cfg->real_offset;
        set_to_0->real_offset = D.27641;
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 != 0B) goto <D.30156>; else goto <D.30153>;
        <D.30156>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.30157 = D.27352->opcode;
        D.30158 = D.30157 + 64985;
        D.30159 = D.30158 <= 9;
        D.30160 = D.30157 + 64878;
        D.30161 = D.30160 <= 9;
        D.30162 = D.30159 | D.30161;
        if (D.30162 != 0) goto <D.30154>; else goto <D.30163>;
        <D.30163>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 <= 9) goto <D.30154>; else goto <D.30153>;
        <D.30154>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        D.27657 = *D.27656;
        if (D.27657 == 0B) goto <D.30164>; else goto <D.30153>;
        <D.30164>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27655 = D.27352->data.op[1].many_blocks;
        D.27656 = D.27655 + 4;
        *D.27656 = set_to_0;
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_0);
        goto <D.30155>;
        <D.30153>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        if (D.27352 == 0B) goto <D.30165>; else goto <D.30167>;
        <D.30167>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.30168 = D.27352->opcode;
        D.30169 = D.30168 != 442;
        D.30170 = D.30168 != 759;
        D.30171 = D.30169 & D.30170;
        if (D.30171 != 0) goto <D.30172>; else goto <D.30166>;
        <D.30172>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.30173 = D.27352->opcode;
        D.30174 = D.30173 + 64985;
        D.30175 = D.30174 > 9;
        D.30176 = D.30173 + 64878;
        D.30177 = D.30176 > 9;
        D.30178 = D.30175 & D.30177;
        if (D.30178 != 0) goto <D.30179>; else goto <D.30166>;
        <D.30179>:
        D.27351 = cfg->cbb;
        D.27352 = D.27351->last_ins;
        D.27653 = D.27352->opcode;
        D.27654 = D.27653 + 64888;
        if (D.27654 > 9) goto <D.30165>; else goto <D.30166>;
        <D.30165>:
        D.27351 = cfg->cbb;
        mono_link_bblock (cfg, D.27351, set_to_0);
        <D.30166>:
        <D.30155>:
        D.27351 = cfg->cbb;
        D.27351->next_bb = set_to_0;
        cfg->cbb = set_to_0;
        next->opcode = 316;
        goto <D.26741>;
      }
      <D.26783>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "decompose.c", 1052);
      <D.26741>:
      goto <D.26470>;
    }
    <D.26784>:
    goto <D.26470>;
    <D.26470>:
    D.27351 = cfg->cbb;
    D.30183 = D.27351->code;
    if (D.30183 != 0B) goto <D.30180>; else goto <D.30184>;
    <D.30184>:
    D.27351 = cfg->cbb;
    if (D.27351 != first_bb) goto <D.30180>; else goto <D.30181>;
    <D.30180>:
    {
      struct MonoInst * new_prev;

      try
        {
          new_prev = prev;
          D.27351 = cfg->cbb;
          mono_replace_ins (cfg, bb, tree, &new_prev, first_bb, D.27351);
          if (prev != 0B) goto <D.30185>; else goto <D.30186>;
          <D.30185>:
          tree = prev->next;
          goto <D.30187>;
          <D.30186>:
          tree = bb->code;
          <D.30187>:
          first_bb->last_ins = 0B;
          D.30188 = first_bb->last_ins;
          first_bb->code = D.30188;
          first_bb->out_count = 0;
          D.30189 = first_bb->out_count;
          first_bb->in_count = D.30189;
          cfg->cbb = first_bb;
        }
      finally
        {
          new_prev = {CLOBBER};
        }
    }
    goto <D.30182>;
    <D.30181>:
    prev = tree;
    tree = tree->next;
    <D.30182>:
    <D.26787>:
    if (tree != 0B) goto <D.26786>; else goto <D.26788>;
    <D.26788>:
  }
  bb = bb->next_bb;
  <D.26790>:
  if (bb != 0B) goto <D.26789>; else goto <D.26791>;
  <D.26791>:
}


mono_decompose_vtype_opts (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.30191;
  void * D.30192;
  unsigned int D.30193;
  struct MonoBasicBlock * D.30196;
  struct MonoInst * D.30197;
  short unsigned int D.30198;
  int D.30199;
  struct MonoInst * iftmp.7;
  int D.30201;
  unsigned int D.30202;
  unsigned int D.30203;
  struct MonoInst * * D.30206;
  unsigned int D.30207;
  unsigned int D.30208;
  struct MonoInst * * D.30209;
  struct MonoInst * iftmp.8;
  int D.30212;
  unsigned int D.30213;
  unsigned int D.30216;
  unsigned int D.30217;
  struct MonoInst * * D.30218;
  struct MonoClass * D.30220;
  _Bool D.30221;
  long int D.30222;
  long int D.30223;
  struct MonoType * D.30228;
  int D.30231;
  int D.30234;
  struct MonoInst * D.30235;
  int D.30236;
  int D.30237;
  const unsigned char * D.30238;
  unsigned char D.30239;
  unsigned char D.30240;
  struct MonoClass * D.30241;
  unsigned int D.30242;
  int D.30243;
  int D.30244;
  _Bool D.30245;
  long int D.30246;
  long int D.30247;
  struct MonoType * D.30250;
  int D.30251;
  _Bool iftmp.9;
  int D.30255;
  unsigned char D.30258;
  _Bool D.30259;
  _Bool D.30260;
  _Bool D.30261;
  int D.30262;
  unsigned char D.30264;
  struct MonoInst * iftmp.10;
  int D.30268;
  int D.30269;
  unsigned int D.30270;
  sizetype D.30273;
  sizetype D.30274;
  sizetype D.30275;
  struct MonoInst * * D.30276;
  struct MonoInst * iftmp.11;
  int D.30279;
  unsigned int D.30280;
  sizetype D.30283;
  sizetype D.30284;
  struct MonoInst * * D.30285;
  _Bool D.30287;
  long int D.30288;
  long int D.30289;
  _Bool D.30292;
  long int D.30293;
  long int D.30294;
  unsigned char D.30297;
  unsigned char D.30298;
  unsigned char D.30299;
  unsigned char D.30300;
  int D.30304;
  struct MonoInst * D.30305;
  int D.30306;
  int D.30307;
  unsigned char D.30308;
  unsigned char D.30309;
  struct MonoClass * D.30310;
  unsigned int D.30311;
  int D.30312;
  struct MonoType * D.30315;
  int D.30316;
  _Bool iftmp.12;
  int D.30320;
  unsigned char D.30323;
  _Bool D.30324;
  _Bool D.30325;
  _Bool D.30326;
  int D.30327;
  unsigned char D.30329;
  struct MonoInst * iftmp.13;
  int D.30333;
  int D.30334;
  unsigned int D.30335;
  sizetype D.30338;
  sizetype D.30339;
  sizetype D.30340;
  struct MonoInst * * D.30341;
  struct MonoInst * iftmp.14;
  int D.30344;
  unsigned int D.30345;
  sizetype D.30348;
  sizetype D.30349;
  struct MonoInst * * D.30350;
  _Bool D.30352;
  long int D.30353;
  long int D.30354;
  _Bool D.30357;
  long int D.30358;
  long int D.30359;
  unsigned char D.30362;
  unsigned char D.30363;
  unsigned char D.30364;
  unsigned char D.30365;
  struct MonoInst * iftmp.15;
  unsigned char D.30377;
  unsigned char D.30378;
  struct MonoClass * D.30379;
  unsigned int D.30380;
  int D.30381;
  struct MonoType * D.30384;
  int D.30385;
  _Bool iftmp.16;
  int D.30389;
  unsigned char D.30392;
  _Bool D.30393;
  _Bool D.30394;
  _Bool D.30395;
  int D.30396;
  unsigned char D.30398;
  struct MonoInst * iftmp.17;
  int D.30402;
  int D.30403;
  unsigned int D.30404;
  sizetype D.30407;
  sizetype D.30408;
  sizetype D.30409;
  struct MonoInst * * D.30410;
  struct MonoInst * iftmp.18;
  int D.30413;
  unsigned int D.30414;
  sizetype D.30417;
  sizetype D.30418;
  struct MonoInst * * D.30419;
  _Bool D.30421;
  long int D.30422;
  long int D.30423;
  _Bool D.30426;
  long int D.30427;
  long int D.30428;
  unsigned char D.30431;
  unsigned char D.30432;
  unsigned char D.30433;
  unsigned char D.30434;
  unsigned char D.30438;
  unsigned char D.30439;
  int D.30442;
  struct MonoInst * D.30443;
  int D.30444;
  int D.30445;
  struct MonoInst * iftmp.19;
  struct MonoInst * iftmp.20;
  unsigned char D.30463;
  unsigned char D.30464;
  struct MonoClass * D.30465;
  unsigned int D.30466;
  int D.30467;
  struct MonoType * D.30470;
  int D.30471;
  _Bool iftmp.21;
  int D.30475;
  unsigned char D.30478;
  _Bool D.30479;
  _Bool D.30480;
  _Bool D.30481;
  int D.30482;
  unsigned char D.30484;
  struct MonoInst * iftmp.22;
  int D.30488;
  int D.30489;
  unsigned int D.30490;
  sizetype D.30493;
  sizetype D.30494;
  sizetype D.30495;
  struct MonoInst * * D.30496;
  struct MonoInst * iftmp.23;
  int D.30499;
  unsigned int D.30500;
  sizetype D.30503;
  sizetype D.30504;
  struct MonoInst * * D.30505;
  _Bool D.30507;
  long int D.30508;
  long int D.30509;
  _Bool D.30512;
  long int D.30513;
  long int D.30514;
  unsigned char D.30517;
  unsigned char D.30518;
  unsigned char D.30519;
  unsigned char D.30520;
  unsigned int D.30524;
  int D.30525;
  struct MonoInst * iftmp.24;
  unsigned int D.30537;
  unsigned int D.30541;
  int D.30542;
  int D.30545;
  _Bool iftmp.25;
  int D.30549;
  unsigned char D.30552;
  _Bool D.30553;
  _Bool D.30554;
  _Bool D.30555;
  int D.30556;
  struct MonoInst * iftmp.26;
  struct MonoInst * iftmp.27;
  _Bool D.30568;
  long int D.30569;
  long int D.30570;
  _Bool D.30573;
  long int D.30574;
  long int D.30575;
  unsigned char D.30578;
  unsigned char D.30579;
  unsigned char D.30580;
  unsigned char D.30581;
  int D.30585;
  struct MonoInst * iftmp.28;
  unsigned int D.30594;
  int D.30595;
  int D.30598;
  _Bool iftmp.29;
  int D.30602;
  unsigned char D.30605;
  _Bool D.30606;
  _Bool D.30607;
  _Bool D.30608;
  int D.30609;
  struct MonoInst * iftmp.30;
  struct MonoInst * iftmp.31;
  _Bool D.30621;
  long int D.30622;
  long int D.30623;
  _Bool D.30626;
  long int D.30627;
  long int D.30628;
  unsigned char D.30631;
  unsigned char D.30632;
  unsigned char D.30633;
  unsigned char D.30634;
  struct MonoInst * iftmp.32;
  int D.30639;
  unsigned int D.30640;
  unsigned int D.30643;
  unsigned int D.30644;
  struct MonoInst * * D.30645;
  struct MonoMethodSignature * D.30649;
  struct MonoType * D.30650;
  unsigned int D.30651;
  int D.30652;
  int D.30655;
  _Bool iftmp.33;
  int D.30659;
  unsigned char D.30662;
  _Bool D.30663;
  _Bool D.30664;
  _Bool D.30665;
  int D.30666;
  struct MonoInst * iftmp.34;
  struct MonoInst * iftmp.35;
  _Bool D.30678;
  long int D.30679;
  long int D.30680;
  _Bool D.30683;
  long int D.30684;
  long int D.30685;
  unsigned char D.30688;
  unsigned char D.30689;
  unsigned char D.30690;
  unsigned char D.30691;
  unsigned char D.30695;
  unsigned char D.30696;
  int D.30699;
  int D.30700;
  unsigned int D.30702;
  int D.30703;
  struct MonoInst * iftmp.36;
  int D.30708;
  unsigned int D.30709;
  unsigned int D.30712;
  unsigned int D.30713;
  struct MonoInst * * D.30714;
  struct MonoMethodSignature * D.30718;
  struct MonoType * D.30719;
  unsigned int D.30720;
  int D.30721;
  int D.30724;
  _Bool iftmp.37;
  int D.30728;
  unsigned char D.30731;
  _Bool D.30732;
  _Bool D.30733;
  _Bool D.30734;
  int D.30735;
  struct MonoInst * iftmp.38;
  struct MonoInst * iftmp.39;
  _Bool D.30747;
  long int D.30748;
  long int D.30749;
  _Bool D.30752;
  long int D.30753;
  long int D.30754;
  unsigned char D.30757;
  unsigned char D.30758;
  unsigned char D.30759;
  unsigned char D.30760;
  struct MonoClass * D.30766;
  int D.30768;
  struct MonoInst * D.30769;
  int D.30770;
  int D.30771;
  int D.30772;
  int D.30773;
  int D.30777;
  struct MonoInst * D.30778;
  int D.30779;
  int D.30780;
  int D.30784;
  struct MonoInst * D.30785;
  int D.30786;
  int D.30787;
  short unsigned int D.30791;
  int D.30792;
  unsigned int D.30794;
  int D.30795;
  int D.30796;
  struct MonoInst * D.30797;
  int D.30798;
  int D.30799;
  int D.30800;
  int D.30804;
  struct MonoInst * D.30805;
  int D.30806;
  int D.30807;
  int D.30808;
  int D.30812;
  struct MonoInst * D.30813;
  int D.30814;
  int D.30815;
  _Bool D.30821;
  long int D.30822;
  long int D.30823;
  struct MonoInst * D.30829;
  struct MonoInst * D.30831;
  short int D.30832;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * first_bb;

  D.30191 = cfg->mempool;
  D.30192 = mono_mempool_alloc0 (D.30191, 172);
  cfg->cbb = D.30192;
  first_bb = cfg->cbb;
  bb = cfg->bb_entry;
  goto <D.26874>;
  <D.26873>:
  {
    struct MonoInst * ins;
    struct MonoInst * prev;
    struct MonoInst * src_var;
    struct MonoInst * dest_var;
    struct MonoInst * src;
    struct MonoInst * dest;
    gboolean restart;
    int dreg;

    try
      {
        prev = 0B;
        D.30193 = cfg->verbose_level;
        if (D.30193 > 2) goto <D.30194>; else goto <D.30195>;
        <D.30194>:
        mono_print_bb (bb, "BEFORE LOWER-VTYPE-OPTS ");
        <D.30195>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = 0B;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        restart = 1;
        goto <D.26871>;
        <D.26870>:
        restart = 0;
        ins = bb->code;
        goto <D.26868>;
        <D.26867>:
        D.30198 = ins->opcode;
        D.30199 = (int) D.30198;
        switch (D.30199) <default: <D.26866>, case 333: <D.26823>, case 334: <D.26826>, case 355: <D.26830>, case 356: <D.26831>, case 357: <D.26832>, case 387: <D.26816>, case 399: <D.26820>, case 427: <D.26805>, case 428: <D.26811>>
        <D.26805>:
        D.30201 = ins->sreg1;
        D.30202 = (unsigned int) D.30201;
        D.30203 = cfg->vreg_to_inst_len;
        if (D.30202 < D.30203) goto <D.30204>; else goto <D.30205>;
        <D.30204>:
        D.30206 = cfg->vreg_to_inst;
        D.30201 = ins->sreg1;
        D.30207 = (unsigned int) D.30201;
        D.30208 = D.30207 * 4;
        D.30209 = D.30206 + D.30208;
        iftmp.7 = *D.30209;
        goto <D.30210>;
        <D.30205>:
        iftmp.7 = 0B;
        <D.30210>:
        src_var = iftmp.7;
        D.30212 = ins->dreg;
        D.30213 = (unsigned int) D.30212;
        D.30203 = cfg->vreg_to_inst_len;
        if (D.30213 < D.30203) goto <D.30214>; else goto <D.30215>;
        <D.30214>:
        D.30206 = cfg->vreg_to_inst;
        D.30212 = ins->dreg;
        D.30216 = (unsigned int) D.30212;
        D.30217 = D.30216 * 4;
        D.30218 = D.30206 + D.30217;
        iftmp.8 = *D.30218;
        goto <D.30219>;
        <D.30215>:
        iftmp.8 = 0B;
        <D.30219>:
        dest_var = iftmp.8;
        D.30220 = ins->klass;
        D.30221 = D.30220 == 0B;
        D.30222 = (long int) D.30221;
        D.30223 = __builtin_expect (D.30222, 0);
        if (D.30223 != 0) goto <D.30224>; else goto <D.30225>;
        <D.30224>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1153, "ins->klass");
        <D.30225>:
        if (src_var == 0B) goto <D.30226>; else goto <D.30227>;
        <D.30226>:
        D.30220 = ins->klass;
        D.30228 = &D.30220->byval_arg;
        D.30212 = ins->dreg;
        src_var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30212);
        <D.30227>:
        if (dest_var == 0B) goto <D.30229>; else goto <D.30230>;
        <D.30229>:
        D.30220 = ins->klass;
        D.30228 = &D.30220->byval_arg;
        D.30212 = ins->dreg;
        dest_var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30212);
        <D.30230>:
        D.30231 = src_var->backend.is_pinvoke;
        if (D.30231 != 0) goto <D.30232>; else goto <D.30233>;
        <D.30232>:
        dest_var->backend.is_pinvoke = 1;
        <D.30233>:
        D.30191 = cfg->mempool;
        src = mono_mempool_alloc (D.30191, 56);
        src->data.op[1].const_val = 0;
        D.30234 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.30234;
        src->prev = 0B;
        D.30235 = src->prev;
        src->next = D.30235;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.30236 = src->sreg3;
        src->sreg2 = D.30236;
        D.30237 = src->sreg2;
        src->sreg1 = D.30237;
        D.30238 = cfg->ip;
        src->cil_code = D.30238;
        src->data.op[0].p = src_var;
        D.30239 = src_var->flags;
        D.30240 = D.30239 | 16;
        src_var->flags = D.30240;
        src->type = 5;
        D.30241 = src_var->klass;
        src->klass = D.30241;
        D.30242 = alloc_dreg (cfg, 5);
        D.30243 = (int) D.30242;
        src->dreg = D.30243;
        cfg->has_indirection = 1;
        D.30244 = cfg->gsharedvt;
        D.30245 = D.30244 != 0;
        D.30246 = (long int) D.30245;
        D.30247 = __builtin_expect (D.30246, 0);
        if (D.30247 != 0) goto <D.30248>; else goto <D.30249>;
        <D.30248>:
        D.30250 = src_var->data.op[1].vtype;
        D.30251 = mini_is_gsharedvt_variable_type (cfg, D.30250);
        if (D.30251 != 0) goto <D.30252>; else goto <D.30253>;
        <D.30252>:
        handle_gsharedvt_ldaddr (cfg);
        <D.30253>:
        <D.30249>:
        D.30255 = mono_arch_is_soft_float ();
        if (D.30255 != 0) goto <D.30256>; else goto <D.30257>;
        <D.30256>:
        D.30258 = src_var->type;
        D.30259 = D.30258 == 2;
        D.30260 = D.30258 == 4;
        D.30261 = D.30259 | D.30260;
        D.30262 = (int) D.30261;
        iftmp.9 = (_Bool) D.30262;
        goto <D.30263>;
        <D.30257>:
        D.30264 = src_var->type;
        iftmp.9 = D.30264 == 2;
        <D.30263>:
        if (iftmp.9 != 0) goto <D.30265>; else goto <D.30266>;
        <D.30265>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30268 = src_var->dreg;
          D.30269 = D.30268 + 1;
          D.30270 = (unsigned int) D.30269;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30270 < D.30203) goto <D.30271>; else goto <D.30272>;
          <D.30271>:
          D.30206 = cfg->vreg_to_inst;
          D.30268 = src_var->dreg;
          D.30273 = (sizetype) D.30268;
          D.30274 = D.30273 + 1;
          D.30275 = D.30274 * 4;
          D.30276 = D.30206 + D.30275;
          iftmp.10 = *D.30276;
          goto <D.30277>;
          <D.30272>:
          iftmp.10 = 0B;
          <D.30277>:
          var1 = iftmp.10;
          D.30268 = src_var->dreg;
          D.30279 = D.30268 + 2;
          D.30280 = (unsigned int) D.30279;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30280 < D.30203) goto <D.30281>; else goto <D.30282>;
          <D.30281>:
          D.30206 = cfg->vreg_to_inst;
          D.30268 = src_var->dreg;
          D.30273 = (sizetype) D.30268;
          D.30283 = D.30273 + 2;
          D.30284 = D.30283 * 4;
          D.30285 = D.30206 + D.30284;
          iftmp.11 = *D.30285;
          goto <D.30286>;
          <D.30282>:
          iftmp.11 = 0B;
          <D.30286>:
          var2 = iftmp.11;
          D.30287 = var1 == 0B;
          D.30288 = (long int) D.30287;
          D.30289 = __builtin_expect (D.30288, 0);
          if (D.30289 != 0) goto <D.30290>; else goto <D.30291>;
          <D.30290>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1165, "var1");
          <D.30291>:
          D.30292 = var2 == 0B;
          D.30293 = (long int) D.30292;
          D.30294 = __builtin_expect (D.30293, 0);
          if (D.30294 != 0) goto <D.30295>; else goto <D.30296>;
          <D.30295>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1165, "var2");
          <D.30296>:
          D.30297 = var1->flags;
          D.30298 = D.30297 | 16;
          var1->flags = D.30298;
          D.30299 = var2->flags;
          D.30300 = D.30299 | 16;
          var2->flags = D.30300;
        }
        <D.30266>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30301>; else goto <D.30302>;
        <D.30301>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = src;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        src->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        goto <D.30303>;
        <D.30302>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30303>:
        D.30191 = cfg->mempool;
        dest = mono_mempool_alloc (D.30191, 56);
        dest->data.op[1].const_val = 0;
        D.30304 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.30304;
        dest->prev = 0B;
        D.30305 = dest->prev;
        dest->next = D.30305;
        dest->opcode = 314;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.30306 = dest->sreg3;
        dest->sreg2 = D.30306;
        D.30307 = dest->sreg2;
        dest->sreg1 = D.30307;
        D.30238 = cfg->ip;
        dest->cil_code = D.30238;
        dest->data.op[0].p = dest_var;
        D.30308 = dest_var->flags;
        D.30309 = D.30308 | 16;
        dest_var->flags = D.30309;
        dest->type = 5;
        D.30310 = dest_var->klass;
        dest->klass = D.30310;
        D.30311 = alloc_dreg (cfg, 5);
        D.30312 = (int) D.30311;
        dest->dreg = D.30312;
        cfg->has_indirection = 1;
        D.30244 = cfg->gsharedvt;
        D.30245 = D.30244 != 0;
        D.30246 = (long int) D.30245;
        D.30247 = __builtin_expect (D.30246, 0);
        if (D.30247 != 0) goto <D.30313>; else goto <D.30314>;
        <D.30313>:
        D.30315 = dest_var->data.op[1].vtype;
        D.30316 = mini_is_gsharedvt_variable_type (cfg, D.30315);
        if (D.30316 != 0) goto <D.30317>; else goto <D.30318>;
        <D.30317>:
        handle_gsharedvt_ldaddr (cfg);
        <D.30318>:
        <D.30314>:
        D.30320 = mono_arch_is_soft_float ();
        if (D.30320 != 0) goto <D.30321>; else goto <D.30322>;
        <D.30321>:
        D.30323 = dest_var->type;
        D.30324 = D.30323 == 2;
        D.30325 = D.30323 == 4;
        D.30326 = D.30324 | D.30325;
        D.30327 = (int) D.30326;
        iftmp.12 = (_Bool) D.30327;
        goto <D.30328>;
        <D.30322>:
        D.30329 = dest_var->type;
        iftmp.12 = D.30329 == 2;
        <D.30328>:
        if (iftmp.12 != 0) goto <D.30330>; else goto <D.30331>;
        <D.30330>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30333 = dest_var->dreg;
          D.30334 = D.30333 + 1;
          D.30335 = (unsigned int) D.30334;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30335 < D.30203) goto <D.30336>; else goto <D.30337>;
          <D.30336>:
          D.30206 = cfg->vreg_to_inst;
          D.30333 = dest_var->dreg;
          D.30338 = (sizetype) D.30333;
          D.30339 = D.30338 + 1;
          D.30340 = D.30339 * 4;
          D.30341 = D.30206 + D.30340;
          iftmp.13 = *D.30341;
          goto <D.30342>;
          <D.30337>:
          iftmp.13 = 0B;
          <D.30342>:
          var1 = iftmp.13;
          D.30333 = dest_var->dreg;
          D.30344 = D.30333 + 2;
          D.30345 = (unsigned int) D.30344;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30345 < D.30203) goto <D.30346>; else goto <D.30347>;
          <D.30346>:
          D.30206 = cfg->vreg_to_inst;
          D.30333 = dest_var->dreg;
          D.30338 = (sizetype) D.30333;
          D.30348 = D.30338 + 2;
          D.30349 = D.30348 * 4;
          D.30350 = D.30206 + D.30349;
          iftmp.14 = *D.30350;
          goto <D.30351>;
          <D.30347>:
          iftmp.14 = 0B;
          <D.30351>:
          var2 = iftmp.14;
          D.30352 = var1 == 0B;
          D.30353 = (long int) D.30352;
          D.30354 = __builtin_expect (D.30353, 0);
          if (D.30354 != 0) goto <D.30355>; else goto <D.30356>;
          <D.30355>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1166, "var1");
          <D.30356>:
          D.30357 = var2 == 0B;
          D.30358 = (long int) D.30357;
          D.30359 = __builtin_expect (D.30358, 0);
          if (D.30359 != 0) goto <D.30360>; else goto <D.30361>;
          <D.30360>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1166, "var2");
          <D.30361>:
          D.30362 = var1->flags;
          D.30363 = D.30362 | 16;
          var1->flags = D.30363;
          D.30364 = var2->flags;
          D.30365 = D.30364 | 16;
          var2->flags = D.30365;
        }
        <D.30331>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30366>; else goto <D.30367>;
        <D.30366>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = dest;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        dest->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        goto <D.30368>;
        <D.30367>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30368>:
        D.30241 = src_var->klass;
        D.30231 = src_var->backend.is_pinvoke;
        mini_emit_stobj (cfg, dest, src, D.30241, D.30231);
        goto <D.26810>;
        <D.26811>:
        D.30220 = ins->klass;
        D.30221 = D.30220 == 0B;
        D.30222 = (long int) D.30221;
        D.30223 = __builtin_expect (D.30222, 0);
        if (D.30223 != 0) goto <D.30369>; else goto <D.30370>;
        <D.30369>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1172, "ins->klass");
        <D.30370>:
        {
          struct MonoInst * var;

          D.30212 = ins->dreg;
          D.30213 = (unsigned int) D.30212;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30213 < D.30203) goto <D.30372>; else goto <D.30373>;
          <D.30372>:
          D.30206 = cfg->vreg_to_inst;
          D.30212 = ins->dreg;
          D.30216 = (unsigned int) D.30212;
          D.30217 = D.30216 * 4;
          D.30218 = D.30206 + D.30217;
          iftmp.15 = *D.30218;
          goto <D.30374>;
          <D.30373>:
          iftmp.15 = 0B;
          <D.30374>:
          var = iftmp.15;
          if (var == 0B) goto <D.30375>; else goto <D.30376>;
          <D.30375>:
          D.30220 = ins->klass;
          D.30228 = &D.30220->byval_arg;
          D.30212 = ins->dreg;
          var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30212);
          <D.30376>:
          D.30191 = cfg->mempool;
          dest = mono_mempool_alloc (D.30191, 56);
          dest->data.op[1].const_val = 0;
          D.30304 = dest->data.op[1].const_val;
          dest->data.op[0].const_val = D.30304;
          dest->prev = 0B;
          D.30305 = dest->prev;
          dest->next = D.30305;
          dest->opcode = 314;
          dest->flags = 0;
          dest->type = 0;
          dest->dreg = -1;
          dest->sreg3 = -1;
          D.30306 = dest->sreg3;
          dest->sreg2 = D.30306;
          D.30307 = dest->sreg2;
          dest->sreg1 = D.30307;
          D.30238 = cfg->ip;
          dest->cil_code = D.30238;
          dest->data.op[0].p = var;
          D.30377 = var->flags;
          D.30378 = D.30377 | 16;
          var->flags = D.30378;
          dest->type = 5;
          D.30379 = var->klass;
          dest->klass = D.30379;
          D.30380 = alloc_dreg (cfg, 5);
          D.30381 = (int) D.30380;
          dest->dreg = D.30381;
          cfg->has_indirection = 1;
          D.30244 = cfg->gsharedvt;
          D.30245 = D.30244 != 0;
          D.30246 = (long int) D.30245;
          D.30247 = __builtin_expect (D.30246, 0);
          if (D.30247 != 0) goto <D.30382>; else goto <D.30383>;
          <D.30382>:
          D.30384 = var->data.op[1].vtype;
          D.30385 = mini_is_gsharedvt_variable_type (cfg, D.30384);
          if (D.30385 != 0) goto <D.30386>; else goto <D.30387>;
          <D.30386>:
          handle_gsharedvt_ldaddr (cfg);
          <D.30387>:
          <D.30383>:
          D.30389 = mono_arch_is_soft_float ();
          if (D.30389 != 0) goto <D.30390>; else goto <D.30391>;
          <D.30390>:
          D.30392 = var->type;
          D.30393 = D.30392 == 2;
          D.30394 = D.30392 == 4;
          D.30395 = D.30393 | D.30394;
          D.30396 = (int) D.30395;
          iftmp.16 = (_Bool) D.30396;
          goto <D.30397>;
          <D.30391>:
          D.30398 = var->type;
          iftmp.16 = D.30398 == 2;
          <D.30397>:
          if (iftmp.16 != 0) goto <D.30399>; else goto <D.30400>;
          <D.30399>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.30402 = var->dreg;
            D.30403 = D.30402 + 1;
            D.30404 = (unsigned int) D.30403;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30404 < D.30203) goto <D.30405>; else goto <D.30406>;
            <D.30405>:
            D.30206 = cfg->vreg_to_inst;
            D.30402 = var->dreg;
            D.30407 = (sizetype) D.30402;
            D.30408 = D.30407 + 1;
            D.30409 = D.30408 * 4;
            D.30410 = D.30206 + D.30409;
            iftmp.17 = *D.30410;
            goto <D.30411>;
            <D.30406>:
            iftmp.17 = 0B;
            <D.30411>:
            var1 = iftmp.17;
            D.30402 = var->dreg;
            D.30413 = D.30402 + 2;
            D.30414 = (unsigned int) D.30413;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30414 < D.30203) goto <D.30415>; else goto <D.30416>;
            <D.30415>:
            D.30206 = cfg->vreg_to_inst;
            D.30402 = var->dreg;
            D.30407 = (sizetype) D.30402;
            D.30417 = D.30407 + 2;
            D.30418 = D.30417 * 4;
            D.30419 = D.30206 + D.30418;
            iftmp.18 = *D.30419;
            goto <D.30420>;
            <D.30416>:
            iftmp.18 = 0B;
            <D.30420>:
            var2 = iftmp.18;
            D.30421 = var1 == 0B;
            D.30422 = (long int) D.30421;
            D.30423 = __builtin_expect (D.30422, 0);
            if (D.30423 != 0) goto <D.30424>; else goto <D.30425>;
            <D.30424>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1174, "var1");
            <D.30425>:
            D.30426 = var2 == 0B;
            D.30427 = (long int) D.30426;
            D.30428 = __builtin_expect (D.30427, 0);
            if (D.30428 != 0) goto <D.30429>; else goto <D.30430>;
            <D.30429>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1174, "var2");
            <D.30430>:
            D.30431 = var1->flags;
            D.30432 = D.30431 | 16;
            var1->flags = D.30432;
            D.30433 = var2->flags;
            D.30434 = D.30433 | 16;
            var2->flags = D.30434;
          }
          <D.30400>:
        }
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30435>; else goto <D.30436>;
        <D.30435>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = dest;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        dest->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        goto <D.30437>;
        <D.30436>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30437>:
        D.30220 = ins->klass;
        mini_emit_initobj (cfg, dest, 0B, D.30220);
        D.30438 = BIT_FIELD_REF <*cfg, 8, 3424>;
        D.30439 = D.30438 & 128;
        if (D.30439 != 0) goto <D.30440>; else goto <D.30441>;
        <D.30440>:
        {
          struct MonoInst * tmp;

          D.30191 = cfg->mempool;
          tmp = mono_mempool_alloc (D.30191, 56);
          tmp->data.op[1].const_val = 0;
          D.30442 = tmp->data.op[1].const_val;
          tmp->data.op[0].const_val = D.30442;
          tmp->prev = 0B;
          D.30443 = tmp->prev;
          tmp->next = D.30443;
          tmp->opcode = 838;
          tmp->flags = 0;
          tmp->type = 0;
          tmp->dreg = -1;
          tmp->sreg3 = -1;
          D.30444 = tmp->sreg3;
          tmp->sreg2 = D.30444;
          D.30445 = tmp->sreg2;
          tmp->sreg1 = D.30445;
          D.30238 = cfg->ip;
          tmp->cil_code = D.30238;
          D.30212 = ins->dreg;
          tmp->data.op[1].const_val = D.30212;
          D.30196 = cfg->cbb;
          D.30197 = D.30196->last_ins;
          if (D.30197 != 0B) goto <D.30446>; else goto <D.30447>;
          <D.30446>:
          D.30196 = cfg->cbb;
          D.30197 = D.30196->last_ins;
          D.30197->next = tmp;
          D.30196 = cfg->cbb;
          D.30197 = D.30196->last_ins;
          tmp->prev = D.30197;
          D.30196 = cfg->cbb;
          D.30196->last_ins = tmp;
          goto <D.30448>;
          <D.30447>:
          D.30196 = cfg->cbb;
          D.30196 = cfg->cbb;
          D.30196->last_ins = tmp;
          D.30197 = D.30196->last_ins;
          D.30196->code = D.30197;
          <D.30448>:
        }
        <D.30441>:
        goto <D.26810>;
        <D.26816>:
        D.30201 = ins->sreg1;
        D.30202 = (unsigned int) D.30201;
        D.30203 = cfg->vreg_to_inst_len;
        if (D.30202 < D.30203) goto <D.30450>; else goto <D.30451>;
        <D.30450>:
        D.30206 = cfg->vreg_to_inst;
        D.30201 = ins->sreg1;
        D.30207 = (unsigned int) D.30201;
        D.30208 = D.30207 * 4;
        D.30209 = D.30206 + D.30208;
        iftmp.19 = *D.30209;
        goto <D.30452>;
        <D.30451>:
        iftmp.19 = 0B;
        <D.30452>:
        src_var = iftmp.19;
        if (src_var == 0B) goto <D.30453>; else goto <D.30454>;
        <D.30453>:
        D.30220 = ins->klass;
        D.30221 = D.30220 == 0B;
        D.30222 = (long int) D.30221;
        D.30223 = __builtin_expect (D.30222, 0);
        if (D.30223 != 0) goto <D.30455>; else goto <D.30456>;
        <D.30455>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1193, "ins->klass");
        <D.30456>:
        D.30220 = ins->klass;
        D.30228 = &D.30220->byval_arg;
        D.30201 = ins->sreg1;
        src_var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30201);
        <D.30454>:
        {
          struct MonoInst * var;

          D.30201 = ins->sreg1;
          D.30202 = (unsigned int) D.30201;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30202 < D.30203) goto <D.30458>; else goto <D.30459>;
          <D.30458>:
          D.30206 = cfg->vreg_to_inst;
          D.30201 = ins->sreg1;
          D.30207 = (unsigned int) D.30201;
          D.30208 = D.30207 * 4;
          D.30209 = D.30206 + D.30208;
          iftmp.20 = *D.30209;
          goto <D.30460>;
          <D.30459>:
          iftmp.20 = 0B;
          <D.30460>:
          var = iftmp.20;
          if (var == 0B) goto <D.30461>; else goto <D.30462>;
          <D.30461>:
          D.30220 = ins->klass;
          D.30228 = &D.30220->byval_arg;
          D.30201 = ins->sreg1;
          var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30201);
          <D.30462>:
          D.30191 = cfg->mempool;
          src = mono_mempool_alloc (D.30191, 56);
          src->data.op[1].const_val = 0;
          D.30234 = src->data.op[1].const_val;
          src->data.op[0].const_val = D.30234;
          src->prev = 0B;
          D.30235 = src->prev;
          src->next = D.30235;
          src->opcode = 314;
          src->flags = 0;
          src->type = 0;
          src->dreg = -1;
          src->sreg3 = -1;
          D.30236 = src->sreg3;
          src->sreg2 = D.30236;
          D.30237 = src->sreg2;
          src->sreg1 = D.30237;
          D.30238 = cfg->ip;
          src->cil_code = D.30238;
          src->data.op[0].p = var;
          D.30463 = var->flags;
          D.30464 = D.30463 | 16;
          var->flags = D.30464;
          src->type = 5;
          D.30465 = var->klass;
          src->klass = D.30465;
          D.30466 = alloc_dreg (cfg, 5);
          D.30467 = (int) D.30466;
          src->dreg = D.30467;
          cfg->has_indirection = 1;
          D.30244 = cfg->gsharedvt;
          D.30245 = D.30244 != 0;
          D.30246 = (long int) D.30245;
          D.30247 = __builtin_expect (D.30246, 0);
          if (D.30247 != 0) goto <D.30468>; else goto <D.30469>;
          <D.30468>:
          D.30470 = var->data.op[1].vtype;
          D.30471 = mini_is_gsharedvt_variable_type (cfg, D.30470);
          if (D.30471 != 0) goto <D.30472>; else goto <D.30473>;
          <D.30472>:
          handle_gsharedvt_ldaddr (cfg);
          <D.30473>:
          <D.30469>:
          D.30475 = mono_arch_is_soft_float ();
          if (D.30475 != 0) goto <D.30476>; else goto <D.30477>;
          <D.30476>:
          D.30478 = var->type;
          D.30479 = D.30478 == 2;
          D.30480 = D.30478 == 4;
          D.30481 = D.30479 | D.30480;
          D.30482 = (int) D.30481;
          iftmp.21 = (_Bool) D.30482;
          goto <D.30483>;
          <D.30477>:
          D.30484 = var->type;
          iftmp.21 = D.30484 == 2;
          <D.30483>:
          if (iftmp.21 != 0) goto <D.30485>; else goto <D.30486>;
          <D.30485>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.30488 = var->dreg;
            D.30489 = D.30488 + 1;
            D.30490 = (unsigned int) D.30489;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30490 < D.30203) goto <D.30491>; else goto <D.30492>;
            <D.30491>:
            D.30206 = cfg->vreg_to_inst;
            D.30488 = var->dreg;
            D.30493 = (sizetype) D.30488;
            D.30494 = D.30493 + 1;
            D.30495 = D.30494 * 4;
            D.30496 = D.30206 + D.30495;
            iftmp.22 = *D.30496;
            goto <D.30497>;
            <D.30492>:
            iftmp.22 = 0B;
            <D.30497>:
            var1 = iftmp.22;
            D.30488 = var->dreg;
            D.30499 = D.30488 + 2;
            D.30500 = (unsigned int) D.30499;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30500 < D.30203) goto <D.30501>; else goto <D.30502>;
            <D.30501>:
            D.30206 = cfg->vreg_to_inst;
            D.30488 = var->dreg;
            D.30493 = (sizetype) D.30488;
            D.30503 = D.30493 + 2;
            D.30504 = D.30503 * 4;
            D.30505 = D.30206 + D.30504;
            iftmp.23 = *D.30505;
            goto <D.30506>;
            <D.30502>:
            iftmp.23 = 0B;
            <D.30506>:
            var2 = iftmp.23;
            D.30507 = var1 == 0B;
            D.30508 = (long int) D.30507;
            D.30509 = __builtin_expect (D.30508, 0);
            if (D.30509 != 0) goto <D.30510>; else goto <D.30511>;
            <D.30510>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1197, "var1");
            <D.30511>:
            D.30512 = var2 == 0B;
            D.30513 = (long int) D.30512;
            D.30514 = __builtin_expect (D.30513, 0);
            if (D.30514 != 0) goto <D.30515>; else goto <D.30516>;
            <D.30515>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1197, "var2");
            <D.30516>:
            D.30517 = var1->flags;
            D.30518 = D.30517 | 16;
            var1->flags = D.30518;
            D.30519 = var2->flags;
            D.30520 = D.30519 | 16;
            var2->flags = D.30520;
          }
          <D.30486>:
        }
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30521>; else goto <D.30522>;
        <D.30521>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = src;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        src->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        goto <D.30523>;
        <D.30522>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30523>:
        D.30524 = alloc_preg (cfg);
        dreg = (int) D.30524;
        D.30191 = cfg->mempool;
        dest = mono_mempool_alloc (D.30191, 56);
        dest->data.op[1].const_val = 0;
        D.30304 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.30304;
        dest->prev = 0B;
        D.30305 = dest->prev;
        dest->next = D.30305;
        dest->opcode = 429;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.30306 = dest->sreg3;
        dest->sreg2 = D.30306;
        D.30307 = dest->sreg2;
        dest->sreg1 = D.30307;
        D.30238 = cfg->ip;
        dest->cil_code = D.30238;
        dest->dreg = dreg;
        D.30212 = ins->dreg;
        dest->sreg1 = D.30212;
        D.30525 = ins->data.op[0].const_val;
        dest->data.op[1].const_val = D.30525;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30526>; else goto <D.30527>;
        <D.30526>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = dest;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        dest->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        goto <D.30528>;
        <D.30527>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30528>:
        D.30241 = src_var->klass;
        D.30231 = src_var->backend.is_pinvoke;
        mini_emit_stobj (cfg, dest, src, D.30241, D.30231);
        goto <D.26810>;
        <D.26820>:
        D.30220 = ins->klass;
        D.30221 = D.30220 == 0B;
        D.30222 = (long int) D.30221;
        D.30223 = __builtin_expect (D.30222, 0);
        if (D.30223 != 0) goto <D.30529>; else goto <D.30530>;
        <D.30529>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1205, "ins->klass");
        <D.30530>:
        D.30212 = ins->dreg;
        D.30213 = (unsigned int) D.30212;
        D.30203 = cfg->vreg_to_inst_len;
        if (D.30213 < D.30203) goto <D.30532>; else goto <D.30533>;
        <D.30532>:
        D.30206 = cfg->vreg_to_inst;
        D.30212 = ins->dreg;
        D.30216 = (unsigned int) D.30212;
        D.30217 = D.30216 * 4;
        D.30218 = D.30206 + D.30217;
        iftmp.24 = *D.30218;
        goto <D.30534>;
        <D.30533>:
        iftmp.24 = 0B;
        <D.30534>:
        dest_var = iftmp.24;
        if (dest_var == 0B) goto <D.30535>; else goto <D.30536>;
        <D.30535>:
        D.30220 = ins->klass;
        D.30228 = &D.30220->byval_arg;
        D.30212 = ins->dreg;
        dest_var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30212);
        <D.30536>:
        D.30537 = alloc_preg (cfg);
        dreg = (int) D.30537;
        D.30191 = cfg->mempool;
        src = mono_mempool_alloc (D.30191, 56);
        src->data.op[1].const_val = 0;
        D.30234 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.30234;
        src->prev = 0B;
        D.30235 = src->prev;
        src->next = D.30235;
        src->opcode = 429;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.30236 = src->sreg3;
        src->sreg2 = D.30236;
        D.30237 = src->sreg2;
        src->sreg1 = D.30237;
        D.30238 = cfg->ip;
        src->cil_code = D.30238;
        src->dreg = dreg;
        D.30201 = ins->sreg1;
        src->sreg1 = D.30201;
        D.30525 = ins->data.op[0].const_val;
        src->data.op[1].const_val = D.30525;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30538>; else goto <D.30539>;
        <D.30538>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = src;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        src->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        goto <D.30540>;
        <D.30539>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30540>:
        D.30191 = cfg->mempool;
        dest = mono_mempool_alloc (D.30191, 56);
        dest->data.op[1].const_val = 0;
        D.30304 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.30304;
        dest->prev = 0B;
        D.30305 = dest->prev;
        dest->next = D.30305;
        dest->opcode = 314;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.30306 = dest->sreg3;
        dest->sreg2 = D.30306;
        D.30307 = dest->sreg2;
        dest->sreg1 = D.30307;
        D.30238 = cfg->ip;
        dest->cil_code = D.30238;
        dest->data.op[0].p = dest_var;
        D.30308 = dest_var->flags;
        D.30309 = D.30308 | 16;
        dest_var->flags = D.30309;
        dest->type = 5;
        D.30310 = dest_var->klass;
        dest->klass = D.30310;
        D.30541 = alloc_dreg (cfg, 5);
        D.30542 = (int) D.30541;
        dest->dreg = D.30542;
        cfg->has_indirection = 1;
        D.30244 = cfg->gsharedvt;
        D.30245 = D.30244 != 0;
        D.30246 = (long int) D.30245;
        D.30247 = __builtin_expect (D.30246, 0);
        if (D.30247 != 0) goto <D.30543>; else goto <D.30544>;
        <D.30543>:
        D.30315 = dest_var->data.op[1].vtype;
        D.30545 = mini_is_gsharedvt_variable_type (cfg, D.30315);
        if (D.30545 != 0) goto <D.30546>; else goto <D.30547>;
        <D.30546>:
        handle_gsharedvt_ldaddr (cfg);
        <D.30547>:
        <D.30544>:
        D.30549 = mono_arch_is_soft_float ();
        if (D.30549 != 0) goto <D.30550>; else goto <D.30551>;
        <D.30550>:
        D.30552 = dest_var->type;
        D.30553 = D.30552 == 2;
        D.30554 = D.30552 == 4;
        D.30555 = D.30553 | D.30554;
        D.30556 = (int) D.30555;
        iftmp.25 = (_Bool) D.30556;
        goto <D.30557>;
        <D.30551>:
        D.30329 = dest_var->type;
        iftmp.25 = D.30329 == 2;
        <D.30557>:
        if (iftmp.25 != 0) goto <D.30558>; else goto <D.30559>;
        <D.30558>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30333 = dest_var->dreg;
          D.30334 = D.30333 + 1;
          D.30335 = (unsigned int) D.30334;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30335 < D.30203) goto <D.30561>; else goto <D.30562>;
          <D.30561>:
          D.30206 = cfg->vreg_to_inst;
          D.30333 = dest_var->dreg;
          D.30338 = (sizetype) D.30333;
          D.30339 = D.30338 + 1;
          D.30340 = D.30339 * 4;
          D.30341 = D.30206 + D.30340;
          iftmp.26 = *D.30341;
          goto <D.30563>;
          <D.30562>:
          iftmp.26 = 0B;
          <D.30563>:
          var1 = iftmp.26;
          D.30333 = dest_var->dreg;
          D.30344 = D.30333 + 2;
          D.30345 = (unsigned int) D.30344;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30345 < D.30203) goto <D.30565>; else goto <D.30566>;
          <D.30565>:
          D.30206 = cfg->vreg_to_inst;
          D.30333 = dest_var->dreg;
          D.30338 = (sizetype) D.30333;
          D.30348 = D.30338 + 2;
          D.30349 = D.30348 * 4;
          D.30350 = D.30206 + D.30349;
          iftmp.27 = *D.30350;
          goto <D.30567>;
          <D.30566>:
          iftmp.27 = 0B;
          <D.30567>:
          var2 = iftmp.27;
          D.30568 = var1 == 0B;
          D.30569 = (long int) D.30568;
          D.30570 = __builtin_expect (D.30569, 0);
          if (D.30570 != 0) goto <D.30571>; else goto <D.30572>;
          <D.30571>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1215, "var1");
          <D.30572>:
          D.30573 = var2 == 0B;
          D.30574 = (long int) D.30573;
          D.30575 = __builtin_expect (D.30574, 0);
          if (D.30575 != 0) goto <D.30576>; else goto <D.30577>;
          <D.30576>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1215, "var2");
          <D.30577>:
          D.30578 = var1->flags;
          D.30579 = D.30578 | 16;
          var1->flags = D.30579;
          D.30580 = var2->flags;
          D.30581 = D.30580 | 16;
          var2->flags = D.30581;
        }
        <D.30559>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30582>; else goto <D.30583>;
        <D.30582>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = dest;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        dest->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        goto <D.30584>;
        <D.30583>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = dest;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30584>:
        D.30310 = dest_var->klass;
        D.30585 = dest_var->backend.is_pinvoke;
        mini_emit_stobj (cfg, dest, src, D.30310, D.30585);
        goto <D.26810>;
        <D.26823>:
        D.30220 = ins->klass;
        D.30221 = D.30220 == 0B;
        D.30222 = (long int) D.30221;
        D.30223 = __builtin_expect (D.30222, 0);
        if (D.30223 != 0) goto <D.30586>; else goto <D.30587>;
        <D.30586>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1220, "ins->klass");
        <D.30587>:
        D.30201 = ins->sreg1;
        D.30202 = (unsigned int) D.30201;
        D.30203 = cfg->vreg_to_inst_len;
        if (D.30202 < D.30203) goto <D.30589>; else goto <D.30590>;
        <D.30589>:
        D.30206 = cfg->vreg_to_inst;
        D.30201 = ins->sreg1;
        D.30207 = (unsigned int) D.30201;
        D.30208 = D.30207 * 4;
        D.30209 = D.30206 + D.30208;
        iftmp.28 = *D.30209;
        goto <D.30591>;
        <D.30590>:
        iftmp.28 = 0B;
        <D.30591>:
        src_var = iftmp.28;
        if (src_var == 0B) goto <D.30592>; else goto <D.30593>;
        <D.30592>:
        D.30220 = ins->klass;
        D.30228 = &D.30220->byval_arg;
        D.30201 = ins->sreg1;
        src_var = mono_compile_create_var_for_vreg (cfg, D.30228, 329, D.30201);
        <D.30593>:
        D.30191 = cfg->mempool;
        src = mono_mempool_alloc (D.30191, 56);
        src->data.op[1].const_val = 0;
        D.30234 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.30234;
        src->prev = 0B;
        D.30235 = src->prev;
        src->next = D.30235;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.30236 = src->sreg3;
        src->sreg2 = D.30236;
        D.30237 = src->sreg2;
        src->sreg1 = D.30237;
        D.30238 = cfg->ip;
        src->cil_code = D.30238;
        src->data.op[0].p = src_var;
        D.30239 = src_var->flags;
        D.30240 = D.30239 | 16;
        src_var->flags = D.30240;
        src->type = 5;
        D.30241 = src_var->klass;
        src->klass = D.30241;
        D.30594 = alloc_dreg (cfg, 5);
        D.30595 = (int) D.30594;
        src->dreg = D.30595;
        cfg->has_indirection = 1;
        D.30244 = cfg->gsharedvt;
        D.30245 = D.30244 != 0;
        D.30246 = (long int) D.30245;
        D.30247 = __builtin_expect (D.30246, 0);
        if (D.30247 != 0) goto <D.30596>; else goto <D.30597>;
        <D.30596>:
        D.30250 = src_var->data.op[1].vtype;
        D.30598 = mini_is_gsharedvt_variable_type (cfg, D.30250);
        if (D.30598 != 0) goto <D.30599>; else goto <D.30600>;
        <D.30599>:
        handle_gsharedvt_ldaddr (cfg);
        <D.30600>:
        <D.30597>:
        D.30602 = mono_arch_is_soft_float ();
        if (D.30602 != 0) goto <D.30603>; else goto <D.30604>;
        <D.30603>:
        D.30605 = src_var->type;
        D.30606 = D.30605 == 2;
        D.30607 = D.30605 == 4;
        D.30608 = D.30606 | D.30607;
        D.30609 = (int) D.30608;
        iftmp.29 = (_Bool) D.30609;
        goto <D.30610>;
        <D.30604>:
        D.30264 = src_var->type;
        iftmp.29 = D.30264 == 2;
        <D.30610>:
        if (iftmp.29 != 0) goto <D.30611>; else goto <D.30612>;
        <D.30611>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30268 = src_var->dreg;
          D.30269 = D.30268 + 1;
          D.30270 = (unsigned int) D.30269;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30270 < D.30203) goto <D.30614>; else goto <D.30615>;
          <D.30614>:
          D.30206 = cfg->vreg_to_inst;
          D.30268 = src_var->dreg;
          D.30273 = (sizetype) D.30268;
          D.30274 = D.30273 + 1;
          D.30275 = D.30274 * 4;
          D.30276 = D.30206 + D.30275;
          iftmp.30 = *D.30276;
          goto <D.30616>;
          <D.30615>:
          iftmp.30 = 0B;
          <D.30616>:
          var1 = iftmp.30;
          D.30268 = src_var->dreg;
          D.30279 = D.30268 + 2;
          D.30280 = (unsigned int) D.30279;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30280 < D.30203) goto <D.30618>; else goto <D.30619>;
          <D.30618>:
          D.30206 = cfg->vreg_to_inst;
          D.30268 = src_var->dreg;
          D.30273 = (sizetype) D.30268;
          D.30283 = D.30273 + 2;
          D.30284 = D.30283 * 4;
          D.30285 = D.30206 + D.30284;
          iftmp.31 = *D.30285;
          goto <D.30620>;
          <D.30619>:
          iftmp.31 = 0B;
          <D.30620>:
          var2 = iftmp.31;
          D.30621 = var1 == 0B;
          D.30622 = (long int) D.30621;
          D.30623 = __builtin_expect (D.30622, 0);
          if (D.30623 != 0) goto <D.30624>; else goto <D.30625>;
          <D.30624>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1225, "var1");
          <D.30625>:
          D.30626 = var2 == 0B;
          D.30627 = (long int) D.30626;
          D.30628 = __builtin_expect (D.30627, 0);
          if (D.30628 != 0) goto <D.30629>; else goto <D.30630>;
          <D.30629>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1225, "var2");
          <D.30630>:
          D.30631 = var1->flags;
          D.30632 = D.30631 | 16;
          var1->flags = D.30632;
          D.30633 = var2->flags;
          D.30634 = D.30633 | 16;
          var2->flags = D.30634;
        }
        <D.30612>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        if (D.30197 != 0B) goto <D.30635>; else goto <D.30636>;
        <D.30635>:
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        D.30197->next = src;
        D.30196 = cfg->cbb;
        D.30197 = D.30196->last_ins;
        src->prev = D.30197;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        goto <D.30637>;
        <D.30636>:
        D.30196 = cfg->cbb;
        D.30196 = cfg->cbb;
        D.30196->last_ins = src;
        D.30197 = D.30196->last_ins;
        D.30196->code = D.30197;
        <D.30637>:
        mono_arch_emit_outarg_vt (cfg, ins, src);
        restart = 1;
        goto <D.26810>;
        <D.26826>:
        {
          struct MonoCallInst * call;

          call = ins->data.op[1].p;
          D.30639 = call->inst.dreg;
          D.30640 = (unsigned int) D.30639;
          D.30203 = cfg->vreg_to_inst_len;
          if (D.30640 < D.30203) goto <D.30641>; else goto <D.30642>;
          <D.30641>:
          D.30206 = cfg->vreg_to_inst;
          D.30639 = call->inst.dreg;
          D.30643 = (unsigned int) D.30639;
          D.30644 = D.30643 * 4;
          D.30645 = D.30206 + D.30644;
          iftmp.32 = *D.30645;
          goto <D.30646>;
          <D.30642>:
          iftmp.32 = 0B;
          <D.30646>:
          src_var = iftmp.32;
          if (src_var == 0B) goto <D.30647>; else goto <D.30648>;
          <D.30647>:
          D.30649 = call->signature;
          D.30650 = D.30649->ret;
          D.30639 = call->inst.dreg;
          src_var = mono_compile_create_var_for_vreg (cfg, D.30650, 329, D.30639);
          <D.30648>:
          D.30191 = cfg->mempool;
          src = mono_mempool_alloc (D.30191, 56);
          src->data.op[1].const_val = 0;
          D.30234 = src->data.op[1].const_val;
          src->data.op[0].const_val = D.30234;
          src->prev = 0B;
          D.30235 = src->prev;
          src->next = D.30235;
          src->opcode = 314;
          src->flags = 0;
          src->type = 0;
          src->dreg = -1;
          src->sreg3 = -1;
          D.30236 = src->sreg3;
          src->sreg2 = D.30236;
          D.30237 = src->sreg2;
          src->sreg1 = D.30237;
          D.30238 = cfg->ip;
          src->cil_code = D.30238;
          src->data.op[0].p = src_var;
          D.30239 = src_var->flags;
          D.30240 = D.30239 | 16;
          src_var->flags = D.30240;
          src->type = 5;
          D.30241 = src_var->klass;
          src->klass = D.30241;
          D.30651 = alloc_dreg (cfg, 5);
          D.30652 = (int) D.30651;
          src->dreg = D.30652;
          cfg->has_indirection = 1;
          D.30244 = cfg->gsharedvt;
          D.30245 = D.30244 != 0;
          D.30246 = (long int) D.30245;
          D.30247 = __builtin_expect (D.30246, 0);
          if (D.30247 != 0) goto <D.30653>; else goto <D.30654>;
          <D.30653>:
          D.30250 = src_var->data.op[1].vtype;
          D.30655 = mini_is_gsharedvt_variable_type (cfg, D.30250);
          if (D.30655 != 0) goto <D.30656>; else goto <D.30657>;
          <D.30656>:
          handle_gsharedvt_ldaddr (cfg);
          <D.30657>:
          <D.30654>:
          D.30659 = mono_arch_is_soft_float ();
          if (D.30659 != 0) goto <D.30660>; else goto <D.30661>;
          <D.30660>:
          D.30662 = src_var->type;
          D.30663 = D.30662 == 2;
          D.30664 = D.30662 == 4;
          D.30665 = D.30663 | D.30664;
          D.30666 = (int) D.30665;
          iftmp.33 = (_Bool) D.30666;
          goto <D.30667>;
          <D.30661>:
          D.30264 = src_var->type;
          iftmp.33 = D.30264 == 2;
          <D.30667>:
          if (iftmp.33 != 0) goto <D.30668>; else goto <D.30669>;
          <D.30668>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.30268 = src_var->dreg;
            D.30269 = D.30268 + 1;
            D.30270 = (unsigned int) D.30269;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30270 < D.30203) goto <D.30671>; else goto <D.30672>;
            <D.30671>:
            D.30206 = cfg->vreg_to_inst;
            D.30268 = src_var->dreg;
            D.30273 = (sizetype) D.30268;
            D.30274 = D.30273 + 1;
            D.30275 = D.30274 * 4;
            D.30276 = D.30206 + D.30275;
            iftmp.34 = *D.30276;
            goto <D.30673>;
            <D.30672>:
            iftmp.34 = 0B;
            <D.30673>:
            var1 = iftmp.34;
            D.30268 = src_var->dreg;
            D.30279 = D.30268 + 2;
            D.30280 = (unsigned int) D.30279;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30280 < D.30203) goto <D.30675>; else goto <D.30676>;
            <D.30675>:
            D.30206 = cfg->vreg_to_inst;
            D.30268 = src_var->dreg;
            D.30273 = (sizetype) D.30268;
            D.30283 = D.30273 + 2;
            D.30284 = D.30283 * 4;
            D.30285 = D.30206 + D.30284;
            iftmp.35 = *D.30285;
            goto <D.30677>;
            <D.30676>:
            iftmp.35 = 0B;
            <D.30677>:
            var2 = iftmp.35;
            D.30678 = var1 == 0B;
            D.30679 = (long int) D.30678;
            D.30680 = __builtin_expect (D.30679, 0);
            if (D.30680 != 0) goto <D.30681>; else goto <D.30682>;
            <D.30681>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1241, "var1");
            <D.30682>:
            D.30683 = var2 == 0B;
            D.30684 = (long int) D.30683;
            D.30685 = __builtin_expect (D.30684, 0);
            if (D.30685 != 0) goto <D.30686>; else goto <D.30687>;
            <D.30686>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1241, "var2");
            <D.30687>:
            D.30688 = var1->flags;
            D.30689 = D.30688 | 16;
            var1->flags = D.30689;
            D.30690 = var2->flags;
            D.30691 = D.30690 | 16;
            var2->flags = D.30691;
          }
          <D.30669>:
          D.30196 = cfg->cbb;
          D.30197 = D.30196->last_ins;
          if (D.30197 != 0B) goto <D.30692>; else goto <D.30693>;
          <D.30692>:
          D.30196 = cfg->cbb;
          D.30197 = D.30196->last_ins;
          D.30197->next = src;
          D.30196 = cfg->cbb;
          D.30197 = D.30196->last_ins;
          src->prev = D.30197;
          D.30196 = cfg->cbb;
          D.30196->last_ins = src;
          goto <D.30694>;
          <D.30693>:
          D.30196 = cfg->cbb;
          D.30196 = cfg->cbb;
          D.30196->last_ins = src;
          D.30197 = D.30196->last_ins;
          D.30196->code = D.30197;
          <D.30694>:
          D.30212 = ins->dreg;
          src->dreg = D.30212;
          goto <D.26810>;
        }
        <D.26830>:
        <D.26831>:
        <D.26832>:
        {
          struct MonoCallInst * call;
          int size;

          call = ins;
          D.30695 = BIT_FIELD_REF <*call, 8, 704>;
          D.30696 = D.30695 & 8;
          if (D.30696 != 0) goto <D.30697>; else goto <D.30698>;
          <D.30697>:
          {
            struct MonoCallInst * call2;

            D.30191 = cfg->mempool;
            call2 = mono_mempool_alloc0 (D.30191, 120);
            call2->inst.opcode = 316;
            call2->inst.dreg = -1;
            call2->inst.sreg3 = -1;
            D.30699 = call2->inst.sreg3;
            call2->inst.sreg2 = D.30699;
            D.30700 = call2->inst.sreg2;
            call2->inst.sreg1 = D.30700;
            D.30238 = cfg->ip;
            call2->inst.cil_code = D.30238;
            memcpy (call2, call, 120);
            D.30198 = ins->opcode;
            D.30199 = (int) D.30198;
            switch (D.30199) <default: <D.30701>, case 355: <D.26836>, case 356: <D.26838>, case 357: <D.26839>>
            <D.26836>:
            call2->inst.opcode = 346;
            goto <D.26837>;
            <D.26838>:
            call2->inst.opcode = 347;
            goto <D.26837>;
            <D.26839>:
            call2->inst.opcode = 348;
            goto <D.26837>;
            <D.30701>:
            <D.26837>:
            D.30702 = alloc_preg (cfg);
            D.30703 = (int) D.30702;
            call2->inst.dreg = D.30703;
            D.30196 = cfg->cbb;
            D.30197 = D.30196->last_ins;
            if (D.30197 != 0B) goto <D.30704>; else goto <D.30705>;
            <D.30704>:
            D.30196 = cfg->cbb;
            D.30197 = D.30196->last_ins;
            D.30197->next = call2;
            D.30196 = cfg->cbb;
            D.30197 = D.30196->last_ins;
            MEM[(struct MonoInst *)call2].prev = D.30197;
            D.30196 = cfg->cbb;
            D.30196->last_ins = call2;
            goto <D.30706>;
            <D.30705>:
            D.30196 = cfg->cbb;
            D.30196 = cfg->cbb;
            D.30196->last_ins = call2;
            D.30197 = D.30196->last_ins;
            D.30196->code = D.30197;
            <D.30706>:
            D.30708 = call->inst.dreg;
            D.30709 = (unsigned int) D.30708;
            D.30203 = cfg->vreg_to_inst_len;
            if (D.30709 < D.30203) goto <D.30710>; else goto <D.30711>;
            <D.30710>:
            D.30206 = cfg->vreg_to_inst;
            D.30708 = call->inst.dreg;
            D.30712 = (unsigned int) D.30708;
            D.30713 = D.30712 * 4;
            D.30714 = D.30206 + D.30713;
            iftmp.36 = *D.30714;
            goto <D.30715>;
            <D.30711>:
            iftmp.36 = 0B;
            <D.30715>:
            dest_var = iftmp.36;
            if (dest_var == 0B) goto <D.30716>; else goto <D.30717>;
            <D.30716>:
            D.30718 = call->signature;
            D.30719 = D.30718->ret;
            D.30708 = call->inst.dreg;
            dest_var = mono_compile_create_var_for_vreg (cfg, D.30719, 329, D.30708);
            <D.30717>:
            D.30191 = cfg->mempool;
            dest = mono_mempool_alloc (D.30191, 56);
            dest->data.op[1].const_val = 0;
            D.30304 = dest->data.op[1].const_val;
            dest->data.op[0].const_val = D.30304;
            dest->prev = 0B;
            D.30305 = dest->prev;
            dest->next = D.30305;
            dest->opcode = 314;
            dest->flags = 0;
            dest->type = 0;
            dest->dreg = -1;
            dest->sreg3 = -1;
            D.30306 = dest->sreg3;
            dest->sreg2 = D.30306;
            D.30307 = dest->sreg2;
            dest->sreg1 = D.30307;
            D.30238 = cfg->ip;
            dest->cil_code = D.30238;
            dest->data.op[0].p = dest_var;
            D.30308 = dest_var->flags;
            D.30309 = D.30308 | 16;
            dest_var->flags = D.30309;
            dest->type = 5;
            D.30310 = dest_var->klass;
            dest->klass = D.30310;
            D.30720 = alloc_dreg (cfg, 5);
            D.30721 = (int) D.30720;
            dest->dreg = D.30721;
            cfg->has_indirection = 1;
            D.30244 = cfg->gsharedvt;
            D.30245 = D.30244 != 0;
            D.30246 = (long int) D.30245;
            D.30247 = __builtin_expect (D.30246, 0);
            if (D.30247 != 0) goto <D.30722>; else goto <D.30723>;
            <D.30722>:
            D.30315 = dest_var->data.op[1].vtype;
            D.30724 = mini_is_gsharedvt_variable_type (cfg, D.30315);
            if (D.30724 != 0) goto <D.30725>; else goto <D.30726>;
            <D.30725>:
            handle_gsharedvt_ldaddr (cfg);
            <D.30726>:
            <D.30723>:
            D.30728 = mono_arch_is_soft_float ();
            if (D.30728 != 0) goto <D.30729>; else goto <D.30730>;
            <D.30729>:
            D.30731 = dest_var->type;
            D.30732 = D.30731 == 2;
            D.30733 = D.30731 == 4;
            D.30734 = D.30732 | D.30733;
            D.30735 = (int) D.30734;
            iftmp.37 = (_Bool) D.30735;
            goto <D.30736>;
            <D.30730>:
            D.30329 = dest_var->type;
            iftmp.37 = D.30329 == 2;
            <D.30736>:
            if (iftmp.37 != 0) goto <D.30737>; else goto <D.30738>;
            <D.30737>:
            {
              struct MonoInst * var1;
              struct MonoInst * var2;

              D.30333 = dest_var->dreg;
              D.30334 = D.30333 + 1;
              D.30335 = (unsigned int) D.30334;
              D.30203 = cfg->vreg_to_inst_len;
              if (D.30335 < D.30203) goto <D.30740>; else goto <D.30741>;
              <D.30740>:
              D.30206 = cfg->vreg_to_inst;
              D.30333 = dest_var->dreg;
              D.30338 = (sizetype) D.30333;
              D.30339 = D.30338 + 1;
              D.30340 = D.30339 * 4;
              D.30341 = D.30206 + D.30340;
              iftmp.38 = *D.30341;
              goto <D.30742>;
              <D.30741>:
              iftmp.38 = 0B;
              <D.30742>:
              var1 = iftmp.38;
              D.30333 = dest_var->dreg;
              D.30344 = D.30333 + 2;
              D.30345 = (unsigned int) D.30344;
              D.30203 = cfg->vreg_to_inst_len;
              if (D.30345 < D.30203) goto <D.30744>; else goto <D.30745>;
              <D.30744>:
              D.30206 = cfg->vreg_to_inst;
              D.30333 = dest_var->dreg;
              D.30338 = (sizetype) D.30333;
              D.30348 = D.30338 + 2;
              D.30349 = D.30348 * 4;
              D.30350 = D.30206 + D.30349;
              iftmp.39 = *D.30350;
              goto <D.30746>;
              <D.30745>:
              iftmp.39 = 0B;
              <D.30746>:
              var2 = iftmp.39;
              D.30747 = var1 == 0B;
              D.30748 = (long int) D.30747;
              D.30749 = __builtin_expect (D.30748, 0);
              if (D.30749 != 0) goto <D.30750>; else goto <D.30751>;
              <D.30750>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1275, "var1");
              <D.30751>:
              D.30752 = var2 == 0B;
              D.30753 = (long int) D.30752;
              D.30754 = __builtin_expect (D.30753, 0);
              if (D.30754 != 0) goto <D.30755>; else goto <D.30756>;
              <D.30755>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1275, "var2");
              <D.30756>:
              D.30757 = var1->flags;
              D.30758 = D.30757 | 16;
              var1->flags = D.30758;
              D.30759 = var2->flags;
              D.30760 = D.30759 | 16;
              var2->flags = D.30760;
            }
            <D.30738>:
            D.30196 = cfg->cbb;
            D.30197 = D.30196->last_ins;
            if (D.30197 != 0B) goto <D.30761>; else goto <D.30762>;
            <D.30761>:
            D.30196 = cfg->cbb;
            D.30197 = D.30196->last_ins;
            D.30197->next = dest;
            D.30196 = cfg->cbb;
            D.30197 = D.30196->last_ins;
            dest->prev = D.30197;
            D.30196 = cfg->cbb;
            D.30196->last_ins = dest;
            goto <D.30763>;
            <D.30762>:
            D.30196 = cfg->cbb;
            D.30196 = cfg->cbb;
            D.30196->last_ins = dest;
            D.30197 = D.30196->last_ins;
            D.30196->code = D.30197;
            <D.30763>:
            D.30585 = dest_var->backend.is_pinvoke;
            if (D.30585 != 0) goto <D.30764>; else goto <D.30765>;
            <D.30764>:
            D.30315 = dest_var->data.op[1].vtype;
            D.30766 = mono_class_from_mono_type (D.30315);
            size = mono_class_native_size (D.30766, 0B);
            goto <D.30767>;
            <D.30765>:
            D.30315 = dest_var->data.op[1].vtype;
            size = mono_type_size (D.30315, 0B);
            <D.30767>:
            switch (size) <default: <D.26860>, case 1: <D.26842>, case 2: <D.26845>, case 3: <D.26847>, case 4: <D.26848>, case 5: <D.26850>, case 6: <D.26851>, case 7: <D.26852>, case 8: <D.26853>>
            <D.26842>:
            {
              struct MonoInst * inst;

              D.30191 = cfg->mempool;
              inst = mono_mempool_alloc (D.30191, 56);
              inst->data.op[1].const_val = 0;
              D.30768 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.30768;
              inst->prev = 0B;
              D.30769 = inst->prev;
              inst->next = D.30769;
              inst->opcode = 375;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.30770 = inst->sreg3;
              inst->sreg2 = D.30770;
              D.30771 = inst->sreg2;
              inst->sreg1 = D.30771;
              D.30238 = cfg->ip;
              inst->cil_code = D.30238;
              D.30772 = call2->inst.dreg;
              inst->sreg1 = D.30772;
              D.30773 = dest->dreg;
              inst->dreg = D.30773;
              inst->data.op[0].const_val = 0;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              if (D.30197 != 0B) goto <D.30774>; else goto <D.30775>;
              <D.30774>:
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              D.30197->next = inst;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              inst->prev = D.30197;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              goto <D.30776>;
              <D.30775>:
              D.30196 = cfg->cbb;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              D.30197 = D.30196->last_ins;
              D.30196->code = D.30197;
              <D.30776>:
            }
            goto <D.26844>;
            <D.26845>:
            {
              struct MonoInst * inst;

              D.30191 = cfg->mempool;
              inst = mono_mempool_alloc (D.30191, 56);
              inst->data.op[1].const_val = 0;
              D.30777 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.30777;
              inst->prev = 0B;
              D.30778 = inst->prev;
              inst->next = D.30778;
              inst->opcode = 376;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.30779 = inst->sreg3;
              inst->sreg2 = D.30779;
              D.30780 = inst->sreg2;
              inst->sreg1 = D.30780;
              D.30238 = cfg->ip;
              inst->cil_code = D.30238;
              D.30772 = call2->inst.dreg;
              inst->sreg1 = D.30772;
              D.30773 = dest->dreg;
              inst->dreg = D.30773;
              inst->data.op[0].const_val = 0;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              if (D.30197 != 0B) goto <D.30781>; else goto <D.30782>;
              <D.30781>:
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              D.30197->next = inst;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              inst->prev = D.30197;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              goto <D.30783>;
              <D.30782>:
              D.30196 = cfg->cbb;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              D.30197 = D.30196->last_ins;
              D.30196->code = D.30197;
              <D.30783>:
            }
            goto <D.26844>;
            <D.26847>:
            <D.26848>:
            {
              struct MonoInst * inst;

              D.30191 = cfg->mempool;
              inst = mono_mempool_alloc (D.30191, 56);
              inst->data.op[1].const_val = 0;
              D.30784 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.30784;
              inst->prev = 0B;
              D.30785 = inst->prev;
              inst->next = D.30785;
              inst->opcode = 377;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.30786 = inst->sreg3;
              inst->sreg2 = D.30786;
              D.30787 = inst->sreg2;
              inst->sreg1 = D.30787;
              D.30238 = cfg->ip;
              inst->cil_code = D.30238;
              D.30772 = call2->inst.dreg;
              inst->sreg1 = D.30772;
              D.30773 = dest->dreg;
              inst->dreg = D.30773;
              inst->data.op[0].const_val = 0;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              if (D.30197 != 0B) goto <D.30788>; else goto <D.30789>;
              <D.30788>:
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              D.30197->next = inst;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              inst->prev = D.30197;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              goto <D.30790>;
              <D.30789>:
              D.30196 = cfg->cbb;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              D.30197 = D.30196->last_ins;
              D.30196->code = D.30197;
              <D.30790>:
            }
            goto <D.26844>;
            <D.26850>:
            <D.26851>:
            <D.26852>:
            <D.26853>:
            D.30791 = call2->inst.opcode;
            D.30792 = (int) D.30791;
            switch (D.30792) <default: <D.30793>, case 346: <D.26854>, case 347: <D.26856>, case 348: <D.26857>>
            <D.26854>:
            call2->inst.opcode = 352;
            goto <D.26855>;
            <D.26856>:
            call2->inst.opcode = 353;
            goto <D.26855>;
            <D.26857>:
            call2->inst.opcode = 354;
            goto <D.26855>;
            <D.30793>:
            <D.26855>:
            D.30794 = alloc_lreg (cfg);
            D.30795 = (int) D.30794;
            call2->inst.dreg = D.30795;
            {
              struct MonoInst * inst;

              D.30191 = cfg->mempool;
              inst = mono_mempool_alloc (D.30191, 56);
              inst->data.op[1].const_val = 0;
              D.30796 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.30796;
              inst->prev = 0B;
              D.30797 = inst->prev;
              inst->next = D.30797;
              inst->opcode = 377;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.30798 = inst->sreg3;
              inst->sreg2 = D.30798;
              D.30799 = inst->sreg2;
              inst->sreg1 = D.30799;
              D.30238 = cfg->ip;
              inst->cil_code = D.30238;
              D.30772 = call2->inst.dreg;
              D.30800 = D.30772 + 2;
              inst->sreg1 = D.30800;
              D.30773 = dest->dreg;
              inst->dreg = D.30773;
              inst->data.op[0].const_val = 4;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              if (D.30197 != 0B) goto <D.30801>; else goto <D.30802>;
              <D.30801>:
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              D.30197->next = inst;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              inst->prev = D.30197;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              goto <D.30803>;
              <D.30802>:
              D.30196 = cfg->cbb;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              D.30197 = D.30196->last_ins;
              D.30196->code = D.30197;
              <D.30803>:
            }
            {
              struct MonoInst * inst;

              D.30191 = cfg->mempool;
              inst = mono_mempool_alloc (D.30191, 56);
              inst->data.op[1].const_val = 0;
              D.30804 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.30804;
              inst->prev = 0B;
              D.30805 = inst->prev;
              inst->next = D.30805;
              inst->opcode = 377;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.30806 = inst->sreg3;
              inst->sreg2 = D.30806;
              D.30807 = inst->sreg2;
              inst->sreg1 = D.30807;
              D.30238 = cfg->ip;
              inst->cil_code = D.30238;
              D.30772 = call2->inst.dreg;
              D.30808 = D.30772 + 1;
              inst->sreg1 = D.30808;
              D.30773 = dest->dreg;
              inst->dreg = D.30773;
              inst->data.op[0].const_val = 0;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              if (D.30197 != 0B) goto <D.30809>; else goto <D.30810>;
              <D.30809>:
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              D.30197->next = inst;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              inst->prev = D.30197;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              goto <D.30811>;
              <D.30810>:
              D.30196 = cfg->cbb;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              D.30197 = D.30196->last_ins;
              D.30196->code = D.30197;
              <D.30811>:
            }
            goto <D.26844>;
            <D.26860>:
            {
              struct MonoInst * inst;

              D.30191 = cfg->mempool;
              inst = mono_mempool_alloc (D.30191, 56);
              inst->data.op[1].const_val = 0;
              D.30812 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.30812;
              inst->prev = 0B;
              D.30813 = inst->prev;
              inst->next = D.30813;
              inst->opcode = 374;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.30814 = inst->sreg3;
              inst->sreg2 = D.30814;
              D.30815 = inst->sreg2;
              inst->sreg1 = D.30815;
              D.30238 = cfg->ip;
              inst->cil_code = D.30238;
              D.30772 = call2->inst.dreg;
              inst->sreg1 = D.30772;
              D.30773 = dest->dreg;
              inst->dreg = D.30773;
              inst->data.op[0].const_val = 0;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              if (D.30197 != 0B) goto <D.30816>; else goto <D.30817>;
              <D.30816>:
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              D.30197->next = inst;
              D.30196 = cfg->cbb;
              D.30197 = D.30196->last_ins;
              inst->prev = D.30197;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              goto <D.30818>;
              <D.30817>:
              D.30196 = cfg->cbb;
              D.30196 = cfg->cbb;
              D.30196->last_ins = inst;
              D.30197 = D.30196->last_ins;
              D.30196->code = D.30197;
              <D.30818>:
            }
            goto <D.26844>;
            <D.26844>:
          }
          goto <D.30819>;
          <D.30698>:
          D.30198 = ins->opcode;
          D.30199 = (int) D.30198;
          switch (D.30199) <default: <D.30820>, case 355: <D.26862>, case 356: <D.26864>, case 357: <D.26865>>
          <D.26862>:
          ins->opcode = 358;
          goto <D.26863>;
          <D.26864>:
          ins->opcode = 359;
          goto <D.26863>;
          <D.26865>:
          ins->opcode = 360;
          goto <D.26863>;
          <D.30820>:
          <D.26863>:
          ins->dreg = -1;
          <D.30819>:
          goto <D.26810>;
        }
        <D.26866>:
        goto <D.26810>;
        <D.26810>:
        D.30196 = cfg->cbb;
        D.30821 = D.30196 != first_bb;
        D.30822 = (long int) D.30821;
        D.30823 = __builtin_expect (D.30822, 0);
        if (D.30823 != 0) goto <D.30824>; else goto <D.30825>;
        <D.30824>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1345, "cfg->cbb == first_bb");
        <D.30825>:
        D.30196 = cfg->cbb;
        D.30829 = D.30196->code;
        if (D.30829 != 0B) goto <D.30826>; else goto <D.30830>;
        <D.30830>:
        D.30196 = cfg->cbb;
        if (D.30196 != first_bb) goto <D.30826>; else goto <D.30827>;
        <D.30826>:
        D.30196 = cfg->cbb;
        mono_replace_ins (cfg, bb, ins, &prev, first_bb, D.30196);
        first_bb->last_ins = 0B;
        D.30831 = first_bb->last_ins;
        first_bb->code = D.30831;
        first_bb->out_count = 0;
        D.30832 = first_bb->out_count;
        first_bb->in_count = D.30832;
        cfg->cbb = first_bb;
        goto <D.30828>;
        <D.30827>:
        prev = ins;
        <D.30828>:
        ins = ins->next;
        <D.26868>:
        if (ins != 0B) goto <D.26867>; else goto <D.26869>;
        <D.26869>:
        <D.26871>:
        if (restart != 0) goto <D.26870>; else goto <D.26872>;
        <D.26872>:
        D.30193 = cfg->verbose_level;
        if (D.30193 > 2) goto <D.30833>; else goto <D.30834>;
        <D.30833>:
        mono_print_bb (bb, "AFTER LOWER-VTYPE-OPTS ");
        <D.30834>:
      }
    finally
      {
        prev = {CLOBBER};
      }
  }
  bb = bb->next_bb;
  <D.26874>:
  if (bb != 0B) goto <D.26873>; else goto <D.26875>;
  <D.26875>:
}


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

  D.30837 = __builtin_object_size (__dest, 0);
  D.30836 = __builtin___memcpy_chk (__dest, __src, __len, D.30837);
  return D.30836;
}


alloc_preg (struct MonoCompile * cfg)
{
  guint32 D.30839;

  D.30839 = alloc_ireg (cfg);
  return D.30839;
}


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

  switch (stack_type) <default: <D.24323>, case 1: <D.24316>, case 2: <D.24321>, case 3: <D.24317>, case 4: <D.24320>, case 5: <D.24318>, case 6: <D.24319>, case 7: <D.24322>>
  <D.24316>:
  <D.24317>:
  D.30841 = alloc_ireg (cfg);
  return D.30841;
  <D.24318>:
  D.30841 = alloc_ireg_mp (cfg);
  return D.30841;
  <D.24319>:
  D.30841 = alloc_ireg_ref (cfg);
  return D.30841;
  <D.24320>:
  D.30841 = alloc_freg (cfg);
  return D.30841;
  <D.24321>:
  D.30841 = alloc_lreg (cfg);
  return D.30841;
  <D.24322>:
  D.30841 = alloc_ireg (cfg);
  return D.30841;
  <D.24323>:
  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.30841 = 4294967295;
  return D.30841;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.30843;
  unsigned char D.30844;
  unsigned char D.30845;
  guint32 D.30848;
  int vreg;

  D.30843 = alloc_ireg (cfg);
  vreg = (int) D.30843;
  D.30844 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.30845 = D.30844 & 128;
  if (D.30845 != 0) goto <D.30846>; else goto <D.30847>;
  <D.30846>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.30847>:
  D.30848 = (guint32) vreg;
  return D.30848;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.30850;
  unsigned char D.30851;
  unsigned char D.30852;
  guint32 D.30855;
  int vreg;

  D.30850 = alloc_ireg (cfg);
  vreg = (int) D.30850;
  D.30851 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.30852 = D.30851 & 128;
  if (D.30852 != 0) goto <D.30853>; else goto <D.30854>;
  <D.30853>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.30854>:
  D.30855 = (guint32) vreg;
  return D.30855;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.30857;
  guint32 D.30860;
  unsigned int D.30861;
  unsigned int D.30862;
  unsigned int D.30863;

  D.30857 = mono_arch_is_soft_float ();
  if (D.30857 != 0) goto <D.30858>; else goto <D.30859>;
  <D.30858>:
  D.30860 = alloc_lreg (cfg);
  return D.30860;
  <D.30859>:
  D.30861 = cfg->next_vreg;
  D.30862 = D.30861;
  D.30863 = D.30862 + 1;
  cfg->next_vreg = D.30863;
  D.30860 = D.30862;
  return D.30860;
}


handle_gsharedvt_ldaddr (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.30865;
  int D.30866;
  struct MonoInst * D.30867;
  int D.30868;
  int D.30869;
  const unsigned char * D.30870;
  struct MonoInst * D.30871;
  int D.30872;
  struct MonoBasicBlock * D.30873;
  struct MonoInst * D.30874;
  struct MonoInst * D.30878;
  int D.30879;
  struct MonoInst * use;

  D.30865 = cfg->mempool;
  use = mono_mempool_alloc (D.30865, 56);
  use->data.op[1].const_val = 0;
  D.30866 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.30866;
  use->prev = 0B;
  D.30867 = use->prev;
  use->next = D.30867;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.30868 = use->sreg3;
  use->sreg2 = D.30868;
  D.30869 = use->sreg2;
  use->sreg1 = D.30869;
  D.30870 = cfg->ip;
  use->cil_code = D.30870;
  D.30871 = cfg->gsharedvt_info_var;
  D.30872 = D.30871->dreg;
  use->sreg1 = D.30872;
  D.30873 = cfg->cbb;
  D.30874 = D.30873->last_ins;
  if (D.30874 != 0B) goto <D.30875>; else goto <D.30876>;
  <D.30875>:
  D.30873 = cfg->cbb;
  D.30874 = D.30873->last_ins;
  D.30874->next = use;
  D.30873 = cfg->cbb;
  D.30874 = D.30873->last_ins;
  use->prev = D.30874;
  D.30873 = cfg->cbb;
  D.30873->last_ins = use;
  goto <D.30877>;
  <D.30876>:
  D.30873 = cfg->cbb;
  D.30873 = cfg->cbb;
  D.30873->last_ins = use;
  D.30874 = D.30873->last_ins;
  D.30873->code = D.30874;
  <D.30877>:
  D.30865 = cfg->mempool;
  use = mono_mempool_alloc (D.30865, 56);
  use->data.op[1].const_val = 0;
  D.30866 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.30866;
  use->prev = 0B;
  D.30867 = use->prev;
  use->next = D.30867;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.30868 = use->sreg3;
  use->sreg2 = D.30868;
  D.30869 = use->sreg2;
  use->sreg1 = D.30869;
  D.30870 = cfg->ip;
  use->cil_code = D.30870;
  D.30878 = cfg->gsharedvt_locals_var;
  D.30879 = D.30878->dreg;
  use->sreg1 = D.30879;
  D.30873 = cfg->cbb;
  D.30874 = D.30873->last_ins;
  if (D.30874 != 0B) goto <D.30880>; else goto <D.30881>;
  <D.30880>:
  D.30873 = cfg->cbb;
  D.30874 = D.30873->last_ins;
  D.30874->next = use;
  D.30873 = cfg->cbb;
  D.30874 = D.30873->last_ins;
  use->prev = D.30874;
  D.30873 = cfg->cbb;
  D.30873->last_ins = use;
  goto <D.30882>;
  <D.30881>:
  D.30873 = cfg->cbb;
  D.30873 = cfg->cbb;
  D.30873->last_ins = use;
  D.30874 = D.30873->last_ins;
  D.30873->code = D.30874;
  <D.30882>:
}


mono_arch_is_soft_float ()
{
  gboolean D.30883;

  D.30883 = 0;
  return D.30883;
}


alloc_lreg (struct MonoCompile * cfg)
{
  unsigned int D.30885;
  unsigned int D.30886;
  guint32 D.30887;
  guint32 res;

  res = cfg->next_vreg;
  D.30885 = cfg->next_vreg;
  D.30886 = D.30885 + 3;
  cfg->next_vreg = D.30886;
  D.30887 = res;
  return D.30887;
}


mono_decompose_vtype_opts_llvm (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.30889;
  void * D.30890;
  unsigned int D.30891;
  struct MonoBasicBlock * D.30894;
  struct MonoInst * D.30895;
  short unsigned int D.30896;
  int D.30897;
  struct MonoInst * iftmp.40;
  int D.30899;
  unsigned int D.30900;
  unsigned int D.30901;
  struct MonoInst * * D.30904;
  unsigned int D.30905;
  unsigned int D.30906;
  struct MonoInst * * D.30907;
  struct MonoClass * D.30911;
  _Bool D.30912;
  long int D.30913;
  long int D.30914;
  struct MonoType * D.30917;
  struct MonoInst * iftmp.41;
  int D.30924;
  struct MonoInst * D.30925;
  int D.30926;
  int D.30927;
  const unsigned char * D.30928;
  unsigned char D.30929;
  unsigned char D.30930;
  struct MonoClass * D.30931;
  unsigned int D.30932;
  int D.30933;
  int D.30934;
  _Bool D.30935;
  long int D.30936;
  long int D.30937;
  struct MonoType * D.30940;
  int D.30941;
  _Bool iftmp.42;
  int D.30945;
  unsigned char D.30948;
  _Bool D.30949;
  _Bool D.30950;
  _Bool D.30951;
  int D.30952;
  unsigned char D.30954;
  struct MonoInst * iftmp.43;
  int D.30958;
  int D.30959;
  unsigned int D.30960;
  sizetype D.30963;
  sizetype D.30964;
  sizetype D.30965;
  struct MonoInst * * D.30966;
  struct MonoInst * iftmp.44;
  int D.30969;
  unsigned int D.30970;
  sizetype D.30973;
  sizetype D.30974;
  struct MonoInst * * D.30975;
  _Bool D.30977;
  long int D.30978;
  long int D.30979;
  _Bool D.30982;
  long int D.30983;
  long int D.30984;
  unsigned char D.30987;
  unsigned char D.30988;
  unsigned char D.30989;
  unsigned char D.30990;
  unsigned int D.30994;
  int D.30995;
  struct MonoInst * D.30996;
  int D.30997;
  int D.30998;
  int D.30999;
  int D.31000;
  struct MonoClass * D.31004;
  int D.31005;
  _Bool D.31006;
  long int D.31007;
  long int D.31008;
  struct MonoInst * D.31014;
  struct MonoInst * D.31016;
  short int D.31017;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * first_bb;

  D.30889 = cfg->mempool;
  D.30890 = mono_mempool_alloc0 (D.30889, 172);
  cfg->cbb = D.30890;
  first_bb = cfg->cbb;
  bb = cfg->bb_entry;
  goto <D.26901>;
  <D.26900>:
  {
    struct MonoInst * ins;
    struct MonoInst * prev;
    struct MonoInst * src_var;
    struct MonoInst * src;
    struct MonoInst * dest;
    gboolean restart;
    int dreg;

    try
      {
        prev = 0B;
        D.30891 = cfg->verbose_level;
        if (D.30891 > 2) goto <D.30892>; else goto <D.30893>;
        <D.30892>:
        mono_print_bb (bb, "BEFORE LOWER-VTYPE-OPTS(LLVM) ");
        <D.30893>:
        D.30894 = cfg->cbb;
        D.30894 = cfg->cbb;
        D.30894->last_ins = 0B;
        D.30895 = D.30894->last_ins;
        D.30894->code = D.30895;
        restart = 1;
        goto <D.26898>;
        <D.26897>:
        restart = 0;
        ins = bb->code;
        goto <D.26895>;
        <D.26894>:
        D.30896 = ins->opcode;
        D.30897 = (int) D.30896;
        switch (D.30897) <default: <D.26893>, case 387: <D.26888>>
        <D.26888>:
        D.30899 = ins->sreg1;
        D.30900 = (unsigned int) D.30899;
        D.30901 = cfg->vreg_to_inst_len;
        if (D.30900 < D.30901) goto <D.30902>; else goto <D.30903>;
        <D.30902>:
        D.30904 = cfg->vreg_to_inst;
        D.30899 = ins->sreg1;
        D.30905 = (unsigned int) D.30899;
        D.30906 = D.30905 * 4;
        D.30907 = D.30904 + D.30906;
        iftmp.40 = *D.30907;
        goto <D.30908>;
        <D.30903>:
        iftmp.40 = 0B;
        <D.30908>:
        src_var = iftmp.40;
        if (src_var == 0B) goto <D.30909>; else goto <D.30910>;
        <D.30909>:
        D.30911 = ins->klass;
        D.30912 = D.30911 == 0B;
        D.30913 = (long int) D.30912;
        D.30914 = __builtin_expect (D.30913, 0);
        if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
        <D.30915>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1395, "ins->klass");
        <D.30916>:
        D.30911 = ins->klass;
        D.30917 = &D.30911->byval_arg;
        D.30899 = ins->sreg1;
        src_var = mono_compile_create_var_for_vreg (cfg, D.30917, 329, D.30899);
        <D.30910>:
        {
          struct MonoInst * var;

          D.30899 = ins->sreg1;
          D.30900 = (unsigned int) D.30899;
          D.30901 = cfg->vreg_to_inst_len;
          if (D.30900 < D.30901) goto <D.30919>; else goto <D.30920>;
          <D.30919>:
          D.30904 = cfg->vreg_to_inst;
          D.30899 = ins->sreg1;
          D.30905 = (unsigned int) D.30899;
          D.30906 = D.30905 * 4;
          D.30907 = D.30904 + D.30906;
          iftmp.41 = *D.30907;
          goto <D.30921>;
          <D.30920>:
          iftmp.41 = 0B;
          <D.30921>:
          var = iftmp.41;
          if (var == 0B) goto <D.30922>; else goto <D.30923>;
          <D.30922>:
          D.30911 = ins->klass;
          D.30917 = &D.30911->byval_arg;
          D.30899 = ins->sreg1;
          var = mono_compile_create_var_for_vreg (cfg, D.30917, 329, D.30899);
          <D.30923>:
          D.30889 = cfg->mempool;
          src = mono_mempool_alloc (D.30889, 56);
          src->data.op[1].const_val = 0;
          D.30924 = src->data.op[1].const_val;
          src->data.op[0].const_val = D.30924;
          src->prev = 0B;
          D.30925 = src->prev;
          src->next = D.30925;
          src->opcode = 314;
          src->flags = 0;
          src->type = 0;
          src->dreg = -1;
          src->sreg3 = -1;
          D.30926 = src->sreg3;
          src->sreg2 = D.30926;
          D.30927 = src->sreg2;
          src->sreg1 = D.30927;
          D.30928 = cfg->ip;
          src->cil_code = D.30928;
          src->data.op[0].p = var;
          D.30929 = var->flags;
          D.30930 = D.30929 | 16;
          var->flags = D.30930;
          src->type = 5;
          D.30931 = var->klass;
          src->klass = D.30931;
          D.30932 = alloc_dreg (cfg, 5);
          D.30933 = (int) D.30932;
          src->dreg = D.30933;
          cfg->has_indirection = 1;
          D.30934 = cfg->gsharedvt;
          D.30935 = D.30934 != 0;
          D.30936 = (long int) D.30935;
          D.30937 = __builtin_expect (D.30936, 0);
          if (D.30937 != 0) goto <D.30938>; else goto <D.30939>;
          <D.30938>:
          D.30940 = var->data.op[1].vtype;
          D.30941 = mini_is_gsharedvt_variable_type (cfg, D.30940);
          if (D.30941 != 0) goto <D.30942>; else goto <D.30943>;
          <D.30942>:
          handle_gsharedvt_ldaddr (cfg);
          <D.30943>:
          <D.30939>:
          D.30945 = mono_arch_is_soft_float ();
          if (D.30945 != 0) goto <D.30946>; else goto <D.30947>;
          <D.30946>:
          D.30948 = var->type;
          D.30949 = D.30948 == 2;
          D.30950 = D.30948 == 4;
          D.30951 = D.30949 | D.30950;
          D.30952 = (int) D.30951;
          iftmp.42 = (_Bool) D.30952;
          goto <D.30953>;
          <D.30947>:
          D.30954 = var->type;
          iftmp.42 = D.30954 == 2;
          <D.30953>:
          if (iftmp.42 != 0) goto <D.30955>; else goto <D.30956>;
          <D.30955>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.30958 = var->dreg;
            D.30959 = D.30958 + 1;
            D.30960 = (unsigned int) D.30959;
            D.30901 = cfg->vreg_to_inst_len;
            if (D.30960 < D.30901) goto <D.30961>; else goto <D.30962>;
            <D.30961>:
            D.30904 = cfg->vreg_to_inst;
            D.30958 = var->dreg;
            D.30963 = (sizetype) D.30958;
            D.30964 = D.30963 + 1;
            D.30965 = D.30964 * 4;
            D.30966 = D.30904 + D.30965;
            iftmp.43 = *D.30966;
            goto <D.30967>;
            <D.30962>:
            iftmp.43 = 0B;
            <D.30967>:
            var1 = iftmp.43;
            D.30958 = var->dreg;
            D.30969 = D.30958 + 2;
            D.30970 = (unsigned int) D.30969;
            D.30901 = cfg->vreg_to_inst_len;
            if (D.30970 < D.30901) goto <D.30971>; else goto <D.30972>;
            <D.30971>:
            D.30904 = cfg->vreg_to_inst;
            D.30958 = var->dreg;
            D.30963 = (sizetype) D.30958;
            D.30973 = D.30963 + 2;
            D.30974 = D.30973 * 4;
            D.30975 = D.30904 + D.30974;
            iftmp.44 = *D.30975;
            goto <D.30976>;
            <D.30972>:
            iftmp.44 = 0B;
            <D.30976>:
            var2 = iftmp.44;
            D.30977 = var1 == 0B;
            D.30978 = (long int) D.30977;
            D.30979 = __builtin_expect (D.30978, 0);
            if (D.30979 != 0) goto <D.30980>; else goto <D.30981>;
            <D.30980>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1399, "var1");
            <D.30981>:
            D.30982 = var2 == 0B;
            D.30983 = (long int) D.30982;
            D.30984 = __builtin_expect (D.30983, 0);
            if (D.30984 != 0) goto <D.30985>; else goto <D.30986>;
            <D.30985>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1399, "var2");
            <D.30986>:
            D.30987 = var1->flags;
            D.30988 = D.30987 | 16;
            var1->flags = D.30988;
            D.30989 = var2->flags;
            D.30990 = D.30989 | 16;
            var2->flags = D.30990;
          }
          <D.30956>:
        }
        D.30894 = cfg->cbb;
        D.30895 = D.30894->last_ins;
        if (D.30895 != 0B) goto <D.30991>; else goto <D.30992>;
        <D.30991>:
        D.30894 = cfg->cbb;
        D.30895 = D.30894->last_ins;
        D.30895->next = src;
        D.30894 = cfg->cbb;
        D.30895 = D.30894->last_ins;
        src->prev = D.30895;
        D.30894 = cfg->cbb;
        D.30894->last_ins = src;
        goto <D.30993>;
        <D.30992>:
        D.30894 = cfg->cbb;
        D.30894 = cfg->cbb;
        D.30894->last_ins = src;
        D.30895 = D.30894->last_ins;
        D.30894->code = D.30895;
        <D.30993>:
        D.30994 = alloc_preg (cfg);
        dreg = (int) D.30994;
        D.30889 = cfg->mempool;
        dest = mono_mempool_alloc (D.30889, 56);
        dest->data.op[1].const_val = 0;
        D.30995 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.30995;
        dest->prev = 0B;
        D.30996 = dest->prev;
        dest->next = D.30996;
        dest->opcode = 429;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.30997 = dest->sreg3;
        dest->sreg2 = D.30997;
        D.30998 = dest->sreg2;
        dest->sreg1 = D.30998;
        D.30928 = cfg->ip;
        dest->cil_code = D.30928;
        dest->dreg = dreg;
        D.30999 = ins->dreg;
        dest->sreg1 = D.30999;
        D.31000 = ins->data.op[0].const_val;
        dest->data.op[1].const_val = D.31000;
        D.30894 = cfg->cbb;
        D.30895 = D.30894->last_ins;
        if (D.30895 != 0B) goto <D.31001>; else goto <D.31002>;
        <D.31001>:
        D.30894 = cfg->cbb;
        D.30895 = D.30894->last_ins;
        D.30895->next = dest;
        D.30894 = cfg->cbb;
        D.30895 = D.30894->last_ins;
        dest->prev = D.30895;
        D.30894 = cfg->cbb;
        D.30894->last_ins = dest;
        goto <D.31003>;
        <D.31002>:
        D.30894 = cfg->cbb;
        D.30894 = cfg->cbb;
        D.30894->last_ins = dest;
        D.30895 = D.30894->last_ins;
        D.30894->code = D.30895;
        <D.31003>:
        D.31004 = src_var->klass;
        D.31005 = src_var->backend.is_pinvoke;
        mini_emit_stobj (cfg, dest, src, D.31004, D.31005);
        goto <D.26892>;
        <D.26893>:
        goto <D.26892>;
        <D.26892>:
        D.30894 = cfg->cbb;
        D.31006 = D.30894 != first_bb;
        D.31007 = (long int) D.31006;
        D.31008 = __builtin_expect (D.31007, 0);
        if (D.31008 != 0) goto <D.31009>; else goto <D.31010>;
        <D.31009>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1410, "cfg->cbb == first_bb");
        <D.31010>:
        D.30894 = cfg->cbb;
        D.31014 = D.30894->code;
        if (D.31014 != 0B) goto <D.31011>; else goto <D.31015>;
        <D.31015>:
        D.30894 = cfg->cbb;
        if (D.30894 != first_bb) goto <D.31011>; else goto <D.31012>;
        <D.31011>:
        D.30894 = cfg->cbb;
        mono_replace_ins (cfg, bb, ins, &prev, first_bb, D.30894);
        first_bb->last_ins = 0B;
        D.31016 = first_bb->last_ins;
        first_bb->code = D.31016;
        first_bb->out_count = 0;
        D.31017 = first_bb->out_count;
        first_bb->in_count = D.31017;
        cfg->cbb = first_bb;
        goto <D.31013>;
        <D.31012>:
        prev = ins;
        <D.31013>:
        ins = ins->next;
        <D.26895>:
        if (ins != 0B) goto <D.26894>; else goto <D.26896>;
        <D.26896>:
        <D.26898>:
        if (restart != 0) goto <D.26897>; else goto <D.26899>;
        <D.26899>:
        D.30891 = cfg->verbose_level;
        if (D.30891 > 2) goto <D.31018>; else goto <D.31019>;
        <D.31018>:
        mono_print_bb (bb, "AFTER LOWER-VTYPE-OPTS(LLVM) ");
        <D.31019>:
      }
    finally
      {
        prev = {CLOBBER};
      }
  }
  bb = bb->next_bb;
  <D.26901>:
  if (bb != 0B) goto <D.26900>; else goto <D.26902>;
  <D.26902>:
}


mono_decompose_array_access_opts (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.31021;
  void * D.31022;
  unsigned char D.31023;
  unsigned char D.31024;
  unsigned int D.31027;
  struct MonoBasicBlock * D.31030;
  struct MonoInst * D.31031;
  short unsigned int D.31032;
  int D.31033;
  unsigned char D.31034;
  unsigned char D.31035;
  int D.31036;
  unsigned char D.31039;
  unsigned char D.31040;
  int D.31043;
  struct MonoInst * D.31044;
  int D.31045;
  int D.31046;
  const unsigned char * D.31047;
  int D.31048;
  int D.31052;
  struct MonoInst * D.31053;
  int D.31054;
  int D.31055;
  int D.31060;
  struct MonoInst * D.31061;
  int D.31062;
  int D.31063;
  int D.31064;
  unsigned char D.31065;
  int D.31071;
  struct MonoInst * D.31072;
  int D.31073;
  int D.31074;
  int D.31078;
  struct MonoInst * D.31079;
  int D.31080;
  int D.31081;
  unsigned int D.31088;
  int D.31089;
  int D.31090;
  int D.31093;
  int D.31098;
  struct MonoInst * D.31099;
  int D.31100;
  int D.31101;
  int D.31105;
  struct MonoInst * D.31106;
  int D.31107;
  int D.31108;
  int D.31113;
  struct MonoInst * D.31114;
  int D.31115;
  int D.31116;
  int D.31117;
  unsigned char D.31118;
  int D.31123;
  int D.31128;
  struct MonoInst * D.31129;
  int D.31130;
  int D.31131;
  int D.31135;
  struct MonoInst * D.31136;
  int D.31137;
  int D.31138;
  int D.31143;
  struct MonoInst * D.31144;
  int D.31145;
  int D.31146;
  unsigned char D.31147;
  int D.31151;
  struct MonoInst * D.31152;
  int D.31153;
  int D.31154;
  int D.31155;
  int D.31159;
  struct MonoInst * D.31160;
  int D.31161;
  int D.31162;
  unsigned int D.31167;
  int D.31170;
  int D.31175;
  struct MonoInst * D.31176;
  int D.31177;
  int D.31178;
  int D.31182;
  struct MonoInst * D.31183;
  int D.31184;
  int D.31185;
  int D.31190;
  struct MonoInst * D.31191;
  int D.31192;
  int D.31193;
  unsigned char D.31194;
  int D.31199;
  int D.31204;
  struct MonoInst * D.31205;
  int D.31206;
  int D.31207;
  int D.31211;
  struct MonoInst * D.31212;
  int D.31213;
  int D.31214;
  int D.31219;
  struct MonoInst * D.31220;
  int D.31221;
  int D.31222;
  unsigned char D.31223;
  int D.31227;
  struct MonoInst * D.31228;
  int D.31229;
  int D.31230;
  int D.31234;
  struct MonoInst * D.31235;
  int D.31236;
  int D.31237;
  unsigned int D.31241;
  unsigned int D.31242;
  unsigned char D.31249;
  unsigned char D.31250;
  void * D.31251;
  struct MonoInst * D.31252;
  int D.31253;
  struct MonoInst * D.31254;
  int D.31255;
  int D.31256;
  struct MonoInst * * D.31257;
  int D.31258;
  unsigned int D.31259;
  unsigned int D.31260;
  struct MonoInst * * D.31261;
  struct MonoInst * D.31262;
  struct MonoType * D.31263;
  unsigned int D.31264;
  short unsigned int D.31265;
  struct MonoClass * D.31266;
  int D.31267;
  unsigned char D.31268;
  <unnamed type> D.31269;
  unsigned int D.31270;
  int D.31271;
  short unsigned int D.31272;
  struct MonoClass * D.31275;
  void * D.31276;
  struct MonoDomain * D.31277;
  unsigned int D.31278;
  int D.31279;
  void * D.31283;
  struct MonoInst * D.31284;
  int D.31285;
  struct MonoInst * D.31286;
  guint16 iftmp.45;
  int D.31291;
  int D.31292;
  struct MonoClass * D.31293;
  unsigned int D.31294;
  int D.31295;
  void * D.31299;
  struct MonoInst * D.31300;
  int D.31301;
  struct MonoInst * D.31302;
  int D.31303;
  int D.31304;
  _Bool D.31306;
  long int D.31307;
  long int D.31308;
  void * D.31311;
  guint16 iftmp.46;
  void * iftmp.47;
  unsigned int D.31320;
  int D.31321;
  void * D.31325;
  int D.31329;
  int D.31334;
  struct MonoInst * D.31335;
  int D.31336;
  int D.31337;
  int D.31341;
  struct MonoInst * D.31342;
  int D.31343;
  int D.31344;
  int D.31349;
  struct MonoInst * D.31350;
  int D.31351;
  int D.31352;
  unsigned char D.31353;
  _Bool D.31357;
  long int D.31358;
  long int D.31359;
  struct MonoInst * D.31365;
  struct MonoInst * D.31367;
  short int D.31368;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * first_bb;

  D.31021 = cfg->mempool;
  D.31022 = mono_mempool_alloc0 (D.31021, 172);
  cfg->cbb = D.31022;
  first_bb = cfg->cbb;
  bb = cfg->bb_entry;
  goto <D.26965>;
  <D.26964>:
  {
    struct MonoInst * ins;
    struct MonoInst * prev;
    struct MonoInst * dest;
    struct MonoInst * iargs[3];
    gboolean restart;

    try
      {
        prev = 0B;
        D.31023 = BIT_FIELD_REF <*bb, 8, 912>;
        D.31024 = D.31023 & 4;
        if (D.31024 == 0) goto <D.31025>; else goto <D.31026>;
        <D.31025>:
        // predicted unlikely by continue predictor.
        goto <D.26916>;
        <D.31026>:
        D.31027 = cfg->verbose_level;
        if (D.31027 > 3) goto <D.31028>; else goto <D.31029>;
        <D.31028>:
        mono_print_bb (bb, "BEFORE DECOMPOSE-ARRAY-ACCESS-OPTS ");
        <D.31029>:
        D.31030 = cfg->cbb;
        D.31030 = cfg->cbb;
        D.31030->last_ins = 0B;
        D.31031 = D.31030->last_ins;
        D.31030->code = D.31031;
        restart = 1;
        goto <D.26962>;
        <D.26961>:
        restart = 0;
        ins = bb->code;
        goto <D.26959>;
        <D.26958>:
        D.31032 = ins->opcode;
        D.31033 = (int) D.31032;
        switch (D.31033) <default: <D.26957>, case 781: <D.26952>, case 782: <D.26947>, case 783: <D.26917>, case 784: <D.26922>>
        <D.26917>:
        {
          int __ins_flags;

          D.31034 = ins->flags;
          D.31035 = D.31034 | 64;
          __ins_flags = (int) D.31035;
          D.31036 = __ins_flags & 32;
          if (D.31036 != 0) goto <D.31037>; else goto <D.31038>;
          <D.31037>:
          D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
          D.31040 = D.31039 & 64;
          if (D.31040 != 0) goto <D.31041>; else goto <D.31042>;
          <D.31041>:
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31043 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31043;
            inst->prev = 0B;
            D.31044 = inst->prev;
            inst->next = D.31044;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31045 = inst->sreg3;
            inst->sreg2 = D.31045;
            D.31046 = inst->sreg2;
            inst->sreg1 = D.31046;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = -1;
            D.31048 = ins->sreg1;
            inst->sreg1 = D.31048;
            inst->data.op[1].const_val = 0;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31049>; else goto <D.31050>;
            <D.31049>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31051>;
            <D.31050>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31051>:
          }
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31052 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31052;
            inst->prev = 0B;
            D.31053 = inst->prev;
            inst->next = D.31053;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31054 = inst->sreg3;
            inst->sreg2 = D.31054;
            D.31055 = inst->sreg2;
            inst->sreg1 = D.31055;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->data.op[1].p = "NullReferenceException";
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31056>; else goto <D.31057>;
            <D.31056>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31058>;
            <D.31057>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31058>:
          }
          goto <D.31059>;
          <D.31042>:
          <D.31059>:
          <D.31038>:
          D.31021 = cfg->mempool;
          dest = mono_mempool_alloc (D.31021, 56);
          dest->data.op[1].const_val = 0;
          D.31060 = dest->data.op[1].const_val;
          dest->data.op[0].const_val = D.31060;
          dest->prev = 0B;
          D.31061 = dest->prev;
          dest->next = D.31061;
          dest->opcode = 393;
          dest->flags = 0;
          dest->type = 0;
          dest->dreg = -1;
          dest->sreg3 = -1;
          D.31062 = dest->sreg3;
          dest->sreg2 = D.31062;
          D.31063 = dest->sreg2;
          dest->sreg1 = D.31063;
          D.31047 = cfg->ip;
          dest->cil_code = D.31047;
          D.31064 = ins->dreg;
          dest->dreg = D.31064;
          D.31048 = ins->sreg1;
          dest->sreg1 = D.31048;
          dest->data.op[0].const_val = 12;
          dest->type = 1;
          D.31065 = (unsigned char) __ins_flags;
          dest->flags = D.31065;
        }
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        if (D.31031 != 0B) goto <D.31066>; else goto <D.31067>;
        <D.31066>:
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        D.31031->next = dest;
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        dest->prev = D.31031;
        D.31030 = cfg->cbb;
        D.31030->last_ins = dest;
        goto <D.31068>;
        <D.31067>:
        D.31030 = cfg->cbb;
        D.31030 = cfg->cbb;
        D.31030->last_ins = dest;
        D.31031 = D.31030->last_ins;
        D.31030->code = D.31031;
        <D.31068>:
        goto <D.26921>;
        <D.26922>:
        D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
        D.31040 = D.31039 & 64;
        if (D.31040 != 0) goto <D.31069>; else goto <D.31070>;
        <D.31069>:
        {
          struct MonoInst * inst;

          D.31021 = cfg->mempool;
          inst = mono_mempool_alloc (D.31021, 56);
          inst->data.op[1].const_val = 0;
          D.31071 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31071;
          inst->prev = 0B;
          D.31072 = inst->prev;
          inst->next = D.31072;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31073 = inst->sreg3;
          inst->sreg2 = D.31073;
          D.31074 = inst->sreg2;
          inst->sreg1 = D.31074;
          D.31047 = cfg->ip;
          inst->cil_code = D.31047;
          inst->dreg = -1;
          D.31048 = ins->sreg1;
          inst->sreg1 = D.31048;
          inst->data.op[1].const_val = 0;
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          if (D.31031 != 0B) goto <D.31075>; else goto <D.31076>;
          <D.31075>:
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          D.31031->next = inst;
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          inst->prev = D.31031;
          D.31030 = cfg->cbb;
          D.31030->last_ins = inst;
          goto <D.31077>;
          <D.31076>:
          D.31030 = cfg->cbb;
          D.31030 = cfg->cbb;
          D.31030->last_ins = inst;
          D.31031 = D.31030->last_ins;
          D.31030->code = D.31031;
          <D.31077>:
        }
        {
          struct MonoInst * inst;

          D.31021 = cfg->mempool;
          inst = mono_mempool_alloc (D.31021, 56);
          inst->data.op[1].const_val = 0;
          D.31078 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31078;
          inst->prev = 0B;
          D.31079 = inst->prev;
          inst->next = D.31079;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31080 = inst->sreg3;
          inst->sreg2 = D.31080;
          D.31081 = inst->sreg2;
          inst->sreg1 = D.31081;
          D.31047 = cfg->ip;
          inst->cil_code = D.31047;
          inst->data.op[1].p = "NullReferenceException";
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          if (D.31031 != 0B) goto <D.31082>; else goto <D.31083>;
          <D.31082>:
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          D.31031->next = inst;
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          inst->prev = D.31031;
          D.31030 = cfg->cbb;
          D.31030->last_ins = inst;
          goto <D.31084>;
          <D.31083>:
          D.31030 = cfg->cbb;
          D.31030 = cfg->cbb;
          D.31030->last_ins = inst;
          D.31031 = D.31030->last_ins;
          D.31030->code = D.31031;
          <D.31084>:
        }
        goto <D.31085>;
        <D.31070>:
        <D.31085>:
        if (0 != 0) goto <D.31086>; else goto <D.31087>;
        <D.31086>:
        {
          int _length_reg;

          D.31088 = alloc_ireg (cfg);
          _length_reg = (int) D.31088;
          D.31034 = ins->flags;
          D.31089 = (int) D.31034;
          D.31090 = D.31089 & 32;
          if (D.31090 != 0) goto <D.31091>; else goto <D.31092>;
          <D.31091>:
          {
            struct MonoInst * inst;
            int __ins_flags;

            __ins_flags = 32;
            D.31093 = __ins_flags & 32;
            if (D.31093 != 0) goto <D.31094>; else goto <D.31095>;
            <D.31094>:
            D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
            D.31040 = D.31039 & 64;
            if (D.31040 != 0) goto <D.31096>; else goto <D.31097>;
            <D.31096>:
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31098 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31098;
              inst->prev = 0B;
              D.31099 = inst->prev;
              inst->next = D.31099;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31100 = inst->sreg3;
              inst->sreg2 = D.31100;
              D.31101 = inst->sreg2;
              inst->sreg1 = D.31101;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->dreg = -1;
              D.31048 = ins->sreg1;
              inst->sreg1 = D.31048;
              inst->data.op[1].const_val = 0;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31102>; else goto <D.31103>;
              <D.31102>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31104>;
              <D.31103>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31104>:
            }
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31105 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31105;
              inst->prev = 0B;
              D.31106 = inst->prev;
              inst->next = D.31106;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31107 = inst->sreg3;
              inst->sreg2 = D.31107;
              D.31108 = inst->sreg2;
              inst->sreg1 = D.31108;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->data.op[1].p = "NullReferenceException";
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31109>; else goto <D.31110>;
              <D.31109>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31111>;
              <D.31110>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31111>:
            }
            goto <D.31112>;
            <D.31097>:
            <D.31112>:
            <D.31095>:
            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31113 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31113;
            inst->prev = 0B;
            D.31114 = inst->prev;
            inst->next = D.31114;
            inst->opcode = 393;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31115 = inst->sreg3;
            inst->sreg2 = D.31115;
            D.31116 = inst->sreg2;
            inst->sreg1 = D.31116;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = _length_reg;
            D.31048 = ins->sreg1;
            inst->sreg1 = D.31048;
            D.31117 = ins->data.op[1].const_val;
            inst->data.op[0].const_val = D.31117;
            inst->type = 1;
            D.31118 = (unsigned char) __ins_flags;
            inst->flags = D.31118;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31119>; else goto <D.31120>;
            <D.31119>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31121>;
            <D.31120>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31121>:
          }
          goto <D.31122>;
          <D.31092>:
          {
            struct MonoInst * inst;
            int __ins_flags;

            __ins_flags = 64;
            D.31123 = __ins_flags & 32;
            if (D.31123 != 0) goto <D.31124>; else goto <D.31125>;
            <D.31124>:
            D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
            D.31040 = D.31039 & 64;
            if (D.31040 != 0) goto <D.31126>; else goto <D.31127>;
            <D.31126>:
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31128 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31128;
              inst->prev = 0B;
              D.31129 = inst->prev;
              inst->next = D.31129;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31130 = inst->sreg3;
              inst->sreg2 = D.31130;
              D.31131 = inst->sreg2;
              inst->sreg1 = D.31131;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->dreg = -1;
              D.31048 = ins->sreg1;
              inst->sreg1 = D.31048;
              inst->data.op[1].const_val = 0;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31132>; else goto <D.31133>;
              <D.31132>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31134>;
              <D.31133>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31134>:
            }
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31135 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31135;
              inst->prev = 0B;
              D.31136 = inst->prev;
              inst->next = D.31136;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31137 = inst->sreg3;
              inst->sreg2 = D.31137;
              D.31138 = inst->sreg2;
              inst->sreg1 = D.31138;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->data.op[1].p = "NullReferenceException";
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31139>; else goto <D.31140>;
              <D.31139>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31141>;
              <D.31140>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31141>:
            }
            goto <D.31142>;
            <D.31127>:
            <D.31142>:
            <D.31125>:
            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31143 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31143;
            inst->prev = 0B;
            D.31144 = inst->prev;
            inst->next = D.31144;
            inst->opcode = 393;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31145 = inst->sreg3;
            inst->sreg2 = D.31145;
            D.31146 = inst->sreg2;
            inst->sreg1 = D.31146;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = _length_reg;
            D.31048 = ins->sreg1;
            inst->sreg1 = D.31048;
            D.31117 = ins->data.op[1].const_val;
            inst->data.op[0].const_val = D.31117;
            inst->type = 1;
            D.31147 = (unsigned char) __ins_flags;
            inst->flags = D.31147;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31148>; else goto <D.31149>;
            <D.31148>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31150>;
            <D.31149>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31150>:
          }
          <D.31122>:
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31151 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31151;
            inst->prev = 0B;
            D.31152 = inst->prev;
            inst->next = D.31152;
            inst->opcode = 322;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31153 = inst->sreg3;
            inst->sreg2 = D.31153;
            D.31154 = inst->sreg2;
            inst->sreg1 = D.31154;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = -1;
            inst->sreg1 = _length_reg;
            D.31155 = ins->sreg2;
            inst->sreg2 = D.31155;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31156>; else goto <D.31157>;
            <D.31156>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31158>;
            <D.31157>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31158>:
          }
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31159 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31159;
            inst->prev = 0B;
            D.31160 = inst->prev;
            inst->next = D.31160;
            inst->opcode = 459;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31161 = inst->sreg3;
            inst->sreg2 = D.31161;
            D.31162 = inst->sreg2;
            inst->sreg1 = D.31162;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->data.op[1].p = "IndexOutOfRangeException";
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31163>; else goto <D.31164>;
            <D.31163>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31165>;
            <D.31164>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31165>:
          }
        }
        goto <D.31166>;
        <D.31087>:
        {
          int _length_reg;

          D.31167 = alloc_ireg (cfg);
          _length_reg = (int) D.31167;
          if (1 != 0) goto <D.31168>; else goto <D.31169>;
          <D.31168>:
          {
            struct MonoInst * inst;
            int __ins_flags;

            __ins_flags = 32;
            D.31170 = __ins_flags & 32;
            if (D.31170 != 0) goto <D.31171>; else goto <D.31172>;
            <D.31171>:
            D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
            D.31040 = D.31039 & 64;
            if (D.31040 != 0) goto <D.31173>; else goto <D.31174>;
            <D.31173>:
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31175 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31175;
              inst->prev = 0B;
              D.31176 = inst->prev;
              inst->next = D.31176;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31177 = inst->sreg3;
              inst->sreg2 = D.31177;
              D.31178 = inst->sreg2;
              inst->sreg1 = D.31178;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->dreg = -1;
              D.31048 = ins->sreg1;
              inst->sreg1 = D.31048;
              inst->data.op[1].const_val = 0;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31179>; else goto <D.31180>;
              <D.31179>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31181>;
              <D.31180>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31181>:
            }
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31182 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31182;
              inst->prev = 0B;
              D.31183 = inst->prev;
              inst->next = D.31183;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31184 = inst->sreg3;
              inst->sreg2 = D.31184;
              D.31185 = inst->sreg2;
              inst->sreg1 = D.31185;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->data.op[1].p = "NullReferenceException";
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31186>; else goto <D.31187>;
              <D.31186>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31188>;
              <D.31187>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31188>:
            }
            goto <D.31189>;
            <D.31174>:
            <D.31189>:
            <D.31172>:
            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31190 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31190;
            inst->prev = 0B;
            D.31191 = inst->prev;
            inst->next = D.31191;
            inst->opcode = 393;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31192 = inst->sreg3;
            inst->sreg2 = D.31192;
            D.31193 = inst->sreg2;
            inst->sreg1 = D.31193;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = _length_reg;
            D.31048 = ins->sreg1;
            inst->sreg1 = D.31048;
            D.31117 = ins->data.op[1].const_val;
            inst->data.op[0].const_val = D.31117;
            inst->type = 1;
            D.31194 = (unsigned char) __ins_flags;
            inst->flags = D.31194;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31195>; else goto <D.31196>;
            <D.31195>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31197>;
            <D.31196>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31197>:
          }
          goto <D.31198>;
          <D.31169>:
          {
            struct MonoInst * inst;
            int __ins_flags;

            __ins_flags = 64;
            D.31199 = __ins_flags & 32;
            if (D.31199 != 0) goto <D.31200>; else goto <D.31201>;
            <D.31200>:
            D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
            D.31040 = D.31039 & 64;
            if (D.31040 != 0) goto <D.31202>; else goto <D.31203>;
            <D.31202>:
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31204 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31204;
              inst->prev = 0B;
              D.31205 = inst->prev;
              inst->next = D.31205;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31206 = inst->sreg3;
              inst->sreg2 = D.31206;
              D.31207 = inst->sreg2;
              inst->sreg1 = D.31207;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->dreg = -1;
              D.31048 = ins->sreg1;
              inst->sreg1 = D.31048;
              inst->data.op[1].const_val = 0;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31208>; else goto <D.31209>;
              <D.31208>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31210>;
              <D.31209>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31210>:
            }
            {
              struct MonoInst * inst;

              D.31021 = cfg->mempool;
              inst = mono_mempool_alloc (D.31021, 56);
              inst->data.op[1].const_val = 0;
              D.31211 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.31211;
              inst->prev = 0B;
              D.31212 = inst->prev;
              inst->next = D.31212;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.31213 = inst->sreg3;
              inst->sreg2 = D.31213;
              D.31214 = inst->sreg2;
              inst->sreg1 = D.31214;
              D.31047 = cfg->ip;
              inst->cil_code = D.31047;
              inst->data.op[1].p = "NullReferenceException";
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              if (D.31031 != 0B) goto <D.31215>; else goto <D.31216>;
              <D.31215>:
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              D.31031->next = inst;
              D.31030 = cfg->cbb;
              D.31031 = D.31030->last_ins;
              inst->prev = D.31031;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              goto <D.31217>;
              <D.31216>:
              D.31030 = cfg->cbb;
              D.31030 = cfg->cbb;
              D.31030->last_ins = inst;
              D.31031 = D.31030->last_ins;
              D.31030->code = D.31031;
              <D.31217>:
            }
            goto <D.31218>;
            <D.31203>:
            <D.31218>:
            <D.31201>:
            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31219 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31219;
            inst->prev = 0B;
            D.31220 = inst->prev;
            inst->next = D.31220;
            inst->opcode = 393;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31221 = inst->sreg3;
            inst->sreg2 = D.31221;
            D.31222 = inst->sreg2;
            inst->sreg1 = D.31222;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = _length_reg;
            D.31048 = ins->sreg1;
            inst->sreg1 = D.31048;
            D.31117 = ins->data.op[1].const_val;
            inst->data.op[0].const_val = D.31117;
            inst->type = 1;
            D.31223 = (unsigned char) __ins_flags;
            inst->flags = D.31223;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31224>; else goto <D.31225>;
            <D.31224>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31226>;
            <D.31225>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31226>:
          }
          <D.31198>:
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31227 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31227;
            inst->prev = 0B;
            D.31228 = inst->prev;
            inst->next = D.31228;
            inst->opcode = 322;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31229 = inst->sreg3;
            inst->sreg2 = D.31229;
            D.31230 = inst->sreg2;
            inst->sreg1 = D.31230;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = -1;
            inst->sreg1 = _length_reg;
            D.31155 = ins->sreg2;
            inst->sreg2 = D.31155;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31231>; else goto <D.31232>;
            <D.31231>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31233>;
            <D.31232>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31233>:
          }
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31234 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31234;
            inst->prev = 0B;
            D.31235 = inst->prev;
            inst->next = D.31235;
            inst->opcode = 459;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31236 = inst->sreg3;
            inst->sreg2 = D.31236;
            D.31237 = inst->sreg2;
            inst->sreg1 = D.31237;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->data.op[1].p = "IndexOutOfRangeException";
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31238>; else goto <D.31239>;
            <D.31238>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31240>;
            <D.31239>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31240>:
          }
        }
        <D.31166>:
        goto <D.26921>;
        <D.26947>:
        D.31241 = cfg->opt;
        D.31242 = D.31241 & 512;
        if (D.31242 != 0) goto <D.31243>; else goto <D.31244>;
        <D.31243>:
        D.31241 = cfg->opt;
        D.31242 = D.31241 & 512;
        if (D.31242 != 0) goto <D.31245>; else goto <D.31248>;
        <D.31248>:
        D.31249 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.31250 = D.31249 & 64;
        if (D.31250 != 0) goto <D.31245>; else goto <D.31246>;
        <D.31245>:
        {
          struct MonoInst * __domain_var;

          __domain_var = mono_get_domainvar (cfg);
          D.31021 = cfg->mempool;
          D.31251 = mono_mempool_alloc (D.31021, 56);
          iargs[0] = D.31251;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252->data.op[1].const_val = 0;
          D.31253 = D.31252->data.op[1].const_val;
          D.31252->data.op[0].const_val = D.31253;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252->prev = 0B;
          D.31254 = D.31252->prev;
          D.31252->next = D.31254;
          D.31252 = iargs[0];
          D.31252->opcode = 424;
          D.31252 = iargs[0];
          D.31252->flags = 0;
          D.31252 = iargs[0];
          D.31252->type = 0;
          D.31252 = iargs[0];
          D.31252->dreg = -1;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252->sreg3 = -1;
          D.31255 = D.31252->sreg3;
          D.31252->sreg2 = D.31255;
          D.31256 = D.31252->sreg2;
          D.31252->sreg1 = D.31256;
          D.31252 = iargs[0];
          D.31047 = cfg->ip;
          D.31252->cil_code = D.31047;
          D.31252 = iargs[0];
          D.31257 = cfg->varinfo;
          D.31258 = __domain_var->data.op[0].const_val;
          D.31259 = (unsigned int) D.31258;
          D.31260 = D.31259 * 4;
          D.31261 = D.31257 + D.31260;
          D.31262 = *D.31261;
          D.31263 = D.31262->data.op[1].vtype;
          D.31264 = mono_type_to_regmove (cfg, D.31263);
          D.31265 = (short unsigned int) D.31264;
          D.31252->opcode = D.31265;
          D.31257 = cfg->varinfo;
          D.31258 = __domain_var->data.op[0].const_val;
          D.31259 = (unsigned int) D.31258;
          D.31260 = D.31259 * 4;
          D.31261 = D.31257 + D.31260;
          D.31262 = *D.31261;
          D.31263 = D.31262->data.op[1].vtype;
          D.31252 = iargs[0];
          type_to_eval_stack_type (cfg, D.31263, D.31252);
          D.31252 = iargs[0];
          D.31257 = cfg->varinfo;
          D.31258 = __domain_var->data.op[0].const_val;
          D.31259 = (unsigned int) D.31258;
          D.31260 = D.31259 * 4;
          D.31261 = D.31257 + D.31260;
          D.31262 = *D.31261;
          D.31266 = D.31262->klass;
          D.31252->klass = D.31266;
          D.31252 = iargs[0];
          D.31257 = cfg->varinfo;
          D.31258 = __domain_var->data.op[0].const_val;
          D.31259 = (unsigned int) D.31258;
          D.31260 = D.31259 * 4;
          D.31261 = D.31257 + D.31260;
          D.31262 = *D.31261;
          D.31267 = D.31262->dreg;
          D.31252->sreg1 = D.31267;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31268 = D.31252->type;
          D.31269 = (<unnamed type>) D.31268;
          D.31270 = alloc_dreg (cfg, D.31269);
          D.31271 = (int) D.31270;
          D.31252->dreg = D.31271;
          D.31252 = iargs[0];
          D.31272 = D.31252->opcode;
          if (D.31272 == 427) goto <D.31273>; else goto <D.31274>;
          <D.31273>:
          D.31252 = iargs[0];
          D.31257 = cfg->varinfo;
          D.31258 = __domain_var->data.op[0].const_val;
          D.31259 = (unsigned int) D.31258;
          D.31260 = D.31259 * 4;
          D.31261 = D.31257 + D.31260;
          D.31262 = *D.31261;
          D.31263 = D.31262->data.op[1].vtype;
          D.31275 = mono_class_from_mono_type (D.31263);
          D.31252->klass = D.31275;
          <D.31274>:
        }
        goto <D.31247>;
        <D.31246>:
        D.31021 = cfg->mempool;
        D.31276 = mono_mempool_alloc (D.31021, 56);
        iargs[0] = D.31276;
        D.31252 = iargs[0];
        D.31252 = iargs[0];
        D.31252->data.op[1].const_val = 0;
        D.31253 = D.31252->data.op[1].const_val;
        D.31252->data.op[0].const_val = D.31253;
        D.31252 = iargs[0];
        D.31252 = iargs[0];
        D.31252->prev = 0B;
        D.31254 = D.31252->prev;
        D.31252->next = D.31254;
        D.31252 = iargs[0];
        D.31252->opcode = 362;
        D.31252 = iargs[0];
        D.31252->flags = 0;
        D.31252 = iargs[0];
        D.31252->type = 0;
        D.31252 = iargs[0];
        D.31252->dreg = -1;
        D.31252 = iargs[0];
        D.31252 = iargs[0];
        D.31252 = iargs[0];
        D.31252->sreg3 = -1;
        D.31255 = D.31252->sreg3;
        D.31252->sreg2 = D.31255;
        D.31256 = D.31252->sreg2;
        D.31252->sreg1 = D.31256;
        D.31252 = iargs[0];
        D.31047 = cfg->ip;
        D.31252->cil_code = D.31047;
        D.31252 = iargs[0];
        D.31277 = cfg->domain;
        D.31252->data.op[0].p = D.31277;
        D.31252 = iargs[0];
        D.31252->type = 3;
        D.31252 = iargs[0];
        D.31278 = alloc_dreg (cfg, 3);
        D.31279 = (int) D.31278;
        D.31252->dreg = D.31279;
        <D.31247>:
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        if (D.31031 != 0B) goto <D.31280>; else goto <D.31281>;
        <D.31280>:
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        D.31252 = iargs[0];
        D.31031->next = D.31252;
        D.31252 = iargs[0];
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        D.31252->prev = D.31031;
        D.31030 = cfg->cbb;
        D.31252 = iargs[0];
        D.31030->last_ins = D.31252;
        goto <D.31282>;
        <D.31281>:
        D.31030 = cfg->cbb;
        D.31030 = cfg->cbb;
        D.31252 = iargs[0];
        D.31030->last_ins = D.31252;
        D.31031 = D.31030->last_ins;
        D.31030->code = D.31031;
        <D.31282>:
        D.31021 = cfg->mempool;
        D.31283 = mono_mempool_alloc (D.31021, 56);
        iargs[1] = D.31283;
        D.31284 = iargs[1];
        D.31284 = iargs[1];
        D.31284->data.op[1].const_val = 0;
        D.31285 = D.31284->data.op[1].const_val;
        D.31284->data.op[0].const_val = D.31285;
        D.31284 = iargs[1];
        D.31284 = iargs[1];
        D.31284->prev = 0B;
        D.31286 = D.31284->prev;
        D.31284->next = D.31286;
        D.31284 = iargs[1];
        D.31249 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.31250 = D.31249 & 64;
        if (D.31250 != 0) goto <D.31288>; else goto <D.31289>;
        <D.31288>:
        iftmp.45 = 732;
        goto <D.31290>;
        <D.31289>:
        iftmp.45 = 362;
        <D.31290>:
        D.31284->opcode = iftmp.45;
        D.31284 = iargs[1];
        D.31284->flags = 0;
        D.31284 = iargs[1];
        D.31284->type = 0;
        D.31284 = iargs[1];
        D.31284->dreg = -1;
        D.31284 = iargs[1];
        D.31284 = iargs[1];
        D.31284 = iargs[1];
        D.31284->sreg3 = -1;
        D.31291 = D.31284->sreg3;
        D.31284->sreg2 = D.31291;
        D.31292 = D.31284->sreg2;
        D.31284->sreg1 = D.31292;
        D.31284 = iargs[1];
        D.31047 = cfg->ip;
        D.31284->cil_code = D.31047;
        D.31284 = iargs[1];
        D.31293 = ins->data.op[1].klass;
        D.31284->data.op[0].p = D.31293;
        D.31284 = iargs[1];
        D.31284->data.op[1].src = 11B;
        D.31284 = iargs[1];
        D.31284->type = 3;
        D.31284 = iargs[1];
        D.31294 = alloc_dreg (cfg, 3);
        D.31295 = (int) D.31294;
        D.31284->dreg = D.31295;
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        if (D.31031 != 0B) goto <D.31296>; else goto <D.31297>;
        <D.31296>:
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        D.31284 = iargs[1];
        D.31031->next = D.31284;
        D.31284 = iargs[1];
        D.31030 = cfg->cbb;
        D.31031 = D.31030->last_ins;
        D.31284->prev = D.31031;
        D.31030 = cfg->cbb;
        D.31284 = iargs[1];
        D.31030->last_ins = D.31284;
        goto <D.31298>;
        <D.31297>:
        D.31030 = cfg->cbb;
        D.31030 = cfg->cbb;
        D.31284 = iargs[1];
        D.31030->last_ins = D.31284;
        D.31031 = D.31030->last_ins;
        D.31030->code = D.31031;
        <D.31298>:
        D.31021 = cfg->mempool;
        D.31299 = mono_mempool_alloc (D.31021, 56);
        iargs[2] = D.31299;
        D.31300 = iargs[2];
        D.31300 = iargs[2];
        D.31300->data.op[1].const_val = 0;
        D.31301 = D.31300->data.op[1].const_val;
        D.31300->data.op[0].const_val = D.31301;
        D.31300 = iargs[2];
        D.31300 = iargs[2];
        D.31300->prev = 0B;
        D.31302 = D.31300->prev;
        D.31300->next = D.31302;
        D.31300 = iargs[2];
        D.31300->opcode = 424;
        D.31300 = iargs[2];
        D.31300->flags = 0;
        D.31300 = iargs[2];
        D.31300->type = 0;
        D.31300 = iargs[2];
        D.31300->dreg = -1;
        D.31300 = iargs[2];
        D.31300 = iargs[2];
        D.31300 = iargs[2];
        D.31300->sreg3 = -1;
        D.31303 = D.31300->sreg3;
        D.31300->sreg2 = D.31303;
        D.31304 = D.31300->sreg2;
        D.31300->sreg1 = D.31304;
        D.31300 = iargs[2];
        D.31047 = cfg->ip;
        D.31300->cil_code = D.31047;
        D.31300 = iargs[2];
        D.31048 = ins->sreg1;
        D.31300->dreg = D.31048;
        dest = mono_emit_jit_icall (cfg, mono_array_new, &iargs);
        D.31064 = ins->dreg;
        dest->dreg = D.31064;
        goto <D.31305>;
        <D.31244>:
        {
          struct MonoClass * array_class;
          struct MonoVTable * vtable;
          struct MonoMethod * managed_alloc;

          D.31293 = ins->data.op[1].klass;
          array_class = mono_array_class_get (D.31293, 1);
          D.31277 = cfg->domain;
          vtable = mono_class_vtable (D.31277, array_class);
          managed_alloc = mono_gc_get_managed_array_allocator (array_class);
          D.31306 = vtable == 0B;
          D.31307 = (long int) D.31306;
          D.31308 = __builtin_expect (D.31307, 0);
          if (D.31308 != 0) goto <D.31309>; else goto <D.31310>;
          <D.31309>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1505, "vtable");
          <D.31310>:
          D.31021 = cfg->mempool;
          D.31311 = mono_mempool_alloc (D.31021, 56);
          iargs[0] = D.31311;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252->data.op[1].const_val = 0;
          D.31253 = D.31252->data.op[1].const_val;
          D.31252->data.op[0].const_val = D.31253;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252->prev = 0B;
          D.31254 = D.31252->prev;
          D.31252->next = D.31254;
          D.31252 = iargs[0];
          D.31249 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.31250 = D.31249 & 64;
          if (D.31250 != 0) goto <D.31313>; else goto <D.31314>;
          <D.31313>:
          iftmp.46 = 732;
          goto <D.31315>;
          <D.31314>:
          iftmp.46 = 362;
          <D.31315>:
          D.31252->opcode = iftmp.46;
          D.31252 = iargs[0];
          D.31252->flags = 0;
          D.31252 = iargs[0];
          D.31252->type = 0;
          D.31252 = iargs[0];
          D.31252->dreg = -1;
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252 = iargs[0];
          D.31252->sreg3 = -1;
          D.31255 = D.31252->sreg3;
          D.31252->sreg2 = D.31255;
          D.31256 = D.31252->sreg2;
          D.31252->sreg1 = D.31256;
          D.31252 = iargs[0];
          D.31047 = cfg->ip;
          D.31252->cil_code = D.31047;
          D.31252 = iargs[0];
          D.31249 = BIT_FIELD_REF <*cfg, 8, 3392>;
          D.31250 = D.31249 & 64;
          if (D.31250 != 0) goto <D.31317>; else goto <D.31318>;
          <D.31317>:
          iftmp.47 = vtable->klass;
          goto <D.31319>;
          <D.31318>:
          iftmp.47 = vtable;
          <D.31319>:
          D.31252->data.op[0].p = iftmp.47;
          D.31252 = iargs[0];
          D.31252->data.op[1].src = 14B;
          D.31252 = iargs[0];
          D.31252->type = 3;
          D.31252 = iargs[0];
          D.31320 = alloc_dreg (cfg, 3);
          D.31321 = (int) D.31320;
          D.31252->dreg = D.31321;
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          if (D.31031 != 0B) goto <D.31322>; else goto <D.31323>;
          <D.31322>:
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          D.31252 = iargs[0];
          D.31031->next = D.31252;
          D.31252 = iargs[0];
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          D.31252->prev = D.31031;
          D.31030 = cfg->cbb;
          D.31252 = iargs[0];
          D.31030->last_ins = D.31252;
          goto <D.31324>;
          <D.31323>:
          D.31030 = cfg->cbb;
          D.31030 = cfg->cbb;
          D.31252 = iargs[0];
          D.31030->last_ins = D.31252;
          D.31031 = D.31030->last_ins;
          D.31030->code = D.31031;
          <D.31324>:
          D.31021 = cfg->mempool;
          D.31325 = mono_mempool_alloc (D.31021, 56);
          iargs[1] = D.31325;
          D.31284 = iargs[1];
          D.31284 = iargs[1];
          D.31284->data.op[1].const_val = 0;
          D.31285 = D.31284->data.op[1].const_val;
          D.31284->data.op[0].const_val = D.31285;
          D.31284 = iargs[1];
          D.31284 = iargs[1];
          D.31284->prev = 0B;
          D.31286 = D.31284->prev;
          D.31284->next = D.31286;
          D.31284 = iargs[1];
          D.31284->opcode = 424;
          D.31284 = iargs[1];
          D.31284->flags = 0;
          D.31284 = iargs[1];
          D.31284->type = 0;
          D.31284 = iargs[1];
          D.31284->dreg = -1;
          D.31284 = iargs[1];
          D.31284 = iargs[1];
          D.31284 = iargs[1];
          D.31284->sreg3 = -1;
          D.31291 = D.31284->sreg3;
          D.31284->sreg2 = D.31291;
          D.31292 = D.31284->sreg2;
          D.31284->sreg1 = D.31292;
          D.31284 = iargs[1];
          D.31047 = cfg->ip;
          D.31284->cil_code = D.31047;
          D.31284 = iargs[1];
          D.31048 = ins->sreg1;
          D.31284->dreg = D.31048;
          if (managed_alloc != 0B) goto <D.31326>; else goto <D.31327>;
          <D.31326>:
          dest = mono_emit_method_call (cfg, managed_alloc, &iargs, 0B);
          goto <D.31328>;
          <D.31327>:
          dest = mono_emit_jit_icall (cfg, mono_array_new_specific, &iargs);
          <D.31328>:
          D.31064 = ins->dreg;
          dest->dreg = D.31064;
        }
        <D.31305>:
        goto <D.26921>;
        <D.26952>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          D.31034 = ins->flags;
          D.31035 = D.31034 | 64;
          __ins_flags = (int) D.31035;
          D.31329 = __ins_flags & 32;
          if (D.31329 != 0) goto <D.31330>; else goto <D.31331>;
          <D.31330>:
          D.31039 = BIT_FIELD_REF <*cfg, 8, 3424>;
          D.31040 = D.31039 & 64;
          if (D.31040 != 0) goto <D.31332>; else goto <D.31333>;
          <D.31332>:
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31334 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31334;
            inst->prev = 0B;
            D.31335 = inst->prev;
            inst->next = D.31335;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31336 = inst->sreg3;
            inst->sreg2 = D.31336;
            D.31337 = inst->sreg2;
            inst->sreg1 = D.31337;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->dreg = -1;
            D.31048 = ins->sreg1;
            inst->sreg1 = D.31048;
            inst->data.op[1].const_val = 0;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31338>; else goto <D.31339>;
            <D.31338>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31340>;
            <D.31339>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31340>:
          }
          {
            struct MonoInst * inst;

            D.31021 = cfg->mempool;
            inst = mono_mempool_alloc (D.31021, 56);
            inst->data.op[1].const_val = 0;
            D.31341 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.31341;
            inst->prev = 0B;
            D.31342 = inst->prev;
            inst->next = D.31342;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.31343 = inst->sreg3;
            inst->sreg2 = D.31343;
            D.31344 = inst->sreg2;
            inst->sreg1 = D.31344;
            D.31047 = cfg->ip;
            inst->cil_code = D.31047;
            inst->data.op[1].p = "NullReferenceException";
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            if (D.31031 != 0B) goto <D.31345>; else goto <D.31346>;
            <D.31345>:
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            D.31031->next = inst;
            D.31030 = cfg->cbb;
            D.31031 = D.31030->last_ins;
            inst->prev = D.31031;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            goto <D.31347>;
            <D.31346>:
            D.31030 = cfg->cbb;
            D.31030 = cfg->cbb;
            D.31030->last_ins = inst;
            D.31031 = D.31030->last_ins;
            D.31030->code = D.31031;
            <D.31347>:
          }
          goto <D.31348>;
          <D.31333>:
          <D.31348>:
          <D.31331>:
          D.31021 = cfg->mempool;
          inst = mono_mempool_alloc (D.31021, 56);
          inst->data.op[1].const_val = 0;
          D.31349 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31349;
          inst->prev = 0B;
          D.31350 = inst->prev;
          inst->next = D.31350;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31351 = inst->sreg3;
          inst->sreg2 = D.31351;
          D.31352 = inst->sreg2;
          inst->sreg1 = D.31352;
          D.31047 = cfg->ip;
          inst->cil_code = D.31047;
          D.31064 = ins->dreg;
          inst->dreg = D.31064;
          D.31048 = ins->sreg1;
          inst->sreg1 = D.31048;
          inst->data.op[0].const_val = 8;
          inst->type = 1;
          D.31353 = (unsigned char) __ins_flags;
          inst->flags = D.31353;
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          if (D.31031 != 0B) goto <D.31354>; else goto <D.31355>;
          <D.31354>:
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          D.31031->next = inst;
          D.31030 = cfg->cbb;
          D.31031 = D.31030->last_ins;
          inst->prev = D.31031;
          D.31030 = cfg->cbb;
          D.31030->last_ins = inst;
          goto <D.31356>;
          <D.31355>:
          D.31030 = cfg->cbb;
          D.31030 = cfg->cbb;
          D.31030->last_ins = inst;
          D.31031 = D.31030->last_ins;
          D.31030->code = D.31031;
          <D.31356>:
        }
        goto <D.26921>;
        <D.26957>:
        goto <D.26921>;
        <D.26921>:
        D.31030 = cfg->cbb;
        D.31357 = D.31030 != first_bb;
        D.31358 = (long int) D.31357;
        D.31359 = __builtin_expect (D.31358, 0);
        if (D.31359 != 0) goto <D.31360>; else goto <D.31361>;
        <D.31360>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decompose.c", 1526, "cfg->cbb == first_bb");
        <D.31361>:
        D.31030 = cfg->cbb;
        D.31365 = D.31030->code;
        if (D.31365 != 0B) goto <D.31362>; else goto <D.31366>;
        <D.31366>:
        D.31030 = cfg->cbb;
        if (D.31030 != first_bb) goto <D.31362>; else goto <D.31363>;
        <D.31362>:
        D.31030 = cfg->cbb;
        mono_replace_ins (cfg, bb, ins, &prev, first_bb, D.31030);
        first_bb->last_ins = 0B;
        D.31367 = first_bb->last_ins;
        first_bb->code = D.31367;
        first_bb->out_count = 0;
        D.31368 = first_bb->out_count;
        first_bb->in_count = D.31368;
        cfg->cbb = first_bb;
        goto <D.31364>;
        <D.31363>:
        prev = ins;
        <D.31364>:
        ins = ins->next;
        <D.26959>:
        if (ins != 0B) goto <D.26958>; else goto <D.26960>;
        <D.26960>:
        <D.26962>:
        if (restart != 0) goto <D.26961>; else goto <D.26963>;
        <D.26963>:
        D.31027 = cfg->verbose_level;
        if (D.31027 > 3) goto <D.31369>; else goto <D.31370>;
        <D.31369>:
        mono_print_bb (bb, "AFTER DECOMPOSE-ARRAY-ACCESS-OPTS ");
        <D.31370>:
      }
    finally
      {
        prev = {CLOBBER};
        iargs = {CLOBBER};
      }
  }
  <D.26916>:
  bb = bb->next_bb;
  <D.26965>:
  if (bb != 0B) goto <D.26964>; else goto <D.26966>;
  <D.26966>:
}


mono_get_domainvar (struct MonoCompile * cfg)
{
  struct MonoInst * D.31374;
  struct MonoClass * D.31377;
  struct MonoType * D.31378;
  struct MonoInst * D.31379;
  struct MonoInst * D.31380;

  D.31374 = cfg->domainvar;
  if (D.31374 == 0B) goto <D.31375>; else goto <D.31376>;
  <D.31375>:
  D.31377 = mono_defaults.int_class;
  D.31378 = &D.31377->byval_arg;
  D.31379 = mono_compile_create_var (cfg, D.31378, 329);
  cfg->domainvar = D.31379;
  <D.31376>:
  D.31380 = cfg->domainvar;
  return D.31380;
}


