mono_arch_get_unbox_trampoline (struct MonoMethod * m, void * addr)
{
  void * code.0;
  guint8 * code.1;
  guint8 * code.2;
  guint8 * code.3;
  guint8 * code.4;
  guint8 * code.5;
  guint8 * code.6;
  guint8 * code.7;
  unsigned int this_pos.8;
  unsigned int D.23470;
  guint8 * code.9;
  guint8 * code.10;
  guint8 * code.11;
  guint8 * code.12;
  unsigned char D.23477;
  guint8 * code.13;
  guint8 * code.14;
  guint8 * code.15;
  guint8 * code.16;
  guint8 * code.17;
  guint8 * code.18;
  guint8 * code.19;
  unsigned char D.23486;
  guint8 * code.20;
  guint8 * code.21;
  unsigned char D.23489;
  guint8 * code.22;
  guint8 * code.23;
  unsigned char D.23492;
  guint8 * code.24;
  guint8 * code.25;
  unsigned char D.23495;
  guint8 * code.26;
  guint8 * code.27;
  guint8 * code.28;
  guint8 * code.29;
  guint8 * code.30;
  guint8 * code.31;
  guint8 * code.32;
  guint8 * code.33;
  unsigned char D.23509;
  guint8 * code.34;
  guint8 * code.35;
  unsigned char D.23512;
  guint8 * code.36;
  guint8 * code.37;
  unsigned char D.23515;
  guint8 * code.38;
  guint8 * code.39;
  unsigned char D.23518;
  guint8 * code.40;
  guint8 * code.41;
  guint8 * code.42;
  guint8 * code.43;
  guint8 * code.44;
  guint8 * code.45;
  guint8 * code.46;
  guint8 * code.47;
  guint8 * code.48;
  guint8 * code.49;
  guint8 * code.50;
  guint8 * code.51;
  guint8 * code.52;
  guint8 * code.53;
  guint8 * code.54;
  guint8 * code.55;
  unsigned char D.23544;
  guint8 * code.56;
  guint8 * code.57;
  unsigned char D.23547;
  guint8 * code.58;
  guint8 * code.59;
  unsigned char D.23550;
  guint8 * code.60;
  guint8 * code.61;
  unsigned char D.23553;
  guint8 * code.62;
  guint8 * code.63;
  guint8 * code.64;
  guint8 * code.65;
  guint8 * code.66;
  guint8 * code.67;
  guint8 * code.68;
  guint8 * code.69;
  unsigned char D.23567;
  guint8 * code.70;
  guint8 * code.71;
  unsigned char D.23570;
  guint8 * code.72;
  guint8 * code.73;
  unsigned char D.23573;
  guint8 * code.74;
  guint8 * code.75;
  unsigned char D.23576;
  guint8 * code.76;
  guint8 * code.77;
  unsigned char D.23579;
  guint8 * code.78;
  guint8 * code.79;
  unsigned char D.23582;
  guint8 * code.80;
  guint8 * code.81;
  unsigned char D.23585;
  guint8 * code.82;
  guint8 * code.83;
  unsigned char D.23588;
  int addr.84;
  int code.85;
  int D.23591;
  unsigned int t.86;
  unsigned int D.23593;
  guint8 * code.87;
  guint8 * code.88;
  unsigned char D.23598;
  guint8 * code.89;
  guint8 * code.90;
  guint8 * code.91;
  guint8 * code.92;
  unsigned char D.23604;
  guint8 * code.93;
  guint8 * code.94;
  unsigned char D.23607;
  guint8 * code.95;
  guint8 * code.96;
  unsigned char D.23610;
  guint8 * code.97;
  guint8 * code.98;
  unsigned char D.23613;
  guint8 * start.99;
  int start.100;
  int D.23616;
  _Bool D.23617;
  long int D.23618;
  long int D.23619;
  void * D.23622;
  guint8 * code;
  guint8 * start;
  int this_pos;
  int size;
  struct MonoDomain * domain;

  try
    {
      this_pos = 4;
      size = 16;
      domain = mono_domain_get ();
      code.0 = mono_domain_code_reserve (domain, size);
      code = code.0;
      code.1 = code;
      start = code.1;
      if (1 != 0) goto <D.23456>; else goto <D.23457>;
      <D.23456>:
      code.1 = code;
      code.2 = code.1;
      code.3 = code.2 + 1;
      code = code.3;
      *code.2 = 131;
      if (1 != 0) goto <D.23460>; else goto <D.23461>;
      <D.23460>:
      if (this_pos == 0) goto <D.23462>; else goto <D.23463>;
      <D.23462>:
      code.1 = code;
      code.4 = code.1;
      code.5 = code.4 + 1;
      code = code.5;
      *code.4 = 4;
      code.1 = code;
      code.6 = code.1;
      code.7 = code.6 + 1;
      code = code.7;
      *code.6 = 36;
      goto <D.23468>;
      <D.23463>:
      this_pos.8 = (unsigned int) this_pos;
      D.23470 = this_pos.8 + 128;
      if (D.23470 <= 255) goto <D.23471>; else goto <D.23472>;
      <D.23471>:
      code.1 = code;
      code.9 = code.1;
      code.10 = code.9 + 1;
      code = code.10;
      *code.9 = 68;
      code.1 = code;
      code.11 = code.1;
      code.12 = code.11 + 1;
      code = code.12;
      *code.11 = 36;
      code.1 = code;
      D.23477 = (unsigned char) this_pos;
      *code.1 = D.23477;
      code.1 = code;
      code.13 = code.1 + 1;
      code = code.13;
      goto <D.23479>;
      <D.23472>:
      code.1 = code;
      code.14 = code.1;
      code.15 = code.14 + 1;
      code = code.15;
      *code.14 = 132;
      code.1 = code;
      code.16 = code.1;
      code.17 = code.16 + 1;
      code = code.17;
      *code.16 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.1 = code;
            code.18 = code.1;
            code.19 = code.18 + 1;
            code = code.19;
            D.23486 = imb.b[0];
            *code.18 = D.23486;
            code.1 = code;
            code.20 = code.1;
            code.21 = code.20 + 1;
            code = code.21;
            D.23489 = imb.b[1];
            *code.20 = D.23489;
            code.1 = code;
            code.22 = code.1;
            code.23 = code.22 + 1;
            code = code.23;
            D.23492 = imb.b[2];
            *code.22 = D.23492;
            code.1 = code;
            code.24 = code.1;
            code.25 = code.24 + 1;
            code = code.25;
            D.23495 = imb.b[3];
            *code.24 = D.23495;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23479>:
      <D.23468>:
      goto <D.22463>;
      <D.23461>:
      if (this_pos == 0) goto <D.23496>; else goto <D.23497>;
      <D.23496>:
      code.1 = code;
      code.26 = code.1;
      code.27 = code.26 + 1;
      code = code.27;
      *code.26 = 4;
      goto <D.22463>;
      <D.23497>:
      this_pos.8 = (unsigned int) this_pos;
      D.23470 = this_pos.8 + 128;
      if (D.23470 <= 255) goto <D.23500>; else goto <D.23501>;
      <D.23500>:
      code.1 = code;
      code.28 = code.1;
      code.29 = code.28 + 1;
      code = code.29;
      *code.28 = 68;
      code.1 = code;
      D.23477 = (unsigned char) this_pos;
      *code.1 = D.23477;
      code.1 = code;
      code.13 = code.1 + 1;
      code = code.13;
      goto <D.23504>;
      <D.23501>:
      code.1 = code;
      code.30 = code.1;
      code.31 = code.30 + 1;
      code = code.31;
      *code.30 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.1 = code;
            code.32 = code.1;
            code.33 = code.32 + 1;
            code = code.33;
            D.23509 = imb.b[0];
            *code.32 = D.23509;
            code.1 = code;
            code.34 = code.1;
            code.35 = code.34 + 1;
            code = code.35;
            D.23512 = imb.b[1];
            *code.34 = D.23512;
            code.1 = code;
            code.36 = code.1;
            code.37 = code.36 + 1;
            code = code.37;
            D.23515 = imb.b[2];
            *code.36 = D.23515;
            code.1 = code;
            code.38 = code.1;
            code.39 = code.38 + 1;
            code = code.39;
            D.23518 = imb.b[3];
            *code.38 = D.23518;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23504>:
      <D.22463>:
      code.1 = code;
      *code.1 = 8;
      code.1 = code;
      code.13 = code.1 + 1;
      code = code.13;
      goto <D.23519>;
      <D.23457>:
      code.1 = code;
      code.40 = code.1;
      code.41 = code.40 + 1;
      code = code.41;
      *code.40 = 129;
      if (1 != 0) goto <D.23522>; else goto <D.23523>;
      <D.23522>:
      if (this_pos == 0) goto <D.23524>; else goto <D.23525>;
      <D.23524>:
      code.1 = code;
      code.42 = code.1;
      code.43 = code.42 + 1;
      code = code.43;
      *code.42 = 4;
      code.1 = code;
      code.44 = code.1;
      code.45 = code.44 + 1;
      code = code.45;
      *code.44 = 36;
      goto <D.23530>;
      <D.23525>:
      this_pos.8 = (unsigned int) this_pos;
      D.23470 = this_pos.8 + 128;
      if (D.23470 <= 255) goto <D.23531>; else goto <D.23532>;
      <D.23531>:
      code.1 = code;
      code.46 = code.1;
      code.47 = code.46 + 1;
      code = code.47;
      *code.46 = 68;
      code.1 = code;
      code.48 = code.1;
      code.49 = code.48 + 1;
      code = code.49;
      *code.48 = 36;
      code.1 = code;
      D.23477 = (unsigned char) this_pos;
      *code.1 = D.23477;
      code.1 = code;
      code.13 = code.1 + 1;
      code = code.13;
      goto <D.23537>;
      <D.23532>:
      code.1 = code;
      code.50 = code.1;
      code.51 = code.50 + 1;
      code = code.51;
      *code.50 = 132;
      code.1 = code;
      code.52 = code.1;
      code.53 = code.52 + 1;
      code = code.53;
      *code.52 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.1 = code;
            code.54 = code.1;
            code.55 = code.54 + 1;
            code = code.55;
            D.23544 = imb.b[0];
            *code.54 = D.23544;
            code.1 = code;
            code.56 = code.1;
            code.57 = code.56 + 1;
            code = code.57;
            D.23547 = imb.b[1];
            *code.56 = D.23547;
            code.1 = code;
            code.58 = code.1;
            code.59 = code.58 + 1;
            code = code.59;
            D.23550 = imb.b[2];
            *code.58 = D.23550;
            code.1 = code;
            code.60 = code.1;
            code.61 = code.60 + 1;
            code = code.61;
            D.23553 = imb.b[3];
            *code.60 = D.23553;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23537>:
      <D.23530>:
      goto <D.22466>;
      <D.23523>:
      if (this_pos == 0) goto <D.23554>; else goto <D.23555>;
      <D.23554>:
      code.1 = code;
      code.62 = code.1;
      code.63 = code.62 + 1;
      code = code.63;
      *code.62 = 4;
      goto <D.22466>;
      <D.23555>:
      this_pos.8 = (unsigned int) this_pos;
      D.23470 = this_pos.8 + 128;
      if (D.23470 <= 255) goto <D.23558>; else goto <D.23559>;
      <D.23558>:
      code.1 = code;
      code.64 = code.1;
      code.65 = code.64 + 1;
      code = code.65;
      *code.64 = 68;
      code.1 = code;
      D.23477 = (unsigned char) this_pos;
      *code.1 = D.23477;
      code.1 = code;
      code.13 = code.1 + 1;
      code = code.13;
      goto <D.23562>;
      <D.23559>:
      code.1 = code;
      code.66 = code.1;
      code.67 = code.66 + 1;
      code = code.67;
      *code.66 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = this_pos;
            code.1 = code;
            code.68 = code.1;
            code.69 = code.68 + 1;
            code = code.69;
            D.23567 = imb.b[0];
            *code.68 = D.23567;
            code.1 = code;
            code.70 = code.1;
            code.71 = code.70 + 1;
            code = code.71;
            D.23570 = imb.b[1];
            *code.70 = D.23570;
            code.1 = code;
            code.72 = code.1;
            code.73 = code.72 + 1;
            code = code.73;
            D.23573 = imb.b[2];
            *code.72 = D.23573;
            code.1 = code;
            code.74 = code.1;
            code.75 = code.74 + 1;
            code = code.75;
            D.23576 = imb.b[3];
            *code.74 = D.23576;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23562>:
      <D.22466>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.1 = code;
            code.76 = code.1;
            code.77 = code.76 + 1;
            code = code.77;
            D.23579 = imb.b[0];
            *code.76 = D.23579;
            code.1 = code;
            code.78 = code.1;
            code.79 = code.78 + 1;
            code = code.79;
            D.23582 = imb.b[1];
            *code.78 = D.23582;
            code.1 = code;
            code.80 = code.1;
            code.81 = code.80 + 1;
            code = code.81;
            D.23585 = imb.b[2];
            *code.80 = D.23585;
            code.1 = code;
            code.82 = code.1;
            code.83 = code.82 + 1;
            code = code.83;
            D.23588 = imb.b[3];
            *code.82 = D.23588;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23519>:
      {
        int t;

        addr.84 = (int) addr;
        code.1 = code;
        code.85 = (int) code.1;
        D.23591 = addr.84 - code.85;
        t = D.23591 + -2;
        t.86 = (unsigned int) t;
        D.23593 = t.86 + 128;
        if (D.23593 <= 255) goto <D.23594>; else goto <D.23595>;
        <D.23594>:
        code.1 = code;
        code.87 = code.1;
        code.88 = code.87 + 1;
        code = code.88;
        *code.87 = 235;
        code.1 = code;
        D.23598 = (unsigned char) t;
        *code.1 = D.23598;
        code.1 = code;
        code.13 = code.1 + 1;
        code = code.13;
        goto <D.23599>;
        <D.23595>:
        addr.84 = (int) addr;
        code.1 = code;
        code.85 = (int) code.1;
        D.23591 = addr.84 - code.85;
        t = D.23591 + -5;
        code.1 = code;
        code.89 = code.1;
        code.90 = code.89 + 1;
        code = code.90;
        *code.89 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.1 = code;
              code.91 = code.1;
              code.92 = code.91 + 1;
              code = code.92;
              D.23604 = imb.b[0];
              *code.91 = D.23604;
              code.1 = code;
              code.93 = code.1;
              code.94 = code.93 + 1;
              code = code.94;
              D.23607 = imb.b[1];
              *code.93 = D.23607;
              code.1 = code;
              code.95 = code.1;
              code.96 = code.95 + 1;
              code = code.96;
              D.23610 = imb.b[2];
              *code.95 = D.23610;
              code.1 = code;
              code.97 = code.1;
              code.98 = code.97 + 1;
              code = code.98;
              D.23613 = imb.b[3];
              *code.97 = D.23613;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.23599>:
      }
      code.1 = code;
      code.85 = (int) code.1;
      start.99 = start;
      start.100 = (int) start.99;
      D.23616 = code.85 - start.100;
      D.23617 = D.23616 >= size;
      D.23618 = (long int) D.23617;
      D.23619 = __builtin_expect (D.23618, 0);
      if (D.23619 != 0) goto <D.23620>; else goto <D.23621>;
      <D.23620>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 48, "(code - start) < size");
      <D.23621>:
      nacl_domain_code_validate (domain, &start, size, &code);
      D.23622 = start;
      return D.23622;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_get_static_rgctx_trampoline (struct MonoMethod * m, struct MonoMethodRuntimeGenericContext * mrgctx, void * addr)
{
  void * code.101;
  guint8 * code.102;
  guint8 * code.103;
  guint8 * code.104;
  int mrgctx.105;
  guint8 * code.106;
  guint8 * code.107;
  unsigned char D.23632;
  guint8 * code.108;
  guint8 * code.109;
  unsigned char D.23635;
  guint8 * code.110;
  guint8 * code.111;
  unsigned char D.23638;
  guint8 * code.112;
  guint8 * code.113;
  unsigned char D.23641;
  int addr.114;
  int code.115;
  int D.23644;
  unsigned int t.116;
  unsigned int D.23646;
  guint8 * code.117;
  guint8 * code.118;
  unsigned char D.23651;
  guint8 * code.119;
  guint8 * code.120;
  guint8 * code.121;
  guint8 * code.122;
  guint8 * code.123;
  unsigned char D.23658;
  guint8 * code.124;
  guint8 * code.125;
  unsigned char D.23661;
  guint8 * code.126;
  guint8 * code.127;
  unsigned char D.23664;
  guint8 * code.128;
  guint8 * code.129;
  unsigned char D.23667;
  guint8 * start.130;
  int start.131;
  int D.23670;
  _Bool D.23671;
  long int D.23672;
  long int D.23673;
  void * D.23676;
  guint8 * code;
  guint8 * start;
  int buf_len;
  struct MonoDomain * domain;

  try
    {
      domain = mono_domain_get ();
      buf_len = 10;
      code.101 = mono_domain_code_reserve (domain, buf_len);
      code = code.101;
      code.102 = code;
      start = code.102;
      code.102 = code;
      code.103 = code.102;
      code.104 = code.103 + 1;
      code = code.104;
      *code.103 = 186;
      {
        union x86_imm_buf imb;

        try
          {
            mrgctx.105 = (int) mrgctx;
            imb.val = mrgctx.105;
            code.102 = code;
            code.106 = code.102;
            code.107 = code.106 + 1;
            code = code.107;
            D.23632 = imb.b[0];
            *code.106 = D.23632;
            code.102 = code;
            code.108 = code.102;
            code.109 = code.108 + 1;
            code = code.109;
            D.23635 = imb.b[1];
            *code.108 = D.23635;
            code.102 = code;
            code.110 = code.102;
            code.111 = code.110 + 1;
            code = code.111;
            D.23638 = imb.b[2];
            *code.110 = D.23638;
            code.102 = code;
            code.112 = code.102;
            code.113 = code.112 + 1;
            code = code.113;
            D.23641 = imb.b[3];
            *code.112 = D.23641;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      {
        int t;

        addr.114 = (int) addr;
        code.102 = code;
        code.115 = (int) code.102;
        D.23644 = addr.114 - code.115;
        t = D.23644 + -2;
        t.116 = (unsigned int) t;
        D.23646 = t.116 + 128;
        if (D.23646 <= 255) goto <D.23647>; else goto <D.23648>;
        <D.23647>:
        code.102 = code;
        code.117 = code.102;
        code.118 = code.117 + 1;
        code = code.118;
        *code.117 = 235;
        code.102 = code;
        D.23651 = (unsigned char) t;
        *code.102 = D.23651;
        code.102 = code;
        code.119 = code.102 + 1;
        code = code.119;
        goto <D.23653>;
        <D.23648>:
        addr.114 = (int) addr;
        code.102 = code;
        code.115 = (int) code.102;
        D.23644 = addr.114 - code.115;
        t = D.23644 + -5;
        code.102 = code;
        code.120 = code.102;
        code.121 = code.120 + 1;
        code = code.121;
        *code.120 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.102 = code;
              code.122 = code.102;
              code.123 = code.122 + 1;
              code = code.123;
              D.23658 = imb.b[0];
              *code.122 = D.23658;
              code.102 = code;
              code.124 = code.102;
              code.125 = code.124 + 1;
              code = code.125;
              D.23661 = imb.b[1];
              *code.124 = D.23661;
              code.102 = code;
              code.126 = code.102;
              code.127 = code.126 + 1;
              code = code.127;
              D.23664 = imb.b[2];
              *code.126 = D.23664;
              code.102 = code;
              code.128 = code.102;
              code.129 = code.128 + 1;
              code = code.129;
              D.23667 = imb.b[3];
              *code.128 = D.23667;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.23653>:
      }
      code.102 = code;
      code.115 = (int) code.102;
      start.130 = start;
      start.131 = (int) start.130;
      D.23670 = code.115 - start.131;
      D.23671 = D.23670 > buf_len;
      D.23672 = (long int) D.23671;
      D.23673 = __builtin_expect (D.23672, 0);
      if (D.23673 != 0) goto <D.23674>; else goto <D.23675>;
      <D.23674>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 69, "(code - start) <= buf_len");
      <D.23675>:
      nacl_domain_code_validate (domain, &start, buf_len, &code);
      code.102 = code;
      code.115 = (int) code.102;
      start.130 = start;
      start.131 = (int) start.130;
      D.23670 = code.115 - start.131;
      start.130 = start;
      mono_arch_flush_icache (start.130, D.23670);
      D.23676 = start;
      return D.23676;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_get_llvm_imt_trampoline (struct MonoDomain * domain, struct MonoMethod * m, int vt_offset)
{
  void * code.132;
  guint8 * code.133;
  struct MonoMethodSignature * D.23681;
  unsigned int D.23682;
  guint8 * code.134;
  guint8 * code.135;
  int m.136;
  guint8 * code.137;
  guint8 * code.138;
  unsigned char D.23688;
  guint8 * code.139;
  guint8 * code.140;
  unsigned char D.23691;
  guint8 * code.141;
  guint8 * code.142;
  unsigned char D.23694;
  guint8 * code.143;
  guint8 * code.144;
  unsigned char D.23697;
  guint8 * code.145;
  guint8 * code.146;
  guint8 * code.147;
  guint8 * code.148;
  guint8 * code.149;
  guint8 * code.150;
  guint8 * code.151;
  guint8 * code.152;
  guint8 * code.153;
  guint8 * code.154;
  unsigned int this_offset.155;
  unsigned int D.23714;
  guint8 * code.156;
  guint8 * code.157;
  guint8 * code.158;
  guint8 * code.159;
  unsigned char D.23721;
  unsigned char D.23722;
  guint8 * code.160;
  guint8 * code.161;
  guint8 * code.162;
  guint8 * code.163;
  guint8 * code.164;
  int D.23729;
  guint8 * code.165;
  guint8 * code.166;
  unsigned char D.23732;
  guint8 * code.167;
  guint8 * code.168;
  unsigned char D.23735;
  guint8 * code.169;
  guint8 * code.170;
  unsigned char D.23738;
  guint8 * code.171;
  guint8 * code.172;
  unsigned char D.23741;
  guint8 * code.173;
  guint8 * code.174;
  guint8 * code.175;
  guint8 * code.176;
  guint8 * code.177;
  guint8 * code.178;
  guint8 * code.179;
  guint8 * code.180;
  unsigned char D.23755;
  guint8 * code.181;
  guint8 * code.182;
  unsigned char D.23758;
  guint8 * code.183;
  guint8 * code.184;
  unsigned char D.23761;
  guint8 * code.185;
  guint8 * code.186;
  unsigned char D.23764;
  guint8 * code.187;
  guint8 * code.188;
  guint8 * code.189;
  guint8 * code.190;
  guint8 * code.191;
  guint8 * code.192;
  guint8 * code.193;
  guint8 * code.194;
  guint8 * code.195;
  guint8 * code.196;
  guint8 * code.197;
  guint8 * code.198;
  guint8 * code.199;
  guint8 * code.200;
  guint8 * code.201;
  guint8 * code.202;
  guint8 * code.203;
  guint8 * code.204;
  guint8 * code.205;
  guint8 * code.206;
  unsigned char D.23793;
  guint8 * code.207;
  guint8 * code.208;
  unsigned char D.23796;
  guint8 * code.209;
  guint8 * code.210;
  unsigned char D.23799;
  guint8 * code.211;
  guint8 * code.212;
  unsigned char D.23802;
  guint8 * code.213;
  guint8 * code.214;
  guint8 * code.215;
  guint8 * code.216;
  guint8 * code.217;
  guint8 * code.218;
  guint8 * code.219;
  guint8 * code.220;
  unsigned char D.23816;
  guint8 * code.221;
  guint8 * code.222;
  unsigned char D.23819;
  guint8 * code.223;
  guint8 * code.224;
  unsigned char D.23822;
  guint8 * code.225;
  guint8 * code.226;
  unsigned char D.23825;
  guint8 * code.227;
  guint8 * code.228;
  guint8 * code.229;
  guint8 * code.230;
  guint8 * code.231;
  guint8 * code.232;
  unsigned int vt_offset.233;
  unsigned int D.23838;
  guint8 * code.234;
  guint8 * code.235;
  guint8 * code.236;
  guint8 * code.237;
  unsigned char D.23845;
  guint8 * code.238;
  guint8 * code.239;
  guint8 * code.240;
  guint8 * code.241;
  guint8 * code.242;
  guint8 * code.243;
  unsigned char D.23853;
  guint8 * code.244;
  guint8 * code.245;
  unsigned char D.23856;
  guint8 * code.246;
  guint8 * code.247;
  unsigned char D.23859;
  guint8 * code.248;
  guint8 * code.249;
  unsigned char D.23862;
  guint8 * code.250;
  guint8 * code.251;
  guint8 * code.252;
  guint8 * code.253;
  guint8 * code.254;
  guint8 * code.255;
  guint8 * code.256;
  guint8 * code.257;
  unsigned char D.23876;
  guint8 * code.258;
  guint8 * code.259;
  unsigned char D.23879;
  guint8 * code.260;
  guint8 * code.261;
  unsigned char D.23882;
  guint8 * code.262;
  guint8 * code.263;
  unsigned char D.23885;
  int code.264;
  guint8 * start.265;
  int start.266;
  int D.23889;
  _Bool D.23890;
  long int D.23891;
  long int D.23892;
  void * D.23895;
  guint8 * code;
  guint8 * start;
  int buf_len;
  int this_offset;
  static const char __PRETTY_FUNCTION__[34] = "mono_arch_get_llvm_imt_trampoline";

  try
    {
      buf_len = 32;
      code.132 = mono_domain_code_reserve (domain, buf_len);
      code = code.132;
      code.133 = code;
      start = code.133;
      D.23681 = mono_method_signature (m);
      D.23682 = mono_x86_get_this_arg_offset (0B, D.23681);
      this_offset = (int) D.23682;
      code.133 = code;
      code.134 = code.133;
      code.135 = code.134 + 1;
      code = code.135;
      *code.134 = 186;
      {
        union x86_imm_buf imb;

        try
          {
            m.136 = (int) m;
            imb.val = m.136;
            code.133 = code;
            code.137 = code.133;
            code.138 = code.137 + 1;
            code = code.138;
            D.23688 = imb.b[0];
            *code.137 = D.23688;
            code.133 = code;
            code.139 = code.133;
            code.140 = code.139 + 1;
            code = code.140;
            D.23691 = imb.b[1];
            *code.139 = D.23691;
            code.133 = code;
            code.141 = code.133;
            code.142 = code.141 + 1;
            code = code.142;
            D.23694 = imb.b[2];
            *code.141 = D.23694;
            code.133 = code;
            code.143 = code.133;
            code.144 = code.143 + 1;
            code = code.144;
            D.23697 = imb.b[3];
            *code.143 = D.23697;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      switch (4) <default: <D.22497>, case 1: <D.22493>, case 2: <D.22495>, case 4: <D.22496>>
      <D.22493>:
      code.133 = code;
      code.145 = code.133;
      code.146 = code.145 + 1;
      code = code.146;
      *code.145 = 138;
      goto <D.22494>;
      <D.22495>:
      code.133 = code;
      code.147 = code.133;
      code.148 = code.147 + 1;
      code = code.148;
      *code.147 = 102;
      <D.22496>:
      code.133 = code;
      code.149 = code.133;
      code.150 = code.149 + 1;
      code = code.150;
      *code.149 = 139;
      goto <D.22494>;
      <D.22497>:
      __assert_fail ("0", "tramp-x86.c", 93, &__PRETTY_FUNCTION__);
      <D.22494>:
      if (1 != 0) goto <D.23704>; else goto <D.23705>;
      <D.23704>:
      if (this_offset == -4) goto <D.23706>; else goto <D.23707>;
      <D.23706>:
      code.133 = code;
      code.151 = code.133;
      code.152 = code.151 + 1;
      code = code.152;
      *code.151 = 4;
      code.133 = code;
      code.153 = code.133;
      code.154 = code.153 + 1;
      code = code.154;
      *code.153 = 36;
      goto <D.23712>;
      <D.23707>:
      this_offset.155 = (unsigned int) this_offset;
      D.23714 = this_offset.155 + 132;
      if (D.23714 <= 255) goto <D.23715>; else goto <D.23716>;
      <D.23715>:
      code.133 = code;
      code.156 = code.133;
      code.157 = code.156 + 1;
      code = code.157;
      *code.156 = 68;
      code.133 = code;
      code.158 = code.133;
      code.159 = code.158 + 1;
      code = code.159;
      *code.158 = 36;
      code.133 = code;
      D.23721 = (unsigned char) this_offset;
      D.23722 = D.23721 + 4;
      *code.133 = D.23722;
      code.133 = code;
      code.160 = code.133 + 1;
      code = code.160;
      goto <D.23724>;
      <D.23716>:
      code.133 = code;
      code.161 = code.133;
      code.162 = code.161 + 1;
      code = code.162;
      *code.161 = 132;
      code.133 = code;
      code.163 = code.133;
      code.164 = code.163 + 1;
      code = code.164;
      *code.163 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.23729 = this_offset + 4;
            imb.val = D.23729;
            code.133 = code;
            code.165 = code.133;
            code.166 = code.165 + 1;
            code = code.166;
            D.23732 = imb.b[0];
            *code.165 = D.23732;
            code.133 = code;
            code.167 = code.133;
            code.168 = code.167 + 1;
            code = code.168;
            D.23735 = imb.b[1];
            *code.167 = D.23735;
            code.133 = code;
            code.169 = code.133;
            code.170 = code.169 + 1;
            code = code.170;
            D.23738 = imb.b[2];
            *code.169 = D.23738;
            code.133 = code;
            code.171 = code.133;
            code.172 = code.171 + 1;
            code = code.172;
            D.23741 = imb.b[3];
            *code.171 = D.23741;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23724>:
      <D.23712>:
      goto <D.22500>;
      <D.23705>:
      if (this_offset == -4) goto <D.23742>; else goto <D.23743>;
      <D.23742>:
      code.133 = code;
      code.173 = code.133;
      code.174 = code.173 + 1;
      code = code.174;
      *code.173 = 4;
      goto <D.22500>;
      <D.23743>:
      this_offset.155 = (unsigned int) this_offset;
      D.23714 = this_offset.155 + 132;
      if (D.23714 <= 255) goto <D.23746>; else goto <D.23747>;
      <D.23746>:
      code.133 = code;
      code.175 = code.133;
      code.176 = code.175 + 1;
      code = code.176;
      *code.175 = 68;
      code.133 = code;
      D.23721 = (unsigned char) this_offset;
      D.23722 = D.23721 + 4;
      *code.133 = D.23722;
      code.133 = code;
      code.160 = code.133 + 1;
      code = code.160;
      goto <D.23750>;
      <D.23747>:
      code.133 = code;
      code.177 = code.133;
      code.178 = code.177 + 1;
      code = code.178;
      *code.177 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.23729 = this_offset + 4;
            imb.val = D.23729;
            code.133 = code;
            code.179 = code.133;
            code.180 = code.179 + 1;
            code = code.180;
            D.23755 = imb.b[0];
            *code.179 = D.23755;
            code.133 = code;
            code.181 = code.133;
            code.182 = code.181 + 1;
            code = code.182;
            D.23758 = imb.b[1];
            *code.181 = D.23758;
            code.133 = code;
            code.183 = code.133;
            code.184 = code.183 + 1;
            code = code.184;
            D.23761 = imb.b[2];
            *code.183 = D.23761;
            code.133 = code;
            code.185 = code.133;
            code.186 = code.185 + 1;
            code = code.186;
            D.23764 = imb.b[3];
            *code.185 = D.23764;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23750>:
      <D.22500>:
      switch (4) <default: <D.22506>, case 1: <D.22502>, case 2: <D.22504>, case 4: <D.22505>>
      <D.22502>:
      code.133 = code;
      code.187 = code.133;
      code.188 = code.187 + 1;
      code = code.188;
      *code.187 = 138;
      goto <D.22503>;
      <D.22504>:
      code.133 = code;
      code.189 = code.133;
      code.190 = code.189 + 1;
      code = code.190;
      *code.189 = 102;
      <D.22505>:
      code.133 = code;
      code.191 = code.133;
      code.192 = code.191 + 1;
      code = code.192;
      *code.191 = 139;
      goto <D.22503>;
      <D.22506>:
      __assert_fail ("0", "tramp-x86.c", 95, &__PRETTY_FUNCTION__);
      <D.22503>:
      if (0 != 0) goto <D.23771>; else goto <D.23772>;
      <D.23771>:
      if (1 != 0) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      code.133 = code;
      code.193 = code.133;
      code.194 = code.193 + 1;
      code = code.194;
      *code.193 = 4;
      code.133 = code;
      code.195 = code.133;
      code.196 = code.195 + 1;
      code = code.196;
      *code.195 = 36;
      goto <D.23779>;
      <D.23774>:
      if (1 != 0) goto <D.23780>; else goto <D.23781>;
      <D.23780>:
      code.133 = code;
      code.197 = code.133;
      code.198 = code.197 + 1;
      code = code.198;
      *code.197 = 68;
      code.133 = code;
      code.199 = code.133;
      code.200 = code.199 + 1;
      code = code.200;
      *code.199 = 36;
      code.133 = code;
      *code.133 = 0;
      code.133 = code;
      code.160 = code.133 + 1;
      code = code.160;
      goto <D.23786>;
      <D.23781>:
      code.133 = code;
      code.201 = code.133;
      code.202 = code.201 + 1;
      code = code.202;
      *code.201 = 132;
      code.133 = code;
      code.203 = code.133;
      code.204 = code.203 + 1;
      code = code.204;
      *code.203 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.133 = code;
            code.205 = code.133;
            code.206 = code.205 + 1;
            code = code.206;
            D.23793 = imb.b[0];
            *code.205 = D.23793;
            code.133 = code;
            code.207 = code.133;
            code.208 = code.207 + 1;
            code = code.208;
            D.23796 = imb.b[1];
            *code.207 = D.23796;
            code.133 = code;
            code.209 = code.133;
            code.210 = code.209 + 1;
            code = code.210;
            D.23799 = imb.b[2];
            *code.209 = D.23799;
            code.133 = code;
            code.211 = code.133;
            code.212 = code.211 + 1;
            code = code.212;
            D.23802 = imb.b[3];
            *code.211 = D.23802;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23786>:
      <D.23779>:
      goto <D.22508>;
      <D.23772>:
      if (1 != 0) goto <D.23803>; else goto <D.23804>;
      <D.23803>:
      code.133 = code;
      code.213 = code.133;
      code.214 = code.213 + 1;
      code = code.214;
      *code.213 = 0;
      goto <D.22508>;
      <D.23804>:
      if (1 != 0) goto <D.23807>; else goto <D.23808>;
      <D.23807>:
      code.133 = code;
      code.215 = code.133;
      code.216 = code.215 + 1;
      code = code.216;
      *code.215 = 64;
      code.133 = code;
      *code.133 = 0;
      code.133 = code;
      code.160 = code.133 + 1;
      code = code.160;
      goto <D.23811>;
      <D.23808>:
      code.133 = code;
      code.217 = code.133;
      code.218 = code.217 + 1;
      code = code.218;
      *code.217 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.133 = code;
            code.219 = code.133;
            code.220 = code.219 + 1;
            code = code.220;
            D.23816 = imb.b[0];
            *code.219 = D.23816;
            code.133 = code;
            code.221 = code.133;
            code.222 = code.221 + 1;
            code = code.222;
            D.23819 = imb.b[1];
            *code.221 = D.23819;
            code.133 = code;
            code.223 = code.133;
            code.224 = code.223 + 1;
            code = code.224;
            D.23822 = imb.b[2];
            *code.223 = D.23822;
            code.133 = code;
            code.225 = code.133;
            code.226 = code.225 + 1;
            code = code.226;
            D.23825 = imb.b[3];
            *code.225 = D.23825;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23811>:
      <D.22508>:
      code.133 = code;
      code.227 = code.133;
      code.228 = code.227 + 1;
      code = code.228;
      *code.227 = 255;
      if (0 != 0) goto <D.23828>; else goto <D.23829>;
      <D.23828>:
      if (vt_offset == 0) goto <D.23830>; else goto <D.23831>;
      <D.23830>:
      code.133 = code;
      code.229 = code.133;
      code.230 = code.229 + 1;
      code = code.230;
      *code.229 = 36;
      code.133 = code;
      code.231 = code.133;
      code.232 = code.231 + 1;
      code = code.232;
      *code.231 = 36;
      goto <D.23836>;
      <D.23831>:
      vt_offset.233 = (unsigned int) vt_offset;
      D.23838 = vt_offset.233 + 128;
      if (D.23838 <= 255) goto <D.23839>; else goto <D.23840>;
      <D.23839>:
      code.133 = code;
      code.234 = code.133;
      code.235 = code.234 + 1;
      code = code.235;
      *code.234 = 100;
      code.133 = code;
      code.236 = code.133;
      code.237 = code.236 + 1;
      code = code.237;
      *code.236 = 36;
      code.133 = code;
      D.23845 = (unsigned char) vt_offset;
      *code.133 = D.23845;
      code.133 = code;
      code.160 = code.133 + 1;
      code = code.160;
      goto <D.23846>;
      <D.23840>:
      code.133 = code;
      code.238 = code.133;
      code.239 = code.238 + 1;
      code = code.239;
      *code.238 = 164;
      code.133 = code;
      code.240 = code.133;
      code.241 = code.240 + 1;
      code = code.241;
      *code.240 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = vt_offset;
            code.133 = code;
            code.242 = code.133;
            code.243 = code.242 + 1;
            code = code.243;
            D.23853 = imb.b[0];
            *code.242 = D.23853;
            code.133 = code;
            code.244 = code.133;
            code.245 = code.244 + 1;
            code = code.245;
            D.23856 = imb.b[1];
            *code.244 = D.23856;
            code.133 = code;
            code.246 = code.133;
            code.247 = code.246 + 1;
            code = code.247;
            D.23859 = imb.b[2];
            *code.246 = D.23859;
            code.133 = code;
            code.248 = code.133;
            code.249 = code.248 + 1;
            code = code.249;
            D.23862 = imb.b[3];
            *code.248 = D.23862;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23846>:
      <D.23836>:
      goto <D.22511>;
      <D.23829>:
      if (vt_offset == 0) goto <D.23863>; else goto <D.23864>;
      <D.23863>:
      code.133 = code;
      code.250 = code.133;
      code.251 = code.250 + 1;
      code = code.251;
      *code.250 = 32;
      goto <D.22511>;
      <D.23864>:
      vt_offset.233 = (unsigned int) vt_offset;
      D.23838 = vt_offset.233 + 128;
      if (D.23838 <= 255) goto <D.23867>; else goto <D.23868>;
      <D.23867>:
      code.133 = code;
      code.252 = code.133;
      code.253 = code.252 + 1;
      code = code.253;
      *code.252 = 96;
      code.133 = code;
      D.23845 = (unsigned char) vt_offset;
      *code.133 = D.23845;
      code.133 = code;
      code.160 = code.133 + 1;
      code = code.160;
      goto <D.23871>;
      <D.23868>:
      code.133 = code;
      code.254 = code.133;
      code.255 = code.254 + 1;
      code = code.255;
      *code.254 = 160;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = vt_offset;
            code.133 = code;
            code.256 = code.133;
            code.257 = code.256 + 1;
            code = code.257;
            D.23876 = imb.b[0];
            *code.256 = D.23876;
            code.133 = code;
            code.258 = code.133;
            code.259 = code.258 + 1;
            code = code.259;
            D.23879 = imb.b[1];
            *code.258 = D.23879;
            code.133 = code;
            code.260 = code.133;
            code.261 = code.260 + 1;
            code = code.261;
            D.23882 = imb.b[2];
            *code.260 = D.23882;
            code.133 = code;
            code.262 = code.133;
            code.263 = code.262 + 1;
            code = code.263;
            D.23885 = imb.b[3];
            *code.262 = D.23885;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23871>:
      <D.22511>:
      code.133 = code;
      code.264 = (int) code.133;
      start.265 = start;
      start.266 = (int) start.265;
      D.23889 = code.264 - start.266;
      D.23890 = D.23889 >= buf_len;
      D.23891 = (long int) D.23890;
      D.23892 = __builtin_expect (D.23891, 0);
      if (D.23892 != 0) goto <D.23893>; else goto <D.23894>;
      <D.23893>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 98, "(code - start) < buf_len");
      <D.23894>:
      nacl_domain_code_validate (domain, &start, buf_len, &code);
      code.133 = code;
      code.264 = (int) code.133;
      start.265 = start;
      start.266 = (int) start.265;
      D.23889 = code.264 - start.266;
      start.265 = start;
      mono_arch_flush_icache (start.265, D.23889);
      D.23895 = start;
      return D.23895;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_patch_callsite (guint8 * method_start, guint8 * orig_code, guint8 * addr)
{
  guint8 * D.23898;
  unsigned char D.23899;
  unsigned int addr.267;
  unsigned int orig_code.268;
  unsigned int D.23906;
  unsigned int D.23907;
  int D.23908;
  volatile gint32 * D.23909;
  volatile unsigned int D.22523;
  guint8 * D.23910;
  unsigned int D.23911;
  guint8 * D.23918;
  unsigned char D.23919;
  int D.23920;
  guint8 * D.23921;
  unsigned char D.23922;
  int D.23923;
  guint8 * D.23924;
  unsigned char D.23925;
  int D.23926;
  guint8 * D.23927;
  unsigned char D.23928;
  int D.23929;
  guint8 * D.23930;
  unsigned char D.23931;
  int D.23932;
  int D.23933;
  unsigned char D.23934;
  int D.23935;
  guint8 * code;
  guint8 buf[8];
  gboolean can_write;

  try
    {
      can_write = mono_breakpoint_clean_code (method_start, orig_code, 8, &buf, 8);
      code = &MEM[(void *)&buf + 8B];
      code = code + 4294967290;
      orig_code = orig_code + 4294967290;
      D.23898 = code + 1;
      D.23899 = *D.23898;
      if (D.23899 == 232) goto <D.23900>; else goto <D.23901>;
      <D.23900>:
      if (can_write != 0) goto <D.23902>; else goto <D.23903>;
      <D.23902>:
      addr.267 = (unsigned int) addr;
      orig_code.268 = (unsigned int) orig_code;
      D.23906 = addr.267 - orig_code.268;
      D.23907 = D.23906 + 4294967290;
      D.23908 = (int) D.23907;
      D.23909 = orig_code + 2;
      InterlockedExchange (D.23909, D.23908);
      {
        volatile unsigned int _zzq_args[6];
        volatile unsigned int _zzq_result;

        _zzq_args[0] = 4098;
        D.23910 = orig_code + 2;
        D.23911 = (unsigned int) D.23910;
        _zzq_args[1] = D.23911;
        _zzq_args[2] = 4;
        _zzq_args[3] = 0;
        _zzq_args[4] = 0;
        _zzq_args[5] = 0;
        __asm__ __volatile__("roll $3,  %%edi ; roll $13, %%edi
	roll $29, %%edi ; roll $19, %%edi
	xchgl %%ebx,%%ebx" : "=d" _zzq_result : "a" &_zzq_args[0], "0" 0 : "memory", "cc");
        D.22523 = _zzq_result;
      }
      <D.23903>:
      goto <D.23912>;
      <D.23901>:
      D.23898 = code + 1;
      D.23899 = *D.23898;
      if (D.23899 == 233) goto <D.23913>; else goto <D.23914>;
      <D.23913>:
      if (can_write != 0) goto <D.23915>; else goto <D.23916>;
      <D.23915>:
      addr.267 = (unsigned int) addr;
      orig_code.268 = (unsigned int) orig_code;
      D.23906 = addr.267 - orig_code.268;
      D.23907 = D.23906 + 4294967290;
      D.23908 = (int) D.23907;
      D.23909 = orig_code + 2;
      InterlockedExchange (D.23909, D.23908);
      <D.23916>:
      goto <D.23917>;
      <D.23914>:
      D.23918 = code + 6;
      D.23919 = *D.23918;
      D.23920 = (int) D.23919;
      D.23921 = code + 5;
      D.23922 = *D.23921;
      D.23923 = (int) D.23922;
      D.23924 = code + 4;
      D.23925 = *D.23924;
      D.23926 = (int) D.23925;
      D.23927 = code + 3;
      D.23928 = *D.23927;
      D.23929 = (int) D.23928;
      D.23930 = code + 2;
      D.23931 = *D.23930;
      D.23932 = (int) D.23931;
      D.23898 = code + 1;
      D.23899 = *D.23898;
      D.23933 = (int) D.23899;
      D.23934 = *code;
      D.23935 = (int) D.23934;
      printf ("Invalid trampoline sequence: %x %x %x %x %x %x %x\n", D.23935, D.23933, D.23932, D.23929, D.23926, D.23923, D.23920);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "tramp-x86.c", 140);
      <D.23917>:
      <D.23912>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


InterlockedExchange (volatile gint32 * val, gint32 new_val)
{
  unsigned int new_val.269;
  unsigned int old_val.270;
  unsigned int D.23938;
  int D.23939;
  gint32 D.23940;
  gint32 old_val;

  <D.18222>:
  old_val = *val;
  new_val.269 = (unsigned int) new_val;
  old_val.270 = (unsigned int) old_val;
  D.23938 = __sync_val_compare_and_swap_4 (val, old_val.270, new_val.269);
  D.23939 = (int) D.23938;
  if (D.23939 != old_val) goto <D.18222>; else goto <D.18223>;
  <D.18223>:
  D.23940 = old_val;
  return D.23940;
}


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

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


mono_arch_patch_plt_entry (guint8 * code, void * * got, mgreg_t * regs, guint8 * addr)
{
  unsigned char D.23944;
  _Bool D.23945;
  long int D.23946;
  long int D.23947;
  guint8 * D.23950;
  unsigned char D.23951;
  _Bool D.23952;
  long int D.23953;
  long int D.23954;
  mgreg_t * D.23959;
  int D.23960;
  guint8 * * D.23961;
  guint32 offset;

  D.23944 = *code;
  D.23945 = D.23944 != 255;
  D.23946 = (long int) D.23945;
  D.23947 = __builtin_expect (D.23946, 0);
  if (D.23947 != 0) goto <D.23948>; else goto <D.23949>;
  <D.23948>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 180, "code [0] == 0xff");
  <D.23949>:
  D.23950 = code + 1;
  D.23951 = *D.23950;
  D.23952 = D.23951 != 163;
  D.23953 = (long int) D.23952;
  D.23954 = __builtin_expect (D.23953, 0);
  if (D.23954 != 0) goto <D.23955>; else goto <D.23956>;
  <D.23955>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 181, "code [1] == 0xa3");
  <D.23956>:
  offset = MEM[(guint32 *)code + 2B];
  if (got == 0B) goto <D.23957>; else goto <D.23958>;
  <D.23957>:
  D.23959 = regs + 12;
  D.23960 = *D.23959;
  got = (void * *) D.23960;
  <D.23958>:
  D.23961 = got + offset;
  *D.23961 = addr;
}


mono_arch_nullify_class_init_trampoline (guint8 * code, mgreg_t * regs)
{
  unsigned char D.23964;
  int D.23967;
  int ops.271;
  guint8 * D.23971;
  guint8 * D.23972;
  guint8 * D.23973;
  unsigned char D.23975;
  _Bool D.23976;
  _Bool D.23977;
  _Bool D.23978;
  guint8 * D.23984;
  unsigned char D.23985;
  unsigned char D.23987;
  int D.23988;
  int D.23989;
  guint8 * D.23991;
  _Bool D.23992;
  long int D.23993;
  long int D.23994;
  guint8 * D.23997;
  unsigned char D.23998;
  int D.23999;
  unsigned char D.24000;
  int D.24001;
  unsigned char D.24002;
  int D.24003;
  unsigned char D.24004;
  int D.24005;
  unsigned char D.24006;
  int D.24007;
  guint8 * D.24008;
  unsigned char D.24009;
  int D.24010;
  int D.24011;
  guint8 buf[16];
  gboolean can_write;
  void * tramp;

  try
    {
      can_write = mono_breakpoint_clean_code (0B, code, 6, &buf, 16);
      tramp = mini_get_nullified_class_init_trampoline ();
      if (can_write == 0) goto <D.23962>; else goto <D.23963>;
      <D.23962>:
      return;
      <D.23963>:
      code = code + 4294967291;
      D.23964 = *code;
      if (D.23964 == 232) goto <D.23965>; else goto <D.23966>;
      <D.23965>:
      D.23967 = mono_running_on_valgrind ();
      if (D.23967 == 0) goto <D.23968>; else goto <D.23969>;
      <D.23968>:
      {
        guint32 ops;

        ops = 65259;
        ops.271 = (int) ops;
        InterlockedExchange (code, ops.271);
        D.23971 = code + 2;
        *D.23971 = 144;
        D.23972 = code + 3;
        *D.23972 = 144;
        D.23973 = code + 4;
        *D.23973 = 144;
        ops = 2425393296;
        ops.271 = (int) ops;
        InterlockedExchange (code, ops.271);
      }
      <D.23969>:
      goto <D.23974>;
      <D.23966>:
      D.23975 = *code;
      D.23976 = D.23975 == 144;
      D.23977 = D.23975 == 235;
      D.23978 = D.23976 | D.23977;
      if (D.23978 != 0) goto <D.23979>; else goto <D.23980>;
      <D.23979>:
      goto <D.23981>;
      <D.23980>:
      D.23984 = code + 4294967295;
      D.23985 = *D.23984;
      if (D.23985 == 255) goto <D.23986>; else goto <D.23982>;
      <D.23986>:
      D.23964 = *code;
      D.23987 = D.23964 >> 3;
      D.23988 = (int) D.23987;
      D.23989 = D.23988 & 7;
      if (D.23989 == 2) goto <D.23990>; else goto <D.23982>;
      <D.23990>:
      {
        void * * vtable_slot;

        D.23991 = code + 5;
        vtable_slot = get_vcall_slot_addr (D.23991, regs);
        D.23992 = vtable_slot == 0B;
        D.23993 = (long int) D.23992;
        D.23994 = __builtin_expect (D.23993, 0);
        if (D.23994 != 0) goto <D.23995>; else goto <D.23996>;
        <D.23995>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 285, "vtable_slot");
        <D.23996>:
        *vtable_slot = tramp;
      }
      goto <D.23983>;
      <D.23982>:
      D.23997 = code + 6;
      D.23998 = *D.23997;
      D.23999 = (int) D.23998;
      D.23991 = code + 5;
      D.24000 = *D.23991;
      D.24001 = (int) D.24000;
      D.23973 = code + 4;
      D.24002 = *D.23973;
      D.24003 = (int) D.24002;
      D.23972 = code + 3;
      D.24004 = *D.23972;
      D.24005 = (int) D.24004;
      D.23971 = code + 2;
      D.24006 = *D.23971;
      D.24007 = (int) D.24006;
      D.24008 = code + 1;
      D.24009 = *D.24008;
      D.24010 = (int) D.24009;
      D.23964 = *code;
      D.24011 = (int) D.23964;
      printf ("Invalid trampoline sequence: %x %x %x %x %x %x %x\n", D.24011, D.24010, D.24007, D.24005, D.24003, D.24001, D.23999);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "tramp-x86.c", 291);
      <D.23983>:
      <D.23981>:
      <D.23974>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_vcall_slot_addr (guint8 * code, mgreg_t * regs)
{
  void * * D.24017;
  int displacement.272;
  sizetype displacement.273;
  void * vt;
  int displacement;

  try
    {
      vt = get_vcall_slot (code, regs, &displacement);
      if (vt == 0B) goto <D.24015>; else goto <D.24016>;
      <D.24015>:
      D.24017 = 0B;
      return D.24017;
      <D.24016>:
      displacement.272 = displacement;
      displacement.273 = (sizetype) displacement.272;
      D.24017 = vt + displacement.273;
      return D.24017;
    }
  finally
    {
      displacement = {CLOBBER};
    }
}


get_vcall_slot (guint8 * code, mgreg_t * regs, int * displacement)
{
  unsigned char D.24024;
  guint8 * D.24026;
  unsigned char D.24027;
  int D.24028;
  int D.24029;
  unsigned char D.24031;
  void * D.24033;
  unsigned int D.24034;
  unsigned int D.24035;
  mgreg_t * D.24036;
  int D.24037;
  const int kBufSize;
  guint8 buf[64];
  guint8 reg;
  gint32 disp;

  try
    {
      kBufSize = 8;
      reg = 0;
      disp = 0;
      mono_breakpoint_clean_code (0B, code, kBufSize, &buf, kBufSize);
      code = &MEM[(void *)&buf + 8B];
      *displacement = 0;
      D.24024 = *code;
      if (D.24024 == 255) goto <D.24025>; else goto <D.24022>;
      <D.24025>:
      D.24026 = code + 1;
      D.24027 = *D.24026;
      D.24028 = (int) D.24027;
      D.24029 = D.24028 & 24;
      if (D.24029 == 16) goto <D.24030>; else goto <D.24022>;
      <D.24030>:
      D.24026 = code + 1;
      D.24027 = *D.24026;
      D.24031 = D.24027 >> 6;
      if (D.24031 == 2) goto <D.24032>; else goto <D.24022>;
      <D.24032>:
      D.24026 = code + 1;
      D.24027 = *D.24026;
      reg = D.24027 & 7;
      disp = MEM[(gint32 *)code + 2B];
      goto <D.24023>;
      <D.24022>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "tramp-x86.c", 216);
      D.24033 = 0B;
      return D.24033;
      <D.24023>:
      *displacement = disp;
      D.24034 = (unsigned int) reg;
      D.24035 = D.24034 * 4;
      D.24036 = regs + D.24035;
      D.24037 = *D.24036;
      D.24033 = (void *) D.24037;
      return D.24033;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_arch_nullify_plt_entry (guint8 * code, mgreg_t * regs)
{
  void * D.24040;

  D.24040 = mini_get_nullified_class_init_trampoline ();
  mono_arch_patch_plt_entry (code, 0B, regs, D.24040);
}


mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, struct MonoTrampInfo * * info, gboolean aot)
{
  void * buf.274;
  guint8 * buf.275;
  guint8 * code.276;
  guint8 * code.277;
  guint8 * code.278;
  guint8 * code.279;
  guint8 * code.280;
  guint8 * code.281;
  guint8 * code.282;
  guint8 * code.283;
  guint8 * code.284;
  guint8 * code.285;
  guint8 * code.286;
  guint8 * code.287;
  guint8 * code.288;
  guint8 * code.289;
  guint8 * code.290;
  guint8 * code.291;
  guint8 * code.292;
  guint8 * code.293;
  guint8 * code.294;
  guint8 * code.295;
  guint8 * code.296;
  unsigned char D.24066;
  guint8 * code.297;
  guint8 * code.298;
  unsigned char D.24069;
  guint8 * code.299;
  guint8 * code.300;
  unsigned char D.24072;
  guint8 * code.301;
  guint8 * code.302;
  unsigned char D.24075;
  guint8 * code.303;
  guint8 * code.304;
  guint8 * code.305;
  guint8 * code.306;
  guint8 * code.307;
  guint8 * code.308;
  guint8 * code.309;
  guint8 * code.310;
  guint8 * code.311;
  guint8 * code.312;
  guint8 * code.313;
  unsigned char D.24090;
  guint8 * code.314;
  guint8 * code.315;
  unsigned char D.24093;
  guint8 * code.316;
  guint8 * code.317;
  unsigned char D.24096;
  guint8 * code.318;
  guint8 * code.319;
  unsigned char D.24099;
  unsigned int _imm.320;
  unsigned int D.24103;
  guint8 * code.321;
  guint8 * code.322;
  unsigned char D.24108;
  guint8 * code.323;
  guint8 * code.324;
  guint8 * code.325;
  guint8 * code.326;
  unsigned char D.24114;
  guint8 * code.327;
  guint8 * code.328;
  unsigned char D.24117;
  guint8 * code.329;
  guint8 * code.330;
  unsigned char D.24120;
  guint8 * code.331;
  guint8 * code.332;
  unsigned char D.24123;
  guint8 * code.333;
  guint8 * code.334;
  int D.24129;
  unsigned int D.24130;
  unsigned int D.24131;
  guint8 * code.335;
  guint8 * code.336;
  guint8 * code.337;
  guint8 * code.338;
  int D.24141;
  guint8 * code.339;
  guint8 * code.340;
  guint8 * code.341;
  guint8 * code.342;
  unsigned char D.24148;
  unsigned char D.24149;
  guint8 * code.343;
  guint8 * code.344;
  guint8 * code.345;
  guint8 * code.346;
  guint8 * code.347;
  guint8 * code.348;
  unsigned char D.24156;
  guint8 * code.349;
  guint8 * code.350;
  unsigned char D.24159;
  guint8 * code.351;
  guint8 * code.352;
  unsigned char D.24162;
  guint8 * code.353;
  guint8 * code.354;
  unsigned char D.24165;
  guint8 * code.355;
  guint8 * code.356;
  guint8 * code.357;
  guint8 * code.358;
  guint8 * code.359;
  guint8 * code.360;
  guint8 * code.361;
  guint8 * code.362;
  unsigned char D.24180;
  guint8 * code.363;
  guint8 * code.364;
  unsigned char D.24183;
  guint8 * code.365;
  guint8 * code.366;
  unsigned char D.24186;
  guint8 * code.367;
  guint8 * code.368;
  unsigned char D.24189;
  guint8 * code.369;
  guint8 * code.370;
  guint8 * code.371;
  guint8 * code.372;
  guint8 * code.373;
  guint8 * code.374;
  guint8 * code.375;
  guint8 * code.376;
  guint8 * code.377;
  guint8 * code.378;
  int D.24200;
  int D.24201;
  unsigned int D.24202;
  unsigned int D.24203;
  guint8 * code.379;
  guint8 * code.380;
  guint8 * code.381;
  guint8 * code.382;
  guint8 * code.383;
  guint8 * code.384;
  guint8 * code.385;
  guint8 * code.386;
  guint8 * code.387;
  guint8 * code.388;
  guint8 * code.389;
  guint8 * code.390;
  guint8 * code.391;
  guint8 * code.392;
  guint8 * code.393;
  guint8 * code.394;
  unsigned char D.24230;
  guint8 * code.395;
  guint8 * code.396;
  unsigned char D.24233;
  guint8 * code.397;
  guint8 * code.398;
  unsigned char D.24236;
  guint8 * code.399;
  guint8 * code.400;
  unsigned char D.24239;
  guint8 * code.401;
  guint8 * code.402;
  guint8 * code.403;
  guint8 * code.404;
  guint8 * code.405;
  guint8 * code.406;
  guint8 * code.407;
  guint8 * code.408;
  unsigned char D.24253;
  guint8 * code.409;
  guint8 * code.410;
  unsigned char D.24256;
  guint8 * code.411;
  guint8 * code.412;
  unsigned char D.24259;
  guint8 * code.413;
  guint8 * code.414;
  unsigned char D.24262;
  unsigned char D.24263;
  unsigned char D.24264;
  guint8 * code.415;
  guint8 * code.416;
  guint8 * code.417;
  guint8 * code.418;
  guint8 * code.419;
  guint8 * code.420;
  guint8 * code.421;
  guint8 * code.422;
  guint8 * code.423;
  guint8 * code.424;
  guint8 * code.425;
  guint8 * code.426;
  guint8 * code.427;
  guint8 * code.428;
  guint8 * code.429;
  guint8 * code.430;
  unsigned char D.24290;
  guint8 * code.431;
  guint8 * code.432;
  unsigned char D.24293;
  guint8 * code.433;
  guint8 * code.434;
  unsigned char D.24296;
  guint8 * code.435;
  guint8 * code.436;
  unsigned char D.24299;
  guint8 * code.437;
  guint8 * code.438;
  guint8 * code.439;
  guint8 * code.440;
  guint8 * code.441;
  guint8 * code.442;
  guint8 * code.443;
  guint8 * code.444;
  unsigned char D.24313;
  guint8 * code.445;
  guint8 * code.446;
  unsigned char D.24316;
  guint8 * code.447;
  guint8 * code.448;
  unsigned char D.24319;
  guint8 * code.449;
  guint8 * code.450;
  unsigned char D.24322;
  guint8 * code.451;
  guint8 * code.452;
  unsigned char D.24325;
  guint8 * code.453;
  guint8 * code.454;
  unsigned char D.24328;
  guint8 * code.455;
  guint8 * code.456;
  unsigned char D.24331;
  guint8 * code.457;
  guint8 * code.458;
  unsigned char D.24334;
  guint8 * code.459;
  guint8 * code.460;
  unsigned int pushed_args.461;
  unsigned int D.24342;
  guint8 * code.462;
  guint8 * code.463;
  guint8 * code.464;
  guint8 * code.465;
  int D.24352;
  guint8 * code.466;
  guint8 * code.467;
  guint8 * code.468;
  guint8 * code.469;
  unsigned char D.24359;
  unsigned char D.24360;
  guint8 * code.470;
  guint8 * code.471;
  guint8 * code.472;
  guint8 * code.473;
  guint8 * code.474;
  guint8 * code.475;
  unsigned char D.24367;
  guint8 * code.476;
  guint8 * code.477;
  unsigned char D.24370;
  guint8 * code.478;
  guint8 * code.479;
  unsigned char D.24373;
  guint8 * code.480;
  guint8 * code.481;
  unsigned char D.24376;
  guint8 * code.482;
  guint8 * code.483;
  guint8 * code.484;
  guint8 * code.485;
  guint8 * code.486;
  guint8 * code.487;
  guint8 * code.488;
  guint8 * code.489;
  unsigned char D.24391;
  guint8 * code.490;
  guint8 * code.491;
  unsigned char D.24394;
  guint8 * code.492;
  guint8 * code.493;
  unsigned char D.24397;
  guint8 * code.494;
  guint8 * code.495;
  unsigned char D.24400;
  unsigned int _imm.496;
  unsigned int D.24403;
  guint8 * code.497;
  guint8 * code.498;
  unsigned char D.24408;
  guint8 * code.499;
  guint8 * code.500;
  guint8 * code.501;
  guint8 * code.502;
  unsigned char D.24414;
  guint8 * code.503;
  guint8 * code.504;
  unsigned char D.24417;
  guint8 * code.505;
  guint8 * code.506;
  unsigned char D.24420;
  guint8 * code.507;
  guint8 * code.508;
  unsigned char D.24423;
  _Bool D.24424;
  long int D.24425;
  long int D.24426;
  guint8 * code.509;
  guint8 * code.510;
  guint8 * code.511;
  guint8 * code.512;
  guint8 * code.513;
  int mono_get_lmf_addr.514;
  int code.515;
  guint8 * code.516;
  guint8 * code.517;
  guint8 * code.518;
  guint8 * code.519;
  unsigned char D.24443;
  guint8 * code.520;
  guint8 * code.521;
  unsigned char D.24446;
  guint8 * code.522;
  guint8 * code.523;
  unsigned char D.24449;
  guint8 * code.524;
  guint8 * code.525;
  unsigned char D.24452;
  guint8 * code.526;
  guint8 * code.527;
  guint8 * code.528;
  guint8 * code.529;
  guint8 * code.530;
  guint8 * code.531;
  guint8 * code.532;
  guint8 * code.533;
  guint8 * code.534;
  guint8 * code.535;
  guint8 * code.536;
  guint8 * code.537;
  guint8 * code.538;
  guint8 * code.539;
  guint8 * code.540;
  guint8 * code.541;
  guint8 * code.542;
  guint8 * code.543;
  unsigned char D.24479;
  guint8 * code.544;
  guint8 * code.545;
  unsigned char D.24482;
  guint8 * code.546;
  guint8 * code.547;
  unsigned char D.24485;
  guint8 * code.548;
  guint8 * code.549;
  unsigned char D.24488;
  guint8 * code.550;
  guint8 * code.551;
  guint8 * code.552;
  guint8 * code.553;
  guint8 * code.554;
  guint8 * code.555;
  guint8 * code.556;
  guint8 * code.557;
  unsigned char D.24502;
  guint8 * code.558;
  guint8 * code.559;
  unsigned char D.24505;
  guint8 * code.560;
  guint8 * code.561;
  unsigned char D.24508;
  guint8 * code.562;
  guint8 * code.563;
  unsigned char D.24511;
  guint8 * code.564;
  guint8 * code.565;
  guint8 * code.566;
  guint8 * code.567;
  guint8 * code.568;
  guint8 * code.569;
  guint8 * code.570;
  guint8 * code.571;
  guint8 * code.572;
  guint8 * code.573;
  guint8 * code.574;
  guint8 * code.575;
  guint8 * code.576;
  guint8 * code.577;
  guint8 * code.578;
  guint8 * code.579;
  unsigned char D.24538;
  guint8 * code.580;
  guint8 * code.581;
  unsigned char D.24541;
  guint8 * code.582;
  guint8 * code.583;
  unsigned char D.24544;
  guint8 * code.584;
  guint8 * code.585;
  unsigned char D.24547;
  guint8 * code.586;
  guint8 * code.587;
  guint8 * code.588;
  guint8 * code.589;
  guint8 * code.590;
  guint8 * code.591;
  guint8 * code.592;
  guint8 * code.593;
  unsigned char D.24561;
  guint8 * code.594;
  guint8 * code.595;
  unsigned char D.24564;
  guint8 * code.596;
  guint8 * code.597;
  unsigned char D.24567;
  guint8 * code.598;
  guint8 * code.599;
  unsigned char D.24570;
  guint8 * code.600;
  guint8 * code.601;
  guint8 * code.602;
  guint8 * code.603;
  guint8 * code.604;
  guint8 * code.605;
  guint8 * code.606;
  guint8 * code.607;
  guint8 * code.608;
  guint8 * code.609;
  guint8 * code.610;
  guint8 * code.611;
  guint8 * code.612;
  guint8 * code.613;
  guint8 * code.614;
  guint8 * code.615;
  unsigned char D.24596;
  guint8 * code.616;
  guint8 * code.617;
  unsigned char D.24599;
  guint8 * code.618;
  guint8 * code.619;
  unsigned char D.24602;
  guint8 * code.620;
  guint8 * code.621;
  unsigned char D.24605;
  guint8 * code.622;
  guint8 * code.623;
  guint8 * code.624;
  guint8 * code.625;
  guint8 * code.626;
  guint8 * code.627;
  guint8 * code.628;
  guint8 * code.629;
  unsigned char D.24619;
  guint8 * code.630;
  guint8 * code.631;
  unsigned char D.24622;
  guint8 * code.632;
  guint8 * code.633;
  unsigned char D.24625;
  guint8 * code.634;
  guint8 * code.635;
  unsigned char D.24628;
  guint8 * code.636;
  guint8 * code.637;
  unsigned char D.24631;
  guint8 * code.638;
  guint8 * code.639;
  unsigned char D.24634;
  guint8 * code.640;
  guint8 * code.641;
  unsigned char D.24637;
  guint8 * code.642;
  guint8 * code.643;
  unsigned char D.24640;
  guint8 * code.644;
  guint8 * code.645;
  guint8 * code.646;
  guint8 * code.647;
  guint8 * code.648;
  guint8 * code.649;
  guint8 * code.650;
  guint8 * code.651;
  guint8 * code.652;
  guint8 * code.653;
  guint8 * code.654;
  guint8 * code.655;
  guint8 * code.656;
  guint8 * code.657;
  guint8 * code.658;
  guint8 * code.659;
  guint8 * code.660;
  guint8 * code.661;
  guint8 * code.662;
  guint8 * code.663;
  unsigned char D.24669;
  guint8 * code.664;
  guint8 * code.665;
  unsigned char D.24672;
  guint8 * code.666;
  guint8 * code.667;
  unsigned char D.24675;
  guint8 * code.668;
  guint8 * code.669;
  unsigned char D.24678;
  guint8 * code.670;
  guint8 * code.671;
  guint8 * code.672;
  guint8 * code.673;
  guint8 * code.674;
  guint8 * code.675;
  guint8 * code.676;
  guint8 * code.677;
  unsigned char D.24692;
  guint8 * code.678;
  guint8 * code.679;
  unsigned char D.24695;
  guint8 * code.680;
  guint8 * code.681;
  unsigned char D.24698;
  guint8 * code.682;
  guint8 * code.683;
  unsigned char D.24701;
  unsigned int _imm.684;
  unsigned int D.24703;
  guint8 * code.685;
  guint8 * code.686;
  unsigned char D.24708;
  guint8 * code.687;
  guint8 * code.688;
  guint8 * code.689;
  guint8 * code.690;
  unsigned char D.24714;
  guint8 * code.691;
  guint8 * code.692;
  unsigned char D.24717;
  guint8 * code.693;
  guint8 * code.694;
  unsigned char D.24720;
  guint8 * code.695;
  guint8 * code.696;
  unsigned char D.24723;
  guint8 * code.697;
  guint8 * code.698;
  guint8 * code.699;
  guint8 * code.700;
  guint8 * code.701;
  guint8 * code.702;
  guint8 * code.703;
  guint8 * code.704;
  guint8 * code.705;
  guint8 * code.706;
  guint8 * code.707;
  guint8 * code.708;
  guint8 * code.709;
  guint8 * code.710;
  guint8 * code.711;
  guint8 * code.712;
  unsigned char D.24749;
  guint8 * code.713;
  guint8 * code.714;
  unsigned char D.24752;
  guint8 * code.715;
  guint8 * code.716;
  unsigned char D.24755;
  guint8 * code.717;
  guint8 * code.718;
  unsigned char D.24758;
  guint8 * code.719;
  guint8 * code.720;
  guint8 * code.721;
  guint8 * code.722;
  guint8 * code.723;
  guint8 * code.724;
  guint8 * code.725;
  guint8 * code.726;
  unsigned char D.24773;
  guint8 * code.727;
  guint8 * code.728;
  unsigned char D.24776;
  guint8 * code.729;
  guint8 * code.730;
  unsigned char D.24779;
  guint8 * code.731;
  guint8 * code.732;
  unsigned char D.24782;
  unsigned int _imm.733;
  unsigned int D.24786;
  guint8 * code.734;
  guint8 * code.735;
  unsigned char D.24791;
  guint8 * code.736;
  guint8 * code.737;
  guint8 * code.738;
  guint8 * code.739;
  unsigned char D.24797;
  guint8 * code.740;
  guint8 * code.741;
  unsigned char D.24800;
  guint8 * code.742;
  guint8 * code.743;
  unsigned char D.24803;
  guint8 * code.744;
  guint8 * code.745;
  unsigned char D.24806;
  guint8 * code.746;
  guint8 * code.747;
  guint8 * code.748;
  guint8 * code.749;
  guint8 * code.750;
  guint8 * code.751;
  guint8 * code.752;
  guint8 * code.753;
  guint8 * code.754;
  guint8 * code.755;
  guint8 * code.756;
  guint8 * code.757;
  guint8 * code.758;
  guint8 * code.759;
  guint8 * code.760;
  guint8 * code.761;
  unsigned char D.24833;
  guint8 * code.762;
  guint8 * code.763;
  unsigned char D.24836;
  guint8 * code.764;
  guint8 * code.765;
  unsigned char D.24839;
  guint8 * code.766;
  guint8 * code.767;
  unsigned char D.24842;
  guint8 * code.768;
  guint8 * code.769;
  guint8 * code.770;
  guint8 * code.771;
  guint8 * code.772;
  guint8 * code.773;
  guint8 * code.774;
  guint8 * code.775;
  unsigned char D.24857;
  guint8 * code.776;
  guint8 * code.777;
  unsigned char D.24860;
  guint8 * code.778;
  guint8 * code.779;
  unsigned char D.24863;
  guint8 * code.780;
  guint8 * code.781;
  unsigned char D.24866;
  guint8 * code.782;
  guint8 * code.783;
  int D.24871;
  unsigned int D.24872;
  unsigned int D.24873;
  guint8 * code.784;
  guint8 * code.785;
  guint8 * code.786;
  guint8 * code.787;
  int D.24883;
  guint8 * code.788;
  guint8 * code.789;
  guint8 * code.790;
  guint8 * code.791;
  unsigned char D.24890;
  unsigned char D.24891;
  guint8 * code.792;
  guint8 * code.793;
  guint8 * code.794;
  guint8 * code.795;
  guint8 * code.796;
  guint8 * code.797;
  unsigned char D.24898;
  guint8 * code.798;
  guint8 * code.799;
  unsigned char D.24901;
  guint8 * code.800;
  guint8 * code.801;
  unsigned char D.24904;
  guint8 * code.802;
  guint8 * code.803;
  unsigned char D.24907;
  guint8 * code.804;
  guint8 * code.805;
  guint8 * code.806;
  guint8 * code.807;
  guint8 * code.808;
  guint8 * code.809;
  guint8 * code.810;
  guint8 * code.811;
  unsigned char D.24922;
  guint8 * code.812;
  guint8 * code.813;
  unsigned char D.24925;
  guint8 * code.814;
  guint8 * code.815;
  unsigned char D.24928;
  guint8 * code.816;
  guint8 * code.817;
  unsigned char D.24931;
  guint8 * code.818;
  guint8 * code.819;
  int buf.820;
  int D.24935;
  struct MonoUnwindOp * D.24936;
  guint8 * code.821;
  guint8 * code.822;
  guint8 * code.823;
  guint8 * code.824;
  guint8 * code.825;
  int tramp.826;
  guint8 * code.827;
  guint8 * code.828;
  guint8 * code.829;
  guint8 * code.830;
  unsigned char D.24950;
  guint8 * code.831;
  guint8 * code.832;
  unsigned char D.24953;
  guint8 * code.833;
  guint8 * code.834;
  unsigned char D.24956;
  guint8 * code.835;
  guint8 * code.836;
  unsigned char D.24959;
  guint8 * code.837;
  guint8 * code.838;
  guint8 * code.839;
  guint8 * code.840;
  unsigned char D.24966;
  guint8 * code.841;
  guint8 * code.842;
  unsigned char D.24969;
  guint8 * code.843;
  guint8 * code.844;
  unsigned char D.24972;
  guint8 * code.845;
  guint8 * code.846;
  unsigned char D.24975;
  guint8 * code.847;
  guint8 * code.848;
  guint8 * code.849;
  guint8 * code.850;
  guint8 * code.851;
  guint8 * code.852;
  guint8 * code.853;
  guint8 * code.854;
  guint8 * code.855;
  guint8 * code.856;
  unsigned char D.24989;
  guint8 * code.857;
  guint8 * code.858;
  unsigned char D.24992;
  guint8 * code.859;
  guint8 * code.860;
  unsigned char D.24995;
  guint8 * code.861;
  guint8 * code.862;
  unsigned char D.24998;
  guint8 * code.863;
  guint8 * code.864;
  guint8 * code.865;
  guint8 * code.866;
  unsigned char D.25005;
  guint8 * code.867;
  guint8 * code.868;
  unsigned char D.25008;
  guint8 * code.869;
  guint8 * code.870;
  unsigned char D.25011;
  guint8 * code.871;
  guint8 * code.872;
  unsigned char D.25014;
  guint8 * code.873;
  guint8 * code.874;
  guint8 * code.875;
  guint8 * code.876;
  guint8 * code.877;
  guint8 * code.878;
  guint8 * code.879;
  guint8 * code.880;
  guint8 * code.881;
  guint8 * code.882;
  unsigned char D.25028;
  guint8 * code.883;
  guint8 * code.884;
  unsigned char D.25031;
  guint8 * code.885;
  guint8 * code.886;
  unsigned char D.25034;
  guint8 * code.887;
  guint8 * code.888;
  unsigned char D.25037;
  guint8 * code.889;
  guint8 * code.890;
  guint8 * code.891;
  guint8 * code.892;
  guint8 * code.893;
  guint8 * code.894;
  guint8 * code.895;
  int mono_thread_force_interruption_checkpoint.896;
  guint8 * code.897;
  guint8 * code.898;
  guint8 * code.899;
  guint8 * code.900;
  unsigned char D.25053;
  guint8 * code.901;
  guint8 * code.902;
  unsigned char D.25056;
  guint8 * code.903;
  guint8 * code.904;
  unsigned char D.25059;
  guint8 * code.905;
  guint8 * code.906;
  unsigned char D.25062;
  guint8 * code.907;
  guint8 * code.908;
  guint8 * code.909;
  guint8 * code.910;
  guint8 * code.911;
  guint8 * code.912;
  unsigned char D.25071;
  guint8 * code.913;
  guint8 * code.914;
  unsigned char D.25074;
  guint8 * code.915;
  guint8 * code.916;
  unsigned char D.25077;
  guint8 * code.917;
  guint8 * code.918;
  unsigned char D.25080;
  guint8 * code.919;
  guint8 * code.920;
  guint8 * code.921;
  guint8 * code.922;
  guint8 * code.923;
  guint8 * code.924;
  guint8 * code.925;
  guint8 * code.926;
  guint8 * code.927;
  guint8 * code.928;
  unsigned char D.25094;
  guint8 * code.929;
  guint8 * code.930;
  unsigned char D.25097;
  guint8 * code.931;
  guint8 * code.932;
  unsigned char D.25100;
  guint8 * code.933;
  guint8 * code.934;
  unsigned char D.25103;
  guint8 * code.935;
  guint8 * code.936;
  guint8 * code.937;
  guint8 * code.938;
  guint8 * code.939;
  guint8 * code.940;
  unsigned char D.25112;
  guint8 * code.941;
  guint8 * code.942;
  unsigned char D.25115;
  guint8 * code.943;
  guint8 * code.944;
  unsigned char D.25118;
  guint8 * code.945;
  guint8 * code.946;
  unsigned char D.25121;
  guint8 * code.947;
  guint8 * code.948;
  guint8 * code.949;
  guint8 * code.950;
  guint8 * code.951;
  guint8 * code.952;
  guint8 * code.953;
  guint8 * code.954;
  guint8 * code.955;
  guint8 * code.956;
  unsigned char D.25135;
  guint8 * code.957;
  guint8 * code.958;
  unsigned char D.25138;
  guint8 * code.959;
  guint8 * code.960;
  unsigned char D.25141;
  guint8 * code.961;
  guint8 * code.962;
  unsigned char D.25144;
  guint8 * code.963;
  guint8 * code.964;
  guint8 * code.965;
  guint8 * code.966;
  guint8 * code.967;
  guint8 * code.968;
  guint8 * code.969;
  guint8 * code.970;
  guint8 * code.971;
  guint8 * code.972;
  guint8 * code.973;
  guint8 * code.974;
  guint8 * code.975;
  guint8 * code.976;
  guint8 * code.977;
  guint8 * code.978;
  guint8 * code.979;
  guint8 * code.980;
  guint8 * code.981;
  guint8 * code.982;
  guint8 * code.983;
  guint8 * code.984;
  unsigned char D.25175;
  guint8 * code.985;
  guint8 * code.986;
  unsigned char D.25178;
  guint8 * code.987;
  guint8 * code.988;
  unsigned char D.25181;
  guint8 * code.989;
  guint8 * code.990;
  unsigned char D.25184;
  guint8 * code.991;
  guint8 * code.992;
  guint8 * code.993;
  guint8 * code.994;
  guint8 * code.995;
  guint8 * code.996;
  guint8 * code.997;
  guint8 * code.998;
  unsigned char D.25198;
  guint8 * code.999;
  guint8 * code.1000;
  unsigned char D.25201;
  guint8 * code.1001;
  guint8 * code.1002;
  unsigned char D.25204;
  guint8 * code.1003;
  guint8 * code.1004;
  unsigned char D.25207;
  guint8 * code.1005;
  guint8 * code.1006;
  guint8 * code.1007;
  guint8 * code.1008;
  guint8 * code.1009;
  guint8 * code.1010;
  guint8 * code.1011;
  guint8 * code.1012;
  guint8 * code.1013;
  guint8 * code.1014;
  guint8 * code.1015;
  guint8 * code.1016;
  guint8 * code.1017;
  guint8 * code.1018;
  guint8 * code.1019;
  guint8 * code.1020;
  unsigned char D.25226;
  guint8 * code.1021;
  guint8 * code.1022;
  unsigned char D.25229;
  guint8 * code.1023;
  guint8 * code.1024;
  unsigned char D.25232;
  guint8 * code.1025;
  guint8 * code.1026;
  unsigned char D.25235;
  guint8 * code.1027;
  guint8 * code.1028;
  guint8 * code.1029;
  guint8 * code.1030;
  guint8 * code.1031;
  guint8 * code.1032;
  guint8 * code.1033;
  guint8 * code.1034;
  guint8 * code.1035;
  guint8 * code.1036;
  unsigned char D.25249;
  guint8 * code.1037;
  guint8 * code.1038;
  unsigned char D.25252;
  guint8 * code.1039;
  guint8 * code.1040;
  unsigned char D.25255;
  guint8 * code.1041;
  guint8 * code.1042;
  unsigned char D.25258;
  unsigned int D.25259;
  _Bool D.25260;
  _Bool D.25261;
  _Bool D.25262;
  _Bool D.25265;
  _Bool D.25266;
  _Bool D.25267;
  guint8 * code.1043;
  guint8 * code.1044;
  guint8 * code.1045;
  guint8 * code.1046;
  guint8 * code.1047;
  guint8 * code.1048;
  guint8 * code.1049;
  guint8 * code.1050;
  guint8 * code.1051;
  guint8 * code.1052;
  guint8 * code.1053;
  guint8 * code.1054;
  guint8 * code.1055;
  guint8 * code.1056;
  guint8 * code.1057;
  guint8 * code.1058;
  guint8 * code.1059;
  guint8 * code.1060;
  guint8 * code.1061;
  guint8 * code.1062;
  unsigned char D.25301;
  guint8 * code.1063;
  guint8 * code.1064;
  unsigned char D.25304;
  guint8 * code.1065;
  guint8 * code.1066;
  unsigned char D.25307;
  guint8 * code.1067;
  guint8 * code.1068;
  unsigned char D.25310;
  guint8 * code.1069;
  guint8 * code.1070;
  guint8 * code.1071;
  guint8 * code.1072;
  guint8 * code.1073;
  guint8 * code.1074;
  guint8 * code.1075;
  guint8 * code.1076;
  unsigned char D.25325;
  guint8 * code.1077;
  guint8 * code.1078;
  unsigned char D.25328;
  guint8 * code.1079;
  guint8 * code.1080;
  unsigned char D.25331;
  guint8 * code.1081;
  guint8 * code.1082;
  unsigned char D.25334;
  guint8 * code.1083;
  guint8 * code.1084;
  guint8 * code.1085;
  guint8 * code.1086;
  guint8 * code.1087;
  guint8 * code.1088;
  int D.25343;
  guint8 * code.1089;
  guint8 * code.1090;
  guint8 * code.1091;
  guint8 * code.1092;
  int D.25351;
  int D.25352;
  unsigned int D.25353;
  unsigned int D.25354;
  guint8 * code.1093;
  guint8 * code.1094;
  guint8 * code.1095;
  guint8 * code.1096;
  unsigned char D.25361;
  unsigned char D.25362;
  guint8 * code.1097;
  guint8 * code.1098;
  guint8 * code.1099;
  guint8 * code.1100;
  guint8 * code.1101;
  guint8 * code.1102;
  unsigned char D.25370;
  guint8 * code.1103;
  guint8 * code.1104;
  unsigned char D.25373;
  guint8 * code.1105;
  guint8 * code.1106;
  unsigned char D.25376;
  guint8 * code.1107;
  guint8 * code.1108;
  unsigned char D.25379;
  guint8 * code.1109;
  guint8 * code.1110;
  guint8 * code.1111;
  guint8 * code.1112;
  guint8 * code.1113;
  guint8 * code.1114;
  guint8 * code.1115;
  guint8 * code.1116;
  unsigned char D.25393;
  guint8 * code.1117;
  guint8 * code.1118;
  unsigned char D.25396;
  guint8 * code.1119;
  guint8 * code.1120;
  unsigned char D.25399;
  guint8 * code.1121;
  guint8 * code.1122;
  unsigned char D.25402;
  guint8 * code.1123;
  guint8 * code.1124;
  guint8 * code.1125;
  guint8 * code.1126;
  guint8 * code.1127;
  guint8 * code.1128;
  guint8 * code.1129;
  guint8 * code.1130;
  guint8 * code.1131;
  guint8 * code.1132;
  int D.25418;
  int D.25419;
  unsigned int D.25420;
  unsigned int D.25421;
  guint8 * code.1133;
  guint8 * code.1134;
  guint8 * code.1135;
  guint8 * code.1136;
  unsigned char D.25428;
  unsigned char D.25429;
  guint8 * code.1137;
  guint8 * code.1138;
  guint8 * code.1139;
  guint8 * code.1140;
  guint8 * code.1141;
  guint8 * code.1142;
  unsigned char D.25437;
  guint8 * code.1143;
  guint8 * code.1144;
  unsigned char D.25440;
  guint8 * code.1145;
  guint8 * code.1146;
  unsigned char D.25443;
  guint8 * code.1147;
  guint8 * code.1148;
  unsigned char D.25446;
  guint8 * code.1149;
  guint8 * code.1150;
  guint8 * code.1151;
  guint8 * code.1152;
  guint8 * code.1153;
  guint8 * code.1154;
  guint8 * code.1155;
  guint8 * code.1156;
  unsigned char D.25460;
  guint8 * code.1157;
  guint8 * code.1158;
  unsigned char D.25463;
  guint8 * code.1159;
  guint8 * code.1160;
  unsigned char D.25466;
  guint8 * code.1161;
  guint8 * code.1162;
  unsigned char D.25469;
  _Bool D.25470;
  _Bool D.25471;
  _Bool D.25472;
  guint8 * code.1163;
  guint8 * code.1164;
  guint8 * code.1165;
  guint8 * code.1166;
  guint8 * code.1167;
  guint8 * code.1168;
  guint8 * code.1169;
  guint8 * code.1170;
  guint8 * code.1171;
  guint8 * code.1172;
  int D.25490;
  unsigned int D.25491;
  unsigned int D.25492;
  guint8 * code.1173;
  guint8 * code.1174;
  guint8 * code.1175;
  guint8 * code.1176;
  unsigned char D.25499;
  unsigned char D.25500;
  guint8 * code.1177;
  guint8 * code.1178;
  guint8 * code.1179;
  guint8 * code.1180;
  guint8 * code.1181;
  guint8 * code.1182;
  unsigned char D.25508;
  guint8 * code.1183;
  guint8 * code.1184;
  unsigned char D.25511;
  guint8 * code.1185;
  guint8 * code.1186;
  unsigned char D.25514;
  guint8 * code.1187;
  guint8 * code.1188;
  unsigned char D.25517;
  guint8 * code.1189;
  guint8 * code.1190;
  guint8 * code.1191;
  guint8 * code.1192;
  guint8 * code.1193;
  guint8 * code.1194;
  guint8 * code.1195;
  guint8 * code.1196;
  unsigned char D.25531;
  guint8 * code.1197;
  guint8 * code.1198;
  unsigned char D.25534;
  guint8 * code.1199;
  guint8 * code.1200;
  unsigned char D.25537;
  guint8 * code.1201;
  guint8 * code.1202;
  unsigned char D.25540;
  guint8 * code.1203;
  guint8 * code.1204;
  guint8 * code.1205;
  guint8 * code.1206;
  unsigned char D.25552;
  guint8 * code.1207;
  guint8 * code.1208;
  unsigned char D.25555;
  guint8 * code.1209;
  guint8 * code.1210;
  unsigned char D.25558;
  guint8 * code.1211;
  guint8 * code.1212;
  unsigned char D.25561;
  guint8 * code.1213;
  guint8 * code.1214;
  guint8 * code.1215;
  guint8 * code.1216;
  guint8 * code.1217;
  guint8 * code.1218;
  guint8 * code.1219;
  guint8 * code.1220;
  guint8 * code.1221;
  guint8 * code.1222;
  unsigned char D.25575;
  guint8 * code.1223;
  guint8 * code.1224;
  unsigned char D.25578;
  guint8 * code.1225;
  guint8 * code.1226;
  unsigned char D.25581;
  guint8 * code.1227;
  guint8 * code.1228;
  unsigned char D.25584;
  _Bool D.25585;
  long int D.25586;
  long int D.25587;
  guint8 * code.1229;
  guint8 * code.1230;
  guint8 * code.1231;
  guint8 * code.1232;
  unsigned char D.25596;
  guint8 * code.1233;
  guint8 * code.1234;
  unsigned char D.25599;
  guint8 * code.1235;
  guint8 * code.1236;
  unsigned char D.25602;
  guint8 * code.1237;
  guint8 * code.1238;
  unsigned char D.25605;
  guint8 * code.1239;
  guint8 * code.1240;
  guint8 * code.1241;
  guint8 * code.1242;
  guint8 * code.1243;
  guint8 * code.1244;
  guint8 * code.1245;
  guint8 * code.1246;
  guint8 * code.1247;
  guint8 * code.1248;
  unsigned char D.25619;
  guint8 * code.1249;
  guint8 * code.1250;
  unsigned char D.25622;
  guint8 * code.1251;
  guint8 * code.1252;
  unsigned char D.25625;
  guint8 * code.1253;
  guint8 * code.1254;
  unsigned char D.25628;
  _Bool D.25629;
  long int D.25630;
  long int D.25631;
  guint8 * code.1255;
  guint8 * code.1256;
  guint8 * code.1257;
  guint8 * code.1258;
  guint8 * code.1259;
  guint8 * code.1260;
  unsigned char D.25644;
  guint8 * code.1261;
  guint8 * code.1262;
  unsigned char D.25647;
  guint8 * code.1263;
  guint8 * code.1264;
  unsigned char D.25650;
  guint8 * code.1265;
  guint8 * code.1266;
  unsigned char D.25653;
  guint8 * code.1267;
  guint8 * code.1268;
  guint8 * code.1269;
  guint8 * code.1270;
  guint8 * code.1271;
  guint8 * code.1272;
  guint8 * code.1273;
  guint8 * code.1274;
  guint8 * code.1275;
  guint8 * code.1276;
  unsigned char D.25667;
  guint8 * code.1277;
  guint8 * code.1278;
  unsigned char D.25670;
  guint8 * code.1279;
  guint8 * code.1280;
  unsigned char D.25673;
  guint8 * code.1281;
  guint8 * code.1282;
  unsigned char D.25676;
  guint8 * code.1283;
  guint8 * code.1284;
  guint8 * code.1285;
  guint8 * code.1286;
  guint8 * code.1287;
  guint8 * code.1288;
  _Bool D.25684;
  long int D.25685;
  long int D.25686;
  struct MonoJumpInfo * ji.1289;
  unsigned int D.25692;
  struct MonoTrampInfo * D.25693;
  guchar * D.25694;
  char * tramp_name;
  guint8 * buf;
  guint8 * code;
  guint8 * tramp;
  int pushed_args;
  int pushed_args_caller_saved;
  struct GSList * unwind_ops;
  struct MonoJumpInfo * ji;
  static const char __PRETTY_FUNCTION__[36] = "mono_arch_create_generic_trampoline";

  try
    {
      unwind_ops = 0B;
      ji = 0B;
      unwind_ops = mono_arch_get_cie_program ();
      buf.274 = mono_global_codeman_reserve (256);
      buf = buf.274;
      buf.275 = buf;
      code = buf.275;
      code.276 = code;
      code.277 = code.276;
      code.278 = code.277 + 1;
      code = code.278;
      *code.277 = 87;
      code.276 = code;
      code.279 = code.276;
      code.280 = code.279 + 1;
      code = code.280;
      *code.279 = 86;
      code.276 = code;
      code.281 = code.276;
      code.282 = code.281 + 1;
      code = code.282;
      *code.281 = 85;
      code.276 = code;
      code.283 = code.276;
      code.284 = code.283 + 1;
      code = code.284;
      *code.283 = 84;
      code.276 = code;
      code.285 = code.276;
      code.286 = code.285 + 1;
      code = code.286;
      *code.285 = 83;
      code.276 = code;
      code.287 = code.276;
      code.288 = code.287 + 1;
      code = code.288;
      *code.287 = 82;
      code.276 = code;
      code.289 = code.276;
      code.290 = code.289 + 1;
      code = code.290;
      *code.289 = 81;
      code.276 = code;
      code.291 = code.276;
      code.292 = code.291 + 1;
      code = code.292;
      *code.291 = 80;
      pushed_args = 8;
      pushed_args_caller_saved = pushed_args;
      if (0 != 0) goto <D.24060>; else goto <D.24061>;
      <D.24060>:
      code.276 = code;
      code.293 = code.276;
      code.294 = code.293 + 1;
      code = code.294;
      *code.293 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.276 = code;
            code.295 = code.276;
            code.296 = code.295 + 1;
            code = code.296;
            D.24066 = imb.b[0];
            *code.295 = D.24066;
            code.276 = code;
            code.297 = code.276;
            code.298 = code.297 + 1;
            code = code.298;
            D.24069 = imb.b[1];
            *code.297 = D.24069;
            code.276 = code;
            code.299 = code.276;
            code.300 = code.299 + 1;
            code = code.300;
            D.24072 = imb.b[2];
            *code.299 = D.24072;
            code.276 = code;
            code.301 = code.276;
            code.302 = code.301 + 1;
            code = code.302;
            D.24075 = imb.b[3];
            *code.301 = D.24075;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22573>;
      <D.24061>:
      if (1 != 0) goto <D.24076>; else goto <D.24077>;
      <D.24076>:
      code.276 = code;
      code.303 = code.276;
      code.304 = code.303 + 1;
      code = code.304;
      *code.303 = 131;
      code.276 = code;
      code.305 = code.276;
      code.306 = code.305 + 1;
      code = code.306;
      *code.305 = 236;
      code.276 = code;
      *code.276 = 4;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24083>;
      <D.24077>:
      code.276 = code;
      code.308 = code.276;
      code.309 = code.308 + 1;
      code = code.309;
      *code.308 = 129;
      code.276 = code;
      code.310 = code.276;
      code.311 = code.310 + 1;
      code = code.311;
      *code.310 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.276 = code;
            code.312 = code.276;
            code.313 = code.312 + 1;
            code = code.313;
            D.24090 = imb.b[0];
            *code.312 = D.24090;
            code.276 = code;
            code.314 = code.276;
            code.315 = code.314 + 1;
            code = code.315;
            D.24093 = imb.b[1];
            *code.314 = D.24093;
            code.276 = code;
            code.316 = code.276;
            code.317 = code.316 + 1;
            code = code.317;
            D.24096 = imb.b[2];
            *code.316 = D.24096;
            code.276 = code;
            code.318 = code.276;
            code.319 = code.318 + 1;
            code = code.319;
            D.24099 = imb.b[3];
            *code.318 = D.24099;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24083>:
      <D.22573>:
      pushed_args = pushed_args + 1;
      if (tramp_type == 1) goto <D.24100>; else goto <D.24101>;
      <D.24100>:
      {
        int _imm;

        _imm = 0;
        _imm.320 = (unsigned int) _imm;
        D.24103 = _imm.320 + 128;
        if (D.24103 <= 255) goto <D.24104>; else goto <D.24105>;
        <D.24104>:
        code.276 = code;
        code.321 = code.276;
        code.322 = code.321 + 1;
        code = code.322;
        *code.321 = 106;
        code.276 = code;
        D.24108 = (unsigned char) _imm;
        *code.276 = D.24108;
        code.276 = code;
        code.307 = code.276 + 1;
        code = code.307;
        goto <D.24109>;
        <D.24105>:
        code.276 = code;
        code.323 = code.276;
        code.324 = code.323 + 1;
        code = code.324;
        *code.323 = 104;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _imm;
              code.276 = code;
              code.325 = code.276;
              code.326 = code.325 + 1;
              code = code.326;
              D.24114 = imb.b[0];
              *code.325 = D.24114;
              code.276 = code;
              code.327 = code.276;
              code.328 = code.327 + 1;
              code = code.328;
              D.24117 = imb.b[1];
              *code.327 = D.24117;
              code.276 = code;
              code.329 = code.276;
              code.330 = code.329 + 1;
              code = code.330;
              D.24120 = imb.b[2];
              *code.329 = D.24120;
              code.276 = code;
              code.331 = code.276;
              code.332 = code.331 + 1;
              code = code.332;
              D.24123 = imb.b[3];
              *code.331 = D.24123;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.24109>:
      }
      goto <D.24124>;
      <D.24101>:
      code.276 = code;
      code.333 = code.276;
      code.334 = code.333 + 1;
      code = code.334;
      *code.333 = 255;
      if (1 != 0) goto <D.24127>; else goto <D.24128>;
      <D.24127>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      if (D.24131 == 0) goto <D.24132>; else goto <D.24133>;
      <D.24132>:
      code.276 = code;
      code.335 = code.276;
      code.336 = code.335 + 1;
      code = code.336;
      *code.335 = 52;
      code.276 = code;
      code.337 = code.276;
      code.338 = code.337 + 1;
      code = code.338;
      *code.337 = 36;
      goto <D.24138>;
      <D.24133>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 >= -128) goto <D.24142>; else goto <D.24139>;
      <D.24142>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 <= 127) goto <D.24143>; else goto <D.24139>;
      <D.24143>:
      code.276 = code;
      code.339 = code.276;
      code.340 = code.339 + 1;
      code = code.340;
      *code.339 = 116;
      code.276 = code;
      code.341 = code.276;
      code.342 = code.341 + 1;
      code = code.342;
      *code.341 = 36;
      code.276 = code;
      D.24129 = pushed_args + 1;
      D.24148 = (unsigned char) D.24129;
      D.24149 = D.24148 * 4;
      *code.276 = D.24149;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24140>;
      <D.24139>:
      code.276 = code;
      code.343 = code.276;
      code.344 = code.343 + 1;
      code = code.344;
      *code.343 = 180;
      code.276 = code;
      code.345 = code.276;
      code.346 = code.345 + 1;
      code = code.346;
      *code.345 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.24129 = pushed_args + 1;
            D.24130 = (unsigned int) D.24129;
            D.24131 = D.24130 * 4;
            D.24141 = (int) D.24131;
            imb.val = D.24141;
            code.276 = code;
            code.347 = code.276;
            code.348 = code.347 + 1;
            code = code.348;
            D.24156 = imb.b[0];
            *code.347 = D.24156;
            code.276 = code;
            code.349 = code.276;
            code.350 = code.349 + 1;
            code = code.350;
            D.24159 = imb.b[1];
            *code.349 = D.24159;
            code.276 = code;
            code.351 = code.276;
            code.352 = code.351 + 1;
            code = code.352;
            D.24162 = imb.b[2];
            *code.351 = D.24162;
            code.276 = code;
            code.353 = code.276;
            code.354 = code.353 + 1;
            code = code.354;
            D.24165 = imb.b[3];
            *code.353 = D.24165;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24140>:
      <D.24138>:
      goto <D.22578>;
      <D.24128>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      if (D.24131 == 0) goto <D.24166>; else goto <D.24167>;
      <D.24166>:
      code.276 = code;
      code.355 = code.276;
      code.356 = code.355 + 1;
      code = code.356;
      *code.355 = 52;
      goto <D.22578>;
      <D.24167>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 >= -128) goto <D.24172>; else goto <D.24170>;
      <D.24172>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 <= 127) goto <D.24173>; else goto <D.24170>;
      <D.24173>:
      code.276 = code;
      code.357 = code.276;
      code.358 = code.357 + 1;
      code = code.358;
      *code.357 = 116;
      code.276 = code;
      D.24129 = pushed_args + 1;
      D.24148 = (unsigned char) D.24129;
      D.24149 = D.24148 * 4;
      *code.276 = D.24149;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24171>;
      <D.24170>:
      code.276 = code;
      code.359 = code.276;
      code.360 = code.359 + 1;
      code = code.360;
      *code.359 = 180;
      {
        union x86_imm_buf imb;

        try
          {
            D.24129 = pushed_args + 1;
            D.24130 = (unsigned int) D.24129;
            D.24131 = D.24130 * 4;
            D.24141 = (int) D.24131;
            imb.val = D.24141;
            code.276 = code;
            code.361 = code.276;
            code.362 = code.361 + 1;
            code = code.362;
            D.24180 = imb.b[0];
            *code.361 = D.24180;
            code.276 = code;
            code.363 = code.276;
            code.364 = code.363 + 1;
            code = code.364;
            D.24183 = imb.b[1];
            *code.363 = D.24183;
            code.276 = code;
            code.365 = code.276;
            code.366 = code.365 + 1;
            code = code.366;
            D.24186 = imb.b[2];
            *code.365 = D.24186;
            code.276 = code;
            code.367 = code.276;
            code.368 = code.367 + 1;
            code = code.368;
            D.24189 = imb.b[3];
            *code.367 = D.24189;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24171>:
      <D.22578>:
      <D.24124>:
      pushed_args = pushed_args + 1;
      code.276 = code;
      code.369 = code.276;
      code.370 = code.369 + 1;
      code = code.370;
      *code.369 = 85;
      code.276 = code;
      code.371 = code.276;
      code.372 = code.371 + 1;
      code = code.372;
      *code.371 = 86;
      code.276 = code;
      code.373 = code.276;
      code.374 = code.373 + 1;
      code = code.374;
      *code.373 = 87;
      code.276 = code;
      code.375 = code.276;
      code.376 = code.375 + 1;
      code = code.376;
      *code.375 = 83;
      pushed_args = pushed_args + 4;
      code.276 = code;
      code.377 = code.276;
      code.378 = code.377 + 1;
      code = code.378;
      *code.377 = 84;
      D.24200 = pushed_args + 2;
      D.24201 = D.24200 * 4;
      D.24202 = (unsigned int) D.24201;
      D.24203 = D.24202 + 128;
      if (D.24203 <= 255) goto <D.24204>; else goto <D.24205>;
      <D.24204>:
      code.276 = code;
      code.379 = code.276;
      code.380 = code.379 + 1;
      code = code.380;
      *code.379 = 131;
      if (1 != 0) goto <D.24208>; else goto <D.24209>;
      <D.24208>:
      if (1 != 0) goto <D.24210>; else goto <D.24211>;
      <D.24210>:
      code.276 = code;
      code.381 = code.276;
      code.382 = code.381 + 1;
      code = code.382;
      *code.381 = 4;
      code.276 = code;
      code.383 = code.276;
      code.384 = code.383 + 1;
      code = code.384;
      *code.383 = 36;
      goto <D.24216>;
      <D.24211>:
      if (1 != 0) goto <D.24217>; else goto <D.24218>;
      <D.24217>:
      code.276 = code;
      code.385 = code.276;
      code.386 = code.385 + 1;
      code = code.386;
      *code.385 = 68;
      code.276 = code;
      code.387 = code.276;
      code.388 = code.387 + 1;
      code = code.388;
      *code.387 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24223>;
      <D.24218>:
      code.276 = code;
      code.389 = code.276;
      code.390 = code.389 + 1;
      code = code.390;
      *code.389 = 132;
      code.276 = code;
      code.391 = code.276;
      code.392 = code.391 + 1;
      code = code.392;
      *code.391 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.393 = code.276;
            code.394 = code.393 + 1;
            code = code.394;
            D.24230 = imb.b[0];
            *code.393 = D.24230;
            code.276 = code;
            code.395 = code.276;
            code.396 = code.395 + 1;
            code = code.396;
            D.24233 = imb.b[1];
            *code.395 = D.24233;
            code.276 = code;
            code.397 = code.276;
            code.398 = code.397 + 1;
            code = code.398;
            D.24236 = imb.b[2];
            *code.397 = D.24236;
            code.276 = code;
            code.399 = code.276;
            code.400 = code.399 + 1;
            code = code.400;
            D.24239 = imb.b[3];
            *code.399 = D.24239;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24223>:
      <D.24216>:
      goto <D.22581>;
      <D.24209>:
      if (1 != 0) goto <D.24240>; else goto <D.24241>;
      <D.24240>:
      code.276 = code;
      code.401 = code.276;
      code.402 = code.401 + 1;
      code = code.402;
      *code.401 = 4;
      goto <D.22581>;
      <D.24241>:
      if (1 != 0) goto <D.24244>; else goto <D.24245>;
      <D.24244>:
      code.276 = code;
      code.403 = code.276;
      code.404 = code.403 + 1;
      code = code.404;
      *code.403 = 68;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24248>;
      <D.24245>:
      code.276 = code;
      code.405 = code.276;
      code.406 = code.405 + 1;
      code = code.406;
      *code.405 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.407 = code.276;
            code.408 = code.407 + 1;
            code = code.408;
            D.24253 = imb.b[0];
            *code.407 = D.24253;
            code.276 = code;
            code.409 = code.276;
            code.410 = code.409 + 1;
            code = code.410;
            D.24256 = imb.b[1];
            *code.409 = D.24256;
            code.276 = code;
            code.411 = code.276;
            code.412 = code.411 + 1;
            code = code.412;
            D.24259 = imb.b[2];
            *code.411 = D.24259;
            code.276 = code;
            code.413 = code.276;
            code.414 = code.413 + 1;
            code = code.414;
            D.24262 = imb.b[3];
            *code.413 = D.24262;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24248>:
      <D.22581>:
      code.276 = code;
      D.24200 = pushed_args + 2;
      D.24263 = (unsigned char) D.24200;
      D.24264 = D.24263 * 4;
      *code.276 = D.24264;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24265>;
      <D.24205>:
      code.276 = code;
      code.415 = code.276;
      code.416 = code.415 + 1;
      code = code.416;
      *code.415 = 129;
      if (1 != 0) goto <D.24268>; else goto <D.24269>;
      <D.24268>:
      if (1 != 0) goto <D.24270>; else goto <D.24271>;
      <D.24270>:
      code.276 = code;
      code.417 = code.276;
      code.418 = code.417 + 1;
      code = code.418;
      *code.417 = 4;
      code.276 = code;
      code.419 = code.276;
      code.420 = code.419 + 1;
      code = code.420;
      *code.419 = 36;
      goto <D.24276>;
      <D.24271>:
      if (1 != 0) goto <D.24277>; else goto <D.24278>;
      <D.24277>:
      code.276 = code;
      code.421 = code.276;
      code.422 = code.421 + 1;
      code = code.422;
      *code.421 = 68;
      code.276 = code;
      code.423 = code.276;
      code.424 = code.423 + 1;
      code = code.424;
      *code.423 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24283>;
      <D.24278>:
      code.276 = code;
      code.425 = code.276;
      code.426 = code.425 + 1;
      code = code.426;
      *code.425 = 132;
      code.276 = code;
      code.427 = code.276;
      code.428 = code.427 + 1;
      code = code.428;
      *code.427 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.429 = code.276;
            code.430 = code.429 + 1;
            code = code.430;
            D.24290 = imb.b[0];
            *code.429 = D.24290;
            code.276 = code;
            code.431 = code.276;
            code.432 = code.431 + 1;
            code = code.432;
            D.24293 = imb.b[1];
            *code.431 = D.24293;
            code.276 = code;
            code.433 = code.276;
            code.434 = code.433 + 1;
            code = code.434;
            D.24296 = imb.b[2];
            *code.433 = D.24296;
            code.276 = code;
            code.435 = code.276;
            code.436 = code.435 + 1;
            code = code.436;
            D.24299 = imb.b[3];
            *code.435 = D.24299;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24283>:
      <D.24276>:
      goto <D.22584>;
      <D.24269>:
      if (1 != 0) goto <D.24300>; else goto <D.24301>;
      <D.24300>:
      code.276 = code;
      code.437 = code.276;
      code.438 = code.437 + 1;
      code = code.438;
      *code.437 = 4;
      goto <D.22584>;
      <D.24301>:
      if (1 != 0) goto <D.24304>; else goto <D.24305>;
      <D.24304>:
      code.276 = code;
      code.439 = code.276;
      code.440 = code.439 + 1;
      code = code.440;
      *code.439 = 68;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24308>;
      <D.24305>:
      code.276 = code;
      code.441 = code.276;
      code.442 = code.441 + 1;
      code = code.442;
      *code.441 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.443 = code.276;
            code.444 = code.443 + 1;
            code = code.444;
            D.24313 = imb.b[0];
            *code.443 = D.24313;
            code.276 = code;
            code.445 = code.276;
            code.446 = code.445 + 1;
            code = code.446;
            D.24316 = imb.b[1];
            *code.445 = D.24316;
            code.276 = code;
            code.447 = code.276;
            code.448 = code.447 + 1;
            code = code.448;
            D.24319 = imb.b[2];
            *code.447 = D.24319;
            code.276 = code;
            code.449 = code.276;
            code.450 = code.449 + 1;
            code = code.450;
            D.24322 = imb.b[3];
            *code.449 = D.24322;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24308>:
      <D.22584>:
      {
        union x86_imm_buf imb;

        try
          {
            D.24200 = pushed_args + 2;
            D.24201 = D.24200 * 4;
            imb.val = D.24201;
            code.276 = code;
            code.451 = code.276;
            code.452 = code.451 + 1;
            code = code.452;
            D.24325 = imb.b[0];
            *code.451 = D.24325;
            code.276 = code;
            code.453 = code.276;
            code.454 = code.453 + 1;
            code = code.454;
            D.24328 = imb.b[1];
            *code.453 = D.24328;
            code.276 = code;
            code.455 = code.276;
            code.456 = code.455 + 1;
            code = code.456;
            D.24331 = imb.b[2];
            *code.455 = D.24331;
            code.276 = code;
            code.457 = code.276;
            code.458 = code.457 + 1;
            code = code.458;
            D.24334 = imb.b[3];
            *code.457 = D.24334;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24265>:
      pushed_args = pushed_args + 1;
      if (tramp_type <= 1) goto <D.24335>; else goto <D.24336>;
      <D.24335>:
      code.276 = code;
      code.459 = code.276;
      code.460 = code.459 + 1;
      code = code.460;
      *code.459 = 255;
      if (1 != 0) goto <D.24339>; else goto <D.24340>;
      <D.24339>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      if (D.24342 == 0) goto <D.24343>; else goto <D.24344>;
      <D.24343>:
      code.276 = code;
      code.462 = code.276;
      code.463 = code.462 + 1;
      code = code.463;
      *code.462 = 52;
      code.276 = code;
      code.464 = code.276;
      code.465 = code.464 + 1;
      code = code.465;
      *code.464 = 36;
      goto <D.24349>;
      <D.24344>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 >= -128) goto <D.24353>; else goto <D.24350>;
      <D.24353>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 <= 127) goto <D.24354>; else goto <D.24350>;
      <D.24354>:
      code.276 = code;
      code.466 = code.276;
      code.467 = code.466 + 1;
      code = code.467;
      *code.466 = 116;
      code.276 = code;
      code.468 = code.276;
      code.469 = code.468 + 1;
      code = code.469;
      *code.468 = 36;
      code.276 = code;
      D.24359 = (unsigned char) pushed_args;
      D.24360 = D.24359 * 4;
      *code.276 = D.24360;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24351>;
      <D.24350>:
      code.276 = code;
      code.470 = code.276;
      code.471 = code.470 + 1;
      code = code.471;
      *code.470 = 180;
      code.276 = code;
      code.472 = code.276;
      code.473 = code.472 + 1;
      code = code.473;
      *code.472 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            pushed_args.461 = (unsigned int) pushed_args;
            D.24342 = pushed_args.461 * 4;
            D.24352 = (int) D.24342;
            imb.val = D.24352;
            code.276 = code;
            code.474 = code.276;
            code.475 = code.474 + 1;
            code = code.475;
            D.24367 = imb.b[0];
            *code.474 = D.24367;
            code.276 = code;
            code.476 = code.276;
            code.477 = code.476 + 1;
            code = code.477;
            D.24370 = imb.b[1];
            *code.476 = D.24370;
            code.276 = code;
            code.478 = code.276;
            code.479 = code.478 + 1;
            code = code.479;
            D.24373 = imb.b[2];
            *code.478 = D.24373;
            code.276 = code;
            code.480 = code.276;
            code.481 = code.480 + 1;
            code = code.481;
            D.24376 = imb.b[3];
            *code.480 = D.24376;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24351>:
      <D.24349>:
      goto <D.22588>;
      <D.24340>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      if (D.24342 == 0) goto <D.24377>; else goto <D.24378>;
      <D.24377>:
      code.276 = code;
      code.482 = code.276;
      code.483 = code.482 + 1;
      code = code.483;
      *code.482 = 52;
      goto <D.22588>;
      <D.24378>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 >= -128) goto <D.24383>; else goto <D.24381>;
      <D.24383>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 <= 127) goto <D.24384>; else goto <D.24381>;
      <D.24384>:
      code.276 = code;
      code.484 = code.276;
      code.485 = code.484 + 1;
      code = code.485;
      *code.484 = 116;
      code.276 = code;
      D.24359 = (unsigned char) pushed_args;
      D.24360 = D.24359 * 4;
      *code.276 = D.24360;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24382>;
      <D.24381>:
      code.276 = code;
      code.486 = code.276;
      code.487 = code.486 + 1;
      code = code.487;
      *code.486 = 180;
      {
        union x86_imm_buf imb;

        try
          {
            pushed_args.461 = (unsigned int) pushed_args;
            D.24342 = pushed_args.461 * 4;
            D.24352 = (int) D.24342;
            imb.val = D.24352;
            code.276 = code;
            code.488 = code.276;
            code.489 = code.488 + 1;
            code = code.489;
            D.24391 = imb.b[0];
            *code.488 = D.24391;
            code.276 = code;
            code.490 = code.276;
            code.491 = code.490 + 1;
            code = code.491;
            D.24394 = imb.b[1];
            *code.490 = D.24394;
            code.276 = code;
            code.492 = code.276;
            code.493 = code.492 + 1;
            code = code.493;
            D.24397 = imb.b[2];
            *code.492 = D.24397;
            code.276 = code;
            code.494 = code.276;
            code.495 = code.494 + 1;
            code = code.495;
            D.24400 = imb.b[3];
            *code.494 = D.24400;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24382>:
      <D.22588>:
      goto <D.24401>;
      <D.24336>:
      {
        int _imm;

        _imm = 0;
        _imm.496 = (unsigned int) _imm;
        D.24403 = _imm.496 + 128;
        if (D.24403 <= 255) goto <D.24404>; else goto <D.24405>;
        <D.24404>:
        code.276 = code;
        code.497 = code.276;
        code.498 = code.497 + 1;
        code = code.498;
        *code.497 = 106;
        code.276 = code;
        D.24408 = (unsigned char) _imm;
        *code.276 = D.24408;
        code.276 = code;
        code.307 = code.276 + 1;
        code = code.307;
        goto <D.24409>;
        <D.24405>:
        code.276 = code;
        code.499 = code.276;
        code.500 = code.499 + 1;
        code = code.500;
        *code.499 = 104;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _imm;
              code.276 = code;
              code.501 = code.276;
              code.502 = code.501 + 1;
              code = code.502;
              D.24414 = imb.b[0];
              *code.501 = D.24414;
              code.276 = code;
              code.503 = code.276;
              code.504 = code.503 + 1;
              code = code.504;
              D.24417 = imb.b[1];
              *code.503 = D.24417;
              code.276 = code;
              code.505 = code.276;
              code.506 = code.505 + 1;
              code = code.506;
              D.24420 = imb.b[2];
              *code.505 = D.24420;
              code.276 = code;
              code.507 = code.276;
              code.508 = code.507 + 1;
              code = code.508;
              D.24423 = imb.b[3];
              *code.507 = D.24423;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.24409>:
      }
      <D.24401>:
      pushed_args = pushed_args + 1;
      D.24424 = pushed_args != 16;
      D.24425 = (long int) D.24424;
      D.24426 = __builtin_expect (D.24425, 0);
      if (D.24426 != 0) goto <D.24427>; else goto <D.24428>;
      <D.24427>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 376, "pushed_args == 16");
      <D.24428>:
      if (aot != 0) goto <D.24429>; else goto <D.24430>;
      <D.24429>:
      code.276 = code;
      buf.275 = buf;
      code.509 = mono_arch_emit_load_aotconst (buf.275, code.276, &ji, 32, "mono_get_lmf_addr");
      code = code.509;
      code.276 = code;
      code.510 = code.276;
      code.511 = code.510 + 1;
      code = code.511;
      *code.510 = 255;
      code.276 = code;
      code.512 = code.276;
      code.513 = code.512 + 1;
      code = code.513;
      *code.512 = 208;
      goto <D.24436>;
      <D.24430>:
      {
        int _x86_offset;

        mono_get_lmf_addr.514 = (int) mono_get_lmf_addr;
        code.276 = code;
        code.515 = (int) code.276;
        _x86_offset = mono_get_lmf_addr.514 - code.515;
        _x86_offset = _x86_offset + -5;
        code.276 = code;
        code.516 = code.276;
        code.517 = code.516 + 1;
        code = code.517;
        *code.516 = 232;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _x86_offset;
              code.276 = code;
              code.518 = code.276;
              code.519 = code.518 + 1;
              code = code.519;
              D.24443 = imb.b[0];
              *code.518 = D.24443;
              code.276 = code;
              code.520 = code.276;
              code.521 = code.520 + 1;
              code = code.521;
              D.24446 = imb.b[1];
              *code.520 = D.24446;
              code.276 = code;
              code.522 = code.276;
              code.523 = code.522 + 1;
              code = code.523;
              D.24449 = imb.b[2];
              *code.522 = D.24449;
              code.276 = code;
              code.524 = code.276;
              code.525 = code.524 + 1;
              code = code.525;
              D.24452 = imb.b[3];
              *code.524 = D.24452;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
      }
      <D.24436>:
      code.276 = code;
      code.526 = code.276;
      code.527 = code.526 + 1;
      code = code.527;
      *code.526 = 80;
      code.276 = code;
      code.528 = code.276;
      code.529 = code.528 + 1;
      code = code.529;
      *code.528 = 255;
      if (0 != 0) goto <D.24457>; else goto <D.24458>;
      <D.24457>:
      if (1 != 0) goto <D.24459>; else goto <D.24460>;
      <D.24459>:
      code.276 = code;
      code.530 = code.276;
      code.531 = code.530 + 1;
      code = code.531;
      *code.530 = 52;
      code.276 = code;
      code.532 = code.276;
      code.533 = code.532 + 1;
      code = code.533;
      *code.532 = 36;
      goto <D.24465>;
      <D.24460>:
      if (1 != 0) goto <D.24466>; else goto <D.24467>;
      <D.24466>:
      code.276 = code;
      code.534 = code.276;
      code.535 = code.534 + 1;
      code = code.535;
      *code.534 = 116;
      code.276 = code;
      code.536 = code.276;
      code.537 = code.536 + 1;
      code = code.537;
      *code.536 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24472>;
      <D.24467>:
      code.276 = code;
      code.538 = code.276;
      code.539 = code.538 + 1;
      code = code.539;
      *code.538 = 180;
      code.276 = code;
      code.540 = code.276;
      code.541 = code.540 + 1;
      code = code.541;
      *code.540 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.542 = code.276;
            code.543 = code.542 + 1;
            code = code.543;
            D.24479 = imb.b[0];
            *code.542 = D.24479;
            code.276 = code;
            code.544 = code.276;
            code.545 = code.544 + 1;
            code = code.545;
            D.24482 = imb.b[1];
            *code.544 = D.24482;
            code.276 = code;
            code.546 = code.276;
            code.547 = code.546 + 1;
            code = code.547;
            D.24485 = imb.b[2];
            *code.546 = D.24485;
            code.276 = code;
            code.548 = code.276;
            code.549 = code.548 + 1;
            code = code.549;
            D.24488 = imb.b[3];
            *code.548 = D.24488;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24472>:
      <D.24465>:
      goto <D.22595>;
      <D.24458>:
      if (1 != 0) goto <D.24489>; else goto <D.24490>;
      <D.24489>:
      code.276 = code;
      code.550 = code.276;
      code.551 = code.550 + 1;
      code = code.551;
      *code.550 = 48;
      goto <D.22595>;
      <D.24490>:
      if (1 != 0) goto <D.24493>; else goto <D.24494>;
      <D.24493>:
      code.276 = code;
      code.552 = code.276;
      code.553 = code.552 + 1;
      code = code.553;
      *code.552 = 112;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24497>;
      <D.24494>:
      code.276 = code;
      code.554 = code.276;
      code.555 = code.554 + 1;
      code = code.555;
      *code.554 = 176;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.556 = code.276;
            code.557 = code.556 + 1;
            code = code.557;
            D.24502 = imb.b[0];
            *code.556 = D.24502;
            code.276 = code;
            code.558 = code.276;
            code.559 = code.558 + 1;
            code = code.559;
            D.24505 = imb.b[1];
            *code.558 = D.24505;
            code.276 = code;
            code.560 = code.276;
            code.561 = code.560 + 1;
            code = code.561;
            D.24508 = imb.b[2];
            *code.560 = D.24508;
            code.276 = code;
            code.562 = code.276;
            code.563 = code.562 + 1;
            code = code.563;
            D.24511 = imb.b[3];
            *code.562 = D.24511;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24497>:
      <D.22595>:
      if (1 != 0) goto <D.24512>; else goto <D.24513>;
      <D.24512>:
      code.276 = code;
      code.564 = code.276;
      code.565 = code.564 + 1;
      code = code.565;
      *code.564 = 131;
      if (1 != 0) goto <D.24516>; else goto <D.24517>;
      <D.24516>:
      if (1 != 0) goto <D.24518>; else goto <D.24519>;
      <D.24518>:
      code.276 = code;
      code.566 = code.276;
      code.567 = code.566 + 1;
      code = code.567;
      *code.566 = 4;
      code.276 = code;
      code.568 = code.276;
      code.569 = code.568 + 1;
      code = code.569;
      *code.568 = 36;
      goto <D.24524>;
      <D.24519>:
      if (1 != 0) goto <D.24525>; else goto <D.24526>;
      <D.24525>:
      code.276 = code;
      code.570 = code.276;
      code.571 = code.570 + 1;
      code = code.571;
      *code.570 = 68;
      code.276 = code;
      code.572 = code.276;
      code.573 = code.572 + 1;
      code = code.573;
      *code.572 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24531>;
      <D.24526>:
      code.276 = code;
      code.574 = code.276;
      code.575 = code.574 + 1;
      code = code.575;
      *code.574 = 132;
      code.276 = code;
      code.576 = code.276;
      code.577 = code.576 + 1;
      code = code.577;
      *code.576 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.578 = code.276;
            code.579 = code.578 + 1;
            code = code.579;
            D.24538 = imb.b[0];
            *code.578 = D.24538;
            code.276 = code;
            code.580 = code.276;
            code.581 = code.580 + 1;
            code = code.581;
            D.24541 = imb.b[1];
            *code.580 = D.24541;
            code.276 = code;
            code.582 = code.276;
            code.583 = code.582 + 1;
            code = code.583;
            D.24544 = imb.b[2];
            *code.582 = D.24544;
            code.276 = code;
            code.584 = code.276;
            code.585 = code.584 + 1;
            code = code.585;
            D.24547 = imb.b[3];
            *code.584 = D.24547;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24531>:
      <D.24524>:
      goto <D.22598>;
      <D.24517>:
      if (1 != 0) goto <D.24548>; else goto <D.24549>;
      <D.24548>:
      code.276 = code;
      code.586 = code.276;
      code.587 = code.586 + 1;
      code = code.587;
      *code.586 = 4;
      goto <D.22598>;
      <D.24549>:
      if (1 != 0) goto <D.24552>; else goto <D.24553>;
      <D.24552>:
      code.276 = code;
      code.588 = code.276;
      code.589 = code.588 + 1;
      code = code.589;
      *code.588 = 68;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24556>;
      <D.24553>:
      code.276 = code;
      code.590 = code.276;
      code.591 = code.590 + 1;
      code = code.591;
      *code.590 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.592 = code.276;
            code.593 = code.592 + 1;
            code = code.593;
            D.24561 = imb.b[0];
            *code.592 = D.24561;
            code.276 = code;
            code.594 = code.276;
            code.595 = code.594 + 1;
            code = code.595;
            D.24564 = imb.b[1];
            *code.594 = D.24564;
            code.276 = code;
            code.596 = code.276;
            code.597 = code.596 + 1;
            code = code.597;
            D.24567 = imb.b[2];
            *code.596 = D.24567;
            code.276 = code;
            code.598 = code.276;
            code.599 = code.598 + 1;
            code = code.599;
            D.24570 = imb.b[3];
            *code.598 = D.24570;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24556>:
      <D.22598>:
      code.276 = code;
      *code.276 = 1;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24571>;
      <D.24513>:
      code.276 = code;
      code.600 = code.276;
      code.601 = code.600 + 1;
      code = code.601;
      *code.600 = 129;
      if (1 != 0) goto <D.24574>; else goto <D.24575>;
      <D.24574>:
      if (1 != 0) goto <D.24576>; else goto <D.24577>;
      <D.24576>:
      code.276 = code;
      code.602 = code.276;
      code.603 = code.602 + 1;
      code = code.603;
      *code.602 = 4;
      code.276 = code;
      code.604 = code.276;
      code.605 = code.604 + 1;
      code = code.605;
      *code.604 = 36;
      goto <D.24582>;
      <D.24577>:
      if (1 != 0) goto <D.24583>; else goto <D.24584>;
      <D.24583>:
      code.276 = code;
      code.606 = code.276;
      code.607 = code.606 + 1;
      code = code.607;
      *code.606 = 68;
      code.276 = code;
      code.608 = code.276;
      code.609 = code.608 + 1;
      code = code.609;
      *code.608 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24589>;
      <D.24584>:
      code.276 = code;
      code.610 = code.276;
      code.611 = code.610 + 1;
      code = code.611;
      *code.610 = 132;
      code.276 = code;
      code.612 = code.276;
      code.613 = code.612 + 1;
      code = code.613;
      *code.612 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.614 = code.276;
            code.615 = code.614 + 1;
            code = code.615;
            D.24596 = imb.b[0];
            *code.614 = D.24596;
            code.276 = code;
            code.616 = code.276;
            code.617 = code.616 + 1;
            code = code.617;
            D.24599 = imb.b[1];
            *code.616 = D.24599;
            code.276 = code;
            code.618 = code.276;
            code.619 = code.618 + 1;
            code = code.619;
            D.24602 = imb.b[2];
            *code.618 = D.24602;
            code.276 = code;
            code.620 = code.276;
            code.621 = code.620 + 1;
            code = code.621;
            D.24605 = imb.b[3];
            *code.620 = D.24605;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24589>:
      <D.24582>:
      goto <D.22601>;
      <D.24575>:
      if (1 != 0) goto <D.24606>; else goto <D.24607>;
      <D.24606>:
      code.276 = code;
      code.622 = code.276;
      code.623 = code.622 + 1;
      code = code.623;
      *code.622 = 4;
      goto <D.22601>;
      <D.24607>:
      if (1 != 0) goto <D.24610>; else goto <D.24611>;
      <D.24610>:
      code.276 = code;
      code.624 = code.276;
      code.625 = code.624 + 1;
      code = code.625;
      *code.624 = 68;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24614>;
      <D.24611>:
      code.276 = code;
      code.626 = code.276;
      code.627 = code.626 + 1;
      code = code.627;
      *code.626 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.628 = code.276;
            code.629 = code.628 + 1;
            code = code.629;
            D.24619 = imb.b[0];
            *code.628 = D.24619;
            code.276 = code;
            code.630 = code.276;
            code.631 = code.630 + 1;
            code = code.631;
            D.24622 = imb.b[1];
            *code.630 = D.24622;
            code.276 = code;
            code.632 = code.276;
            code.633 = code.632 + 1;
            code = code.633;
            D.24625 = imb.b[2];
            *code.632 = D.24625;
            code.276 = code;
            code.634 = code.276;
            code.635 = code.634 + 1;
            code = code.635;
            D.24628 = imb.b[3];
            *code.634 = D.24628;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24614>:
      <D.22601>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 1;
            code.276 = code;
            code.636 = code.276;
            code.637 = code.636 + 1;
            code = code.637;
            D.24631 = imb.b[0];
            *code.636 = D.24631;
            code.276 = code;
            code.638 = code.276;
            code.639 = code.638 + 1;
            code = code.639;
            D.24634 = imb.b[1];
            *code.638 = D.24634;
            code.276 = code;
            code.640 = code.276;
            code.641 = code.640 + 1;
            code = code.641;
            D.24637 = imb.b[2];
            *code.640 = D.24637;
            code.276 = code;
            code.642 = code.276;
            code.643 = code.642 + 1;
            code = code.643;
            D.24640 = imb.b[3];
            *code.642 = D.24640;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24571>:
      switch (4) <default: <D.22608>, case 1: <D.22604>, case 2: <D.22606>, case 4: <D.22607>>
      <D.22604>:
      code.276 = code;
      code.644 = code.276;
      code.645 = code.644 + 1;
      code = code.645;
      *code.644 = 136;
      goto <D.22605>;
      <D.22606>:
      code.276 = code;
      code.646 = code.276;
      code.647 = code.646 + 1;
      code = code.647;
      *code.646 = 102;
      <D.22607>:
      code.276 = code;
      code.648 = code.276;
      code.649 = code.648 + 1;
      code = code.649;
      *code.648 = 137;
      goto <D.22605>;
      <D.22608>:
      __assert_fail ("0", "tramp-x86.c", 392, &__PRETTY_FUNCTION__);
      <D.22605>:
      if (0 != 0) goto <D.24647>; else goto <D.24648>;
      <D.24647>:
      if (1 != 0) goto <D.24649>; else goto <D.24650>;
      <D.24649>:
      code.276 = code;
      code.650 = code.276;
      code.651 = code.650 + 1;
      code = code.651;
      *code.650 = 36;
      code.276 = code;
      code.652 = code.276;
      code.653 = code.652 + 1;
      code = code.653;
      *code.652 = 36;
      goto <D.24655>;
      <D.24650>:
      if (1 != 0) goto <D.24656>; else goto <D.24657>;
      <D.24656>:
      code.276 = code;
      code.654 = code.276;
      code.655 = code.654 + 1;
      code = code.655;
      *code.654 = 100;
      code.276 = code;
      code.656 = code.276;
      code.657 = code.656 + 1;
      code = code.657;
      *code.656 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24662>;
      <D.24657>:
      code.276 = code;
      code.658 = code.276;
      code.659 = code.658 + 1;
      code = code.659;
      *code.658 = 164;
      code.276 = code;
      code.660 = code.276;
      code.661 = code.660 + 1;
      code = code.661;
      *code.660 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.662 = code.276;
            code.663 = code.662 + 1;
            code = code.663;
            D.24669 = imb.b[0];
            *code.662 = D.24669;
            code.276 = code;
            code.664 = code.276;
            code.665 = code.664 + 1;
            code = code.665;
            D.24672 = imb.b[1];
            *code.664 = D.24672;
            code.276 = code;
            code.666 = code.276;
            code.667 = code.666 + 1;
            code = code.667;
            D.24675 = imb.b[2];
            *code.666 = D.24675;
            code.276 = code;
            code.668 = code.276;
            code.669 = code.668 + 1;
            code = code.669;
            D.24678 = imb.b[3];
            *code.668 = D.24678;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24662>:
      <D.24655>:
      goto <D.22611>;
      <D.24648>:
      if (1 != 0) goto <D.24679>; else goto <D.24680>;
      <D.24679>:
      code.276 = code;
      code.670 = code.276;
      code.671 = code.670 + 1;
      code = code.671;
      *code.670 = 32;
      goto <D.22611>;
      <D.24680>:
      if (1 != 0) goto <D.24683>; else goto <D.24684>;
      <D.24683>:
      code.276 = code;
      code.672 = code.276;
      code.673 = code.672 + 1;
      code = code.673;
      *code.672 = 96;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24687>;
      <D.24684>:
      code.276 = code;
      code.674 = code.276;
      code.675 = code.674 + 1;
      code = code.675;
      *code.674 = 160;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.676 = code.276;
            code.677 = code.676 + 1;
            code = code.677;
            D.24692 = imb.b[0];
            *code.676 = D.24692;
            code.276 = code;
            code.678 = code.276;
            code.679 = code.678 + 1;
            code = code.679;
            D.24695 = imb.b[1];
            *code.678 = D.24695;
            code.276 = code;
            code.680 = code.276;
            code.681 = code.680 + 1;
            code = code.681;
            D.24698 = imb.b[2];
            *code.680 = D.24698;
            code.276 = code;
            code.682 = code.276;
            code.683 = code.682 + 1;
            code = code.683;
            D.24701 = imb.b[3];
            *code.682 = D.24701;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24687>:
      <D.22611>:
      pushed_args = pushed_args + 2;
      {
        int _imm;

        _imm = 0;
        _imm.684 = (unsigned int) _imm;
        D.24703 = _imm.684 + 128;
        if (D.24703 <= 255) goto <D.24704>; else goto <D.24705>;
        <D.24704>:
        code.276 = code;
        code.685 = code.276;
        code.686 = code.685 + 1;
        code = code.686;
        *code.685 = 106;
        code.276 = code;
        D.24708 = (unsigned char) _imm;
        *code.276 = D.24708;
        code.276 = code;
        code.307 = code.276 + 1;
        code = code.307;
        goto <D.24709>;
        <D.24705>:
        code.276 = code;
        code.687 = code.276;
        code.688 = code.687 + 1;
        code = code.688;
        *code.687 = 104;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _imm;
              code.276 = code;
              code.689 = code.276;
              code.690 = code.689 + 1;
              code = code.690;
              D.24714 = imb.b[0];
              *code.689 = D.24714;
              code.276 = code;
              code.691 = code.276;
              code.692 = code.691 + 1;
              code = code.692;
              D.24717 = imb.b[1];
              *code.691 = D.24717;
              code.276 = code;
              code.693 = code.276;
              code.694 = code.693 + 1;
              code = code.694;
              D.24720 = imb.b[2];
              *code.693 = D.24720;
              code.276 = code;
              code.695 = code.276;
              code.696 = code.695 + 1;
              code = code.696;
              D.24723 = imb.b[3];
              *code.695 = D.24723;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.24709>:
      }
      pushed_args = pushed_args + 1;
      code.276 = code;
      code.697 = code.276;
      code.698 = code.697 + 1;
      code = code.698;
      *code.697 = 255;
      if (1 != 0) goto <D.24726>; else goto <D.24727>;
      <D.24726>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      if (D.24342 == 0) goto <D.24728>; else goto <D.24729>;
      <D.24728>:
      code.276 = code;
      code.699 = code.276;
      code.700 = code.699 + 1;
      code = code.700;
      *code.699 = 52;
      code.276 = code;
      code.701 = code.276;
      code.702 = code.701 + 1;
      code = code.702;
      *code.701 = 36;
      goto <D.24734>;
      <D.24729>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 >= -128) goto <D.24737>; else goto <D.24735>;
      <D.24737>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 <= 127) goto <D.24738>; else goto <D.24735>;
      <D.24738>:
      code.276 = code;
      code.703 = code.276;
      code.704 = code.703 + 1;
      code = code.704;
      *code.703 = 116;
      code.276 = code;
      code.705 = code.276;
      code.706 = code.705 + 1;
      code = code.706;
      *code.705 = 36;
      code.276 = code;
      D.24359 = (unsigned char) pushed_args;
      D.24360 = D.24359 * 4;
      *code.276 = D.24360;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24736>;
      <D.24735>:
      code.276 = code;
      code.707 = code.276;
      code.708 = code.707 + 1;
      code = code.708;
      *code.707 = 180;
      code.276 = code;
      code.709 = code.276;
      code.710 = code.709 + 1;
      code = code.710;
      *code.709 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            pushed_args.461 = (unsigned int) pushed_args;
            D.24342 = pushed_args.461 * 4;
            D.24352 = (int) D.24342;
            imb.val = D.24352;
            code.276 = code;
            code.711 = code.276;
            code.712 = code.711 + 1;
            code = code.712;
            D.24749 = imb.b[0];
            *code.711 = D.24749;
            code.276 = code;
            code.713 = code.276;
            code.714 = code.713 + 1;
            code = code.714;
            D.24752 = imb.b[1];
            *code.713 = D.24752;
            code.276 = code;
            code.715 = code.276;
            code.716 = code.715 + 1;
            code = code.716;
            D.24755 = imb.b[2];
            *code.715 = D.24755;
            code.276 = code;
            code.717 = code.276;
            code.718 = code.717 + 1;
            code = code.718;
            D.24758 = imb.b[3];
            *code.717 = D.24758;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24736>:
      <D.24734>:
      goto <D.22616>;
      <D.24727>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      if (D.24342 == 0) goto <D.24759>; else goto <D.24760>;
      <D.24759>:
      code.276 = code;
      code.719 = code.276;
      code.720 = code.719 + 1;
      code = code.720;
      *code.719 = 52;
      goto <D.22616>;
      <D.24760>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 >= -128) goto <D.24765>; else goto <D.24763>;
      <D.24765>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 <= 127) goto <D.24766>; else goto <D.24763>;
      <D.24766>:
      code.276 = code;
      code.721 = code.276;
      code.722 = code.721 + 1;
      code = code.722;
      *code.721 = 116;
      code.276 = code;
      D.24359 = (unsigned char) pushed_args;
      D.24360 = D.24359 * 4;
      *code.276 = D.24360;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24764>;
      <D.24763>:
      code.276 = code;
      code.723 = code.276;
      code.724 = code.723 + 1;
      code = code.724;
      *code.723 = 180;
      {
        union x86_imm_buf imb;

        try
          {
            pushed_args.461 = (unsigned int) pushed_args;
            D.24342 = pushed_args.461 * 4;
            D.24352 = (int) D.24342;
            imb.val = D.24352;
            code.276 = code;
            code.725 = code.276;
            code.726 = code.725 + 1;
            code = code.726;
            D.24773 = imb.b[0];
            *code.725 = D.24773;
            code.276 = code;
            code.727 = code.276;
            code.728 = code.727 + 1;
            code = code.728;
            D.24776 = imb.b[1];
            *code.727 = D.24776;
            code.276 = code;
            code.729 = code.276;
            code.730 = code.729 + 1;
            code = code.730;
            D.24779 = imb.b[2];
            *code.729 = D.24779;
            code.276 = code;
            code.731 = code.276;
            code.732 = code.731 + 1;
            code = code.732;
            D.24782 = imb.b[3];
            *code.731 = D.24782;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24764>:
      <D.22616>:
      pushed_args = pushed_args + 1;
      if (tramp_type == 1) goto <D.24783>; else goto <D.24784>;
      <D.24783>:
      {
        int _imm;

        _imm = 0;
        _imm.733 = (unsigned int) _imm;
        D.24786 = _imm.733 + 128;
        if (D.24786 <= 255) goto <D.24787>; else goto <D.24788>;
        <D.24787>:
        code.276 = code;
        code.734 = code.276;
        code.735 = code.734 + 1;
        code = code.735;
        *code.734 = 106;
        code.276 = code;
        D.24791 = (unsigned char) _imm;
        *code.276 = D.24791;
        code.276 = code;
        code.307 = code.276 + 1;
        code = code.307;
        goto <D.24792>;
        <D.24788>:
        code.276 = code;
        code.736 = code.276;
        code.737 = code.736 + 1;
        code = code.737;
        *code.736 = 104;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _imm;
              code.276 = code;
              code.738 = code.276;
              code.739 = code.738 + 1;
              code = code.739;
              D.24797 = imb.b[0];
              *code.738 = D.24797;
              code.276 = code;
              code.740 = code.276;
              code.741 = code.740 + 1;
              code = code.741;
              D.24800 = imb.b[1];
              *code.740 = D.24800;
              code.276 = code;
              code.742 = code.276;
              code.743 = code.742 + 1;
              code = code.743;
              D.24803 = imb.b[2];
              *code.742 = D.24803;
              code.276 = code;
              code.744 = code.276;
              code.745 = code.744 + 1;
              code = code.745;
              D.24806 = imb.b[3];
              *code.744 = D.24806;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.24792>:
      }
      goto <D.24807>;
      <D.24784>:
      code.276 = code;
      code.746 = code.276;
      code.747 = code.746 + 1;
      code = code.747;
      *code.746 = 255;
      if (1 != 0) goto <D.24810>; else goto <D.24811>;
      <D.24810>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      if (D.24131 == 0) goto <D.24812>; else goto <D.24813>;
      <D.24812>:
      code.276 = code;
      code.748 = code.276;
      code.749 = code.748 + 1;
      code = code.749;
      *code.748 = 52;
      code.276 = code;
      code.750 = code.276;
      code.751 = code.750 + 1;
      code = code.751;
      *code.750 = 36;
      goto <D.24818>;
      <D.24813>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 >= -128) goto <D.24821>; else goto <D.24819>;
      <D.24821>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 <= 127) goto <D.24822>; else goto <D.24819>;
      <D.24822>:
      code.276 = code;
      code.752 = code.276;
      code.753 = code.752 + 1;
      code = code.753;
      *code.752 = 116;
      code.276 = code;
      code.754 = code.276;
      code.755 = code.754 + 1;
      code = code.755;
      *code.754 = 36;
      code.276 = code;
      D.24129 = pushed_args + 1;
      D.24148 = (unsigned char) D.24129;
      D.24149 = D.24148 * 4;
      *code.276 = D.24149;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24820>;
      <D.24819>:
      code.276 = code;
      code.756 = code.276;
      code.757 = code.756 + 1;
      code = code.757;
      *code.756 = 180;
      code.276 = code;
      code.758 = code.276;
      code.759 = code.758 + 1;
      code = code.759;
      *code.758 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.24129 = pushed_args + 1;
            D.24130 = (unsigned int) D.24129;
            D.24131 = D.24130 * 4;
            D.24141 = (int) D.24131;
            imb.val = D.24141;
            code.276 = code;
            code.760 = code.276;
            code.761 = code.760 + 1;
            code = code.761;
            D.24833 = imb.b[0];
            *code.760 = D.24833;
            code.276 = code;
            code.762 = code.276;
            code.763 = code.762 + 1;
            code = code.763;
            D.24836 = imb.b[1];
            *code.762 = D.24836;
            code.276 = code;
            code.764 = code.276;
            code.765 = code.764 + 1;
            code = code.765;
            D.24839 = imb.b[2];
            *code.764 = D.24839;
            code.276 = code;
            code.766 = code.276;
            code.767 = code.766 + 1;
            code = code.767;
            D.24842 = imb.b[3];
            *code.766 = D.24842;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24820>:
      <D.24818>:
      goto <D.22621>;
      <D.24811>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      if (D.24131 == 0) goto <D.24843>; else goto <D.24844>;
      <D.24843>:
      code.276 = code;
      code.768 = code.276;
      code.769 = code.768 + 1;
      code = code.769;
      *code.768 = 52;
      goto <D.22621>;
      <D.24844>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 >= -128) goto <D.24849>; else goto <D.24847>;
      <D.24849>:
      D.24129 = pushed_args + 1;
      D.24130 = (unsigned int) D.24129;
      D.24131 = D.24130 * 4;
      D.24141 = (int) D.24131;
      if (D.24141 <= 127) goto <D.24850>; else goto <D.24847>;
      <D.24850>:
      code.276 = code;
      code.770 = code.276;
      code.771 = code.770 + 1;
      code = code.771;
      *code.770 = 116;
      code.276 = code;
      D.24129 = pushed_args + 1;
      D.24148 = (unsigned char) D.24129;
      D.24149 = D.24148 * 4;
      *code.276 = D.24149;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24848>;
      <D.24847>:
      code.276 = code;
      code.772 = code.276;
      code.773 = code.772 + 1;
      code = code.773;
      *code.772 = 180;
      {
        union x86_imm_buf imb;

        try
          {
            D.24129 = pushed_args + 1;
            D.24130 = (unsigned int) D.24129;
            D.24131 = D.24130 * 4;
            D.24141 = (int) D.24131;
            imb.val = D.24141;
            code.276 = code;
            code.774 = code.276;
            code.775 = code.774 + 1;
            code = code.775;
            D.24857 = imb.b[0];
            *code.774 = D.24857;
            code.276 = code;
            code.776 = code.276;
            code.777 = code.776 + 1;
            code = code.777;
            D.24860 = imb.b[1];
            *code.776 = D.24860;
            code.276 = code;
            code.778 = code.276;
            code.779 = code.778 + 1;
            code = code.779;
            D.24863 = imb.b[2];
            *code.778 = D.24863;
            code.276 = code;
            code.780 = code.276;
            code.781 = code.780 + 1;
            code = code.781;
            D.24866 = imb.b[3];
            *code.780 = D.24866;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24848>:
      <D.22621>:
      <D.24807>:
      pushed_args = pushed_args + 1;
      code.276 = code;
      code.782 = code.276;
      code.783 = code.782 + 1;
      code = code.783;
      *code.782 = 141;
      if (1 != 0) goto <D.24869>; else goto <D.24870>;
      <D.24869>:
      D.24871 = pushed_args + -8;
      D.24872 = (unsigned int) D.24871;
      D.24873 = D.24872 * 4;
      if (D.24873 == 0) goto <D.24874>; else goto <D.24875>;
      <D.24874>:
      code.276 = code;
      code.784 = code.276;
      code.785 = code.784 + 1;
      code = code.785;
      *code.784 = 4;
      code.276 = code;
      code.786 = code.276;
      code.787 = code.786 + 1;
      code = code.787;
      *code.786 = 36;
      goto <D.24880>;
      <D.24875>:
      D.24871 = pushed_args + -8;
      D.24872 = (unsigned int) D.24871;
      D.24873 = D.24872 * 4;
      D.24883 = (int) D.24873;
      if (D.24883 >= -128) goto <D.24884>; else goto <D.24881>;
      <D.24884>:
      D.24871 = pushed_args + -8;
      D.24872 = (unsigned int) D.24871;
      D.24873 = D.24872 * 4;
      D.24883 = (int) D.24873;
      if (D.24883 <= 127) goto <D.24885>; else goto <D.24881>;
      <D.24885>:
      code.276 = code;
      code.788 = code.276;
      code.789 = code.788 + 1;
      code = code.789;
      *code.788 = 68;
      code.276 = code;
      code.790 = code.276;
      code.791 = code.790 + 1;
      code = code.791;
      *code.790 = 36;
      code.276 = code;
      D.24871 = pushed_args + -8;
      D.24890 = (unsigned char) D.24871;
      D.24891 = D.24890 * 4;
      *code.276 = D.24891;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24882>;
      <D.24881>:
      code.276 = code;
      code.792 = code.276;
      code.793 = code.792 + 1;
      code = code.793;
      *code.792 = 132;
      code.276 = code;
      code.794 = code.276;
      code.795 = code.794 + 1;
      code = code.795;
      *code.794 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.24871 = pushed_args + -8;
            D.24872 = (unsigned int) D.24871;
            D.24873 = D.24872 * 4;
            D.24883 = (int) D.24873;
            imb.val = D.24883;
            code.276 = code;
            code.796 = code.276;
            code.797 = code.796 + 1;
            code = code.797;
            D.24898 = imb.b[0];
            *code.796 = D.24898;
            code.276 = code;
            code.798 = code.276;
            code.799 = code.798 + 1;
            code = code.799;
            D.24901 = imb.b[1];
            *code.798 = D.24901;
            code.276 = code;
            code.800 = code.276;
            code.801 = code.800 + 1;
            code = code.801;
            D.24904 = imb.b[2];
            *code.800 = D.24904;
            code.276 = code;
            code.802 = code.276;
            code.803 = code.802 + 1;
            code = code.803;
            D.24907 = imb.b[3];
            *code.802 = D.24907;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24882>:
      <D.24880>:
      goto <D.22624>;
      <D.24870>:
      D.24871 = pushed_args + -8;
      D.24872 = (unsigned int) D.24871;
      D.24873 = D.24872 * 4;
      if (D.24873 == 0) goto <D.24908>; else goto <D.24909>;
      <D.24908>:
      code.276 = code;
      code.804 = code.276;
      code.805 = code.804 + 1;
      code = code.805;
      *code.804 = 4;
      goto <D.22624>;
      <D.24909>:
      D.24871 = pushed_args + -8;
      D.24872 = (unsigned int) D.24871;
      D.24873 = D.24872 * 4;
      D.24883 = (int) D.24873;
      if (D.24883 >= -128) goto <D.24914>; else goto <D.24912>;
      <D.24914>:
      D.24871 = pushed_args + -8;
      D.24872 = (unsigned int) D.24871;
      D.24873 = D.24872 * 4;
      D.24883 = (int) D.24873;
      if (D.24883 <= 127) goto <D.24915>; else goto <D.24912>;
      <D.24915>:
      code.276 = code;
      code.806 = code.276;
      code.807 = code.806 + 1;
      code = code.807;
      *code.806 = 68;
      code.276 = code;
      D.24871 = pushed_args + -8;
      D.24890 = (unsigned char) D.24871;
      D.24891 = D.24890 * 4;
      *code.276 = D.24891;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24913>;
      <D.24912>:
      code.276 = code;
      code.808 = code.276;
      code.809 = code.808 + 1;
      code = code.809;
      *code.808 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.24871 = pushed_args + -8;
            D.24872 = (unsigned int) D.24871;
            D.24873 = D.24872 * 4;
            D.24883 = (int) D.24873;
            imb.val = D.24883;
            code.276 = code;
            code.810 = code.276;
            code.811 = code.810 + 1;
            code = code.811;
            D.24922 = imb.b[0];
            *code.810 = D.24922;
            code.276 = code;
            code.812 = code.276;
            code.813 = code.812 + 1;
            code = code.813;
            D.24925 = imb.b[1];
            *code.812 = D.24925;
            code.276 = code;
            code.814 = code.276;
            code.815 = code.814 + 1;
            code = code.815;
            D.24928 = imb.b[2];
            *code.814 = D.24928;
            code.276 = code;
            code.816 = code.276;
            code.817 = code.816 + 1;
            code = code.817;
            D.24931 = imb.b[3];
            *code.816 = D.24931;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24913>:
      <D.22624>:
      code.276 = code;
      code.818 = code.276;
      code.819 = code.818 + 1;
      code = code.819;
      *code.818 = 80;
      pushed_args = pushed_args + 1;
      D.24200 = pushed_args + 2;
      D.24201 = D.24200 * 4;
      code.276 = code;
      code.515 = (int) code.276;
      buf.275 = buf;
      buf.820 = (int) buf.275;
      D.24935 = code.515 - buf.820;
      D.24936 = mono_create_unwind_op (D.24935, 12, 4, D.24201);
      unwind_ops = monoeg_g_slist_append (unwind_ops, D.24936);
      if (aot != 0) goto <D.24937>; else goto <D.24938>;
      <D.24937>:
      {
        char * icall_name;

        icall_name = monoeg_g_strdup_printf ("trampoline_func_%d", tramp_type);
        code.276 = code;
        buf.275 = buf;
        code.821 = mono_arch_emit_load_aotconst (buf.275, code.276, &ji, 32, icall_name);
        code = code.821;
        code.276 = code;
        code.822 = code.276;
        code.823 = code.822 + 1;
        code = code.823;
        *code.822 = 255;
        code.276 = code;
        code.824 = code.276;
        code.825 = code.824 + 1;
        code = code.825;
        *code.824 = 208;
      }
      goto <D.24944>;
      <D.24938>:
      tramp = mono_get_trampoline_func (tramp_type);
      {
        int _x86_offset;

        tramp.826 = (int) tramp;
        code.276 = code;
        code.515 = (int) code.276;
        _x86_offset = tramp.826 - code.515;
        _x86_offset = _x86_offset + -5;
        code.276 = code;
        code.827 = code.276;
        code.828 = code.827 + 1;
        code = code.828;
        *code.827 = 232;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _x86_offset;
              code.276 = code;
              code.829 = code.276;
              code.830 = code.829 + 1;
              code = code.830;
              D.24950 = imb.b[0];
              *code.829 = D.24950;
              code.276 = code;
              code.831 = code.276;
              code.832 = code.831 + 1;
              code = code.832;
              D.24953 = imb.b[1];
              *code.831 = D.24953;
              code.276 = code;
              code.833 = code.276;
              code.834 = code.833 + 1;
              code = code.834;
              D.24956 = imb.b[2];
              *code.833 = D.24956;
              code.276 = code;
              code.835 = code.276;
              code.836 = code.835 + 1;
              code = code.836;
              D.24959 = imb.b[3];
              *code.835 = D.24959;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
      }
      <D.24944>:
      if (0 != 0) goto <D.24960>; else goto <D.24961>;
      <D.24960>:
      code.276 = code;
      code.837 = code.276;
      code.838 = code.837 + 1;
      code = code.838;
      *code.837 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.276 = code;
            code.839 = code.276;
            code.840 = code.839 + 1;
            code = code.840;
            D.24966 = imb.b[0];
            *code.839 = D.24966;
            code.276 = code;
            code.841 = code.276;
            code.842 = code.841 + 1;
            code = code.842;
            D.24969 = imb.b[1];
            *code.841 = D.24969;
            code.276 = code;
            code.843 = code.276;
            code.844 = code.843 + 1;
            code = code.844;
            D.24972 = imb.b[2];
            *code.843 = D.24972;
            code.276 = code;
            code.845 = code.276;
            code.846 = code.845 + 1;
            code = code.846;
            D.24975 = imb.b[3];
            *code.845 = D.24975;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22630>;
      <D.24961>:
      if (1 != 0) goto <D.24976>; else goto <D.24977>;
      <D.24976>:
      code.276 = code;
      code.847 = code.276;
      code.848 = code.847 + 1;
      code = code.848;
      *code.847 = 131;
      code.276 = code;
      code.849 = code.276;
      code.850 = code.849 + 1;
      code = code.850;
      *code.849 = 196;
      code.276 = code;
      *code.276 = 16;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.24982>;
      <D.24977>:
      code.276 = code;
      code.851 = code.276;
      code.852 = code.851 + 1;
      code = code.852;
      *code.851 = 129;
      code.276 = code;
      code.853 = code.276;
      code.854 = code.853 + 1;
      code = code.854;
      *code.853 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.276 = code;
            code.855 = code.276;
            code.856 = code.855 + 1;
            code = code.856;
            D.24989 = imb.b[0];
            *code.855 = D.24989;
            code.276 = code;
            code.857 = code.276;
            code.858 = code.857 + 1;
            code = code.858;
            D.24992 = imb.b[1];
            *code.857 = D.24992;
            code.276 = code;
            code.859 = code.276;
            code.860 = code.859 + 1;
            code = code.860;
            D.24995 = imb.b[2];
            *code.859 = D.24995;
            code.276 = code;
            code.861 = code.276;
            code.862 = code.861 + 1;
            code = code.862;
            D.24998 = imb.b[3];
            *code.861 = D.24998;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24982>:
      <D.22630>:
      pushed_args = pushed_args + -4;
      if (0 != 0) goto <D.24999>; else goto <D.25000>;
      <D.24999>:
      code.276 = code;
      code.863 = code.276;
      code.864 = code.863 + 1;
      code = code.864;
      *code.863 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 12;
            code.276 = code;
            code.865 = code.276;
            code.866 = code.865 + 1;
            code = code.866;
            D.25005 = imb.b[0];
            *code.865 = D.25005;
            code.276 = code;
            code.867 = code.276;
            code.868 = code.867 + 1;
            code = code.868;
            D.25008 = imb.b[1];
            *code.867 = D.25008;
            code.276 = code;
            code.869 = code.276;
            code.870 = code.869 + 1;
            code = code.870;
            D.25011 = imb.b[2];
            *code.869 = D.25011;
            code.276 = code;
            code.871 = code.276;
            code.872 = code.871 + 1;
            code = code.872;
            D.25014 = imb.b[3];
            *code.871 = D.25014;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22633>;
      <D.25000>:
      if (1 != 0) goto <D.25015>; else goto <D.25016>;
      <D.25015>:
      code.276 = code;
      code.873 = code.276;
      code.874 = code.873 + 1;
      code = code.874;
      *code.873 = 131;
      code.276 = code;
      code.875 = code.276;
      code.876 = code.875 + 1;
      code = code.876;
      *code.875 = 236;
      code.276 = code;
      *code.276 = 12;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25021>;
      <D.25016>:
      code.276 = code;
      code.877 = code.276;
      code.878 = code.877 + 1;
      code = code.878;
      *code.877 = 129;
      code.276 = code;
      code.879 = code.276;
      code.880 = code.879 + 1;
      code = code.880;
      *code.879 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 12;
            code.276 = code;
            code.881 = code.276;
            code.882 = code.881 + 1;
            code = code.882;
            D.25028 = imb.b[0];
            *code.881 = D.25028;
            code.276 = code;
            code.883 = code.276;
            code.884 = code.883 + 1;
            code = code.884;
            D.25031 = imb.b[1];
            *code.883 = D.25031;
            code.276 = code;
            code.885 = code.276;
            code.886 = code.885 + 1;
            code = code.886;
            D.25034 = imb.b[2];
            *code.885 = D.25034;
            code.276 = code;
            code.887 = code.276;
            code.888 = code.887 + 1;
            code = code.888;
            D.25037 = imb.b[3];
            *code.887 = D.25037;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25021>:
      <D.22633>:
      code.276 = code;
      code.889 = code.276;
      code.890 = code.889 + 1;
      code = code.890;
      *code.889 = 80;
      if (aot != 0) goto <D.25040>; else goto <D.25041>;
      <D.25040>:
      code.276 = code;
      buf.275 = buf;
      code.891 = mono_arch_emit_load_aotconst (buf.275, code.276, &ji, 32, "mono_thread_force_interruption_checkpoint");
      code = code.891;
      code.276 = code;
      code.892 = code.276;
      code.893 = code.892 + 1;
      code = code.893;
      *code.892 = 255;
      code.276 = code;
      code.894 = code.276;
      code.895 = code.894 + 1;
      code = code.895;
      *code.894 = 208;
      goto <D.25047>;
      <D.25041>:
      {
        int _x86_offset;

        mono_thread_force_interruption_checkpoint.896 = (int) mono_thread_force_interruption_checkpoint;
        code.276 = code;
        code.515 = (int) code.276;
        _x86_offset = mono_thread_force_interruption_checkpoint.896 - code.515;
        _x86_offset = _x86_offset + -5;
        code.276 = code;
        code.897 = code.276;
        code.898 = code.897 + 1;
        code = code.898;
        *code.897 = 232;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _x86_offset;
              code.276 = code;
              code.899 = code.276;
              code.900 = code.899 + 1;
              code = code.900;
              D.25053 = imb.b[0];
              *code.899 = D.25053;
              code.276 = code;
              code.901 = code.276;
              code.902 = code.901 + 1;
              code = code.902;
              D.25056 = imb.b[1];
              *code.901 = D.25056;
              code.276 = code;
              code.903 = code.276;
              code.904 = code.903 + 1;
              code = code.904;
              D.25059 = imb.b[2];
              *code.903 = D.25059;
              code.276 = code;
              code.905 = code.276;
              code.906 = code.905 + 1;
              code = code.906;
              D.25062 = imb.b[3];
              *code.905 = D.25062;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
      }
      <D.25047>:
      code.276 = code;
      code.907 = code.276;
      code.908 = code.907 + 1;
      code = code.908;
      *code.907 = 88;
      if (0 != 0) goto <D.25065>; else goto <D.25066>;
      <D.25065>:
      code.276 = code;
      code.909 = code.276;
      code.910 = code.909 + 1;
      code = code.910;
      *code.909 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 12;
            code.276 = code;
            code.911 = code.276;
            code.912 = code.911 + 1;
            code = code.912;
            D.25071 = imb.b[0];
            *code.911 = D.25071;
            code.276 = code;
            code.913 = code.276;
            code.914 = code.913 + 1;
            code = code.914;
            D.25074 = imb.b[1];
            *code.913 = D.25074;
            code.276 = code;
            code.915 = code.276;
            code.916 = code.915 + 1;
            code = code.916;
            D.25077 = imb.b[2];
            *code.915 = D.25077;
            code.276 = code;
            code.917 = code.276;
            code.918 = code.917 + 1;
            code = code.918;
            D.25080 = imb.b[3];
            *code.917 = D.25080;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22638>;
      <D.25066>:
      if (1 != 0) goto <D.25081>; else goto <D.25082>;
      <D.25081>:
      code.276 = code;
      code.919 = code.276;
      code.920 = code.919 + 1;
      code = code.920;
      *code.919 = 131;
      code.276 = code;
      code.921 = code.276;
      code.922 = code.921 + 1;
      code = code.922;
      *code.921 = 196;
      code.276 = code;
      *code.276 = 12;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25087>;
      <D.25082>:
      code.276 = code;
      code.923 = code.276;
      code.924 = code.923 + 1;
      code = code.924;
      *code.923 = 129;
      code.276 = code;
      code.925 = code.276;
      code.926 = code.925 + 1;
      code = code.926;
      *code.925 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 12;
            code.276 = code;
            code.927 = code.276;
            code.928 = code.927 + 1;
            code = code.928;
            D.25094 = imb.b[0];
            *code.927 = D.25094;
            code.276 = code;
            code.929 = code.276;
            code.930 = code.929 + 1;
            code = code.930;
            D.25097 = imb.b[1];
            *code.929 = D.25097;
            code.276 = code;
            code.931 = code.276;
            code.932 = code.931 + 1;
            code = code.932;
            D.25100 = imb.b[2];
            *code.931 = D.25100;
            code.276 = code;
            code.933 = code.276;
            code.934 = code.933 + 1;
            code = code.934;
            D.25103 = imb.b[3];
            *code.933 = D.25103;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25087>:
      <D.22638>:
      code.276 = code;
      code.935 = code.276;
      code.936 = code.935 + 1;
      code = code.936;
      *code.935 = 91;
      pushed_args = pushed_args + -1;
      if (0 != 0) goto <D.25106>; else goto <D.25107>;
      <D.25106>:
      code.276 = code;
      code.937 = code.276;
      code.938 = code.937 + 1;
      code = code.938;
      *code.937 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 1;
            code.276 = code;
            code.939 = code.276;
            code.940 = code.939 + 1;
            code = code.940;
            D.25112 = imb.b[0];
            *code.939 = D.25112;
            code.276 = code;
            code.941 = code.276;
            code.942 = code.941 + 1;
            code = code.942;
            D.25115 = imb.b[1];
            *code.941 = D.25115;
            code.276 = code;
            code.943 = code.276;
            code.944 = code.943 + 1;
            code = code.944;
            D.25118 = imb.b[2];
            *code.943 = D.25118;
            code.276 = code;
            code.945 = code.276;
            code.946 = code.945 + 1;
            code = code.946;
            D.25121 = imb.b[3];
            *code.945 = D.25121;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22641>;
      <D.25107>:
      if (1 != 0) goto <D.25122>; else goto <D.25123>;
      <D.25122>:
      code.276 = code;
      code.947 = code.276;
      code.948 = code.947 + 1;
      code = code.948;
      *code.947 = 131;
      code.276 = code;
      code.949 = code.276;
      code.950 = code.949 + 1;
      code = code.950;
      *code.949 = 235;
      code.276 = code;
      *code.276 = 1;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25128>;
      <D.25123>:
      code.276 = code;
      code.951 = code.276;
      code.952 = code.951 + 1;
      code = code.952;
      *code.951 = 129;
      code.276 = code;
      code.953 = code.276;
      code.954 = code.953 + 1;
      code = code.954;
      *code.953 = 235;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 1;
            code.276 = code;
            code.955 = code.276;
            code.956 = code.955 + 1;
            code = code.956;
            D.25135 = imb.b[0];
            *code.955 = D.25135;
            code.276 = code;
            code.957 = code.276;
            code.958 = code.957 + 1;
            code = code.958;
            D.25138 = imb.b[1];
            *code.957 = D.25138;
            code.276 = code;
            code.959 = code.276;
            code.960 = code.959 + 1;
            code = code.960;
            D.25141 = imb.b[2];
            *code.959 = D.25141;
            code.276 = code;
            code.961 = code.276;
            code.962 = code.961 + 1;
            code = code.962;
            D.25144 = imb.b[3];
            *code.961 = D.25144;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25128>:
      <D.22641>:
      code.276 = code;
      code.963 = code.276;
      code.964 = code.963 + 1;
      code = code.964;
      *code.963 = 95;
      pushed_args = pushed_args + -1;
      switch (4) <default: <D.22647>, case 1: <D.22643>, case 2: <D.22645>, case 4: <D.22646>>
      <D.22643>:
      code.276 = code;
      code.965 = code.276;
      code.966 = code.965 + 1;
      code = code.966;
      *code.965 = 136;
      goto <D.22644>;
      <D.22645>:
      code.276 = code;
      code.967 = code.276;
      code.968 = code.967 + 1;
      code = code.968;
      *code.967 = 102;
      <D.22646>:
      code.276 = code;
      code.969 = code.276;
      code.970 = code.969 + 1;
      code = code.970;
      *code.969 = 137;
      goto <D.22644>;
      <D.22647>:
      __assert_fail ("0", "tramp-x86.c", 471, &__PRETTY_FUNCTION__);
      <D.22644>:
      if (0 != 0) goto <D.25153>; else goto <D.25154>;
      <D.25153>:
      if (1 != 0) goto <D.25155>; else goto <D.25156>;
      <D.25155>:
      code.276 = code;
      code.971 = code.276;
      code.972 = code.971 + 1;
      code = code.972;
      *code.971 = 28;
      code.276 = code;
      code.973 = code.276;
      code.974 = code.973 + 1;
      code = code.974;
      *code.973 = 36;
      goto <D.25161>;
      <D.25156>:
      if (1 != 0) goto <D.25162>; else goto <D.25163>;
      <D.25162>:
      code.276 = code;
      code.975 = code.276;
      code.976 = code.975 + 1;
      code = code.976;
      *code.975 = 92;
      code.276 = code;
      code.977 = code.276;
      code.978 = code.977 + 1;
      code = code.978;
      *code.977 = 36;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25168>;
      <D.25163>:
      code.276 = code;
      code.979 = code.276;
      code.980 = code.979 + 1;
      code = code.980;
      *code.979 = 156;
      code.276 = code;
      code.981 = code.276;
      code.982 = code.981 + 1;
      code = code.982;
      *code.981 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.983 = code.276;
            code.984 = code.983 + 1;
            code = code.984;
            D.25175 = imb.b[0];
            *code.983 = D.25175;
            code.276 = code;
            code.985 = code.276;
            code.986 = code.985 + 1;
            code = code.986;
            D.25178 = imb.b[1];
            *code.985 = D.25178;
            code.276 = code;
            code.987 = code.276;
            code.988 = code.987 + 1;
            code = code.988;
            D.25181 = imb.b[2];
            *code.987 = D.25181;
            code.276 = code;
            code.989 = code.276;
            code.990 = code.989 + 1;
            code = code.990;
            D.25184 = imb.b[3];
            *code.989 = D.25184;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25168>:
      <D.25161>:
      goto <D.22649>;
      <D.25154>:
      if (1 != 0) goto <D.25185>; else goto <D.25186>;
      <D.25185>:
      code.276 = code;
      code.991 = code.276;
      code.992 = code.991 + 1;
      code = code.992;
      *code.991 = 31;
      goto <D.22649>;
      <D.25186>:
      if (1 != 0) goto <D.25189>; else goto <D.25190>;
      <D.25189>:
      code.276 = code;
      code.993 = code.276;
      code.994 = code.993 + 1;
      code = code.994;
      *code.993 = 95;
      code.276 = code;
      *code.276 = 0;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25193>;
      <D.25190>:
      code.276 = code;
      code.995 = code.276;
      code.996 = code.995 + 1;
      code = code.996;
      *code.995 = 159;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.276 = code;
            code.997 = code.276;
            code.998 = code.997 + 1;
            code = code.998;
            D.25198 = imb.b[0];
            *code.997 = D.25198;
            code.276 = code;
            code.999 = code.276;
            code.1000 = code.999 + 1;
            code = code.1000;
            D.25201 = imb.b[1];
            *code.999 = D.25201;
            code.276 = code;
            code.1001 = code.276;
            code.1002 = code.1001 + 1;
            code = code.1002;
            D.25204 = imb.b[2];
            *code.1001 = D.25204;
            code.276 = code;
            code.1003 = code.276;
            code.1004 = code.1003 + 1;
            code = code.1004;
            D.25207 = imb.b[3];
            *code.1003 = D.25207;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25193>:
      <D.22649>:
      code.276 = code;
      code.1005 = code.276;
      code.1006 = code.1005 + 1;
      code = code.1006;
      *code.1005 = 94;
      pushed_args = pushed_args + -1;
      code.276 = code;
      code.1007 = code.276;
      code.1008 = code.1007 + 1;
      code = code.1008;
      *code.1007 = 94;
      pushed_args = pushed_args + -1;
      code.276 = code;
      code.1009 = code.276;
      code.1010 = code.1009 + 1;
      code = code.1010;
      *code.1009 = 91;
      code.276 = code;
      code.1011 = code.276;
      code.1012 = code.1011 + 1;
      code = code.1012;
      *code.1011 = 95;
      code.276 = code;
      code.1013 = code.276;
      code.1014 = code.1013 + 1;
      code = code.1014;
      *code.1013 = 94;
      code.276 = code;
      code.1015 = code.276;
      code.1016 = code.1015 + 1;
      code = code.1016;
      *code.1015 = 93;
      pushed_args = pushed_args + -4;
      if (0 != 0) goto <D.25220>; else goto <D.25221>;
      <D.25220>:
      code.276 = code;
      code.1017 = code.276;
      code.1018 = code.1017 + 1;
      code = code.1018;
      *code.1017 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.276 = code;
            code.1019 = code.276;
            code.1020 = code.1019 + 1;
            code = code.1020;
            D.25226 = imb.b[0];
            *code.1019 = D.25226;
            code.276 = code;
            code.1021 = code.276;
            code.1022 = code.1021 + 1;
            code = code.1022;
            D.25229 = imb.b[1];
            *code.1021 = D.25229;
            code.276 = code;
            code.1023 = code.276;
            code.1024 = code.1023 + 1;
            code = code.1024;
            D.25232 = imb.b[2];
            *code.1023 = D.25232;
            code.276 = code;
            code.1025 = code.276;
            code.1026 = code.1025 + 1;
            code = code.1026;
            D.25235 = imb.b[3];
            *code.1025 = D.25235;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22652>;
      <D.25221>:
      if (1 != 0) goto <D.25236>; else goto <D.25237>;
      <D.25236>:
      code.276 = code;
      code.1027 = code.276;
      code.1028 = code.1027 + 1;
      code = code.1028;
      *code.1027 = 131;
      code.276 = code;
      code.1029 = code.276;
      code.1030 = code.1029 + 1;
      code = code.1030;
      *code.1029 = 196;
      code.276 = code;
      *code.276 = 4;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25242>;
      <D.25237>:
      code.276 = code;
      code.1031 = code.276;
      code.1032 = code.1031 + 1;
      code = code.1032;
      *code.1031 = 129;
      code.276 = code;
      code.1033 = code.276;
      code.1034 = code.1033 + 1;
      code = code.1034;
      *code.1033 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.276 = code;
            code.1035 = code.276;
            code.1036 = code.1035 + 1;
            code = code.1036;
            D.25249 = imb.b[0];
            *code.1035 = D.25249;
            code.276 = code;
            code.1037 = code.276;
            code.1038 = code.1037 + 1;
            code = code.1038;
            D.25252 = imb.b[1];
            *code.1037 = D.25252;
            code.276 = code;
            code.1039 = code.276;
            code.1040 = code.1039 + 1;
            code = code.1040;
            D.25255 = imb.b[2];
            *code.1039 = D.25255;
            code.276 = code;
            code.1041 = code.276;
            code.1042 = code.1041 + 1;
            code = code.1042;
            D.25258 = imb.b[3];
            *code.1041 = D.25258;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25242>:
      <D.22652>:
      pushed_args = pushed_args + -1;
      D.25259 = tramp_type + 4294967294;
      D.25260 = D.25259 > 1;
      D.25261 = tramp_type != 8;
      D.25262 = D.25260 & D.25261;
      if (D.25262 != 0) goto <D.25263>; else goto <D.25264>;
      <D.25263>:
      D.25265 = tramp_type != 4;
      D.25266 = tramp_type != 10;
      D.25267 = D.25265 & D.25266;
      if (D.25267 != 0) goto <D.25268>; else goto <D.25269>;
      <D.25268>:
      if (tramp_type != 11) goto <D.25270>; else goto <D.25271>;
      <D.25270>:
      switch (4) <default: <D.22658>, case 1: <D.22654>, case 2: <D.22656>, case 4: <D.22657>>
      <D.22654>:
      code.276 = code;
      code.1043 = code.276;
      code.1044 = code.1043 + 1;
      code = code.1044;
      *code.1043 = 136;
      goto <D.22655>;
      <D.22656>:
      code.276 = code;
      code.1045 = code.276;
      code.1046 = code.1045 + 1;
      code = code.1046;
      *code.1045 = 102;
      <D.22657>:
      code.276 = code;
      code.1047 = code.276;
      code.1048 = code.1047 + 1;
      code = code.1048;
      *code.1047 = 137;
      goto <D.22655>;
      <D.22658>:
      __assert_fail ("0", "tramp-x86.c", 500, &__PRETTY_FUNCTION__);
      <D.22655>:
      if (1 != 0) goto <D.25278>; else goto <D.25279>;
      <D.25278>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      if (D.24342 == 0) goto <D.25280>; else goto <D.25281>;
      <D.25280>:
      code.276 = code;
      code.1049 = code.276;
      code.1050 = code.1049 + 1;
      code = code.1050;
      *code.1049 = 4;
      code.276 = code;
      code.1051 = code.276;
      code.1052 = code.1051 + 1;
      code = code.1052;
      *code.1051 = 36;
      goto <D.25286>;
      <D.25281>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 >= -128) goto <D.25289>; else goto <D.25287>;
      <D.25289>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 <= 127) goto <D.25290>; else goto <D.25287>;
      <D.25290>:
      code.276 = code;
      code.1053 = code.276;
      code.1054 = code.1053 + 1;
      code = code.1054;
      *code.1053 = 68;
      code.276 = code;
      code.1055 = code.276;
      code.1056 = code.1055 + 1;
      code = code.1056;
      *code.1055 = 36;
      code.276 = code;
      D.24359 = (unsigned char) pushed_args;
      D.24360 = D.24359 * 4;
      *code.276 = D.24360;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25288>;
      <D.25287>:
      code.276 = code;
      code.1057 = code.276;
      code.1058 = code.1057 + 1;
      code = code.1058;
      *code.1057 = 132;
      code.276 = code;
      code.1059 = code.276;
      code.1060 = code.1059 + 1;
      code = code.1060;
      *code.1059 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            pushed_args.461 = (unsigned int) pushed_args;
            D.24342 = pushed_args.461 * 4;
            D.24352 = (int) D.24342;
            imb.val = D.24352;
            code.276 = code;
            code.1061 = code.276;
            code.1062 = code.1061 + 1;
            code = code.1062;
            D.25301 = imb.b[0];
            *code.1061 = D.25301;
            code.276 = code;
            code.1063 = code.276;
            code.1064 = code.1063 + 1;
            code = code.1064;
            D.25304 = imb.b[1];
            *code.1063 = D.25304;
            code.276 = code;
            code.1065 = code.276;
            code.1066 = code.1065 + 1;
            code = code.1066;
            D.25307 = imb.b[2];
            *code.1065 = D.25307;
            code.276 = code;
            code.1067 = code.276;
            code.1068 = code.1067 + 1;
            code = code.1068;
            D.25310 = imb.b[3];
            *code.1067 = D.25310;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25288>:
      <D.25286>:
      goto <D.22660>;
      <D.25279>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      if (D.24342 == 0) goto <D.25311>; else goto <D.25312>;
      <D.25311>:
      code.276 = code;
      code.1069 = code.276;
      code.1070 = code.1069 + 1;
      code = code.1070;
      *code.1069 = 4;
      goto <D.22660>;
      <D.25312>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 >= -128) goto <D.25317>; else goto <D.25315>;
      <D.25317>:
      pushed_args.461 = (unsigned int) pushed_args;
      D.24342 = pushed_args.461 * 4;
      D.24352 = (int) D.24342;
      if (D.24352 <= 127) goto <D.25318>; else goto <D.25315>;
      <D.25318>:
      code.276 = code;
      code.1071 = code.276;
      code.1072 = code.1071 + 1;
      code = code.1072;
      *code.1071 = 68;
      code.276 = code;
      D.24359 = (unsigned char) pushed_args;
      D.24360 = D.24359 * 4;
      *code.276 = D.24360;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25316>;
      <D.25315>:
      code.276 = code;
      code.1073 = code.276;
      code.1074 = code.1073 + 1;
      code = code.1074;
      *code.1073 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            pushed_args.461 = (unsigned int) pushed_args;
            D.24342 = pushed_args.461 * 4;
            D.24352 = (int) D.24342;
            imb.val = D.24352;
            code.276 = code;
            code.1075 = code.276;
            code.1076 = code.1075 + 1;
            code = code.1076;
            D.25325 = imb.b[0];
            *code.1075 = D.25325;
            code.276 = code;
            code.1077 = code.276;
            code.1078 = code.1077 + 1;
            code = code.1078;
            D.25328 = imb.b[1];
            *code.1077 = D.25328;
            code.276 = code;
            code.1079 = code.276;
            code.1080 = code.1079 + 1;
            code = code.1080;
            D.25331 = imb.b[2];
            *code.1079 = D.25331;
            code.276 = code;
            code.1081 = code.276;
            code.1082 = code.1081 + 1;
            code = code.1082;
            D.25334 = imb.b[3];
            *code.1081 = D.25334;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25316>:
      <D.22660>:
      <D.25271>:
      <D.25269>:
      <D.25264>:
      switch (4) <default: <D.22666>, case 1: <D.22662>, case 2: <D.22664>, case 4: <D.22665>>
      <D.22662>:
      code.276 = code;
      code.1083 = code.276;
      code.1084 = code.1083 + 1;
      code = code.1084;
      *code.1083 = 138;
      goto <D.22663>;
      <D.22664>:
      code.276 = code;
      code.1085 = code.276;
      code.1086 = code.1085 + 1;
      code = code.1086;
      *code.1085 = 102;
      <D.22665>:
      code.276 = code;
      code.1087 = code.276;
      code.1088 = code.1087 + 1;
      code = code.1088;
      *code.1087 = 139;
      goto <D.22663>;
      <D.22666>:
      __assert_fail ("0", "tramp-x86.c", 504, &__PRETTY_FUNCTION__);
      <D.22663>:
      if (1 != 0) goto <D.25341>; else goto <D.25342>;
      <D.25341>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      if (D.25343 == -1) goto <D.25344>; else goto <D.25345>;
      <D.25344>:
      code.276 = code;
      code.1089 = code.276;
      code.1090 = code.1089 + 1;
      code = code.1090;
      *code.1089 = 12;
      code.276 = code;
      code.1091 = code.276;
      code.1092 = code.1091 + 1;
      code = code.1092;
      *code.1091 = 36;
      goto <D.25350>;
      <D.25345>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25351 = D.25343 + 1;
      D.25352 = D.25351 * 4;
      D.25353 = (unsigned int) D.25352;
      D.25354 = D.25353 + 128;
      if (D.25354 <= 255) goto <D.25355>; else goto <D.25356>;
      <D.25355>:
      code.276 = code;
      code.1093 = code.276;
      code.1094 = code.1093 + 1;
      code = code.1094;
      *code.1093 = 76;
      code.276 = code;
      code.1095 = code.276;
      code.1096 = code.1095 + 1;
      code = code.1096;
      *code.1095 = 36;
      code.276 = code;
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25351 = D.25343 + 1;
      D.25361 = (unsigned char) D.25351;
      D.25362 = D.25361 * 4;
      *code.276 = D.25362;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25363>;
      <D.25356>:
      code.276 = code;
      code.1097 = code.276;
      code.1098 = code.1097 + 1;
      code = code.1098;
      *code.1097 = 140;
      code.276 = code;
      code.1099 = code.276;
      code.1100 = code.1099 + 1;
      code = code.1100;
      *code.1099 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.25343 = pushed_args - pushed_args_caller_saved;
            D.25351 = D.25343 + 1;
            D.25352 = D.25351 * 4;
            imb.val = D.25352;
            code.276 = code;
            code.1101 = code.276;
            code.1102 = code.1101 + 1;
            code = code.1102;
            D.25370 = imb.b[0];
            *code.1101 = D.25370;
            code.276 = code;
            code.1103 = code.276;
            code.1104 = code.1103 + 1;
            code = code.1104;
            D.25373 = imb.b[1];
            *code.1103 = D.25373;
            code.276 = code;
            code.1105 = code.276;
            code.1106 = code.1105 + 1;
            code = code.1106;
            D.25376 = imb.b[2];
            *code.1105 = D.25376;
            code.276 = code;
            code.1107 = code.276;
            code.1108 = code.1107 + 1;
            code = code.1108;
            D.25379 = imb.b[3];
            *code.1107 = D.25379;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25363>:
      <D.25350>:
      goto <D.22668>;
      <D.25342>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      if (D.25343 == -1) goto <D.25380>; else goto <D.25381>;
      <D.25380>:
      code.276 = code;
      code.1109 = code.276;
      code.1110 = code.1109 + 1;
      code = code.1110;
      *code.1109 = 12;
      goto <D.22668>;
      <D.25381>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25351 = D.25343 + 1;
      D.25352 = D.25351 * 4;
      D.25353 = (unsigned int) D.25352;
      D.25354 = D.25353 + 128;
      if (D.25354 <= 255) goto <D.25384>; else goto <D.25385>;
      <D.25384>:
      code.276 = code;
      code.1111 = code.276;
      code.1112 = code.1111 + 1;
      code = code.1112;
      *code.1111 = 76;
      code.276 = code;
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25351 = D.25343 + 1;
      D.25361 = (unsigned char) D.25351;
      D.25362 = D.25361 * 4;
      *code.276 = D.25362;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25388>;
      <D.25385>:
      code.276 = code;
      code.1113 = code.276;
      code.1114 = code.1113 + 1;
      code = code.1114;
      *code.1113 = 140;
      {
        union x86_imm_buf imb;

        try
          {
            D.25343 = pushed_args - pushed_args_caller_saved;
            D.25351 = D.25343 + 1;
            D.25352 = D.25351 * 4;
            imb.val = D.25352;
            code.276 = code;
            code.1115 = code.276;
            code.1116 = code.1115 + 1;
            code = code.1116;
            D.25393 = imb.b[0];
            *code.1115 = D.25393;
            code.276 = code;
            code.1117 = code.276;
            code.1118 = code.1117 + 1;
            code = code.1118;
            D.25396 = imb.b[1];
            *code.1117 = D.25396;
            code.276 = code;
            code.1119 = code.276;
            code.1120 = code.1119 + 1;
            code = code.1120;
            D.25399 = imb.b[2];
            *code.1119 = D.25399;
            code.276 = code;
            code.1121 = code.276;
            code.1122 = code.1121 + 1;
            code = code.1122;
            D.25402 = imb.b[3];
            *code.1121 = D.25402;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25388>:
      <D.22668>:
      switch (4) <default: <D.22674>, case 1: <D.22670>, case 2: <D.22672>, case 4: <D.22673>>
      <D.22670>:
      code.276 = code;
      code.1123 = code.276;
      code.1124 = code.1123 + 1;
      code = code.1124;
      *code.1123 = 138;
      goto <D.22671>;
      <D.22672>:
      code.276 = code;
      code.1125 = code.276;
      code.1126 = code.1125 + 1;
      code = code.1126;
      *code.1125 = 102;
      <D.22673>:
      code.276 = code;
      code.1127 = code.276;
      code.1128 = code.1127 + 1;
      code = code.1128;
      *code.1127 = 139;
      goto <D.22671>;
      <D.22674>:
      __assert_fail ("0", "tramp-x86.c", 505, &__PRETTY_FUNCTION__);
      <D.22671>:
      if (1 != 0) goto <D.25409>; else goto <D.25410>;
      <D.25409>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      if (D.25343 == -2) goto <D.25411>; else goto <D.25412>;
      <D.25411>:
      code.276 = code;
      code.1129 = code.276;
      code.1130 = code.1129 + 1;
      code = code.1130;
      *code.1129 = 20;
      code.276 = code;
      code.1131 = code.276;
      code.1132 = code.1131 + 1;
      code = code.1132;
      *code.1131 = 36;
      goto <D.25417>;
      <D.25412>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25418 = D.25343 + 2;
      D.25419 = D.25418 * 4;
      D.25420 = (unsigned int) D.25419;
      D.25421 = D.25420 + 128;
      if (D.25421 <= 255) goto <D.25422>; else goto <D.25423>;
      <D.25422>:
      code.276 = code;
      code.1133 = code.276;
      code.1134 = code.1133 + 1;
      code = code.1134;
      *code.1133 = 84;
      code.276 = code;
      code.1135 = code.276;
      code.1136 = code.1135 + 1;
      code = code.1136;
      *code.1135 = 36;
      code.276 = code;
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25418 = D.25343 + 2;
      D.25428 = (unsigned char) D.25418;
      D.25429 = D.25428 * 4;
      *code.276 = D.25429;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25430>;
      <D.25423>:
      code.276 = code;
      code.1137 = code.276;
      code.1138 = code.1137 + 1;
      code = code.1138;
      *code.1137 = 148;
      code.276 = code;
      code.1139 = code.276;
      code.1140 = code.1139 + 1;
      code = code.1140;
      *code.1139 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.25343 = pushed_args - pushed_args_caller_saved;
            D.25418 = D.25343 + 2;
            D.25419 = D.25418 * 4;
            imb.val = D.25419;
            code.276 = code;
            code.1141 = code.276;
            code.1142 = code.1141 + 1;
            code = code.1142;
            D.25437 = imb.b[0];
            *code.1141 = D.25437;
            code.276 = code;
            code.1143 = code.276;
            code.1144 = code.1143 + 1;
            code = code.1144;
            D.25440 = imb.b[1];
            *code.1143 = D.25440;
            code.276 = code;
            code.1145 = code.276;
            code.1146 = code.1145 + 1;
            code = code.1146;
            D.25443 = imb.b[2];
            *code.1145 = D.25443;
            code.276 = code;
            code.1147 = code.276;
            code.1148 = code.1147 + 1;
            code = code.1148;
            D.25446 = imb.b[3];
            *code.1147 = D.25446;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25430>:
      <D.25417>:
      goto <D.22676>;
      <D.25410>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      if (D.25343 == -2) goto <D.25447>; else goto <D.25448>;
      <D.25447>:
      code.276 = code;
      code.1149 = code.276;
      code.1150 = code.1149 + 1;
      code = code.1150;
      *code.1149 = 20;
      goto <D.22676>;
      <D.25448>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25418 = D.25343 + 2;
      D.25419 = D.25418 * 4;
      D.25420 = (unsigned int) D.25419;
      D.25421 = D.25420 + 128;
      if (D.25421 <= 255) goto <D.25451>; else goto <D.25452>;
      <D.25451>:
      code.276 = code;
      code.1151 = code.276;
      code.1152 = code.1151 + 1;
      code = code.1152;
      *code.1151 = 84;
      code.276 = code;
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25418 = D.25343 + 2;
      D.25428 = (unsigned char) D.25418;
      D.25429 = D.25428 * 4;
      *code.276 = D.25429;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25455>;
      <D.25452>:
      code.276 = code;
      code.1153 = code.276;
      code.1154 = code.1153 + 1;
      code = code.1154;
      *code.1153 = 148;
      {
        union x86_imm_buf imb;

        try
          {
            D.25343 = pushed_args - pushed_args_caller_saved;
            D.25418 = D.25343 + 2;
            D.25419 = D.25418 * 4;
            imb.val = D.25419;
            code.276 = code;
            code.1155 = code.276;
            code.1156 = code.1155 + 1;
            code = code.1156;
            D.25460 = imb.b[0];
            *code.1155 = D.25460;
            code.276 = code;
            code.1157 = code.276;
            code.1158 = code.1157 + 1;
            code = code.1158;
            D.25463 = imb.b[1];
            *code.1157 = D.25463;
            code.276 = code;
            code.1159 = code.276;
            code.1160 = code.1159 + 1;
            code = code.1160;
            D.25466 = imb.b[2];
            *code.1159 = D.25466;
            code.276 = code;
            code.1161 = code.276;
            code.1162 = code.1161 + 1;
            code = code.1162;
            D.25469 = imb.b[3];
            *code.1161 = D.25469;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25455>:
      <D.22676>:
      D.25470 = tramp_type == 8;
      D.25471 = tramp_type == 6;
      D.25472 = D.25470 | D.25471;
      if (D.25472 != 0) goto <D.25473>; else goto <D.25474>;
      <D.25473>:
      switch (4) <default: <D.22682>, case 1: <D.22678>, case 2: <D.22680>, case 4: <D.22681>>
      <D.22678>:
      code.276 = code;
      code.1163 = code.276;
      code.1164 = code.1163 + 1;
      code = code.1164;
      *code.1163 = 138;
      goto <D.22679>;
      <D.22680>:
      code.276 = code;
      code.1165 = code.276;
      code.1166 = code.1165 + 1;
      code = code.1166;
      *code.1165 = 102;
      <D.22681>:
      code.276 = code;
      code.1167 = code.276;
      code.1168 = code.1167 + 1;
      code = code.1168;
      *code.1167 = 139;
      goto <D.22679>;
      <D.22682>:
      __assert_fail ("0", "tramp-x86.c", 507, &__PRETTY_FUNCTION__);
      <D.22679>:
      if (1 != 0) goto <D.25481>; else goto <D.25482>;
      <D.25481>:
      if (pushed_args == pushed_args_caller_saved) goto <D.25483>; else goto <D.25484>;
      <D.25483>:
      code.276 = code;
      code.1169 = code.276;
      code.1170 = code.1169 + 1;
      code = code.1170;
      *code.1169 = 4;
      code.276 = code;
      code.1171 = code.276;
      code.1172 = code.1171 + 1;
      code = code.1172;
      *code.1171 = 36;
      goto <D.25489>;
      <D.25484>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25490 = D.25343 * 4;
      D.25491 = (unsigned int) D.25490;
      D.25492 = D.25491 + 128;
      if (D.25492 <= 255) goto <D.25493>; else goto <D.25494>;
      <D.25493>:
      code.276 = code;
      code.1173 = code.276;
      code.1174 = code.1173 + 1;
      code = code.1174;
      *code.1173 = 68;
      code.276 = code;
      code.1175 = code.276;
      code.1176 = code.1175 + 1;
      code = code.1176;
      *code.1175 = 36;
      code.276 = code;
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25499 = (unsigned char) D.25343;
      D.25500 = D.25499 * 4;
      *code.276 = D.25500;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25501>;
      <D.25494>:
      code.276 = code;
      code.1177 = code.276;
      code.1178 = code.1177 + 1;
      code = code.1178;
      *code.1177 = 132;
      code.276 = code;
      code.1179 = code.276;
      code.1180 = code.1179 + 1;
      code = code.1180;
      *code.1179 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.25343 = pushed_args - pushed_args_caller_saved;
            D.25490 = D.25343 * 4;
            imb.val = D.25490;
            code.276 = code;
            code.1181 = code.276;
            code.1182 = code.1181 + 1;
            code = code.1182;
            D.25508 = imb.b[0];
            *code.1181 = D.25508;
            code.276 = code;
            code.1183 = code.276;
            code.1184 = code.1183 + 1;
            code = code.1184;
            D.25511 = imb.b[1];
            *code.1183 = D.25511;
            code.276 = code;
            code.1185 = code.276;
            code.1186 = code.1185 + 1;
            code = code.1186;
            D.25514 = imb.b[2];
            *code.1185 = D.25514;
            code.276 = code;
            code.1187 = code.276;
            code.1188 = code.1187 + 1;
            code = code.1188;
            D.25517 = imb.b[3];
            *code.1187 = D.25517;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25501>:
      <D.25489>:
      goto <D.22684>;
      <D.25482>:
      if (pushed_args == pushed_args_caller_saved) goto <D.25518>; else goto <D.25519>;
      <D.25518>:
      code.276 = code;
      code.1189 = code.276;
      code.1190 = code.1189 + 1;
      code = code.1190;
      *code.1189 = 4;
      goto <D.22684>;
      <D.25519>:
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25490 = D.25343 * 4;
      D.25491 = (unsigned int) D.25490;
      D.25492 = D.25491 + 128;
      if (D.25492 <= 255) goto <D.25522>; else goto <D.25523>;
      <D.25522>:
      code.276 = code;
      code.1191 = code.276;
      code.1192 = code.1191 + 1;
      code = code.1192;
      *code.1191 = 68;
      code.276 = code;
      D.25343 = pushed_args - pushed_args_caller_saved;
      D.25499 = (unsigned char) D.25343;
      D.25500 = D.25499 * 4;
      *code.276 = D.25500;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25526>;
      <D.25523>:
      code.276 = code;
      code.1193 = code.276;
      code.1194 = code.1193 + 1;
      code = code.1194;
      *code.1193 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.25343 = pushed_args - pushed_args_caller_saved;
            D.25490 = D.25343 * 4;
            imb.val = D.25490;
            code.276 = code;
            code.1195 = code.276;
            code.1196 = code.1195 + 1;
            code = code.1196;
            D.25531 = imb.b[0];
            *code.1195 = D.25531;
            code.276 = code;
            code.1197 = code.276;
            code.1198 = code.1197 + 1;
            code = code.1198;
            D.25534 = imb.b[1];
            *code.1197 = D.25534;
            code.276 = code;
            code.1199 = code.276;
            code.1200 = code.1199 + 1;
            code = code.1200;
            D.25537 = imb.b[2];
            *code.1199 = D.25537;
            code.276 = code;
            code.1201 = code.276;
            code.1202 = code.1201 + 1;
            code = code.1202;
            D.25540 = imb.b[3];
            *code.1201 = D.25540;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25526>:
      <D.22684>:
      <D.25474>:
      D.25259 = tramp_type + 4294967294;
      D.25260 = D.25259 > 1;
      D.25261 = tramp_type != 8;
      D.25262 = D.25260 & D.25261;
      if (D.25262 != 0) goto <D.25543>; else goto <D.25541>;
      <D.25543>:
      D.25265 = tramp_type != 4;
      D.25266 = tramp_type != 10;
      D.25267 = D.25265 & D.25266;
      if (D.25267 != 0) goto <D.25544>; else goto <D.25541>;
      <D.25544>:
      if (tramp_type != 11) goto <D.25545>; else goto <D.25541>;
      <D.25545>:
      if (0 != 0) goto <D.25546>; else goto <D.25547>;
      <D.25546>:
      code.276 = code;
      code.1203 = code.276;
      code.1204 = code.1203 + 1;
      code = code.1204;
      *code.1203 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 36;
            code.276 = code;
            code.1205 = code.276;
            code.1206 = code.1205 + 1;
            code = code.1206;
            D.25552 = imb.b[0];
            *code.1205 = D.25552;
            code.276 = code;
            code.1207 = code.276;
            code.1208 = code.1207 + 1;
            code = code.1208;
            D.25555 = imb.b[1];
            *code.1207 = D.25555;
            code.276 = code;
            code.1209 = code.276;
            code.1210 = code.1209 + 1;
            code = code.1210;
            D.25558 = imb.b[2];
            *code.1209 = D.25558;
            code.276 = code;
            code.1211 = code.276;
            code.1212 = code.1211 + 1;
            code = code.1212;
            D.25561 = imb.b[3];
            *code.1211 = D.25561;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22687>;
      <D.25547>:
      if (1 != 0) goto <D.25562>; else goto <D.25563>;
      <D.25562>:
      code.276 = code;
      code.1213 = code.276;
      code.1214 = code.1213 + 1;
      code = code.1214;
      *code.1213 = 131;
      code.276 = code;
      code.1215 = code.276;
      code.1216 = code.1215 + 1;
      code = code.1216;
      *code.1215 = 196;
      code.276 = code;
      *code.276 = 36;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25568>;
      <D.25563>:
      code.276 = code;
      code.1217 = code.276;
      code.1218 = code.1217 + 1;
      code = code.1218;
      *code.1217 = 129;
      code.276 = code;
      code.1219 = code.276;
      code.1220 = code.1219 + 1;
      code = code.1220;
      *code.1219 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 36;
            code.276 = code;
            code.1221 = code.276;
            code.1222 = code.1221 + 1;
            code = code.1222;
            D.25575 = imb.b[0];
            *code.1221 = D.25575;
            code.276 = code;
            code.1223 = code.276;
            code.1224 = code.1223 + 1;
            code = code.1224;
            D.25578 = imb.b[1];
            *code.1223 = D.25578;
            code.276 = code;
            code.1225 = code.276;
            code.1226 = code.1225 + 1;
            code = code.1226;
            D.25581 = imb.b[2];
            *code.1225 = D.25581;
            code.276 = code;
            code.1227 = code.276;
            code.1228 = code.1227 + 1;
            code = code.1228;
            D.25584 = imb.b[3];
            *code.1227 = D.25584;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25568>:
      <D.22687>:
      pushed_args = pushed_args + -9;
      D.25585 = pushed_args != 0;
      D.25586 = (long int) D.25585;
      D.25587 = __builtin_expect (D.25586, 0);
      if (D.25587 != 0) goto <D.25588>; else goto <D.25589>;
      <D.25588>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 513, "pushed_args == 0");
      <D.25589>:
      goto <D.25542>;
      <D.25541>:
      if (0 != 0) goto <D.25590>; else goto <D.25591>;
      <D.25590>:
      code.276 = code;
      code.1229 = code.276;
      code.1230 = code.1229 + 1;
      code = code.1230;
      *code.1229 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.276 = code;
            code.1231 = code.276;
            code.1232 = code.1231 + 1;
            code = code.1232;
            D.25596 = imb.b[0];
            *code.1231 = D.25596;
            code.276 = code;
            code.1233 = code.276;
            code.1234 = code.1233 + 1;
            code = code.1234;
            D.25599 = imb.b[1];
            *code.1233 = D.25599;
            code.276 = code;
            code.1235 = code.276;
            code.1236 = code.1235 + 1;
            code = code.1236;
            D.25602 = imb.b[2];
            *code.1235 = D.25602;
            code.276 = code;
            code.1237 = code.276;
            code.1238 = code.1237 + 1;
            code = code.1238;
            D.25605 = imb.b[3];
            *code.1237 = D.25605;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22690>;
      <D.25591>:
      if (1 != 0) goto <D.25606>; else goto <D.25607>;
      <D.25606>:
      code.276 = code;
      code.1239 = code.276;
      code.1240 = code.1239 + 1;
      code = code.1240;
      *code.1239 = 131;
      code.276 = code;
      code.1241 = code.276;
      code.1242 = code.1241 + 1;
      code = code.1242;
      *code.1241 = 196;
      code.276 = code;
      *code.276 = 40;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25612>;
      <D.25607>:
      code.276 = code;
      code.1243 = code.276;
      code.1244 = code.1243 + 1;
      code = code.1244;
      *code.1243 = 129;
      code.276 = code;
      code.1245 = code.276;
      code.1246 = code.1245 + 1;
      code = code.1246;
      *code.1245 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.276 = code;
            code.1247 = code.276;
            code.1248 = code.1247 + 1;
            code = code.1248;
            D.25619 = imb.b[0];
            *code.1247 = D.25619;
            code.276 = code;
            code.1249 = code.276;
            code.1250 = code.1249 + 1;
            code = code.1250;
            D.25622 = imb.b[1];
            *code.1249 = D.25622;
            code.276 = code;
            code.1251 = code.276;
            code.1252 = code.1251 + 1;
            code = code.1252;
            D.25625 = imb.b[2];
            *code.1251 = D.25625;
            code.276 = code;
            code.1253 = code.276;
            code.1254 = code.1253 + 1;
            code = code.1254;
            D.25628 = imb.b[3];
            *code.1253 = D.25628;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25612>:
      <D.22690>:
      pushed_args = pushed_args + -10;
      D.25629 = pushed_args != -1;
      D.25630 = (long int) D.25629;
      D.25631 = __builtin_expect (D.25630, 0);
      if (D.25631 != 0) goto <D.25632>; else goto <D.25633>;
      <D.25632>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 521, "pushed_args == -1");
      <D.25633>:
      <D.25542>:
      if (tramp_type == 13) goto <D.25634>; else goto <D.25635>;
      <D.25634>:
      code.276 = code;
      code.1255 = code.276;
      code.1256 = code.1255 + 1;
      code = code.1256;
      *code.1255 = 88;
      if (0 != 0) goto <D.25638>; else goto <D.25639>;
      <D.25638>:
      code.276 = code;
      code.1257 = code.276;
      code.1258 = code.1257 + 1;
      code = code.1258;
      *code.1257 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.276 = code;
            code.1259 = code.276;
            code.1260 = code.1259 + 1;
            code = code.1260;
            D.25644 = imb.b[0];
            *code.1259 = D.25644;
            code.276 = code;
            code.1261 = code.276;
            code.1262 = code.1261 + 1;
            code = code.1262;
            D.25647 = imb.b[1];
            *code.1261 = D.25647;
            code.276 = code;
            code.1263 = code.276;
            code.1264 = code.1263 + 1;
            code = code.1264;
            D.25650 = imb.b[2];
            *code.1263 = D.25650;
            code.276 = code;
            code.1265 = code.276;
            code.1266 = code.1265 + 1;
            code = code.1266;
            D.25653 = imb.b[3];
            *code.1265 = D.25653;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22693>;
      <D.25639>:
      if (1 != 0) goto <D.25654>; else goto <D.25655>;
      <D.25654>:
      code.276 = code;
      code.1267 = code.276;
      code.1268 = code.1267 + 1;
      code = code.1268;
      *code.1267 = 131;
      code.276 = code;
      code.1269 = code.276;
      code.1270 = code.1269 + 1;
      code = code.1270;
      *code.1269 = 196;
      code.276 = code;
      *code.276 = 8;
      code.276 = code;
      code.307 = code.276 + 1;
      code = code.307;
      goto <D.25660>;
      <D.25655>:
      code.276 = code;
      code.1271 = code.276;
      code.1272 = code.1271 + 1;
      code = code.1272;
      *code.1271 = 129;
      code.276 = code;
      code.1273 = code.276;
      code.1274 = code.1273 + 1;
      code = code.1274;
      *code.1273 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.276 = code;
            code.1275 = code.276;
            code.1276 = code.1275 + 1;
            code = code.1276;
            D.25667 = imb.b[0];
            *code.1275 = D.25667;
            code.276 = code;
            code.1277 = code.276;
            code.1278 = code.1277 + 1;
            code = code.1278;
            D.25670 = imb.b[1];
            *code.1277 = D.25670;
            code.276 = code;
            code.1279 = code.276;
            code.1280 = code.1279 + 1;
            code = code.1280;
            D.25673 = imb.b[2];
            *code.1279 = D.25673;
            code.276 = code;
            code.1281 = code.276;
            code.1282 = code.1281 + 1;
            code = code.1282;
            D.25676 = imb.b[3];
            *code.1281 = D.25676;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25660>:
      <D.22693>:
      code.276 = code;
      code.1283 = code.276;
      code.1284 = code.1283 + 1;
      code = code.1284;
      *code.1283 = 255;
      code.276 = code;
      code.1285 = code.276;
      code.1286 = code.1285 + 1;
      code = code.1286;
      *code.1285 = 224;
      goto <D.25681>;
      <D.25635>:
      code.276 = code;
      code.1287 = code.276;
      code.1288 = code.1287 + 1;
      code = code.1288;
      *code.1287 = 195;
      <D.25681>:
      nacl_global_codeman_validate (&buf, 256, &code);
      code.276 = code;
      code.515 = (int) code.276;
      buf.275 = buf;
      buf.820 = (int) buf.275;
      D.24935 = code.515 - buf.820;
      D.25684 = D.24935 > 256;
      D.25685 = (long int) D.25684;
      D.25686 = __builtin_expect (D.25685, 0);
      if (D.25686 != 0) goto <D.25687>; else goto <D.25688>;
      <D.25687>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 534, "(code - buf) <= 256");
      <D.25688>:
      if (info != 0B) goto <D.25689>; else goto <D.25690>;
      <D.25689>:
      tramp_name = mono_get_generic_trampoline_name (tramp_type);
      ji.1289 = ji;
      code.276 = code;
      code.515 = (int) code.276;
      buf.275 = buf;
      buf.820 = (int) buf.275;
      D.24935 = code.515 - buf.820;
      D.25692 = (unsigned int) D.24935;
      buf.275 = buf;
      D.25693 = mono_tramp_info_create (tramp_name, buf.275, D.25692, ji.1289, unwind_ops);
      *info = D.25693;
      monoeg_g_free (tramp_name);
      <D.25690>:
      D.25694 = buf;
      return D.25694;
    }
  finally
    {
      buf = {CLOBBER};
      code = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_arch_get_nullified_class_init_trampoline (struct MonoTrampInfo * * info)
{
  void * buf.1290;
  guint8 * buf.1291;
  guint8 * code.1292;
  guint8 * code.1293;
  guint8 * code.1294;
  int code.1295;
  int buf.1296;
  int D.25704;
  unsigned int D.25707;
  struct MonoTrampInfo * D.25708;
  void * D.25709;
  guint8 * code;
  guint8 * buf;
  int tramp_size;

  try
    {
      tramp_size = 16;
      buf.1290 = mono_global_codeman_reserve (tramp_size);
      buf = buf.1290;
      buf.1291 = buf;
      code = buf.1291;
      code.1292 = code;
      code.1293 = code.1292;
      code.1294 = code.1293 + 1;
      code = code.1294;
      *code.1293 = 195;
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      code.1292 = code;
      code.1295 = (int) code.1292;
      buf.1291 = buf;
      buf.1296 = (int) buf.1291;
      D.25704 = code.1295 - buf.1296;
      buf.1291 = buf;
      mono_arch_flush_icache (buf.1291, D.25704);
      if (info != 0B) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      code.1292 = code;
      code.1295 = (int) code.1292;
      buf.1291 = buf;
      buf.1296 = (int) buf.1291;
      D.25704 = code.1295 - buf.1296;
      D.25707 = (unsigned int) D.25704;
      buf.1291 = buf;
      D.25708 = mono_tramp_info_create ("nullified_class_init_trampoline", buf.1291, D.25707, 0B, 0B);
      *info = D.25708;
      <D.25706>:
      D.25709 = buf;
      return D.25709;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
    }
}


mono_arch_create_specific_trampoline (void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  void * buf.1297;
  guint8 * buf.1298;
  unsigned int _imm.1299;
  unsigned int D.25715;
  guint8 * buf.1300;
  guint8 * buf.1301;
  unsigned char D.25720;
  guint8 * buf.1302;
  guint8 * buf.1303;
  guint8 * buf.1304;
  guint8 * buf.1305;
  guint8 * buf.1306;
  unsigned char D.25727;
  guint8 * buf.1307;
  guint8 * buf.1308;
  unsigned char D.25730;
  guint8 * buf.1309;
  guint8 * buf.1310;
  unsigned char D.25733;
  guint8 * buf.1311;
  guint8 * buf.1312;
  unsigned char D.25736;
  int tramp.1313;
  int buf.1314;
  int D.25739;
  unsigned int t.1315;
  unsigned int D.25741;
  guint8 * buf.1316;
  guint8 * buf.1317;
  unsigned char D.25746;
  guint8 * buf.1318;
  guint8 * buf.1319;
  guint8 * buf.1320;
  guint8 * buf.1321;
  unsigned char D.25752;
  guint8 * buf.1322;
  guint8 * buf.1323;
  unsigned char D.25755;
  guint8 * buf.1324;
  guint8 * buf.1325;
  unsigned char D.25758;
  guint8 * buf.1326;
  guint8 * buf.1327;
  unsigned char D.25761;
  guint8 * code.1328;
  int code.1329;
  int D.25764;
  _Bool D.25765;
  long int D.25766;
  long int D.25767;
  unsigned int D.25772;
  void * D.25773;
  guint8 * code;
  guint8 * buf;
  guint8 * tramp;

  try
    {
      tramp = mono_get_trampoline_code (tramp_type);
      buf.1297 = mono_domain_code_reserve_align (domain, 10, 4);
      buf = buf.1297;
      buf.1298 = buf;
      code = buf.1298;
      {
        int _imm;

        _imm = (int) arg1;
        _imm.1299 = (unsigned int) _imm;
        D.25715 = _imm.1299 + 128;
        if (D.25715 <= 255) goto <D.25716>; else goto <D.25717>;
        <D.25716>:
        buf.1298 = buf;
        buf.1300 = buf.1298;
        buf.1301 = buf.1300 + 1;
        buf = buf.1301;
        *buf.1300 = 106;
        buf.1298 = buf;
        D.25720 = (unsigned char) _imm;
        *buf.1298 = D.25720;
        buf.1298 = buf;
        buf.1302 = buf.1298 + 1;
        buf = buf.1302;
        goto <D.25722>;
        <D.25717>:
        buf.1298 = buf;
        buf.1303 = buf.1298;
        buf.1304 = buf.1303 + 1;
        buf = buf.1304;
        *buf.1303 = 104;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _imm;
              buf.1298 = buf;
              buf.1305 = buf.1298;
              buf.1306 = buf.1305 + 1;
              buf = buf.1306;
              D.25727 = imb.b[0];
              *buf.1305 = D.25727;
              buf.1298 = buf;
              buf.1307 = buf.1298;
              buf.1308 = buf.1307 + 1;
              buf = buf.1308;
              D.25730 = imb.b[1];
              *buf.1307 = D.25730;
              buf.1298 = buf;
              buf.1309 = buf.1298;
              buf.1310 = buf.1309 + 1;
              buf = buf.1310;
              D.25733 = imb.b[2];
              *buf.1309 = D.25733;
              buf.1298 = buf;
              buf.1311 = buf.1298;
              buf.1312 = buf.1311 + 1;
              buf = buf.1312;
              D.25736 = imb.b[3];
              *buf.1311 = D.25736;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.25722>:
      }
      {
        int t;

        tramp.1313 = (int) tramp;
        buf.1298 = buf;
        buf.1314 = (int) buf.1298;
        D.25739 = tramp.1313 - buf.1314;
        t = D.25739 + -2;
        t.1315 = (unsigned int) t;
        D.25741 = t.1315 + 128;
        if (D.25741 <= 255) goto <D.25742>; else goto <D.25743>;
        <D.25742>:
        buf.1298 = buf;
        buf.1316 = buf.1298;
        buf.1317 = buf.1316 + 1;
        buf = buf.1317;
        *buf.1316 = 235;
        buf.1298 = buf;
        D.25746 = (unsigned char) t;
        *buf.1298 = D.25746;
        buf.1298 = buf;
        buf.1302 = buf.1298 + 1;
        buf = buf.1302;
        goto <D.25747>;
        <D.25743>:
        tramp.1313 = (int) tramp;
        buf.1298 = buf;
        buf.1314 = (int) buf.1298;
        D.25739 = tramp.1313 - buf.1314;
        t = D.25739 + -5;
        buf.1298 = buf;
        buf.1318 = buf.1298;
        buf.1319 = buf.1318 + 1;
        buf = buf.1319;
        *buf.1318 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              buf.1298 = buf;
              buf.1320 = buf.1298;
              buf.1321 = buf.1320 + 1;
              buf = buf.1321;
              D.25752 = imb.b[0];
              *buf.1320 = D.25752;
              buf.1298 = buf;
              buf.1322 = buf.1298;
              buf.1323 = buf.1322 + 1;
              buf = buf.1323;
              D.25755 = imb.b[1];
              *buf.1322 = D.25755;
              buf.1298 = buf;
              buf.1324 = buf.1298;
              buf.1325 = buf.1324 + 1;
              buf = buf.1325;
              D.25758 = imb.b[2];
              *buf.1324 = D.25758;
              buf.1298 = buf;
              buf.1326 = buf.1298;
              buf.1327 = buf.1326 + 1;
              buf = buf.1327;
              D.25761 = imb.b[3];
              *buf.1326 = D.25761;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.25747>:
      }
      buf.1298 = buf;
      buf.1314 = (int) buf.1298;
      code.1328 = code;
      code.1329 = (int) code.1328;
      D.25764 = buf.1314 - code.1329;
      D.25765 = D.25764 > 10;
      D.25766 = (long int) D.25765;
      D.25767 = __builtin_expect (D.25766, 0);
      if (D.25767 != 0) goto <D.25768>; else goto <D.25769>;
      <D.25768>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 577, "(buf - code) <= TRAMPOLINE_SIZE");
      <D.25769>:
      nacl_domain_code_validate (domain, &code, 4, &buf);
      buf.1298 = buf;
      buf.1314 = (int) buf.1298;
      code.1328 = code;
      code.1329 = (int) code.1328;
      D.25764 = buf.1314 - code.1329;
      code.1328 = code;
      mono_arch_flush_icache (code.1328, D.25764);
      if (code_len != 0B) goto <D.25770>; else goto <D.25771>;
      <D.25770>:
      buf.1298 = buf;
      buf.1314 = (int) buf.1298;
      code.1328 = code;
      code.1329 = (int) code.1328;
      D.25764 = buf.1314 - code.1329;
      D.25772 = (unsigned int) D.25764;
      *code_len = D.25772;
      <D.25771>:
      D.25773 = code;
      return D.25773;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
    }
}


mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, struct MonoTrampInfo * * info, gboolean aot)
{
  signed int slot.1330;
  _Bool D.25777;
  int slot.1331;
  unsigned int index.1332;
  unsigned int D.25782;
  int D.25783;
  int D.25785;
  int iftmp.1333;
  int D.25790;
  void * buf.1334;
  guint8 * buf.1335;
  int D.25793;
  unsigned int D.25794;
  unsigned int D.25795;
  guint8 * code.1336;
  guint8 * code.1337;
  guint8 * code.1338;
  guint8 * code.1339;
  guint8 * code.1340;
  guint8 * code.1341;
  guint8 * code.1342;
  guint8 * code.1343;
  guint8 * code.1344;
  guint8 * code.1345;
  guint8 * code.1346;
  guint8 * code.1347;
  guint8 * code.1348;
  guint8 * code.1349;
  guint8 * code.1350;
  guint8 * code.1351;
  guint8 * code.1352;
  guint8 * code.1353;
  guint8 * code.1354;
  guint8 * code.1355;
  guint8 * code.1356;
  guint8 * code.1357;
  unsigned char D.25826;
  guint8 * code.1358;
  guint8 * code.1359;
  unsigned char D.25829;
  guint8 * code.1360;
  guint8 * code.1361;
  unsigned char D.25832;
  guint8 * code.1362;
  guint8 * code.1363;
  unsigned char D.25835;
  guint8 * code.1364;
  guint8 * code.1365;
  guint8 * code.1366;
  guint8 * code.1367;
  guint8 * code.1368;
  guint8 * code.1369;
  guint8 * code.1370;
  guint8 * code.1371;
  unsigned char D.25849;
  guint8 * code.1372;
  guint8 * code.1373;
  unsigned char D.25852;
  guint8 * code.1374;
  guint8 * code.1375;
  unsigned char D.25855;
  guint8 * code.1376;
  guint8 * code.1377;
  unsigned char D.25858;
  guint8 * code.1378;
  guint8 * code.1379;
  guint8 * code.1380;
  guint8 * code.1381;
  guint8 * code.1382;
  guint8 * code.1383;
  guint8 * code.1384;
  guint8 * code.1385;
  guint8 * code.1386;
  guint8 * code.1387;
  guint8 * code.1388;
  guint8 * code.1389;
  guint8 * code.1390;
  guint8 * code.1391;
  guint8 * code.1392;
  guint8 * code.1393;
  guint8 * code.1394;
  guint8 * code.1395;
  guint8 * code.1396;
  guint8 * code.1397;
  unsigned char D.25889;
  guint8 * code.1398;
  guint8 * code.1399;
  unsigned char D.25892;
  guint8 * code.1400;
  guint8 * code.1401;
  unsigned char D.25895;
  guint8 * code.1402;
  guint8 * code.1403;
  unsigned char D.25898;
  guint8 * code.1404;
  guint8 * code.1405;
  guint8 * code.1406;
  guint8 * code.1407;
  guint8 * code.1408;
  guint8 * code.1409;
  guint8 * code.1410;
  guint8 * code.1411;
  unsigned char D.25912;
  guint8 * code.1412;
  guint8 * code.1413;
  unsigned char D.25915;
  guint8 * code.1414;
  guint8 * code.1415;
  unsigned char D.25918;
  guint8 * code.1416;
  guint8 * code.1417;
  unsigned char D.25921;
  guint8 * code.1418;
  guint8 * code.1419;
  guint8 * code.1420;
  guint8 * code.1421;
  guint8 * code.1422;
  guint8 * code.1423;
  unsigned char D.25930;
  guint8 * code.1424;
  guint8 * code.1425;
  unsigned char D.25934;
  _Bool D.25935;
  _Bool D.25936;
  _Bool D.25937;
  guint8 * code.1426;
  guint8 * code.1427;
  guint8 * code.1428;
  guint8 * code.1429;
  guint8 * code.1430;
  guint8 * code.1431;
  guint8 * code.1432;
  guint8 * code.1433;
  guint8 * code.1434;
  guint8 * code.1435;
  guint8 * code.1436;
  guint8 * code.1437;
  guint8 * code.1438;
  guint8 * code.1439;
  guint8 * code.1440;
  guint8 * code.1441;
  guint8 * code.1442;
  guint8 * code.1443;
  guint8 * code.1444;
  guint8 * code.1445;
  unsigned char D.25968;
  guint8 * code.1446;
  guint8 * code.1447;
  unsigned char D.25971;
  guint8 * code.1448;
  guint8 * code.1449;
  unsigned char D.25974;
  guint8 * code.1450;
  guint8 * code.1451;
  unsigned char D.25977;
  guint8 * code.1452;
  guint8 * code.1453;
  guint8 * code.1454;
  guint8 * code.1455;
  guint8 * code.1456;
  guint8 * code.1457;
  guint8 * code.1458;
  guint8 * code.1459;
  unsigned char D.25991;
  guint8 * code.1460;
  guint8 * code.1461;
  unsigned char D.25994;
  guint8 * code.1462;
  guint8 * code.1463;
  unsigned char D.25997;
  guint8 * code.1464;
  guint8 * code.1465;
  unsigned char D.26000;
  guint8 * code.1466;
  guint8 * code.1467;
  guint8 * code.1468;
  guint8 * code.1469;
  guint8 * code.1470;
  guint8 * code.1471;
  guint8 * code.1472;
  guint8 * code.1473;
  guint8 * code.1474;
  guint8 * code.1475;
  guint8 * code.1476;
  guint8 * code.1477;
  guint8 * code.1478;
  guint8 * code.1479;
  guint8 * code.1480;
  guint8 * code.1481;
  guint8 * code.1482;
  guint8 * code.1483;
  guint8 * code.1484;
  guint8 * code.1485;
  unsigned char D.26030;
  guint8 * code.1486;
  guint8 * code.1487;
  unsigned char D.26033;
  guint8 * code.1488;
  guint8 * code.1489;
  unsigned char D.26036;
  guint8 * code.1490;
  guint8 * code.1491;
  unsigned char D.26039;
  guint8 * code.1492;
  guint8 * code.1493;
  guint8 * code.1494;
  guint8 * code.1495;
  guint8 * code.1496;
  guint8 * code.1497;
  guint8 * code.1498;
  guint8 * code.1499;
  unsigned char D.26053;
  guint8 * code.1500;
  guint8 * code.1501;
  unsigned char D.26056;
  guint8 * code.1502;
  guint8 * code.1503;
  unsigned char D.26059;
  guint8 * code.1504;
  guint8 * code.1505;
  unsigned char D.26062;
  guint8 * code.1506;
  guint8 * code.1507;
  guint8 * code.1508;
  guint8 * code.1509;
  sizetype i.1510;
  sizetype D.26068;
  sizetype D.26069;
  guint8 * * D.26070;
  guint8 * code.1511;
  guint8 * code.1512;
  guint8 * code.1513;
  guint8 * code.1514;
  guint8 * code.1515;
  guint8 * code.1516;
  guint8 * code.1517;
  guint8 * code.1518;
  guint8 * code.1519;
  guint8 * code.1520;
  int D.26086;
  unsigned int D.26087;
  unsigned int D.26088;
  guint8 * code.1521;
  guint8 * code.1522;
  guint8 * code.1523;
  guint8 * code.1524;
  int D.26098;
  guint8 * code.1525;
  guint8 * code.1526;
  guint8 * code.1527;
  guint8 * code.1528;
  unsigned char D.26105;
  unsigned char D.26106;
  guint8 * code.1529;
  guint8 * code.1530;
  guint8 * code.1531;
  guint8 * code.1532;
  guint8 * code.1533;
  guint8 * code.1534;
  unsigned char D.26113;
  guint8 * code.1535;
  guint8 * code.1536;
  unsigned char D.26116;
  guint8 * code.1537;
  guint8 * code.1538;
  unsigned char D.26119;
  guint8 * code.1539;
  guint8 * code.1540;
  unsigned char D.26122;
  guint8 * code.1541;
  guint8 * code.1542;
  guint8 * code.1543;
  guint8 * code.1544;
  guint8 * code.1545;
  guint8 * code.1546;
  guint8 * code.1547;
  guint8 * code.1548;
  unsigned char D.26137;
  guint8 * code.1549;
  guint8 * code.1550;
  unsigned char D.26140;
  guint8 * code.1551;
  guint8 * code.1552;
  unsigned char D.26143;
  guint8 * code.1553;
  guint8 * code.1554;
  unsigned char D.26146;
  guint8 * code.1555;
  guint8 * code.1556;
  guint8 * code.1557;
  guint8 * code.1558;
  sizetype depth.1559;
  sizetype D.26152;
  sizetype D.26153;
  guint8 * * D.26154;
  guint8 * code.1560;
  guint8 * code.1561;
  guint8 * code.1562;
  guint8 * code.1563;
  guint8 * code.1564;
  guint8 * code.1565;
  unsigned int i.1566;
  unsigned int D.26165;
  guint8 * * D.26166;
  guint8 * D.26167;
  unsigned char D.26168;
  int D.26169;
  unsigned char D.26170;
  unsigned char D.26171;
  int code.1567;
  int pos.1568;
  int D.26178;
  unsigned char * pos.1569;
  unsigned char D.26180;
  unsigned char * pos.1570;
  unsigned char D.26182;
  unsigned char * pos.1571;
  unsigned char D.26184;
  unsigned char * pos.1572;
  unsigned char D.26186;
  unsigned int disp.1573;
  unsigned int D.26189;
  unsigned char D.26192;
  unsigned char D.26193;
  int D.26195;
  guint8 * code.1574;
  guint8 * code.1575;
  guint8 * code.1576;
  guint8 * code.1577;
  guint8 * code.1578;
  guint8 * code.1579;
  guint8 * code.1580;
  guint8 * code.1581;
  guint8 * code.1582;
  guint8 * code.1583;
  guint8 * code.1584;
  guint8 * code.1585;
  guint8 * code.1586;
  guint8 * code.1587;
  guint8 * code.1588;
  guint8 * code.1589;
  guint8 * code.1590;
  guint8 * code.1591;
  guint8 * code.1592;
  guint8 * code.1593;
  unsigned char D.26224;
  guint8 * code.1594;
  guint8 * code.1595;
  unsigned char D.26227;
  guint8 * code.1596;
  guint8 * code.1597;
  unsigned char D.26230;
  guint8 * code.1598;
  guint8 * code.1599;
  unsigned char D.26233;
  guint8 * code.1600;
  guint8 * code.1601;
  guint8 * code.1602;
  guint8 * code.1603;
  guint8 * code.1604;
  guint8 * code.1605;
  guint8 * code.1606;
  guint8 * code.1607;
  unsigned char D.26247;
  guint8 * code.1608;
  guint8 * code.1609;
  unsigned char D.26250;
  guint8 * code.1610;
  guint8 * code.1611;
  unsigned char D.26253;
  guint8 * code.1612;
  guint8 * code.1613;
  unsigned char D.26256;
  gchar * D.26259;
  guint8 * code.1614;
  guint8 * code.1615;
  guint8 * code.1616;
  guint8 * code.1617;
  guint8 * code.1618;
  struct MonoDomain * D.26266;
  void * slot.1619;
  int tramp.1620;
  int D.26269;
  unsigned int t.1621;
  unsigned int D.26271;
  guint8 * code.1622;
  guint8 * code.1623;
  unsigned char D.26276;
  guint8 * code.1624;
  guint8 * code.1625;
  guint8 * code.1626;
  guint8 * code.1627;
  unsigned char D.26282;
  guint8 * code.1628;
  guint8 * code.1629;
  unsigned char D.26285;
  guint8 * code.1630;
  guint8 * code.1631;
  unsigned char D.26288;
  guint8 * code.1632;
  guint8 * code.1633;
  unsigned char D.26291;
  int buf.1634;
  int D.26293;
  _Bool D.26294;
  long int D.26295;
  long int D.26296;
  struct MonoJumpInfo * ji.1635;
  unsigned int D.26302;
  struct MonoTrampInfo * D.26303;
  void * D.26304;
  guint8 * tramp;
  guint8 * code;
  guint8 * buf;
  guint8 * * rgctx_null_jumps;
  int tramp_size;
  int depth;
  int index;
  int i;
  gboolean mrgctx;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  static const char __PRETTY_FUNCTION__[45] = "mono_arch_create_rgctx_lazy_fetch_trampoline";

  try
    {
      ji = 0B;
      unwind_ops = 0B;
      unwind_ops = mono_arch_get_cie_program ();
      slot.1330 = (signed int) slot;
      D.25777 = slot.1330 < 0;
      mrgctx = (gboolean) D.25777;
      slot.1331 = (int) slot;
      index = slot.1331 & 2147483647;
      if (mrgctx != 0) goto <D.25779>; else goto <D.25780>;
      <D.25779>:
      index.1332 = (unsigned int) index;
      D.25782 = index.1332 + 2;
      index = (int) D.25782;
      <D.25780>:
      depth = 0;
      <D.22732>:
      {
        int size;

        size = mono_class_rgctx_get_array_size (depth, mrgctx);
        D.25783 = size + -1;
        if (D.25783 > index) goto <D.22731>; else goto <D.25784>;
        <D.25784>:
        D.25785 = 1 - size;
        index = D.25785 + index;
      }
      depth = depth + 1;
      goto <D.22732>;
      <D.22731>:
      if (aot != 0) goto <D.25787>; else goto <D.25788>;
      <D.25787>:
      iftmp.1333 = 64;
      goto <D.25789>;
      <D.25788>:
      iftmp.1333 = 36;
      <D.25789>:
      D.25790 = depth * 6;
      tramp_size = iftmp.1333 + D.25790;
      buf.1334 = mono_global_codeman_reserve (tramp_size);
      buf = buf.1334;
      buf.1335 = buf;
      code = buf.1335;
      D.25793 = depth + 2;
      D.25794 = (unsigned int) D.25793;
      D.25795 = D.25794 * 4;
      rgctx_null_jumps = monoeg_malloc (D.25795);
      switch (4) <default: <D.22737>, case 1: <D.22733>, case 2: <D.22735>, case 4: <D.22736>>
      <D.22733>:
      code.1336 = code;
      code.1337 = code.1336;
      code.1338 = code.1337 + 1;
      code = code.1338;
      *code.1337 = 138;
      goto <D.22734>;
      <D.22735>:
      code.1336 = code;
      code.1339 = code.1336;
      code.1340 = code.1339 + 1;
      code = code.1340;
      *code.1339 = 102;
      <D.22736>:
      code.1336 = code;
      code.1341 = code.1336;
      code.1342 = code.1341 + 1;
      code = code.1342;
      *code.1341 = 139;
      goto <D.22734>;
      <D.22737>:
      __assert_fail ("0", "tramp-x86.c", 628, &__PRETTY_FUNCTION__);
      <D.22734>:
      if (1 != 0) goto <D.25803>; else goto <D.25804>;
      <D.25803>:
      if (0 != 0) goto <D.25805>; else goto <D.25806>;
      <D.25805>:
      code.1336 = code;
      code.1343 = code.1336;
      code.1344 = code.1343 + 1;
      code = code.1344;
      *code.1343 = 4;
      code.1336 = code;
      code.1345 = code.1336;
      code.1346 = code.1345 + 1;
      code = code.1346;
      *code.1345 = 36;
      goto <D.25811>;
      <D.25806>:
      if (1 != 0) goto <D.25812>; else goto <D.25813>;
      <D.25812>:
      code.1336 = code;
      code.1347 = code.1336;
      code.1348 = code.1347 + 1;
      code = code.1348;
      *code.1347 = 68;
      code.1336 = code;
      code.1349 = code.1336;
      code.1350 = code.1349 + 1;
      code = code.1350;
      *code.1349 = 36;
      code.1336 = code;
      *code.1336 = 4;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.25819>;
      <D.25813>:
      code.1336 = code;
      code.1352 = code.1336;
      code.1353 = code.1352 + 1;
      code = code.1353;
      *code.1352 = 132;
      code.1336 = code;
      code.1354 = code.1336;
      code.1355 = code.1354 + 1;
      code = code.1355;
      *code.1354 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1336 = code;
            code.1356 = code.1336;
            code.1357 = code.1356 + 1;
            code = code.1357;
            D.25826 = imb.b[0];
            *code.1356 = D.25826;
            code.1336 = code;
            code.1358 = code.1336;
            code.1359 = code.1358 + 1;
            code = code.1359;
            D.25829 = imb.b[1];
            *code.1358 = D.25829;
            code.1336 = code;
            code.1360 = code.1336;
            code.1361 = code.1360 + 1;
            code = code.1361;
            D.25832 = imb.b[2];
            *code.1360 = D.25832;
            code.1336 = code;
            code.1362 = code.1336;
            code.1363 = code.1362 + 1;
            code = code.1363;
            D.25835 = imb.b[3];
            *code.1362 = D.25835;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25819>:
      <D.25811>:
      goto <D.22740>;
      <D.25804>:
      if (0 != 0) goto <D.25836>; else goto <D.25837>;
      <D.25836>:
      code.1336 = code;
      code.1364 = code.1336;
      code.1365 = code.1364 + 1;
      code = code.1365;
      *code.1364 = 4;
      goto <D.22740>;
      <D.25837>:
      if (1 != 0) goto <D.25840>; else goto <D.25841>;
      <D.25840>:
      code.1336 = code;
      code.1366 = code.1336;
      code.1367 = code.1366 + 1;
      code = code.1367;
      *code.1366 = 68;
      code.1336 = code;
      *code.1336 = 4;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.25844>;
      <D.25841>:
      code.1336 = code;
      code.1368 = code.1336;
      code.1369 = code.1368 + 1;
      code = code.1369;
      *code.1368 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1336 = code;
            code.1370 = code.1336;
            code.1371 = code.1370 + 1;
            code = code.1371;
            D.25849 = imb.b[0];
            *code.1370 = D.25849;
            code.1336 = code;
            code.1372 = code.1336;
            code.1373 = code.1372 + 1;
            code = code.1373;
            D.25852 = imb.b[1];
            *code.1372 = D.25852;
            code.1336 = code;
            code.1374 = code.1336;
            code.1375 = code.1374 + 1;
            code = code.1375;
            D.25855 = imb.b[2];
            *code.1374 = D.25855;
            code.1336 = code;
            code.1376 = code.1336;
            code.1377 = code.1376 + 1;
            code = code.1377;
            D.25858 = imb.b[3];
            *code.1376 = D.25858;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25844>:
      <D.22740>:
      if (mrgctx == 0) goto <D.25859>; else goto <D.25860>;
      <D.25859>:
      switch (4) <default: <D.22746>, case 1: <D.22742>, case 2: <D.22744>, case 4: <D.22745>>
      <D.22742>:
      code.1336 = code;
      code.1378 = code.1336;
      code.1379 = code.1378 + 1;
      code = code.1379;
      *code.1378 = 138;
      goto <D.22743>;
      <D.22744>:
      code.1336 = code;
      code.1380 = code.1336;
      code.1381 = code.1380 + 1;
      code = code.1381;
      *code.1380 = 102;
      <D.22745>:
      code.1336 = code;
      code.1382 = code.1336;
      code.1383 = code.1382 + 1;
      code = code.1383;
      *code.1382 = 139;
      goto <D.22743>;
      <D.22746>:
      __assert_fail ("0", "tramp-x86.c", 631, &__PRETTY_FUNCTION__);
      <D.22743>:
      if (0 != 0) goto <D.25867>; else goto <D.25868>;
      <D.25867>:
      if (0 != 0) goto <D.25869>; else goto <D.25870>;
      <D.25869>:
      code.1336 = code;
      code.1384 = code.1336;
      code.1385 = code.1384 + 1;
      code = code.1385;
      *code.1384 = 4;
      code.1336 = code;
      code.1386 = code.1336;
      code.1387 = code.1386 + 1;
      code = code.1387;
      *code.1386 = 36;
      goto <D.25875>;
      <D.25870>:
      if (1 != 0) goto <D.25876>; else goto <D.25877>;
      <D.25876>:
      code.1336 = code;
      code.1388 = code.1336;
      code.1389 = code.1388 + 1;
      code = code.1389;
      *code.1388 = 68;
      code.1336 = code;
      code.1390 = code.1336;
      code.1391 = code.1390 + 1;
      code = code.1391;
      *code.1390 = 36;
      code.1336 = code;
      *code.1336 = 28;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.25882>;
      <D.25877>:
      code.1336 = code;
      code.1392 = code.1336;
      code.1393 = code.1392 + 1;
      code = code.1393;
      *code.1392 = 132;
      code.1336 = code;
      code.1394 = code.1336;
      code.1395 = code.1394 + 1;
      code = code.1395;
      *code.1394 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 28;
            code.1336 = code;
            code.1396 = code.1336;
            code.1397 = code.1396 + 1;
            code = code.1397;
            D.25889 = imb.b[0];
            *code.1396 = D.25889;
            code.1336 = code;
            code.1398 = code.1336;
            code.1399 = code.1398 + 1;
            code = code.1399;
            D.25892 = imb.b[1];
            *code.1398 = D.25892;
            code.1336 = code;
            code.1400 = code.1336;
            code.1401 = code.1400 + 1;
            code = code.1401;
            D.25895 = imb.b[2];
            *code.1400 = D.25895;
            code.1336 = code;
            code.1402 = code.1336;
            code.1403 = code.1402 + 1;
            code = code.1403;
            D.25898 = imb.b[3];
            *code.1402 = D.25898;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25882>:
      <D.25875>:
      goto <D.22748>;
      <D.25868>:
      if (0 != 0) goto <D.25899>; else goto <D.25900>;
      <D.25899>:
      code.1336 = code;
      code.1404 = code.1336;
      code.1405 = code.1404 + 1;
      code = code.1405;
      *code.1404 = 0;
      goto <D.22748>;
      <D.25900>:
      if (1 != 0) goto <D.25903>; else goto <D.25904>;
      <D.25903>:
      code.1336 = code;
      code.1406 = code.1336;
      code.1407 = code.1406 + 1;
      code = code.1407;
      *code.1406 = 64;
      code.1336 = code;
      *code.1336 = 28;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.25907>;
      <D.25904>:
      code.1336 = code;
      code.1408 = code.1336;
      code.1409 = code.1408 + 1;
      code = code.1409;
      *code.1408 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 28;
            code.1336 = code;
            code.1410 = code.1336;
            code.1411 = code.1410 + 1;
            code = code.1411;
            D.25912 = imb.b[0];
            *code.1410 = D.25912;
            code.1336 = code;
            code.1412 = code.1336;
            code.1413 = code.1412 + 1;
            code = code.1413;
            D.25915 = imb.b[1];
            *code.1412 = D.25915;
            code.1336 = code;
            code.1414 = code.1336;
            code.1415 = code.1414 + 1;
            code = code.1415;
            D.25918 = imb.b[2];
            *code.1414 = D.25918;
            code.1336 = code;
            code.1416 = code.1336;
            code.1417 = code.1416 + 1;
            code = code.1417;
            D.25921 = imb.b[3];
            *code.1416 = D.25921;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25907>:
      <D.22748>:
      code.1336 = code;
      code.1418 = code.1336;
      code.1419 = code.1418 + 1;
      code = code.1419;
      *code.1418 = 133;
      code.1336 = code;
      code.1420 = code.1336;
      code.1421 = code.1420 + 1;
      code = code.1421;
      *code.1420 = 192;
      code.1336 = code;
      *rgctx_null_jumps = code.1336;
      if (1 != 0) goto <D.25926>; else goto <D.25927>;
      <D.25926>:
      code.1336 = code;
      code.1422 = code.1336;
      code.1423 = code.1422 + 1;
      code = code.1423;
      D.25930 = 116;
      *code.1422 = D.25930;
      goto <D.25931>;
      <D.25927>:
      code.1336 = code;
      code.1424 = code.1336;
      code.1425 = code.1424 + 1;
      code = code.1425;
      D.25934 = 116;
      *code.1424 = D.25934;
      <D.25931>:
      code.1336 = code;
      *code.1336 = 255;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      <D.25860>:
      i = 0;
      goto <D.22767>;
      <D.22766>:
      D.25935 = mrgctx != 0;
      D.25936 = i == 0;
      D.25937 = D.25935 & D.25936;
      if (D.25937 != 0) goto <D.25938>; else goto <D.25939>;
      <D.25938>:
      switch (4) <default: <D.22754>, case 1: <D.22750>, case 2: <D.22752>, case 4: <D.22753>>
      <D.22750>:
      code.1336 = code;
      code.1426 = code.1336;
      code.1427 = code.1426 + 1;
      code = code.1427;
      *code.1426 = 138;
      goto <D.22751>;
      <D.22752>:
      code.1336 = code;
      code.1428 = code.1336;
      code.1429 = code.1428 + 1;
      code = code.1429;
      *code.1428 = 102;
      <D.22753>:
      code.1336 = code;
      code.1430 = code.1336;
      code.1431 = code.1430 + 1;
      code = code.1431;
      *code.1430 = 139;
      goto <D.22751>;
      <D.22754>:
      __assert_fail ("0", "tramp-x86.c", 642, &__PRETTY_FUNCTION__);
      <D.22751>:
      if (0 != 0) goto <D.25946>; else goto <D.25947>;
      <D.25946>:
      if (0 != 0) goto <D.25948>; else goto <D.25949>;
      <D.25948>:
      code.1336 = code;
      code.1432 = code.1336;
      code.1433 = code.1432 + 1;
      code = code.1433;
      *code.1432 = 4;
      code.1336 = code;
      code.1434 = code.1336;
      code.1435 = code.1434 + 1;
      code = code.1435;
      *code.1434 = 36;
      goto <D.25954>;
      <D.25949>:
      if (1 != 0) goto <D.25955>; else goto <D.25956>;
      <D.25955>:
      code.1336 = code;
      code.1436 = code.1336;
      code.1437 = code.1436 + 1;
      code = code.1437;
      *code.1436 = 68;
      code.1336 = code;
      code.1438 = code.1336;
      code.1439 = code.1438 + 1;
      code = code.1439;
      *code.1438 = 36;
      code.1336 = code;
      *code.1336 = 8;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.25961>;
      <D.25956>:
      code.1336 = code;
      code.1440 = code.1336;
      code.1441 = code.1440 + 1;
      code = code.1441;
      *code.1440 = 132;
      code.1336 = code;
      code.1442 = code.1336;
      code.1443 = code.1442 + 1;
      code = code.1443;
      *code.1442 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.1336 = code;
            code.1444 = code.1336;
            code.1445 = code.1444 + 1;
            code = code.1445;
            D.25968 = imb.b[0];
            *code.1444 = D.25968;
            code.1336 = code;
            code.1446 = code.1336;
            code.1447 = code.1446 + 1;
            code = code.1447;
            D.25971 = imb.b[1];
            *code.1446 = D.25971;
            code.1336 = code;
            code.1448 = code.1336;
            code.1449 = code.1448 + 1;
            code = code.1449;
            D.25974 = imb.b[2];
            *code.1448 = D.25974;
            code.1336 = code;
            code.1450 = code.1336;
            code.1451 = code.1450 + 1;
            code = code.1451;
            D.25977 = imb.b[3];
            *code.1450 = D.25977;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25961>:
      <D.25954>:
      goto <D.22756>;
      <D.25947>:
      if (0 != 0) goto <D.25978>; else goto <D.25979>;
      <D.25978>:
      code.1336 = code;
      code.1452 = code.1336;
      code.1453 = code.1452 + 1;
      code = code.1453;
      *code.1452 = 0;
      goto <D.22756>;
      <D.25979>:
      if (1 != 0) goto <D.25982>; else goto <D.25983>;
      <D.25982>:
      code.1336 = code;
      code.1454 = code.1336;
      code.1455 = code.1454 + 1;
      code = code.1455;
      *code.1454 = 64;
      code.1336 = code;
      *code.1336 = 8;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.25986>;
      <D.25983>:
      code.1336 = code;
      code.1456 = code.1336;
      code.1457 = code.1456 + 1;
      code = code.1457;
      *code.1456 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.1336 = code;
            code.1458 = code.1336;
            code.1459 = code.1458 + 1;
            code = code.1459;
            D.25991 = imb.b[0];
            *code.1458 = D.25991;
            code.1336 = code;
            code.1460 = code.1336;
            code.1461 = code.1460 + 1;
            code = code.1461;
            D.25994 = imb.b[1];
            *code.1460 = D.25994;
            code.1336 = code;
            code.1462 = code.1336;
            code.1463 = code.1462 + 1;
            code = code.1463;
            D.25997 = imb.b[2];
            *code.1462 = D.25997;
            code.1336 = code;
            code.1464 = code.1336;
            code.1465 = code.1464 + 1;
            code = code.1465;
            D.26000 = imb.b[3];
            *code.1464 = D.26000;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25986>:
      <D.22756>:
      goto <D.26001>;
      <D.25939>:
      switch (4) <default: <D.22762>, case 1: <D.22758>, case 2: <D.22760>, case 4: <D.22761>>
      <D.22758>:
      code.1336 = code;
      code.1466 = code.1336;
      code.1467 = code.1466 + 1;
      code = code.1467;
      *code.1466 = 138;
      goto <D.22759>;
      <D.22760>:
      code.1336 = code;
      code.1468 = code.1336;
      code.1469 = code.1468 + 1;
      code = code.1469;
      *code.1468 = 102;
      <D.22761>:
      code.1336 = code;
      code.1470 = code.1336;
      code.1471 = code.1470 + 1;
      code = code.1471;
      *code.1470 = 139;
      goto <D.22759>;
      <D.22762>:
      __assert_fail ("0", "tramp-x86.c", 644, &__PRETTY_FUNCTION__);
      <D.22759>:
      if (0 != 0) goto <D.26008>; else goto <D.26009>;
      <D.26008>:
      if (1 != 0) goto <D.26010>; else goto <D.26011>;
      <D.26010>:
      code.1336 = code;
      code.1472 = code.1336;
      code.1473 = code.1472 + 1;
      code = code.1473;
      *code.1472 = 4;
      code.1336 = code;
      code.1474 = code.1336;
      code.1475 = code.1474 + 1;
      code = code.1475;
      *code.1474 = 36;
      goto <D.26016>;
      <D.26011>:
      if (1 != 0) goto <D.26017>; else goto <D.26018>;
      <D.26017>:
      code.1336 = code;
      code.1476 = code.1336;
      code.1477 = code.1476 + 1;
      code = code.1477;
      *code.1476 = 68;
      code.1336 = code;
      code.1478 = code.1336;
      code.1479 = code.1478 + 1;
      code = code.1479;
      *code.1478 = 36;
      code.1336 = code;
      *code.1336 = 0;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.26023>;
      <D.26018>:
      code.1336 = code;
      code.1480 = code.1336;
      code.1481 = code.1480 + 1;
      code = code.1481;
      *code.1480 = 132;
      code.1336 = code;
      code.1482 = code.1336;
      code.1483 = code.1482 + 1;
      code = code.1483;
      *code.1482 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1336 = code;
            code.1484 = code.1336;
            code.1485 = code.1484 + 1;
            code = code.1485;
            D.26030 = imb.b[0];
            *code.1484 = D.26030;
            code.1336 = code;
            code.1486 = code.1336;
            code.1487 = code.1486 + 1;
            code = code.1487;
            D.26033 = imb.b[1];
            *code.1486 = D.26033;
            code.1336 = code;
            code.1488 = code.1336;
            code.1489 = code.1488 + 1;
            code = code.1489;
            D.26036 = imb.b[2];
            *code.1488 = D.26036;
            code.1336 = code;
            code.1490 = code.1336;
            code.1491 = code.1490 + 1;
            code = code.1491;
            D.26039 = imb.b[3];
            *code.1490 = D.26039;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26023>:
      <D.26016>:
      goto <D.22764>;
      <D.26009>:
      if (1 != 0) goto <D.26040>; else goto <D.26041>;
      <D.26040>:
      code.1336 = code;
      code.1492 = code.1336;
      code.1493 = code.1492 + 1;
      code = code.1493;
      *code.1492 = 0;
      goto <D.22764>;
      <D.26041>:
      if (1 != 0) goto <D.26044>; else goto <D.26045>;
      <D.26044>:
      code.1336 = code;
      code.1494 = code.1336;
      code.1495 = code.1494 + 1;
      code = code.1495;
      *code.1494 = 64;
      code.1336 = code;
      *code.1336 = 0;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.26048>;
      <D.26045>:
      code.1336 = code;
      code.1496 = code.1336;
      code.1497 = code.1496 + 1;
      code = code.1497;
      *code.1496 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1336 = code;
            code.1498 = code.1336;
            code.1499 = code.1498 + 1;
            code = code.1499;
            D.26053 = imb.b[0];
            *code.1498 = D.26053;
            code.1336 = code;
            code.1500 = code.1336;
            code.1501 = code.1500 + 1;
            code = code.1501;
            D.26056 = imb.b[1];
            *code.1500 = D.26056;
            code.1336 = code;
            code.1502 = code.1336;
            code.1503 = code.1502 + 1;
            code = code.1503;
            D.26059 = imb.b[2];
            *code.1502 = D.26059;
            code.1336 = code;
            code.1504 = code.1336;
            code.1505 = code.1504 + 1;
            code = code.1505;
            D.26062 = imb.b[3];
            *code.1504 = D.26062;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26048>:
      <D.22764>:
      <D.26001>:
      code.1336 = code;
      code.1506 = code.1336;
      code.1507 = code.1506 + 1;
      code = code.1507;
      *code.1506 = 133;
      code.1336 = code;
      code.1508 = code.1336;
      code.1509 = code.1508 + 1;
      code = code.1509;
      *code.1508 = 192;
      i.1510 = (sizetype) i;
      D.26068 = i.1510 + 1;
      D.26069 = D.26068 * 4;
      D.26070 = rgctx_null_jumps + D.26069;
      code.1336 = code;
      *D.26070 = code.1336;
      if (1 != 0) goto <D.26071>; else goto <D.26072>;
      <D.26071>:
      code.1336 = code;
      code.1511 = code.1336;
      code.1512 = code.1511 + 1;
      code = code.1512;
      D.25930 = 116;
      *code.1511 = D.25930;
      goto <D.26075>;
      <D.26072>:
      code.1336 = code;
      code.1513 = code.1336;
      code.1514 = code.1513 + 1;
      code = code.1514;
      D.25934 = 116;
      *code.1513 = D.25934;
      <D.26075>:
      code.1336 = code;
      *code.1336 = 255;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      i = i + 1;
      <D.22767>:
      if (i < depth) goto <D.22766>; else goto <D.22768>;
      <D.22768>:
      switch (4) <default: <D.22773>, case 1: <D.22769>, case 2: <D.22771>, case 4: <D.22772>>
      <D.22769>:
      code.1336 = code;
      code.1515 = code.1336;
      code.1516 = code.1515 + 1;
      code = code.1516;
      *code.1515 = 138;
      goto <D.22770>;
      <D.22771>:
      code.1336 = code;
      code.1517 = code.1336;
      code.1518 = code.1517 + 1;
      code = code.1518;
      *code.1517 = 102;
      <D.22772>:
      code.1336 = code;
      code.1519 = code.1336;
      code.1520 = code.1519 + 1;
      code = code.1520;
      *code.1519 = 139;
      goto <D.22770>;
      <D.22773>:
      __assert_fail ("0", "tramp-x86.c", 653, &__PRETTY_FUNCTION__);
      <D.22770>:
      if (0 != 0) goto <D.26084>; else goto <D.26085>;
      <D.26084>:
      D.26086 = index + 1;
      D.26087 = (unsigned int) D.26086;
      D.26088 = D.26087 * 4;
      if (D.26088 == 0) goto <D.26089>; else goto <D.26090>;
      <D.26089>:
      code.1336 = code;
      code.1521 = code.1336;
      code.1522 = code.1521 + 1;
      code = code.1522;
      *code.1521 = 4;
      code.1336 = code;
      code.1523 = code.1336;
      code.1524 = code.1523 + 1;
      code = code.1524;
      *code.1523 = 36;
      goto <D.26095>;
      <D.26090>:
      D.26086 = index + 1;
      D.26087 = (unsigned int) D.26086;
      D.26088 = D.26087 * 4;
      D.26098 = (int) D.26088;
      if (D.26098 >= -128) goto <D.26099>; else goto <D.26096>;
      <D.26099>:
      D.26086 = index + 1;
      D.26087 = (unsigned int) D.26086;
      D.26088 = D.26087 * 4;
      D.26098 = (int) D.26088;
      if (D.26098 <= 127) goto <D.26100>; else goto <D.26096>;
      <D.26100>:
      code.1336 = code;
      code.1525 = code.1336;
      code.1526 = code.1525 + 1;
      code = code.1526;
      *code.1525 = 68;
      code.1336 = code;
      code.1527 = code.1336;
      code.1528 = code.1527 + 1;
      code = code.1528;
      *code.1527 = 36;
      code.1336 = code;
      D.26086 = index + 1;
      D.26105 = (unsigned char) D.26086;
      D.26106 = D.26105 * 4;
      *code.1336 = D.26106;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.26097>;
      <D.26096>:
      code.1336 = code;
      code.1529 = code.1336;
      code.1530 = code.1529 + 1;
      code = code.1530;
      *code.1529 = 132;
      code.1336 = code;
      code.1531 = code.1336;
      code.1532 = code.1531 + 1;
      code = code.1532;
      *code.1531 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26086 = index + 1;
            D.26087 = (unsigned int) D.26086;
            D.26088 = D.26087 * 4;
            D.26098 = (int) D.26088;
            imb.val = D.26098;
            code.1336 = code;
            code.1533 = code.1336;
            code.1534 = code.1533 + 1;
            code = code.1534;
            D.26113 = imb.b[0];
            *code.1533 = D.26113;
            code.1336 = code;
            code.1535 = code.1336;
            code.1536 = code.1535 + 1;
            code = code.1536;
            D.26116 = imb.b[1];
            *code.1535 = D.26116;
            code.1336 = code;
            code.1537 = code.1336;
            code.1538 = code.1537 + 1;
            code = code.1538;
            D.26119 = imb.b[2];
            *code.1537 = D.26119;
            code.1336 = code;
            code.1539 = code.1336;
            code.1540 = code.1539 + 1;
            code = code.1540;
            D.26122 = imb.b[3];
            *code.1539 = D.26122;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26097>:
      <D.26095>:
      goto <D.22775>;
      <D.26085>:
      D.26086 = index + 1;
      D.26087 = (unsigned int) D.26086;
      D.26088 = D.26087 * 4;
      if (D.26088 == 0) goto <D.26123>; else goto <D.26124>;
      <D.26123>:
      code.1336 = code;
      code.1541 = code.1336;
      code.1542 = code.1541 + 1;
      code = code.1542;
      *code.1541 = 0;
      goto <D.22775>;
      <D.26124>:
      D.26086 = index + 1;
      D.26087 = (unsigned int) D.26086;
      D.26088 = D.26087 * 4;
      D.26098 = (int) D.26088;
      if (D.26098 >= -128) goto <D.26129>; else goto <D.26127>;
      <D.26129>:
      D.26086 = index + 1;
      D.26087 = (unsigned int) D.26086;
      D.26088 = D.26087 * 4;
      D.26098 = (int) D.26088;
      if (D.26098 <= 127) goto <D.26130>; else goto <D.26127>;
      <D.26130>:
      code.1336 = code;
      code.1543 = code.1336;
      code.1544 = code.1543 + 1;
      code = code.1544;
      *code.1543 = 64;
      code.1336 = code;
      D.26086 = index + 1;
      D.26105 = (unsigned char) D.26086;
      D.26106 = D.26105 * 4;
      *code.1336 = D.26106;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.26128>;
      <D.26127>:
      code.1336 = code;
      code.1545 = code.1336;
      code.1546 = code.1545 + 1;
      code = code.1546;
      *code.1545 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            D.26086 = index + 1;
            D.26087 = (unsigned int) D.26086;
            D.26088 = D.26087 * 4;
            D.26098 = (int) D.26088;
            imb.val = D.26098;
            code.1336 = code;
            code.1547 = code.1336;
            code.1548 = code.1547 + 1;
            code = code.1548;
            D.26137 = imb.b[0];
            *code.1547 = D.26137;
            code.1336 = code;
            code.1549 = code.1336;
            code.1550 = code.1549 + 1;
            code = code.1550;
            D.26140 = imb.b[1];
            *code.1549 = D.26140;
            code.1336 = code;
            code.1551 = code.1336;
            code.1552 = code.1551 + 1;
            code = code.1552;
            D.26143 = imb.b[2];
            *code.1551 = D.26143;
            code.1336 = code;
            code.1553 = code.1336;
            code.1554 = code.1553 + 1;
            code = code.1554;
            D.26146 = imb.b[3];
            *code.1553 = D.26146;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26128>:
      <D.22775>:
      code.1336 = code;
      code.1555 = code.1336;
      code.1556 = code.1555 + 1;
      code = code.1556;
      *code.1555 = 133;
      code.1336 = code;
      code.1557 = code.1336;
      code.1558 = code.1557 + 1;
      code = code.1558;
      *code.1557 = 192;
      depth.1559 = (sizetype) depth;
      D.26152 = depth.1559 + 1;
      D.26153 = D.26152 * 4;
      D.26154 = rgctx_null_jumps + D.26153;
      code.1336 = code;
      *D.26154 = code.1336;
      if (1 != 0) goto <D.26155>; else goto <D.26156>;
      <D.26155>:
      code.1336 = code;
      code.1560 = code.1336;
      code.1561 = code.1560 + 1;
      code = code.1561;
      D.25930 = 116;
      *code.1560 = D.25930;
      goto <D.26159>;
      <D.26156>:
      code.1336 = code;
      code.1562 = code.1336;
      code.1563 = code.1562 + 1;
      code = code.1563;
      D.25934 = 116;
      *code.1562 = D.25934;
      <D.26159>:
      code.1336 = code;
      *code.1336 = 255;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      code.1336 = code;
      code.1564 = code.1336;
      code.1565 = code.1564 + 1;
      code = code.1565;
      *code.1564 = 195;
      D.25935 = mrgctx != 0;
      i = (int) D.25935;
      goto <D.22807>;
      <D.22806>:
      {
        unsigned char * pos;
        int disp;
        int size;

        i.1566 = (unsigned int) i;
        D.26165 = i.1566 * 4;
        D.26166 = rgctx_null_jumps + D.26165;
        D.26167 = *D.26166;
        pos = D.26167 + 1;
        size = 0;
        i.1566 = (unsigned int) i;
        D.26165 = i.1566 * 4;
        D.26166 = rgctx_null_jumps + D.26165;
        D.26167 = *D.26166;
        D.26168 = MEM[(unsigned char *)D.26167];
        D.26169 = (int) D.26168;
        switch (D.26169) <default: <D.22804>, case 15: <D.22783>, case 112: <D.22788>, case 113: <D.22789>, case 114: <D.22790>, case 115: <D.22791>, case 116: <D.22792>, case 117: <D.22793>, case 118: <D.22794>, case 119: <D.22795>, case 120: <D.22796>, case 121: <D.22797>, case 122: <D.22798>, case 123: <D.22799>, case 124: <D.22800>, case 125: <D.22801>, case 126: <D.22802>, case 127: <D.22803>, case 224: <D.22784>, case 225: <D.22785>, case 226: <D.22786>, case 232: <D.22780>, case 233: <D.22781>, case 235: <D.22787>>
        <D.22780>:
        <D.22781>:
        size = size + 1;
        goto <D.22782>;
        <D.22783>:
        D.26170 = *pos;
        D.26171 = D.26170 + 144;
        if (D.26171 > 31) goto <D.26172>; else goto <D.26173>;
        <D.26172>:
        __assert_fail ("0", "tramp-x86.c", 663, &__PRETTY_FUNCTION__);
        <D.26173>:
        size = size + 1;
        pos = pos + 1;
        goto <D.22782>;
        <D.22784>:
        <D.22785>:
        <D.22786>:
        <D.22787>:
        <D.22788>:
        <D.22789>:
        <D.22790>:
        <D.22791>:
        <D.22792>:
        <D.22793>:
        <D.22794>:
        <D.22795>:
        <D.22796>:
        <D.22797>:
        <D.22798>:
        <D.22799>:
        <D.22800>:
        <D.22801>:
        <D.22802>:
        <D.22803>:
        goto <D.22782>;
        <D.22804>:
        __assert_fail ("0", "tramp-x86.c", 663, &__PRETTY_FUNCTION__);
        <D.22782>:
        code.1336 = code;
        code.1567 = (int) code.1336;
        pos.1568 = (int) pos;
        disp = code.1567 - pos.1568;
        if (size != 0) goto <D.26176>; else goto <D.26177>;
        <D.26176>:
        {
          union x86_imm_buf imb;

          try
            {
              D.26178 = disp + -4;
              imb.val = D.26178;
              pos.1569 = pos;
              pos = pos.1569 + 1;
              D.26180 = imb.b[0];
              *pos.1569 = D.26180;
              pos.1570 = pos;
              pos = pos.1570 + 1;
              D.26182 = imb.b[1];
              *pos.1570 = D.26182;
              pos.1571 = pos;
              pos = pos.1571 + 1;
              D.26184 = imb.b[2];
              *pos.1571 = D.26184;
              pos.1572 = pos;
              pos = pos.1572 + 1;
              D.26186 = imb.b[3];
              *pos.1572 = D.26186;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.26187>;
        <D.26177>:
        disp.1573 = (unsigned int) disp;
        D.26189 = disp.1573 + 127;
        if (D.26189 <= 255) goto <D.26190>; else goto <D.26191>;
        <D.26190>:
        D.26192 = (unsigned char) disp;
        D.26193 = D.26192 + 255;
        *pos = D.26193;
        pos = pos + 1;
        goto <D.26194>;
        <D.26191>:
        __assert_fail ("0", "tramp-x86.c", 663, &__PRETTY_FUNCTION__);
        <D.26194>:
        <D.26187>:
      }
      i = i + 1;
      <D.22807>:
      D.26195 = depth + 1;
      if (D.26195 >= i) goto <D.22806>; else goto <D.22808>;
      <D.22808>:
      monoeg_g_free (rgctx_null_jumps);
      switch (4) <default: <D.22813>, case 1: <D.22809>, case 2: <D.22811>, case 4: <D.22812>>
      <D.22809>:
      code.1336 = code;
      code.1574 = code.1336;
      code.1575 = code.1574 + 1;
      code = code.1575;
      *code.1574 = 138;
      goto <D.22810>;
      <D.22811>:
      code.1336 = code;
      code.1576 = code.1336;
      code.1577 = code.1576 + 1;
      code = code.1577;
      *code.1576 = 102;
      <D.22812>:
      code.1336 = code;
      code.1578 = code.1336;
      code.1579 = code.1578 + 1;
      code = code.1579;
      *code.1578 = 139;
      goto <D.22810>;
      <D.22813>:
      __assert_fail ("0", "tramp-x86.c", 667, &__PRETTY_FUNCTION__);
      <D.22810>:
      if (1 != 0) goto <D.26202>; else goto <D.26203>;
      <D.26202>:
      if (0 != 0) goto <D.26204>; else goto <D.26205>;
      <D.26204>:
      code.1336 = code;
      code.1580 = code.1336;
      code.1581 = code.1580 + 1;
      code = code.1581;
      *code.1580 = 20;
      code.1336 = code;
      code.1582 = code.1336;
      code.1583 = code.1582 + 1;
      code = code.1583;
      *code.1582 = 36;
      goto <D.26210>;
      <D.26205>:
      if (1 != 0) goto <D.26211>; else goto <D.26212>;
      <D.26211>:
      code.1336 = code;
      code.1584 = code.1336;
      code.1585 = code.1584 + 1;
      code = code.1585;
      *code.1584 = 84;
      code.1336 = code;
      code.1586 = code.1336;
      code.1587 = code.1586 + 1;
      code = code.1587;
      *code.1586 = 36;
      code.1336 = code;
      *code.1336 = 4;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.26217>;
      <D.26212>:
      code.1336 = code;
      code.1588 = code.1336;
      code.1589 = code.1588 + 1;
      code = code.1589;
      *code.1588 = 148;
      code.1336 = code;
      code.1590 = code.1336;
      code.1591 = code.1590 + 1;
      code = code.1591;
      *code.1590 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1336 = code;
            code.1592 = code.1336;
            code.1593 = code.1592 + 1;
            code = code.1593;
            D.26224 = imb.b[0];
            *code.1592 = D.26224;
            code.1336 = code;
            code.1594 = code.1336;
            code.1595 = code.1594 + 1;
            code = code.1595;
            D.26227 = imb.b[1];
            *code.1594 = D.26227;
            code.1336 = code;
            code.1596 = code.1336;
            code.1597 = code.1596 + 1;
            code = code.1597;
            D.26230 = imb.b[2];
            *code.1596 = D.26230;
            code.1336 = code;
            code.1598 = code.1336;
            code.1599 = code.1598 + 1;
            code = code.1599;
            D.26233 = imb.b[3];
            *code.1598 = D.26233;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26217>:
      <D.26210>:
      goto <D.22815>;
      <D.26203>:
      if (0 != 0) goto <D.26234>; else goto <D.26235>;
      <D.26234>:
      code.1336 = code;
      code.1600 = code.1336;
      code.1601 = code.1600 + 1;
      code = code.1601;
      *code.1600 = 20;
      goto <D.22815>;
      <D.26235>:
      if (1 != 0) goto <D.26238>; else goto <D.26239>;
      <D.26238>:
      code.1336 = code;
      code.1602 = code.1336;
      code.1603 = code.1602 + 1;
      code = code.1603;
      *code.1602 = 84;
      code.1336 = code;
      *code.1336 = 4;
      code.1336 = code;
      code.1351 = code.1336 + 1;
      code = code.1351;
      goto <D.26242>;
      <D.26239>:
      code.1336 = code;
      code.1604 = code.1336;
      code.1605 = code.1604 + 1;
      code = code.1605;
      *code.1604 = 148;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1336 = code;
            code.1606 = code.1336;
            code.1607 = code.1606 + 1;
            code = code.1607;
            D.26247 = imb.b[0];
            *code.1606 = D.26247;
            code.1336 = code;
            code.1608 = code.1336;
            code.1609 = code.1608 + 1;
            code = code.1609;
            D.26250 = imb.b[1];
            *code.1608 = D.26250;
            code.1336 = code;
            code.1610 = code.1336;
            code.1611 = code.1610 + 1;
            code = code.1611;
            D.26253 = imb.b[2];
            *code.1610 = D.26253;
            code.1336 = code;
            code.1612 = code.1336;
            code.1613 = code.1612 + 1;
            code = code.1613;
            D.26256 = imb.b[3];
            *code.1612 = D.26256;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26242>:
      <D.22815>:
      if (aot != 0) goto <D.26257>; else goto <D.26258>;
      <D.26257>:
      D.26259 = monoeg_g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot);
      code.1336 = code;
      buf.1335 = buf;
      code.1614 = mono_arch_emit_load_aotconst (buf.1335, code.1336, &ji, 32, D.26259);
      code = code.1614;
      code.1336 = code;
      code.1615 = code.1336;
      code.1616 = code.1615 + 1;
      code = code.1616;
      *code.1615 = 255;
      code.1336 = code;
      code.1617 = code.1336;
      code.1618 = code.1617 + 1;
      code = code.1618;
      *code.1617 = 224;
      goto <D.26265>;
      <D.26258>:
      D.26266 = mono_get_root_domain ();
      slot.1619 = (void *) slot;
      tramp = mono_arch_create_specific_trampoline (slot.1619, 4, D.26266, 0B);
      {
        int t;

        tramp.1620 = (int) tramp;
        code.1336 = code;
        code.1567 = (int) code.1336;
        D.26269 = tramp.1620 - code.1567;
        t = D.26269 + -2;
        t.1621 = (unsigned int) t;
        D.26271 = t.1621 + 128;
        if (D.26271 <= 255) goto <D.26272>; else goto <D.26273>;
        <D.26272>:
        code.1336 = code;
        code.1622 = code.1336;
        code.1623 = code.1622 + 1;
        code = code.1623;
        *code.1622 = 235;
        code.1336 = code;
        D.26276 = (unsigned char) t;
        *code.1336 = D.26276;
        code.1336 = code;
        code.1351 = code.1336 + 1;
        code = code.1351;
        goto <D.26277>;
        <D.26273>:
        tramp.1620 = (int) tramp;
        code.1336 = code;
        code.1567 = (int) code.1336;
        D.26269 = tramp.1620 - code.1567;
        t = D.26269 + -5;
        code.1336 = code;
        code.1624 = code.1336;
        code.1625 = code.1624 + 1;
        code = code.1625;
        *code.1624 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.1336 = code;
              code.1626 = code.1336;
              code.1627 = code.1626 + 1;
              code = code.1627;
              D.26282 = imb.b[0];
              *code.1626 = D.26282;
              code.1336 = code;
              code.1628 = code.1336;
              code.1629 = code.1628 + 1;
              code = code.1629;
              D.26285 = imb.b[1];
              *code.1628 = D.26285;
              code.1336 = code;
              code.1630 = code.1336;
              code.1631 = code.1630 + 1;
              code = code.1631;
              D.26288 = imb.b[2];
              *code.1630 = D.26288;
              code.1336 = code;
              code.1632 = code.1336;
              code.1633 = code.1632 + 1;
              code = code.1633;
              D.26291 = imb.b[3];
              *code.1632 = D.26291;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.26277>:
      }
      <D.26265>:
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      code.1336 = code;
      code.1567 = (int) code.1336;
      buf.1335 = buf;
      buf.1634 = (int) buf.1335;
      D.26293 = code.1567 - buf.1634;
      buf.1335 = buf;
      mono_arch_flush_icache (buf.1335, D.26293);
      code.1336 = code;
      code.1567 = (int) code.1336;
      buf.1335 = buf;
      buf.1634 = (int) buf.1335;
      D.26293 = code.1567 - buf.1634;
      D.26294 = D.26293 > tramp_size;
      D.26295 = (long int) D.26294;
      D.26296 = __builtin_expect (D.26295, 0);
      if (D.26296 != 0) goto <D.26297>; else goto <D.26298>;
      <D.26297>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 682, "code - buf <= tramp_size");
      <D.26298>:
      if (info != 0B) goto <D.26299>; else goto <D.26300>;
      <D.26299>:
      {
        char * name;

        slot.1331 = (int) slot;
        name = mono_get_rgctx_fetch_trampoline_name (slot.1331);
        ji.1635 = ji;
        code.1336 = code;
        code.1567 = (int) code.1336;
        buf.1335 = buf;
        buf.1634 = (int) buf.1335;
        D.26293 = code.1567 - buf.1634;
        D.26302 = (unsigned int) D.26293;
        buf.1335 = buf;
        D.26303 = mono_tramp_info_create (name, buf.1335, D.26302, ji.1635, unwind_ops);
        *info = D.26303;
        monoeg_g_free (name);
      }
      <D.26300>:
      D.26304 = buf;
      return D.26304;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_arch_create_general_rgctx_lazy_fetch_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  _Bool D.26308;
  long int D.26309;
  long int D.26310;
  void * buf.1636;
  guint8 * buf.1637;
  guint8 * code.1638;
  guint8 * code.1639;
  guint8 * code.1640;
  guint8 * code.1641;
  guint8 * code.1642;
  guint8 * code.1643;
  guint8 * code.1644;
  guint8 * code.1645;
  guint8 * code.1646;
  guint8 * code.1647;
  guint8 * code.1648;
  guint8 * code.1649;
  guint8 * code.1650;
  guint8 * code.1651;
  guint8 * code.1652;
  guint8 * code.1653;
  guint8 * code.1654;
  guint8 * code.1655;
  guint8 * code.1656;
  guint8 * code.1657;
  guint8 * code.1658;
  guint8 * code.1659;
  unsigned char D.26345;
  guint8 * code.1660;
  guint8 * code.1661;
  unsigned char D.26348;
  guint8 * code.1662;
  guint8 * code.1663;
  unsigned char D.26351;
  guint8 * code.1664;
  guint8 * code.1665;
  unsigned char D.26354;
  guint8 * code.1666;
  guint8 * code.1667;
  guint8 * code.1668;
  guint8 * code.1669;
  guint8 * code.1670;
  guint8 * code.1671;
  guint8 * code.1672;
  guint8 * code.1673;
  unsigned char D.26368;
  guint8 * code.1674;
  guint8 * code.1675;
  unsigned char D.26371;
  guint8 * code.1676;
  guint8 * code.1677;
  unsigned char D.26374;
  guint8 * code.1678;
  guint8 * code.1679;
  unsigned char D.26377;
  guint8 * code.1680;
  guint8 * code.1681;
  guint8 * code.1682;
  guint8 * code.1683;
  guint8 * code.1684;
  guint8 * code.1685;
  guint8 * code.1686;
  guint8 * code.1687;
  guint8 * code.1688;
  guint8 * code.1689;
  guint8 * code.1690;
  guint8 * code.1691;
  guint8 * code.1692;
  guint8 * code.1693;
  guint8 * code.1694;
  guint8 * code.1695;
  guint8 * code.1696;
  guint8 * code.1697;
  guint8 * code.1698;
  guint8 * code.1699;
  unsigned char D.26406;
  guint8 * code.1700;
  guint8 * code.1701;
  unsigned char D.26409;
  guint8 * code.1702;
  guint8 * code.1703;
  unsigned char D.26412;
  guint8 * code.1704;
  guint8 * code.1705;
  unsigned char D.26415;
  guint8 * code.1706;
  guint8 * code.1707;
  guint8 * code.1708;
  guint8 * code.1709;
  guint8 * code.1710;
  guint8 * code.1711;
  guint8 * code.1712;
  guint8 * code.1713;
  unsigned char D.26429;
  guint8 * code.1714;
  guint8 * code.1715;
  unsigned char D.26432;
  guint8 * code.1716;
  guint8 * code.1717;
  unsigned char D.26435;
  guint8 * code.1718;
  guint8 * code.1719;
  unsigned char D.26438;
  guint8 * code.1720;
  guint8 * code.1721;
  guint8 * code.1722;
  guint8 * code.1723;
  int code.1724;
  int buf.1725;
  int D.26445;
  _Bool D.26446;
  long int D.26447;
  long int D.26448;
  unsigned int D.26453;
  struct MonoTrampInfo * D.26454;
  void * D.26455;
  guint8 * code;
  guint8 * buf;
  int tramp_size;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  static const char __PRETTY_FUNCTION__[53] = "mono_arch_create_general_rgctx_lazy_fetch_trampoline";

  try
    {
      ji = 0B;
      unwind_ops = 0B;
      D.26308 = aot == 0;
      D.26309 = (long int) D.26308;
      D.26310 = __builtin_expect (D.26309, 0);
      if (D.26310 != 0) goto <D.26311>; else goto <D.26312>;
      <D.26311>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 707, "aot");
      <D.26312>:
      unwind_ops = mono_arch_get_cie_program ();
      tramp_size = 64;
      buf.1636 = mono_global_codeman_reserve (tramp_size);
      buf = buf.1636;
      buf.1637 = buf;
      code = buf.1637;
      switch (4) <default: <D.22833>, case 1: <D.22829>, case 2: <D.22831>, case 4: <D.22832>>
      <D.22829>:
      code.1638 = code;
      code.1639 = code.1638;
      code.1640 = code.1639 + 1;
      code = code.1640;
      *code.1639 = 138;
      goto <D.22830>;
      <D.22831>:
      code.1638 = code;
      code.1641 = code.1638;
      code.1642 = code.1641 + 1;
      code = code.1642;
      *code.1641 = 102;
      <D.22832>:
      code.1638 = code;
      code.1643 = code.1638;
      code.1644 = code.1643 + 1;
      code = code.1644;
      *code.1643 = 139;
      goto <D.22830>;
      <D.22833>:
      __assert_fail ("0", "tramp-x86.c", 718, &__PRETTY_FUNCTION__);
      <D.22830>:
      if (0 != 0) goto <D.26322>; else goto <D.26323>;
      <D.26322>:
      if (0 != 0) goto <D.26324>; else goto <D.26325>;
      <D.26324>:
      code.1638 = code;
      code.1645 = code.1638;
      code.1646 = code.1645 + 1;
      code = code.1646;
      *code.1645 = 4;
      code.1638 = code;
      code.1647 = code.1638;
      code.1648 = code.1647 + 1;
      code = code.1648;
      *code.1647 = 36;
      goto <D.26330>;
      <D.26325>:
      if (1 != 0) goto <D.26331>; else goto <D.26332>;
      <D.26331>:
      code.1638 = code;
      code.1649 = code.1638;
      code.1650 = code.1649 + 1;
      code = code.1650;
      *code.1649 = 68;
      code.1638 = code;
      code.1651 = code.1638;
      code.1652 = code.1651 + 1;
      code = code.1652;
      *code.1651 = 36;
      code.1638 = code;
      *code.1638 = 4;
      code.1638 = code;
      code.1653 = code.1638 + 1;
      code = code.1653;
      goto <D.26338>;
      <D.26332>:
      code.1638 = code;
      code.1654 = code.1638;
      code.1655 = code.1654 + 1;
      code = code.1655;
      *code.1654 = 132;
      code.1638 = code;
      code.1656 = code.1638;
      code.1657 = code.1656 + 1;
      code = code.1657;
      *code.1656 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1638 = code;
            code.1658 = code.1638;
            code.1659 = code.1658 + 1;
            code = code.1659;
            D.26345 = imb.b[0];
            *code.1658 = D.26345;
            code.1638 = code;
            code.1660 = code.1638;
            code.1661 = code.1660 + 1;
            code = code.1661;
            D.26348 = imb.b[1];
            *code.1660 = D.26348;
            code.1638 = code;
            code.1662 = code.1638;
            code.1663 = code.1662 + 1;
            code = code.1663;
            D.26351 = imb.b[2];
            *code.1662 = D.26351;
            code.1638 = code;
            code.1664 = code.1638;
            code.1665 = code.1664 + 1;
            code = code.1665;
            D.26354 = imb.b[3];
            *code.1664 = D.26354;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26338>:
      <D.26330>:
      goto <D.22836>;
      <D.26323>:
      if (0 != 0) goto <D.26355>; else goto <D.26356>;
      <D.26355>:
      code.1638 = code;
      code.1666 = code.1638;
      code.1667 = code.1666 + 1;
      code = code.1667;
      *code.1666 = 2;
      goto <D.22836>;
      <D.26356>:
      if (1 != 0) goto <D.26359>; else goto <D.26360>;
      <D.26359>:
      code.1638 = code;
      code.1668 = code.1638;
      code.1669 = code.1668 + 1;
      code = code.1669;
      *code.1668 = 66;
      code.1638 = code;
      *code.1638 = 4;
      code.1638 = code;
      code.1653 = code.1638 + 1;
      code = code.1653;
      goto <D.26363>;
      <D.26360>:
      code.1638 = code;
      code.1670 = code.1638;
      code.1671 = code.1670 + 1;
      code = code.1671;
      *code.1670 = 130;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1638 = code;
            code.1672 = code.1638;
            code.1673 = code.1672 + 1;
            code = code.1673;
            D.26368 = imb.b[0];
            *code.1672 = D.26368;
            code.1638 = code;
            code.1674 = code.1638;
            code.1675 = code.1674 + 1;
            code = code.1675;
            D.26371 = imb.b[1];
            *code.1674 = D.26371;
            code.1638 = code;
            code.1676 = code.1638;
            code.1677 = code.1676 + 1;
            code = code.1677;
            D.26374 = imb.b[2];
            *code.1676 = D.26374;
            code.1638 = code;
            code.1678 = code.1638;
            code.1679 = code.1678 + 1;
            code = code.1679;
            D.26377 = imb.b[3];
            *code.1678 = D.26377;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26363>:
      <D.22836>:
      switch (4) <default: <D.22842>, case 1: <D.22838>, case 2: <D.22840>, case 4: <D.22841>>
      <D.22838>:
      code.1638 = code;
      code.1680 = code.1638;
      code.1681 = code.1680 + 1;
      code = code.1681;
      *code.1680 = 138;
      goto <D.22839>;
      <D.22840>:
      code.1638 = code;
      code.1682 = code.1638;
      code.1683 = code.1682 + 1;
      code = code.1683;
      *code.1682 = 102;
      <D.22841>:
      code.1638 = code;
      code.1684 = code.1638;
      code.1685 = code.1684 + 1;
      code = code.1685;
      *code.1684 = 139;
      goto <D.22839>;
      <D.22842>:
      __assert_fail ("0", "tramp-x86.c", 720, &__PRETTY_FUNCTION__);
      <D.22839>:
      if (1 != 0) goto <D.26384>; else goto <D.26385>;
      <D.26384>:
      if (0 != 0) goto <D.26386>; else goto <D.26387>;
      <D.26386>:
      code.1638 = code;
      code.1686 = code.1638;
      code.1687 = code.1686 + 1;
      code = code.1687;
      *code.1686 = 20;
      code.1638 = code;
      code.1688 = code.1638;
      code.1689 = code.1688 + 1;
      code = code.1689;
      *code.1688 = 36;
      goto <D.26392>;
      <D.26387>:
      if (1 != 0) goto <D.26393>; else goto <D.26394>;
      <D.26393>:
      code.1638 = code;
      code.1690 = code.1638;
      code.1691 = code.1690 + 1;
      code = code.1691;
      *code.1690 = 84;
      code.1638 = code;
      code.1692 = code.1638;
      code.1693 = code.1692 + 1;
      code = code.1693;
      *code.1692 = 36;
      code.1638 = code;
      *code.1638 = 4;
      code.1638 = code;
      code.1653 = code.1638 + 1;
      code = code.1653;
      goto <D.26399>;
      <D.26394>:
      code.1638 = code;
      code.1694 = code.1638;
      code.1695 = code.1694 + 1;
      code = code.1695;
      *code.1694 = 148;
      code.1638 = code;
      code.1696 = code.1638;
      code.1697 = code.1696 + 1;
      code = code.1697;
      *code.1696 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1638 = code;
            code.1698 = code.1638;
            code.1699 = code.1698 + 1;
            code = code.1699;
            D.26406 = imb.b[0];
            *code.1698 = D.26406;
            code.1638 = code;
            code.1700 = code.1638;
            code.1701 = code.1700 + 1;
            code = code.1701;
            D.26409 = imb.b[1];
            *code.1700 = D.26409;
            code.1638 = code;
            code.1702 = code.1638;
            code.1703 = code.1702 + 1;
            code = code.1703;
            D.26412 = imb.b[2];
            *code.1702 = D.26412;
            code.1638 = code;
            code.1704 = code.1638;
            code.1705 = code.1704 + 1;
            code = code.1705;
            D.26415 = imb.b[3];
            *code.1704 = D.26415;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26399>:
      <D.26392>:
      goto <D.22844>;
      <D.26385>:
      if (0 != 0) goto <D.26416>; else goto <D.26417>;
      <D.26416>:
      code.1638 = code;
      code.1706 = code.1638;
      code.1707 = code.1706 + 1;
      code = code.1707;
      *code.1706 = 20;
      goto <D.22844>;
      <D.26417>:
      if (1 != 0) goto <D.26420>; else goto <D.26421>;
      <D.26420>:
      code.1638 = code;
      code.1708 = code.1638;
      code.1709 = code.1708 + 1;
      code = code.1709;
      *code.1708 = 84;
      code.1638 = code;
      *code.1638 = 4;
      code.1638 = code;
      code.1653 = code.1638 + 1;
      code = code.1653;
      goto <D.26424>;
      <D.26421>:
      code.1638 = code;
      code.1710 = code.1638;
      code.1711 = code.1710 + 1;
      code = code.1711;
      *code.1710 = 148;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1638 = code;
            code.1712 = code.1638;
            code.1713 = code.1712 + 1;
            code = code.1713;
            D.26429 = imb.b[0];
            *code.1712 = D.26429;
            code.1638 = code;
            code.1714 = code.1638;
            code.1715 = code.1714 + 1;
            code = code.1715;
            D.26432 = imb.b[1];
            *code.1714 = D.26432;
            code.1638 = code;
            code.1716 = code.1638;
            code.1717 = code.1716 + 1;
            code = code.1717;
            D.26435 = imb.b[2];
            *code.1716 = D.26435;
            code.1638 = code;
            code.1718 = code.1638;
            code.1719 = code.1718 + 1;
            code = code.1719;
            D.26438 = imb.b[3];
            *code.1718 = D.26438;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26424>:
      <D.22844>:
      code.1638 = code;
      code.1720 = code.1638;
      code.1721 = code.1720 + 1;
      code = code.1721;
      *code.1720 = 255;
      code.1638 = code;
      code.1722 = code.1638;
      code.1723 = code.1722 + 1;
      code = code.1723;
      *code.1722 = 224;
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      code.1638 = code;
      code.1724 = (int) code.1638;
      buf.1637 = buf;
      buf.1725 = (int) buf.1637;
      D.26445 = code.1724 - buf.1725;
      buf.1637 = buf;
      mono_arch_flush_icache (buf.1637, D.26445);
      code.1638 = code;
      code.1724 = (int) code.1638;
      buf.1637 = buf;
      buf.1725 = (int) buf.1637;
      D.26445 = code.1724 - buf.1725;
      D.26446 = D.26445 > tramp_size;
      D.26447 = (long int) D.26446;
      D.26448 = __builtin_expect (D.26447, 0);
      if (D.26448 != 0) goto <D.26449>; else goto <D.26450>;
      <D.26449>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 727, "code - buf <= tramp_size");
      <D.26450>:
      if (info != 0B) goto <D.26451>; else goto <D.26452>;
      <D.26451>:
      code.1638 = code;
      code.1724 = (int) code.1638;
      buf.1637 = buf;
      buf.1725 = (int) buf.1637;
      D.26445 = code.1724 - buf.1725;
      D.26453 = (unsigned int) D.26445;
      buf.1637 = buf;
      D.26454 = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf.1637, D.26453, ji, unwind_ops);
      *info = D.26454;
      <D.26452>:
      D.26455 = buf;
      return D.26455;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
    }
}


mono_arch_create_generic_class_init_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  void * buf.1726;
  guint8 * buf.1727;
  int byte_offset.1728;
  guint8 * code.1729;
  guint8 * code.1730;
  guint8 * code.1731;
  guint8 * code.1732;
  guint8 * code.1733;
  guint8 * code.1734;
  guint8 * code.1735;
  unsigned int byte_offset.1736;
  unsigned int D.26476;
  guint8 * code.1737;
  guint8 * code.1738;
  guint8 * code.1739;
  guint8 * code.1740;
  unsigned char D.26483;
  guint8 * code.1741;
  guint8 * code.1742;
  guint8 * code.1743;
  guint8 * code.1744;
  guint8 * code.1745;
  guint8 * code.1746;
  guint8 * code.1747;
  unsigned char D.26492;
  guint8 * code.1748;
  guint8 * code.1749;
  unsigned char D.26495;
  guint8 * code.1750;
  guint8 * code.1751;
  unsigned char D.26498;
  guint8 * code.1752;
  guint8 * code.1753;
  unsigned char D.26501;
  guint8 * code.1754;
  guint8 * code.1755;
  guint8 * code.1756;
  guint8 * code.1757;
  guint8 * code.1758;
  guint8 * code.1759;
  guint8 * code.1760;
  guint8 * code.1761;
  unsigned char D.26515;
  guint8 * code.1762;
  guint8 * code.1763;
  unsigned char D.26518;
  guint8 * code.1764;
  guint8 * code.1765;
  unsigned char D.26521;
  guint8 * code.1766;
  guint8 * code.1767;
  unsigned char D.26524;
  unsigned char bitmask.1768;
  int D.26526;
  guint8 * code.1769;
  guint8 * code.1770;
  unsigned char D.26529;
  guint8 * code.1771;
  guint8 * code.1772;
  unsigned char D.26532;
  guint8 * code.1773;
  guint8 * code.1774;
  unsigned char D.26535;
  guint8 * code.1775;
  guint8 * code.1776;
  unsigned char D.26538;
  guint8 * code.1777;
  guint8 * code.1778;
  unsigned char D.26543;
  guint8 * code.1779;
  guint8 * code.1780;
  unsigned char D.26547;
  guint8 * code.1781;
  guint8 * code.1782;
  unsigned char D.26550;
  int D.26551;
  unsigned char D.26552;
  unsigned char D.26553;
  int code.1783;
  int pos.1784;
  int D.26560;
  unsigned char * pos.1785;
  unsigned char D.26562;
  unsigned char * pos.1786;
  unsigned char D.26564;
  unsigned char * pos.1787;
  unsigned char D.26566;
  unsigned char * pos.1788;
  unsigned char D.26568;
  unsigned int disp.1789;
  unsigned int D.26571;
  unsigned char D.26574;
  unsigned char D.26575;
  guint8 * code.1790;
  guint8 * code.1791;
  guint8 * code.1792;
  guint8 * code.1793;
  guint8 * code.1794;
  guint8 * code.1795;
  guint8 * code.1796;
  int tramp.1797;
  int D.26588;
  unsigned int t.1798;
  unsigned int D.26590;
  guint8 * code.1799;
  guint8 * code.1800;
  unsigned char D.26595;
  guint8 * code.1801;
  guint8 * code.1802;
  guint8 * code.1803;
  guint8 * code.1804;
  unsigned char D.26601;
  guint8 * code.1805;
  guint8 * code.1806;
  unsigned char D.26604;
  guint8 * code.1807;
  guint8 * code.1808;
  unsigned char D.26607;
  guint8 * code.1809;
  guint8 * code.1810;
  unsigned char D.26610;
  int buf.1811;
  int D.26612;
  _Bool D.26613;
  long int D.26614;
  long int D.26615;
  struct MonoJumpInfo * ji.1812;
  unsigned int D.26621;
  struct MonoTrampInfo * D.26622;
  void * D.26623;
  guint8 * tramp;
  guint8 * code;
  guint8 * buf;
  static int byte_offset = -1;
  static guint8 bitmask;
  guint8 * jump;
  int tramp_size;
  struct GSList * unwind_ops;
  struct MonoJumpInfo * ji;
  static const char __PRETTY_FUNCTION__[47] = "mono_arch_create_generic_class_init_trampoline";

  try
    {
      unwind_ops = 0B;
      ji = 0B;
      tramp_size = 64;
      buf.1726 = mono_global_codeman_reserve (tramp_size);
      buf = buf.1726;
      buf.1727 = buf;
      code = buf.1727;
      unwind_ops = mono_arch_get_cie_program ();
      byte_offset.1728 = byte_offset;
      if (byte_offset.1728 < 0) goto <D.26461>; else goto <D.26462>;
      <D.26461>:
      {
        struct MonoVTable tmp;

        try
          {
            memset (&tmp, 0, 32);
            tmp.initialized = 1;
            mono_marshal_find_nonzero_bit_offset (&tmp, 32, &byte_offset, &bitmask);
          }
        finally
          {
            tmp = {CLOBBER};
          }
      }
      <D.26462>:
      code.1729 = code;
      code.1730 = code.1729;
      code.1731 = code.1730 + 1;
      code = code.1731;
      *code.1730 = 247;
      if (0 != 0) goto <D.26466>; else goto <D.26467>;
      <D.26466>:
      byte_offset.1728 = byte_offset;
      if (byte_offset.1728 == 0) goto <D.26468>; else goto <D.26469>;
      <D.26468>:
      code.1729 = code;
      code.1732 = code.1729;
      code.1733 = code.1732 + 1;
      code = code.1733;
      *code.1732 = 4;
      code.1729 = code;
      code.1734 = code.1729;
      code.1735 = code.1734 + 1;
      code = code.1735;
      *code.1734 = 36;
      goto <D.26474>;
      <D.26469>:
      byte_offset.1728 = byte_offset;
      byte_offset.1736 = (unsigned int) byte_offset.1728;
      D.26476 = byte_offset.1736 + 128;
      if (D.26476 <= 255) goto <D.26477>; else goto <D.26478>;
      <D.26477>:
      code.1729 = code;
      code.1737 = code.1729;
      code.1738 = code.1737 + 1;
      code = code.1738;
      *code.1737 = 68;
      code.1729 = code;
      code.1739 = code.1729;
      code.1740 = code.1739 + 1;
      code = code.1740;
      *code.1739 = 36;
      code.1729 = code;
      byte_offset.1728 = byte_offset;
      D.26483 = (unsigned char) byte_offset.1728;
      *code.1729 = D.26483;
      code.1729 = code;
      code.1741 = code.1729 + 1;
      code = code.1741;
      goto <D.26485>;
      <D.26478>:
      code.1729 = code;
      code.1742 = code.1729;
      code.1743 = code.1742 + 1;
      code = code.1743;
      *code.1742 = 132;
      code.1729 = code;
      code.1744 = code.1729;
      code.1745 = code.1744 + 1;
      code = code.1745;
      *code.1744 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            byte_offset.1728 = byte_offset;
            imb.val = byte_offset.1728;
            code.1729 = code;
            code.1746 = code.1729;
            code.1747 = code.1746 + 1;
            code = code.1747;
            D.26492 = imb.b[0];
            *code.1746 = D.26492;
            code.1729 = code;
            code.1748 = code.1729;
            code.1749 = code.1748 + 1;
            code = code.1749;
            D.26495 = imb.b[1];
            *code.1748 = D.26495;
            code.1729 = code;
            code.1750 = code.1729;
            code.1751 = code.1750 + 1;
            code = code.1751;
            D.26498 = imb.b[2];
            *code.1750 = D.26498;
            code.1729 = code;
            code.1752 = code.1729;
            code.1753 = code.1752 + 1;
            code = code.1753;
            D.26501 = imb.b[3];
            *code.1752 = D.26501;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26485>:
      <D.26474>:
      goto <D.22861>;
      <D.26467>:
      byte_offset.1728 = byte_offset;
      if (byte_offset.1728 == 0) goto <D.26502>; else goto <D.26503>;
      <D.26502>:
      code.1729 = code;
      code.1754 = code.1729;
      code.1755 = code.1754 + 1;
      code = code.1755;
      *code.1754 = 2;
      goto <D.22861>;
      <D.26503>:
      byte_offset.1728 = byte_offset;
      byte_offset.1736 = (unsigned int) byte_offset.1728;
      D.26476 = byte_offset.1736 + 128;
      if (D.26476 <= 255) goto <D.26506>; else goto <D.26507>;
      <D.26506>:
      code.1729 = code;
      code.1756 = code.1729;
      code.1757 = code.1756 + 1;
      code = code.1757;
      *code.1756 = 66;
      code.1729 = code;
      byte_offset.1728 = byte_offset;
      D.26483 = (unsigned char) byte_offset.1728;
      *code.1729 = D.26483;
      code.1729 = code;
      code.1741 = code.1729 + 1;
      code = code.1741;
      goto <D.26510>;
      <D.26507>:
      code.1729 = code;
      code.1758 = code.1729;
      code.1759 = code.1758 + 1;
      code = code.1759;
      *code.1758 = 130;
      {
        union x86_imm_buf imb;

        try
          {
            byte_offset.1728 = byte_offset;
            imb.val = byte_offset.1728;
            code.1729 = code;
            code.1760 = code.1729;
            code.1761 = code.1760 + 1;
            code = code.1761;
            D.26515 = imb.b[0];
            *code.1760 = D.26515;
            code.1729 = code;
            code.1762 = code.1729;
            code.1763 = code.1762 + 1;
            code = code.1763;
            D.26518 = imb.b[1];
            *code.1762 = D.26518;
            code.1729 = code;
            code.1764 = code.1729;
            code.1765 = code.1764 + 1;
            code = code.1765;
            D.26521 = imb.b[2];
            *code.1764 = D.26521;
            code.1729 = code;
            code.1766 = code.1729;
            code.1767 = code.1766 + 1;
            code = code.1767;
            D.26524 = imb.b[3];
            *code.1766 = D.26524;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26510>:
      <D.22861>:
      {
        union x86_imm_buf imb;

        try
          {
            bitmask.1768 = bitmask;
            D.26526 = (int) bitmask.1768;
            imb.val = D.26526;
            code.1729 = code;
            code.1769 = code.1729;
            code.1770 = code.1769 + 1;
            code = code.1770;
            D.26529 = imb.b[0];
            *code.1769 = D.26529;
            code.1729 = code;
            code.1771 = code.1729;
            code.1772 = code.1771 + 1;
            code = code.1772;
            D.26532 = imb.b[1];
            *code.1771 = D.26532;
            code.1729 = code;
            code.1773 = code.1729;
            code.1774 = code.1773 + 1;
            code = code.1774;
            D.26535 = imb.b[2];
            *code.1773 = D.26535;
            code.1729 = code;
            code.1775 = code.1729;
            code.1776 = code.1775 + 1;
            code = code.1776;
            D.26538 = imb.b[3];
            *code.1775 = D.26538;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      jump = code;
      if (1 != 0) goto <D.26539>; else goto <D.26540>;
      <D.26539>:
      code.1729 = code;
      code.1777 = code.1729;
      code.1778 = code.1777 + 1;
      code = code.1778;
      D.26543 = 116;
      *code.1777 = D.26543;
      goto <D.26544>;
      <D.26540>:
      code.1729 = code;
      code.1779 = code.1729;
      code.1780 = code.1779 + 1;
      code = code.1780;
      D.26547 = 116;
      *code.1779 = D.26547;
      <D.26544>:
      code.1729 = code;
      *code.1729 = 255;
      code.1729 = code;
      code.1741 = code.1729 + 1;
      code = code.1741;
      code.1729 = code;
      code.1781 = code.1729;
      code.1782 = code.1781 + 1;
      code = code.1782;
      *code.1781 = 195;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump + 1;
        size = 0;
        D.26550 = MEM[(unsigned char *)jump];
        D.26551 = (int) D.26550;
        switch (D.26551) <default: <D.22892>, case 15: <D.22870>, case 112: <D.22876>, case 113: <D.22877>, case 114: <D.22878>, case 115: <D.22879>, case 116: <D.22880>, case 117: <D.22881>, case 118: <D.22882>, case 119: <D.22883>, case 120: <D.22884>, case 121: <D.22885>, case 122: <D.22886>, case 123: <D.22887>, case 124: <D.22888>, case 125: <D.22889>, case 126: <D.22890>, case 127: <D.22891>, case 224: <D.22872>, case 225: <D.22873>, case 226: <D.22874>, case 232: <D.22867>, case 233: <D.22868>, case 235: <D.22875>>
        <D.22867>:
        <D.22868>:
        size = size + 1;
        goto <D.22869>;
        <D.22870>:
        D.26552 = *pos;
        D.26553 = D.26552 + 144;
        if (D.26553 > 31) goto <D.26554>; else goto <D.26555>;
        <D.26554>:
        __assert_fail ("0", "tramp-x86.c", 762, &__PRETTY_FUNCTION__);
        <D.26555>:
        size = size + 1;
        pos = pos + 1;
        goto <D.22869>;
        <D.22872>:
        <D.22873>:
        <D.22874>:
        <D.22875>:
        <D.22876>:
        <D.22877>:
        <D.22878>:
        <D.22879>:
        <D.22880>:
        <D.22881>:
        <D.22882>:
        <D.22883>:
        <D.22884>:
        <D.22885>:
        <D.22886>:
        <D.22887>:
        <D.22888>:
        <D.22889>:
        <D.22890>:
        <D.22891>:
        goto <D.22869>;
        <D.22892>:
        __assert_fail ("0", "tramp-x86.c", 762, &__PRETTY_FUNCTION__);
        <D.22869>:
        code.1729 = code;
        code.1783 = (int) code.1729;
        pos.1784 = (int) pos;
        disp = code.1783 - pos.1784;
        if (size != 0) goto <D.26558>; else goto <D.26559>;
        <D.26558>:
        {
          union x86_imm_buf imb;

          try
            {
              D.26560 = disp + -4;
              imb.val = D.26560;
              pos.1785 = pos;
              pos = pos.1785 + 1;
              D.26562 = imb.b[0];
              *pos.1785 = D.26562;
              pos.1786 = pos;
              pos = pos.1786 + 1;
              D.26564 = imb.b[1];
              *pos.1786 = D.26564;
              pos.1787 = pos;
              pos = pos.1787 + 1;
              D.26566 = imb.b[2];
              *pos.1787 = D.26566;
              pos.1788 = pos;
              pos = pos.1788 + 1;
              D.26568 = imb.b[3];
              *pos.1788 = D.26568;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.26569>;
        <D.26559>:
        disp.1789 = (unsigned int) disp;
        D.26571 = disp.1789 + 127;
        if (D.26571 <= 255) goto <D.26572>; else goto <D.26573>;
        <D.26572>:
        D.26574 = (unsigned char) disp;
        D.26575 = D.26574 + 255;
        *pos = D.26575;
        pos = pos + 1;
        goto <D.26576>;
        <D.26573>:
        __assert_fail ("0", "tramp-x86.c", 762, &__PRETTY_FUNCTION__);
        <D.26576>:
        <D.26569>:
      }
      code.1729 = code;
      code.1790 = code.1729;
      code.1791 = code.1790 + 1;
      code = code.1791;
      *code.1790 = 82;
      if (aot != 0) goto <D.26579>; else goto <D.26580>;
      <D.26579>:
      code.1729 = code;
      buf.1727 = buf;
      code.1792 = mono_arch_emit_load_aotconst (buf.1727, code.1729, &ji, 32, "generic_trampoline_generic_class_init");
      code = code.1792;
      code.1729 = code;
      code.1793 = code.1729;
      code.1794 = code.1793 + 1;
      code = code.1794;
      *code.1793 = 255;
      code.1729 = code;
      code.1795 = code.1729;
      code.1796 = code.1795 + 1;
      code = code.1796;
      *code.1795 = 224;
      goto <D.26586>;
      <D.26580>:
      tramp = mono_get_trampoline_code (3);
      {
        int t;

        tramp.1797 = (int) tramp;
        code.1729 = code;
        code.1783 = (int) code.1729;
        D.26588 = tramp.1797 - code.1783;
        t = D.26588 + -2;
        t.1798 = (unsigned int) t;
        D.26590 = t.1798 + 128;
        if (D.26590 <= 255) goto <D.26591>; else goto <D.26592>;
        <D.26591>:
        code.1729 = code;
        code.1799 = code.1729;
        code.1800 = code.1799 + 1;
        code = code.1800;
        *code.1799 = 235;
        code.1729 = code;
        D.26595 = (unsigned char) t;
        *code.1729 = D.26595;
        code.1729 = code;
        code.1741 = code.1729 + 1;
        code = code.1741;
        goto <D.26596>;
        <D.26592>:
        tramp.1797 = (int) tramp;
        code.1729 = code;
        code.1783 = (int) code.1729;
        D.26588 = tramp.1797 - code.1783;
        t = D.26588 + -5;
        code.1729 = code;
        code.1801 = code.1729;
        code.1802 = code.1801 + 1;
        code = code.1802;
        *code.1801 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.1729 = code;
              code.1803 = code.1729;
              code.1804 = code.1803 + 1;
              code = code.1804;
              D.26601 = imb.b[0];
              *code.1803 = D.26601;
              code.1729 = code;
              code.1805 = code.1729;
              code.1806 = code.1805 + 1;
              code = code.1806;
              D.26604 = imb.b[1];
              *code.1805 = D.26604;
              code.1729 = code;
              code.1807 = code.1729;
              code.1808 = code.1807 + 1;
              code = code.1808;
              D.26607 = imb.b[2];
              *code.1807 = D.26607;
              code.1729 = code;
              code.1809 = code.1729;
              code.1810 = code.1809 + 1;
              code = code.1810;
              D.26610 = imb.b[3];
              *code.1809 = D.26610;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.26596>:
      }
      <D.26586>:
      code.1729 = code;
      code.1783 = (int) code.1729;
      buf.1727 = buf;
      buf.1811 = (int) buf.1727;
      D.26612 = code.1783 - buf.1811;
      code.1729 = code;
      mono_arch_flush_icache (code.1729, D.26612);
      code.1729 = code;
      code.1783 = (int) code.1729;
      buf.1727 = buf;
      buf.1811 = (int) buf.1727;
      D.26612 = code.1783 - buf.1811;
      D.26613 = D.26612 > tramp_size;
      D.26614 = (long int) D.26613;
      D.26615 = __builtin_expect (D.26614, 0);
      if (D.26615 != 0) goto <D.26616>; else goto <D.26617>;
      <D.26616>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 779, "code - buf <= tramp_size");
      <D.26617>:
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      if (info != 0B) goto <D.26618>; else goto <D.26619>;
      <D.26618>:
      ji.1812 = ji;
      code.1729 = code;
      code.1783 = (int) code.1729;
      buf.1727 = buf;
      buf.1811 = (int) buf.1727;
      D.26612 = code.1783 - buf.1811;
      D.26621 = (unsigned int) D.26612;
      buf.1727 = buf;
      D.26622 = mono_tramp_info_create ("generic_class_init_trampoline", buf.1727, D.26621, ji.1812, unwind_ops);
      *info = D.26622;
      <D.26619>:
      D.26623 = buf;
      return D.26623;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
      ji = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26629;
  int D.26634;
  void * D.26636;
  unsigned int D.26637;

  D.26629 = __builtin_constant_p (__len);
  if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
  <D.26630>:
  if (__len == 0) goto <D.26632>; else goto <D.26633>;
  <D.26632>:
  D.26634 = __builtin_constant_p (__ch);
  if (D.26634 == 0) goto <D.26627>; else goto <D.26635>;
  <D.26635>:
  if (__ch != 0) goto <D.26627>; else goto <D.26628>;
  <D.26627>:
  __warn_memset_zero_len ();
  D.26636 = __dest;
  return D.26636;
  <D.26628>:
  <D.26633>:
  <D.26631>:
  D.26637 = __builtin_object_size (__dest, 0);
  D.26636 = __builtin___memset_chk (__dest, __ch, __len, D.26637);
  return D.26636;
}


mono_arch_create_monitor_enter_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  int owner_offset.1813;
  unsigned int owner_offset.1814;
  unsigned int D.26643;
  _Bool D.26644;
  long int D.26645;
  long int D.26646;
  int nest_offset.1815;
  unsigned int nest_offset.1816;
  unsigned int D.26651;
  _Bool D.26652;
  long int D.26653;
  long int D.26654;
  int owner_offset.1817;
  int nest_offset.1818;
  void * buf.1819;
  guint8 * buf.1820;
  int D.26661;
  guint8 * code.1821;
  guint8 * code.1822;
  guint8 * code.1823;
  guint8 * code.1824;
  guint8 * code.1825;
  guint8 * code.1826;
  guint8 * code.1827;
  unsigned char D.26673;
  guint8 * code.1828;
  guint8 * code.1829;
  unsigned char D.26677;
  guint8 * code.1830;
  guint8 * code.1831;
  guint8 * code.1832;
  guint8 * code.1833;
  guint8 * code.1834;
  guint8 * code.1835;
  guint8 * code.1836;
  guint8 * code.1837;
  guint8 * code.1838;
  guint8 * code.1839;
  guint8 * code.1840;
  guint8 * code.1841;
  guint8 * code.1842;
  guint8 * code.1843;
  guint8 * code.1844;
  guint8 * code.1845;
  guint8 * code.1846;
  guint8 * code.1847;
  guint8 * code.1848;
  guint8 * code.1849;
  guint8 * code.1850;
  unsigned char D.26707;
  guint8 * code.1851;
  guint8 * code.1852;
  unsigned char D.26710;
  guint8 * code.1853;
  guint8 * code.1854;
  unsigned char D.26713;
  guint8 * code.1855;
  guint8 * code.1856;
  unsigned char D.26716;
  guint8 * code.1857;
  guint8 * code.1858;
  guint8 * code.1859;
  guint8 * code.1860;
  guint8 * code.1861;
  guint8 * code.1862;
  guint8 * code.1863;
  guint8 * code.1864;
  unsigned char D.26730;
  guint8 * code.1865;
  guint8 * code.1866;
  unsigned char D.26733;
  guint8 * code.1867;
  guint8 * code.1868;
  unsigned char D.26736;
  guint8 * code.1869;
  guint8 * code.1870;
  unsigned char D.26739;
  int D.26740;
  guint8 * code.1871;
  guint8 * code.1872;
  guint8 * code.1873;
  guint8 * code.1874;
  guint8 * code.1875;
  guint8 * code.1876;
  guint8 * code.1877;
  guint8 * code.1878;
  unsigned char D.26754;
  guint8 * code.1879;
  guint8 * code.1880;
  unsigned char D.26757;
  guint8 * code.1881;
  guint8 * code.1882;
  unsigned char D.26760;
  guint8 * code.1883;
  guint8 * code.1884;
  unsigned char D.26763;
  guint8 * code.1885;
  guint8 * code.1886;
  unsigned char D.26768;
  guint8 * code.1887;
  guint8 * code.1888;
  unsigned char D.26772;
  guint8 * code.1889;
  guint8 * code.1890;
  guint8 * code.1891;
  guint8 * code.1892;
  unsigned char D.26779;
  guint8 * code.1893;
  guint8 * code.1894;
  unsigned char D.26782;
  guint8 * code.1895;
  guint8 * code.1896;
  unsigned char D.26785;
  guint8 * code.1897;
  guint8 * code.1898;
  unsigned char D.26788;
  guint8 * code.1899;
  guint8 * code.1900;
  guint8 * code.1901;
  guint8 * code.1902;
  guint8 * code.1903;
  guint8 * code.1904;
  guint8 * code.1905;
  guint8 * code.1906;
  guint8 * code.1907;
  guint8 * code.1908;
  unsigned char D.26802;
  guint8 * code.1909;
  guint8 * code.1910;
  unsigned char D.26805;
  guint8 * code.1911;
  guint8 * code.1912;
  unsigned char D.26808;
  guint8 * code.1913;
  guint8 * code.1914;
  unsigned char D.26811;
  guint8 * code.1915;
  guint8 * code.1916;
  guint8 * code.1917;
  guint8 * code.1918;
  guint8 * code.1919;
  guint8 * code.1920;
  guint8 * code.1921;
  guint8 * code.1922;
  guint8 * code.1923;
  guint8 * code.1924;
  guint8 * code.1925;
  guint8 * code.1926;
  guint8 * code.1927;
  guint8 * code.1928;
  guint8 * code.1929;
  guint8 * code.1930;
  guint8 * code.1931;
  guint8 * code.1932;
  guint8 * code.1933;
  guint8 * code.1934;
  guint8 * code.1935;
  guint8 * code.1936;
  guint8 * code.1937;
  guint8 * code.1938;
  int D.26845;
  guint8 * code.1939;
  guint8 * code.1940;
  guint8 * code.1941;
  guint8 * code.1942;
  guint8 * code.1943;
  guint8 * code.1944;
  guint8 * code.1945;
  guint8 * code.1946;
  guint8 * code.1947;
  guint8 * code.1948;
  guint8 * code.1949;
  guint8 * code.1950;
  guint8 * code.1951;
  guint8 * code.1952;
  guint8 * code.1953;
  guint8 * code.1954;
  guint8 * code.1955;
  guint8 * code.1956;
  guint8 * code.1957;
  guint8 * code.1958;
  guint8 * code.1959;
  unsigned char D.26875;
  guint8 * code.1960;
  guint8 * code.1961;
  unsigned char D.26878;
  guint8 * code.1962;
  guint8 * code.1963;
  unsigned char D.26881;
  guint8 * code.1964;
  guint8 * code.1965;
  unsigned char D.26884;
  guint8 * code.1966;
  guint8 * code.1967;
  guint8 * code.1968;
  guint8 * code.1969;
  guint8 * code.1970;
  guint8 * code.1971;
  guint8 * code.1972;
  guint8 * code.1973;
  unsigned char D.26898;
  guint8 * code.1974;
  guint8 * code.1975;
  unsigned char D.26901;
  guint8 * code.1976;
  guint8 * code.1977;
  unsigned char D.26904;
  guint8 * code.1978;
  guint8 * code.1979;
  unsigned char D.26907;
  guint8 * code.1980;
  guint8 * code.1981;
  guint8 * code.1982;
  guint8 * code.1983;
  guint8 * code.1984;
  guint8 * code.1985;
  unsigned int owner_offset.1986;
  unsigned int D.26922;
  guint8 * code.1987;
  guint8 * code.1988;
  guint8 * code.1989;
  guint8 * code.1990;
  unsigned char D.26929;
  guint8 * code.1991;
  guint8 * code.1992;
  guint8 * code.1993;
  guint8 * code.1994;
  guint8 * code.1995;
  guint8 * code.1996;
  unsigned char D.26937;
  guint8 * code.1997;
  guint8 * code.1998;
  unsigned char D.26940;
  guint8 * code.1999;
  guint8 * code.2000;
  unsigned char D.26943;
  guint8 * code.2001;
  guint8 * code.2002;
  unsigned char D.26946;
  guint8 * code.2003;
  guint8 * code.2004;
  guint8 * code.2005;
  guint8 * code.2006;
  guint8 * code.2007;
  guint8 * code.2008;
  guint8 * code.2009;
  guint8 * code.2010;
  unsigned char D.26960;
  guint8 * code.2011;
  guint8 * code.2012;
  unsigned char D.26963;
  guint8 * code.2013;
  guint8 * code.2014;
  unsigned char D.26966;
  guint8 * code.2015;
  guint8 * code.2016;
  unsigned char D.26969;
  guint8 * code.2017;
  guint8 * code.2018;
  guint8 * code.2019;
  guint8 * code.2020;
  guint8 * code.2021;
  guint8 * code.2022;
  guint8 * code.2023;
  guint8 * code.2024;
  guint8 * code.2025;
  guint8 * code.2026;
  guint8 * code.2027;
  guint8 * code.2028;
  guint8 * code.2029;
  guint8 * code.2030;
  guint8 * code.2031;
  guint8 * code.2032;
  unsigned char D.26995;
  guint8 * code.2033;
  guint8 * code.2034;
  unsigned char D.26998;
  guint8 * code.2035;
  guint8 * code.2036;
  unsigned char D.27001;
  guint8 * code.2037;
  guint8 * code.2038;
  unsigned char D.27004;
  guint8 * code.2039;
  guint8 * code.2040;
  guint8 * code.2041;
  guint8 * code.2042;
  guint8 * code.2043;
  guint8 * code.2044;
  guint8 * code.2045;
  guint8 * code.2046;
  unsigned char D.27018;
  guint8 * code.2047;
  guint8 * code.2048;
  unsigned char D.27021;
  guint8 * code.2049;
  guint8 * code.2050;
  unsigned char D.27024;
  guint8 * code.2051;
  guint8 * code.2052;
  unsigned char D.27027;
  guint8 * code.2053;
  guint8 * code.2054;
  unsigned char D.27030;
  guint8 * code.2055;
  guint8 * code.2056;
  unsigned char D.27033;
  guint8 * code.2057;
  guint8 * code.2058;
  unsigned char D.27036;
  guint8 * code.2059;
  guint8 * code.2060;
  unsigned char D.27039;
  guint8 * code.2061;
  guint8 * code.2062;
  guint8 * code.2063;
  guint8 * code.2064;
  guint8 * code.2065;
  guint8 * code.2066;
  guint8 * code.2067;
  guint8 * code.2068;
  guint8 * code.2069;
  guint8 * code.2070;
  guint8 * code.2071;
  guint8 * code.2072;
  guint8 * code.2073;
  guint8 * code.2074;
  guint8 * code.2075;
  guint8 * code.2076;
  guint8 * code.2077;
  guint8 * code.2078;
  guint8 * code.2079;
  guint8 * code.2080;
  guint8 * code.2081;
  guint8 * code.2082;
  guint8 * code.2083;
  guint8 * code.2084;
  guint8 * code.2085;
  guint8 * code.2086;
  guint8 * code.2087;
  guint8 * code.2088;
  guint8 * code.2089;
  guint8 * code.2090;
  unsigned char D.27081;
  guint8 * code.2091;
  guint8 * code.2092;
  unsigned char D.27084;
  guint8 * code.2093;
  guint8 * code.2094;
  unsigned char D.27087;
  guint8 * code.2095;
  guint8 * code.2096;
  unsigned char D.27090;
  guint8 * code.2097;
  guint8 * code.2098;
  guint8 * code.2099;
  guint8 * code.2100;
  guint8 * code.2101;
  guint8 * code.2102;
  guint8 * code.2103;
  guint8 * code.2104;
  unsigned char D.27104;
  guint8 * code.2105;
  guint8 * code.2106;
  unsigned char D.27107;
  guint8 * code.2107;
  guint8 * code.2108;
  unsigned char D.27110;
  guint8 * code.2109;
  guint8 * code.2110;
  unsigned char D.27113;
  guint8 * code.2111;
  guint8 * code.2112;
  guint8 * code.2113;
  guint8 * code.2114;
  guint8 * code.2115;
  guint8 * code.2116;
  guint8 * code.2117;
  guint8 * code.2118;
  unsigned char D.27125;
  int D.27126;
  unsigned char D.27127;
  unsigned char D.27128;
  int code.2119;
  int pos.2120;
  int D.27135;
  unsigned char * pos.2121;
  unsigned char D.27137;
  unsigned char * pos.2122;
  unsigned char D.27139;
  unsigned char * pos.2123;
  unsigned char D.27141;
  unsigned char * pos.2124;
  unsigned char D.27143;
  unsigned int disp.2125;
  unsigned int D.27146;
  unsigned char D.27149;
  unsigned char D.27150;
  guint8 * code.2126;
  guint8 * code.2127;
  guint8 * code.2128;
  guint8 * code.2129;
  guint8 * code.2130;
  guint8 * code.2131;
  guint8 * code.2132;
  guint8 * code.2133;
  guint8 * code.2134;
  guint8 * code.2135;
  guint8 * code.2136;
  guint8 * code.2137;
  guint8 * code.2138;
  guint8 * code.2139;
  guint8 * code.2140;
  guint8 * code.2141;
  unsigned char D.27176;
  guint8 * code.2142;
  guint8 * code.2143;
  unsigned char D.27179;
  guint8 * code.2144;
  guint8 * code.2145;
  unsigned char D.27182;
  guint8 * code.2146;
  guint8 * code.2147;
  unsigned char D.27185;
  guint8 * code.2148;
  guint8 * code.2149;
  guint8 * code.2150;
  guint8 * code.2151;
  guint8 * code.2152;
  guint8 * code.2153;
  guint8 * code.2154;
  guint8 * code.2155;
  unsigned char D.27199;
  guint8 * code.2156;
  guint8 * code.2157;
  unsigned char D.27202;
  guint8 * code.2158;
  guint8 * code.2159;
  unsigned char D.27205;
  guint8 * code.2160;
  guint8 * code.2161;
  unsigned char D.27208;
  guint8 * code.2162;
  guint8 * code.2163;
  guint8 * code.2164;
  guint8 * code.2165;
  guint8 * code.2166;
  guint8 * code.2167;
  guint8 * code.2168;
  guint8 * code.2169;
  guint8 * code.2170;
  guint8 * code.2171;
  unsigned int nest_offset.2172;
  unsigned int D.27228;
  guint8 * code.2173;
  guint8 * code.2174;
  guint8 * code.2175;
  guint8 * code.2176;
  unsigned char D.27235;
  guint8 * code.2177;
  guint8 * code.2178;
  guint8 * code.2179;
  guint8 * code.2180;
  guint8 * code.2181;
  guint8 * code.2182;
  unsigned char D.27243;
  guint8 * code.2183;
  guint8 * code.2184;
  unsigned char D.27246;
  guint8 * code.2185;
  guint8 * code.2186;
  unsigned char D.27249;
  guint8 * code.2187;
  guint8 * code.2188;
  unsigned char D.27252;
  guint8 * code.2189;
  guint8 * code.2190;
  guint8 * code.2191;
  guint8 * code.2192;
  guint8 * code.2193;
  guint8 * code.2194;
  guint8 * code.2195;
  guint8 * code.2196;
  unsigned char D.27266;
  guint8 * code.2197;
  guint8 * code.2198;
  unsigned char D.27269;
  guint8 * code.2199;
  guint8 * code.2200;
  unsigned char D.27272;
  guint8 * code.2201;
  guint8 * code.2202;
  unsigned char D.27275;
  guint8 * code.2203;
  guint8 * code.2204;
  unsigned char D.27278;
  int D.27279;
  unsigned char D.27280;
  unsigned char D.27281;
  int pos.2205;
  int D.27287;
  unsigned char * pos.2206;
  unsigned char D.27289;
  unsigned char * pos.2207;
  unsigned char D.27291;
  unsigned char * pos.2208;
  unsigned char D.27293;
  unsigned char * pos.2209;
  unsigned char D.27295;
  unsigned int disp.2210;
  unsigned int D.27298;
  unsigned char D.27301;
  unsigned char D.27302;
  unsigned char D.27306;
  int D.27307;
  unsigned char D.27308;
  unsigned char D.27309;
  int pos.2211;
  int D.27315;
  unsigned char * pos.2212;
  unsigned char D.27317;
  unsigned char * pos.2213;
  unsigned char D.27319;
  unsigned char * pos.2214;
  unsigned char D.27321;
  unsigned char * pos.2215;
  unsigned char D.27323;
  unsigned int disp.2216;
  unsigned int D.27326;
  unsigned char D.27329;
  unsigned char D.27330;
  unsigned char D.27332;
  int D.27333;
  unsigned char D.27334;
  unsigned char D.27335;
  int pos.2217;
  int D.27341;
  unsigned char * pos.2218;
  unsigned char D.27343;
  unsigned char * pos.2219;
  unsigned char D.27345;
  unsigned char * pos.2220;
  unsigned char D.27347;
  unsigned char * pos.2221;
  unsigned char D.27349;
  unsigned int disp.2222;
  unsigned int D.27352;
  unsigned char D.27355;
  unsigned char D.27356;
  unsigned char D.27358;
  int D.27359;
  unsigned char D.27360;
  unsigned char D.27361;
  int pos.2223;
  int D.27367;
  unsigned char * pos.2224;
  unsigned char D.27369;
  unsigned char * pos.2225;
  unsigned char D.27371;
  unsigned char * pos.2226;
  unsigned char D.27373;
  unsigned char * pos.2227;
  unsigned char D.27375;
  unsigned int disp.2228;
  unsigned int D.27378;
  unsigned char D.27381;
  unsigned char D.27382;
  guint8 * code.2229;
  guint8 * code.2230;
  unsigned char D.27386;
  int D.27387;
  unsigned char D.27388;
  unsigned char D.27389;
  int pos.2231;
  int D.27395;
  unsigned char * pos.2232;
  unsigned char D.27397;
  unsigned char * pos.2233;
  unsigned char D.27399;
  unsigned char * pos.2234;
  unsigned char D.27401;
  unsigned char * pos.2235;
  unsigned char D.27403;
  unsigned int disp.2236;
  unsigned int D.27406;
  unsigned char D.27409;
  unsigned char D.27410;
  guint8 * code.2237;
  guint8 * code.2238;
  guint8 * code.2239;
  guint8 * code.2240;
  guint8 * code.2241;
  int tramp.2242;
  int D.27421;
  unsigned int t.2243;
  unsigned int D.27423;
  guint8 * code.2244;
  guint8 * code.2245;
  unsigned char D.27428;
  guint8 * code.2246;
  guint8 * code.2247;
  guint8 * code.2248;
  guint8 * code.2249;
  unsigned char D.27434;
  guint8 * code.2250;
  guint8 * code.2251;
  unsigned char D.27437;
  guint8 * code.2252;
  guint8 * code.2253;
  unsigned char D.27440;
  guint8 * code.2254;
  guint8 * code.2255;
  unsigned char D.27443;
  guint8 * code.2256;
  guint8 * code.2257;
  guint8 * code.2258;
  guint8 * code.2259;
  guint8 * code.2260;
  guint8 * code.2261;
  guint8 * code.2262;
  unsigned int t.2263;
  unsigned int D.27456;
  guint8 * code.2264;
  guint8 * code.2265;
  unsigned char D.27461;
  guint8 * code.2266;
  guint8 * code.2267;
  guint8 * code.2268;
  guint8 * code.2269;
  unsigned char D.27467;
  guint8 * code.2270;
  guint8 * code.2271;
  unsigned char D.27470;
  guint8 * code.2272;
  guint8 * code.2273;
  unsigned char D.27473;
  guint8 * code.2274;
  guint8 * code.2275;
  unsigned char D.27476;
  int buf.2276;
  int D.27478;
  _Bool D.27479;
  long int D.27480;
  long int D.27481;
  struct MonoJumpInfo * ji.2277;
  unsigned int D.27487;
  struct MonoTrampInfo * D.27488;
  void * D.27489;
  guint8 * tramp;
  guint8 * code;
  guint8 * buf;
  guint8 * jump_obj_null;
  guint8 * jump_sync_null;
  guint8 * jump_other_owner;
  guint8 * jump_cmpxchg_failed;
  guint8 * jump_tid;
  guint8 * jump_sync_thin_hash;
  int tramp_size;
  int owner_offset;
  int nest_offset;
  int dummy;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  static const char __PRETTY_FUNCTION__[42] = "mono_arch_create_monitor_enter_trampoline";

  try
    {
      tramp = mono_get_trampoline_code (10);
      jump_sync_thin_hash = 0B;
      ji = 0B;
      unwind_ops = 0B;
      if (0 != 0) goto <D.26639>; else goto <D.26640>;
      <D.26639>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 822, "MONO_ARCH_MONITOR_OBJECT_REG == X86_EAX");
      <D.26640>:
      mono_monitor_threads_sync_members_offset (&owner_offset, &nest_offset, &dummy);
      owner_offset.1813 = owner_offset;
      owner_offset.1814 = (unsigned int) owner_offset.1813;
      D.26643 = owner_offset.1814 & 255;
      D.26644 = D.26643 != 4;
      D.26645 = (long int) D.26644;
      D.26646 = __builtin_expect (D.26645, 0);
      if (D.26646 != 0) goto <D.26647>; else goto <D.26648>;
      <D.26647>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 825, "MONO_THREADS_SYNC_MEMBER_SIZE (owner_offset) == sizeof (gpointer)");
      <D.26648>:
      nest_offset.1815 = nest_offset;
      nest_offset.1816 = (unsigned int) nest_offset.1815;
      D.26651 = nest_offset.1816 & 255;
      D.26652 = D.26651 != 4;
      D.26653 = (long int) D.26652;
      D.26654 = __builtin_expect (D.26653, 0);
      if (D.26654 != 0) goto <D.26655>; else goto <D.26656>;
      <D.26655>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 826, "MONO_THREADS_SYNC_MEMBER_SIZE (nest_offset) == sizeof (guint32)");
      <D.26656>:
      owner_offset.1813 = owner_offset;
      owner_offset.1817 = owner_offset.1813 >> 8;
      owner_offset = owner_offset.1817;
      nest_offset.1815 = nest_offset;
      nest_offset.1818 = nest_offset.1815 >> 8;
      nest_offset = nest_offset.1818;
      tramp_size = 96;
      buf.1819 = mono_global_codeman_reserve (tramp_size);
      buf = buf.1819;
      buf.1820 = buf;
      code = buf.1820;
      D.26661 = mono_thread_get_tls_offset ();
      if (D.26661 != -1) goto <D.26662>; else goto <D.26663>;
      <D.26662>:
      code.1821 = code;
      code.1822 = code.1821;
      code.1823 = code.1822 + 1;
      code = code.1823;
      *code.1822 = 133;
      code.1821 = code;
      code.1824 = code.1821;
      code.1825 = code.1824 + 1;
      code = code.1825;
      *code.1824 = 192;
      jump_obj_null = code;
      if (1 != 0) goto <D.26669>; else goto <D.26670>;
      <D.26669>:
      code.1821 = code;
      code.1826 = code.1821;
      code.1827 = code.1826 + 1;
      code = code.1827;
      D.26673 = 116;
      *code.1826 = D.26673;
      goto <D.26674>;
      <D.26670>:
      code.1821 = code;
      code.1828 = code.1821;
      code.1829 = code.1828 + 1;
      code = code.1829;
      D.26677 = 116;
      *code.1828 = D.26677;
      <D.26674>:
      code.1821 = code;
      *code.1821 = 255;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      switch (4) <default: <D.22919>, case 1: <D.22915>, case 2: <D.22917>, case 4: <D.22918>>
      <D.22915>:
      code.1821 = code;
      code.1831 = code.1821;
      code.1832 = code.1831 + 1;
      code = code.1832;
      *code.1831 = 138;
      goto <D.22916>;
      <D.22917>:
      code.1821 = code;
      code.1833 = code.1821;
      code.1834 = code.1833 + 1;
      code = code.1834;
      *code.1833 = 102;
      <D.22918>:
      code.1821 = code;
      code.1835 = code.1821;
      code.1836 = code.1835 + 1;
      code = code.1836;
      *code.1835 = 139;
      goto <D.22916>;
      <D.22919>:
      __assert_fail ("0", "tramp-x86.c", 843, &__PRETTY_FUNCTION__);
      <D.22916>:
      if (0 != 0) goto <D.26685>; else goto <D.26686>;
      <D.26685>:
      if (0 != 0) goto <D.26687>; else goto <D.26688>;
      <D.26687>:
      code.1821 = code;
      code.1837 = code.1821;
      code.1838 = code.1837 + 1;
      code = code.1838;
      *code.1837 = 12;
      code.1821 = code;
      code.1839 = code.1821;
      code.1840 = code.1839 + 1;
      code = code.1840;
      *code.1839 = 36;
      goto <D.26693>;
      <D.26688>:
      if (1 != 0) goto <D.26694>; else goto <D.26695>;
      <D.26694>:
      code.1821 = code;
      code.1841 = code.1821;
      code.1842 = code.1841 + 1;
      code = code.1842;
      *code.1841 = 76;
      code.1821 = code;
      code.1843 = code.1821;
      code.1844 = code.1843 + 1;
      code = code.1844;
      *code.1843 = 36;
      code.1821 = code;
      *code.1821 = 4;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26700>;
      <D.26695>:
      code.1821 = code;
      code.1845 = code.1821;
      code.1846 = code.1845 + 1;
      code = code.1846;
      *code.1845 = 140;
      code.1821 = code;
      code.1847 = code.1821;
      code.1848 = code.1847 + 1;
      code = code.1848;
      *code.1847 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1821 = code;
            code.1849 = code.1821;
            code.1850 = code.1849 + 1;
            code = code.1850;
            D.26707 = imb.b[0];
            *code.1849 = D.26707;
            code.1821 = code;
            code.1851 = code.1821;
            code.1852 = code.1851 + 1;
            code = code.1852;
            D.26710 = imb.b[1];
            *code.1851 = D.26710;
            code.1821 = code;
            code.1853 = code.1821;
            code.1854 = code.1853 + 1;
            code = code.1854;
            D.26713 = imb.b[2];
            *code.1853 = D.26713;
            code.1821 = code;
            code.1855 = code.1821;
            code.1856 = code.1855 + 1;
            code = code.1856;
            D.26716 = imb.b[3];
            *code.1855 = D.26716;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26700>:
      <D.26693>:
      goto <D.22922>;
      <D.26686>:
      if (0 != 0) goto <D.26717>; else goto <D.26718>;
      <D.26717>:
      code.1821 = code;
      code.1857 = code.1821;
      code.1858 = code.1857 + 1;
      code = code.1858;
      *code.1857 = 8;
      goto <D.22922>;
      <D.26718>:
      if (1 != 0) goto <D.26721>; else goto <D.26722>;
      <D.26721>:
      code.1821 = code;
      code.1859 = code.1821;
      code.1860 = code.1859 + 1;
      code = code.1860;
      *code.1859 = 72;
      code.1821 = code;
      *code.1821 = 4;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26725>;
      <D.26722>:
      code.1821 = code;
      code.1861 = code.1821;
      code.1862 = code.1861 + 1;
      code = code.1862;
      *code.1861 = 136;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.1821 = code;
            code.1863 = code.1821;
            code.1864 = code.1863 + 1;
            code = code.1864;
            D.26730 = imb.b[0];
            *code.1863 = D.26730;
            code.1821 = code;
            code.1865 = code.1821;
            code.1866 = code.1865 + 1;
            code = code.1866;
            D.26733 = imb.b[1];
            *code.1865 = D.26733;
            code.1821 = code;
            code.1867 = code.1821;
            code.1868 = code.1867 + 1;
            code = code.1868;
            D.26736 = imb.b[2];
            *code.1867 = D.26736;
            code.1821 = code;
            code.1869 = code.1821;
            code.1870 = code.1869 + 1;
            code = code.1870;
            D.26739 = imb.b[3];
            *code.1869 = D.26739;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26725>:
      <D.22922>:
      D.26740 = mono_gc_is_moving ();
      if (D.26740 != 0) goto <D.26741>; else goto <D.26742>;
      <D.26741>:
      if (0 != 0) goto <D.26743>; else goto <D.26744>;
      <D.26743>:
      code.1821 = code;
      code.1871 = code.1821;
      code.1872 = code.1871 + 1;
      code = code.1872;
      *code.1871 = 169;
      goto <D.26747>;
      <D.26744>:
      code.1821 = code;
      code.1873 = code.1821;
      code.1874 = code.1873 + 1;
      code = code.1874;
      *code.1873 = 247;
      code.1821 = code;
      code.1875 = code.1821;
      code.1876 = code.1875 + 1;
      code = code.1876;
      *code.1875 = 193;
      <D.26747>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 1;
            code.1821 = code;
            code.1877 = code.1821;
            code.1878 = code.1877 + 1;
            code = code.1878;
            D.26754 = imb.b[0];
            *code.1877 = D.26754;
            code.1821 = code;
            code.1879 = code.1821;
            code.1880 = code.1879 + 1;
            code = code.1880;
            D.26757 = imb.b[1];
            *code.1879 = D.26757;
            code.1821 = code;
            code.1881 = code.1821;
            code.1882 = code.1881 + 1;
            code = code.1882;
            D.26760 = imb.b[2];
            *code.1881 = D.26760;
            code.1821 = code;
            code.1883 = code.1821;
            code.1884 = code.1883 + 1;
            code = code.1884;
            D.26763 = imb.b[3];
            *code.1883 = D.26763;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      jump_sync_thin_hash = code;
      if (1 != 0) goto <D.26764>; else goto <D.26765>;
      <D.26764>:
      code.1821 = code;
      code.1885 = code.1821;
      code.1886 = code.1885 + 1;
      code = code.1886;
      D.26768 = 117;
      *code.1885 = D.26768;
      goto <D.26769>;
      <D.26765>:
      code.1821 = code;
      code.1887 = code.1821;
      code.1888 = code.1887 + 1;
      code = code.1888;
      D.26772 = 117;
      *code.1887 = D.26772;
      <D.26769>:
      code.1821 = code;
      *code.1821 = 255;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      if (0 != 0) goto <D.26773>; else goto <D.26774>;
      <D.26773>:
      code.1821 = code;
      code.1889 = code.1821;
      code.1890 = code.1889 + 1;
      code = code.1890;
      *code.1889 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = -4;
            code.1821 = code;
            code.1891 = code.1821;
            code.1892 = code.1891 + 1;
            code = code.1892;
            D.26779 = imb.b[0];
            *code.1891 = D.26779;
            code.1821 = code;
            code.1893 = code.1821;
            code.1894 = code.1893 + 1;
            code = code.1894;
            D.26782 = imb.b[1];
            *code.1893 = D.26782;
            code.1821 = code;
            code.1895 = code.1821;
            code.1896 = code.1895 + 1;
            code = code.1896;
            D.26785 = imb.b[2];
            *code.1895 = D.26785;
            code.1821 = code;
            code.1897 = code.1821;
            code.1898 = code.1897 + 1;
            code = code.1898;
            D.26788 = imb.b[3];
            *code.1897 = D.26788;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.22926>;
      <D.26774>:
      if (1 != 0) goto <D.26789>; else goto <D.26790>;
      <D.26789>:
      code.1821 = code;
      code.1899 = code.1821;
      code.1900 = code.1899 + 1;
      code = code.1900;
      *code.1899 = 131;
      code.1821 = code;
      code.1901 = code.1821;
      code.1902 = code.1901 + 1;
      code = code.1902;
      *code.1901 = 225;
      code.1821 = code;
      *code.1821 = 252;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26795>;
      <D.26790>:
      code.1821 = code;
      code.1903 = code.1821;
      code.1904 = code.1903 + 1;
      code = code.1904;
      *code.1903 = 129;
      code.1821 = code;
      code.1905 = code.1821;
      code.1906 = code.1905 + 1;
      code = code.1906;
      *code.1905 = 225;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = -4;
            code.1821 = code;
            code.1907 = code.1821;
            code.1908 = code.1907 + 1;
            code = code.1908;
            D.26802 = imb.b[0];
            *code.1907 = D.26802;
            code.1821 = code;
            code.1909 = code.1821;
            code.1910 = code.1909 + 1;
            code = code.1910;
            D.26805 = imb.b[1];
            *code.1909 = D.26805;
            code.1821 = code;
            code.1911 = code.1821;
            code.1912 = code.1911 + 1;
            code = code.1912;
            D.26808 = imb.b[2];
            *code.1911 = D.26808;
            code.1821 = code;
            code.1913 = code.1821;
            code.1914 = code.1913 + 1;
            code = code.1914;
            D.26811 = imb.b[3];
            *code.1913 = D.26811;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26795>:
      <D.22926>:
      <D.26742>:
      code.1821 = code;
      code.1915 = code.1821;
      code.1916 = code.1915 + 1;
      code = code.1916;
      *code.1915 = 133;
      code.1821 = code;
      code.1917 = code.1821;
      code.1918 = code.1917 + 1;
      code = code.1918;
      *code.1917 = 201;
      jump_sync_null = code;
      if (1 != 0) goto <D.26816>; else goto <D.26817>;
      <D.26816>:
      code.1821 = code;
      code.1919 = code.1821;
      code.1920 = code.1919 + 1;
      code = code.1920;
      D.26673 = 116;
      *code.1919 = D.26673;
      goto <D.26820>;
      <D.26817>:
      code.1821 = code;
      code.1921 = code.1821;
      code.1922 = code.1921 + 1;
      code = code.1922;
      D.26677 = 116;
      *code.1921 = D.26677;
      <D.26820>:
      code.1821 = code;
      *code.1821 = 255;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      if (aot != 0) goto <D.26823>; else goto <D.26824>;
      <D.26823>:
      switch (4) <default: <D.22932>, case 1: <D.22928>, case 2: <D.22930>, case 4: <D.22931>>
      <D.22928>:
      code.1821 = code;
      code.1923 = code.1821;
      code.1924 = code.1923 + 1;
      code = code.1924;
      *code.1923 = 138;
      goto <D.22929>;
      <D.22930>:
      code.1821 = code;
      code.1925 = code.1821;
      code.1926 = code.1925 + 1;
      code = code.1926;
      *code.1925 = 102;
      <D.22931>:
      code.1821 = code;
      code.1927 = code.1821;
      code.1928 = code.1927 + 1;
      code = code.1928;
      *code.1927 = 139;
      goto <D.22929>;
      <D.22932>:
      __assert_fail ("0", "tramp-x86.c", 866, &__PRETTY_FUNCTION__);
      <D.22929>:
      code.1821 = code;
      code.1929 = code.1821;
      code.1930 = code.1929 + 1;
      code = code.1930;
      *code.1929 = 208;
      code.1821 = code;
      buf.1820 = buf;
      code.1931 = mono_arch_emit_load_aotconst (buf.1820, code.1821, &ji, 48, 0B);
      code = code.1931;
      code.1821 = code;
      code.1932 = mono_x86_emit_tls_get_reg (code.1821, 0, 0);
      code = code.1932;
      if (0 != 0) goto <D.26835>; else goto <D.26836>;
      <D.26835>:
      code.1821 = code;
      code.1933 = code.1821;
      code.1934 = code.1933 + 1;
      code = code.1934;
      *code.1933 = 134;
      goto <D.26839>;
      <D.26836>:
      code.1821 = code;
      code.1935 = code.1821;
      code.1936 = code.1935 + 1;
      code = code.1936;
      *code.1935 = 135;
      <D.26839>:
      code.1821 = code;
      code.1937 = code.1821;
      code.1938 = code.1937 + 1;
      code = code.1938;
      *code.1937 = 208;
      goto <D.26844>;
      <D.26824>:
      D.26845 = mono_thread_get_tls_offset ();
      code.1821 = code;
      code.1939 = mono_x86_emit_tls_get (code.1821, 2, D.26845);
      code = code.1939;
      <D.26844>:
      switch (4) <default: <D.22937>, case 1: <D.22933>, case 2: <D.22935>, case 4: <D.22936>>
      <D.22933>:
      code.1821 = code;
      code.1940 = code.1821;
      code.1941 = code.1940 + 1;
      code = code.1941;
      *code.1940 = 138;
      goto <D.22934>;
      <D.22935>:
      code.1821 = code;
      code.1942 = code.1821;
      code.1943 = code.1942 + 1;
      code = code.1943;
      *code.1942 = 102;
      <D.22936>:
      code.1821 = code;
      code.1944 = code.1821;
      code.1945 = code.1944 + 1;
      code = code.1945;
      *code.1944 = 139;
      goto <D.22934>;
      <D.22937>:
      __assert_fail ("0", "tramp-x86.c", 874, &__PRETTY_FUNCTION__);
      <D.22934>:
      if (0 != 0) goto <D.26853>; else goto <D.26854>;
      <D.26853>:
      if (0 != 0) goto <D.26855>; else goto <D.26856>;
      <D.26855>:
      code.1821 = code;
      code.1946 = code.1821;
      code.1947 = code.1946 + 1;
      code = code.1947;
      *code.1946 = 20;
      code.1821 = code;
      code.1948 = code.1821;
      code.1949 = code.1948 + 1;
      code = code.1949;
      *code.1948 = 36;
      goto <D.26861>;
      <D.26856>:
      if (1 != 0) goto <D.26862>; else goto <D.26863>;
      <D.26862>:
      code.1821 = code;
      code.1950 = code.1821;
      code.1951 = code.1950 + 1;
      code = code.1951;
      *code.1950 = 84;
      code.1821 = code;
      code.1952 = code.1821;
      code.1953 = code.1952 + 1;
      code = code.1953;
      *code.1952 = 36;
      code.1821 = code;
      *code.1821 = 40;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26868>;
      <D.26863>:
      code.1821 = code;
      code.1954 = code.1821;
      code.1955 = code.1954 + 1;
      code = code.1955;
      *code.1954 = 148;
      code.1821 = code;
      code.1956 = code.1821;
      code.1957 = code.1956 + 1;
      code = code.1957;
      *code.1956 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.1821 = code;
            code.1958 = code.1821;
            code.1959 = code.1958 + 1;
            code = code.1959;
            D.26875 = imb.b[0];
            *code.1958 = D.26875;
            code.1821 = code;
            code.1960 = code.1821;
            code.1961 = code.1960 + 1;
            code = code.1961;
            D.26878 = imb.b[1];
            *code.1960 = D.26878;
            code.1821 = code;
            code.1962 = code.1821;
            code.1963 = code.1962 + 1;
            code = code.1963;
            D.26881 = imb.b[2];
            *code.1962 = D.26881;
            code.1821 = code;
            code.1964 = code.1821;
            code.1965 = code.1964 + 1;
            code = code.1965;
            D.26884 = imb.b[3];
            *code.1964 = D.26884;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26868>:
      <D.26861>:
      goto <D.22939>;
      <D.26854>:
      if (0 != 0) goto <D.26885>; else goto <D.26886>;
      <D.26885>:
      code.1821 = code;
      code.1966 = code.1821;
      code.1967 = code.1966 + 1;
      code = code.1967;
      *code.1966 = 18;
      goto <D.22939>;
      <D.26886>:
      if (1 != 0) goto <D.26889>; else goto <D.26890>;
      <D.26889>:
      code.1821 = code;
      code.1968 = code.1821;
      code.1969 = code.1968 + 1;
      code = code.1969;
      *code.1968 = 82;
      code.1821 = code;
      *code.1821 = 40;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26893>;
      <D.26890>:
      code.1821 = code;
      code.1970 = code.1821;
      code.1971 = code.1970 + 1;
      code = code.1971;
      *code.1970 = 146;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.1821 = code;
            code.1972 = code.1821;
            code.1973 = code.1972 + 1;
            code = code.1973;
            D.26898 = imb.b[0];
            *code.1972 = D.26898;
            code.1821 = code;
            code.1974 = code.1821;
            code.1975 = code.1974 + 1;
            code = code.1975;
            D.26901 = imb.b[1];
            *code.1974 = D.26901;
            code.1821 = code;
            code.1976 = code.1821;
            code.1977 = code.1976 + 1;
            code = code.1977;
            D.26904 = imb.b[2];
            *code.1976 = D.26904;
            code.1821 = code;
            code.1978 = code.1821;
            code.1979 = code.1978 + 1;
            code = code.1979;
            D.26907 = imb.b[3];
            *code.1978 = D.26907;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26893>:
      <D.22939>:
      if (1 != 0) goto <D.26908>; else goto <D.26909>;
      <D.26908>:
      code.1821 = code;
      code.1980 = code.1821;
      code.1981 = code.1980 + 1;
      code = code.1981;
      *code.1980 = 131;
      if (0 != 0) goto <D.26912>; else goto <D.26913>;
      <D.26912>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.26914>; else goto <D.26915>;
      <D.26914>:
      code.1821 = code;
      code.1982 = code.1821;
      code.1983 = code.1982 + 1;
      code = code.1983;
      *code.1982 = 60;
      code.1821 = code;
      code.1984 = code.1821;
      code.1985 = code.1984 + 1;
      code = code.1985;
      *code.1984 = 36;
      goto <D.26920>;
      <D.26915>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.26923>; else goto <D.26924>;
      <D.26923>:
      code.1821 = code;
      code.1987 = code.1821;
      code.1988 = code.1987 + 1;
      code = code.1988;
      *code.1987 = 124;
      code.1821 = code;
      code.1989 = code.1821;
      code.1990 = code.1989 + 1;
      code = code.1990;
      *code.1989 = 36;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26930>;
      <D.26924>:
      code.1821 = code;
      code.1991 = code.1821;
      code.1992 = code.1991 + 1;
      code = code.1992;
      *code.1991 = 188;
      code.1821 = code;
      code.1993 = code.1821;
      code.1994 = code.1993 + 1;
      code = code.1994;
      *code.1993 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.1995 = code.1821;
            code.1996 = code.1995 + 1;
            code = code.1996;
            D.26937 = imb.b[0];
            *code.1995 = D.26937;
            code.1821 = code;
            code.1997 = code.1821;
            code.1998 = code.1997 + 1;
            code = code.1998;
            D.26940 = imb.b[1];
            *code.1997 = D.26940;
            code.1821 = code;
            code.1999 = code.1821;
            code.2000 = code.1999 + 1;
            code = code.2000;
            D.26943 = imb.b[2];
            *code.1999 = D.26943;
            code.1821 = code;
            code.2001 = code.1821;
            code.2002 = code.2001 + 1;
            code = code.2002;
            D.26946 = imb.b[3];
            *code.2001 = D.26946;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26930>:
      <D.26920>:
      goto <D.22942>;
      <D.26913>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.26947>; else goto <D.26948>;
      <D.26947>:
      code.1821 = code;
      code.2003 = code.1821;
      code.2004 = code.2003 + 1;
      code = code.2004;
      *code.2003 = 57;
      goto <D.22942>;
      <D.26948>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.26951>; else goto <D.26952>;
      <D.26951>:
      code.1821 = code;
      code.2005 = code.1821;
      code.2006 = code.2005 + 1;
      code = code.2006;
      *code.2005 = 121;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26955>;
      <D.26952>:
      code.1821 = code;
      code.2007 = code.1821;
      code.2008 = code.2007 + 1;
      code = code.2008;
      *code.2007 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2009 = code.1821;
            code.2010 = code.2009 + 1;
            code = code.2010;
            D.26960 = imb.b[0];
            *code.2009 = D.26960;
            code.1821 = code;
            code.2011 = code.1821;
            code.2012 = code.2011 + 1;
            code = code.2012;
            D.26963 = imb.b[1];
            *code.2011 = D.26963;
            code.1821 = code;
            code.2013 = code.1821;
            code.2014 = code.2013 + 1;
            code = code.2014;
            D.26966 = imb.b[2];
            *code.2013 = D.26966;
            code.1821 = code;
            code.2015 = code.1821;
            code.2016 = code.2015 + 1;
            code = code.2016;
            D.26969 = imb.b[3];
            *code.2015 = D.26969;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26955>:
      <D.22942>:
      code.1821 = code;
      *code.1821 = 0;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26970>;
      <D.26909>:
      code.1821 = code;
      code.2017 = code.1821;
      code.2018 = code.2017 + 1;
      code = code.2018;
      *code.2017 = 129;
      if (0 != 0) goto <D.26973>; else goto <D.26974>;
      <D.26973>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.26975>; else goto <D.26976>;
      <D.26975>:
      code.1821 = code;
      code.2019 = code.1821;
      code.2020 = code.2019 + 1;
      code = code.2020;
      *code.2019 = 60;
      code.1821 = code;
      code.2021 = code.1821;
      code.2022 = code.2021 + 1;
      code = code.2022;
      *code.2021 = 36;
      goto <D.26981>;
      <D.26976>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.26982>; else goto <D.26983>;
      <D.26982>:
      code.1821 = code;
      code.2023 = code.1821;
      code.2024 = code.2023 + 1;
      code = code.2024;
      *code.2023 = 124;
      code.1821 = code;
      code.2025 = code.1821;
      code.2026 = code.2025 + 1;
      code = code.2026;
      *code.2025 = 36;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.26988>;
      <D.26983>:
      code.1821 = code;
      code.2027 = code.1821;
      code.2028 = code.2027 + 1;
      code = code.2028;
      *code.2027 = 188;
      code.1821 = code;
      code.2029 = code.1821;
      code.2030 = code.2029 + 1;
      code = code.2030;
      *code.2029 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2031 = code.1821;
            code.2032 = code.2031 + 1;
            code = code.2032;
            D.26995 = imb.b[0];
            *code.2031 = D.26995;
            code.1821 = code;
            code.2033 = code.1821;
            code.2034 = code.2033 + 1;
            code = code.2034;
            D.26998 = imb.b[1];
            *code.2033 = D.26998;
            code.1821 = code;
            code.2035 = code.1821;
            code.2036 = code.2035 + 1;
            code = code.2036;
            D.27001 = imb.b[2];
            *code.2035 = D.27001;
            code.1821 = code;
            code.2037 = code.1821;
            code.2038 = code.2037 + 1;
            code = code.2038;
            D.27004 = imb.b[3];
            *code.2037 = D.27004;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26988>:
      <D.26981>:
      goto <D.22945>;
      <D.26974>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.27005>; else goto <D.27006>;
      <D.27005>:
      code.1821 = code;
      code.2039 = code.1821;
      code.2040 = code.2039 + 1;
      code = code.2040;
      *code.2039 = 57;
      goto <D.22945>;
      <D.27006>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.27009>; else goto <D.27010>;
      <D.27009>:
      code.1821 = code;
      code.2041 = code.1821;
      code.2042 = code.2041 + 1;
      code = code.2042;
      *code.2041 = 121;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27013>;
      <D.27010>:
      code.1821 = code;
      code.2043 = code.1821;
      code.2044 = code.2043 + 1;
      code = code.2044;
      *code.2043 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2045 = code.1821;
            code.2046 = code.2045 + 1;
            code = code.2046;
            D.27018 = imb.b[0];
            *code.2045 = D.27018;
            code.1821 = code;
            code.2047 = code.1821;
            code.2048 = code.2047 + 1;
            code = code.2048;
            D.27021 = imb.b[1];
            *code.2047 = D.27021;
            code.1821 = code;
            code.2049 = code.1821;
            code.2050 = code.2049 + 1;
            code = code.2050;
            D.27024 = imb.b[2];
            *code.2049 = D.27024;
            code.1821 = code;
            code.2051 = code.1821;
            code.2052 = code.2051 + 1;
            code = code.2052;
            D.27027 = imb.b[3];
            *code.2051 = D.27027;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27013>:
      <D.22945>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1821 = code;
            code.2053 = code.1821;
            code.2054 = code.2053 + 1;
            code = code.2054;
            D.27030 = imb.b[0];
            *code.2053 = D.27030;
            code.1821 = code;
            code.2055 = code.1821;
            code.2056 = code.2055 + 1;
            code = code.2056;
            D.27033 = imb.b[1];
            *code.2055 = D.27033;
            code.1821 = code;
            code.2057 = code.1821;
            code.2058 = code.2057 + 1;
            code = code.2058;
            D.27036 = imb.b[2];
            *code.2057 = D.27036;
            code.1821 = code;
            code.2059 = code.1821;
            code.2060 = code.2059 + 1;
            code = code.2060;
            D.27039 = imb.b[3];
            *code.2059 = D.27039;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26970>:
      jump_tid = code;
      if (1 != 0) goto <D.27040>; else goto <D.27041>;
      <D.27040>:
      code.1821 = code;
      code.2061 = code.1821;
      code.2062 = code.2061 + 1;
      code = code.2062;
      D.26768 = 117;
      *code.2061 = D.26768;
      goto <D.27044>;
      <D.27041>:
      code.1821 = code;
      code.2063 = code.1821;
      code.2064 = code.2063 + 1;
      code = code.2064;
      D.26772 = 117;
      *code.2063 = D.26772;
      <D.27044>:
      code.1821 = code;
      *code.1821 = 255;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      code.1821 = code;
      code.2065 = code.1821;
      code.2066 = code.2065 + 1;
      code = code.2066;
      *code.2065 = 80;
      code.1821 = code;
      code.2067 = code.1821;
      code.2068 = code.2067 + 1;
      code = code.2068;
      *code.2067 = 51;
      code.1821 = code;
      code.2069 = code.1821;
      code.2070 = code.2069 + 1;
      code = code.2070;
      *code.2069 = 192;
      code.1821 = code;
      code.2071 = code.1821;
      code.2072 = code.2071 + 1;
      code = code.2072;
      *code.2071 = 240;
      code.1821 = code;
      code.2073 = code.1821;
      code.2074 = code.2073 + 1;
      code = code.2074;
      *code.2073 = 15;
      code.1821 = code;
      code.2075 = code.1821;
      code.2076 = code.2075 + 1;
      code = code.2076;
      *code.2075 = 177;
      if (0 != 0) goto <D.27059>; else goto <D.27060>;
      <D.27059>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.27061>; else goto <D.27062>;
      <D.27061>:
      code.1821 = code;
      code.2077 = code.1821;
      code.2078 = code.2077 + 1;
      code = code.2078;
      *code.2077 = 20;
      code.1821 = code;
      code.2079 = code.1821;
      code.2080 = code.2079 + 1;
      code = code.2080;
      *code.2079 = 36;
      goto <D.27067>;
      <D.27062>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.27068>; else goto <D.27069>;
      <D.27068>:
      code.1821 = code;
      code.2081 = code.1821;
      code.2082 = code.2081 + 1;
      code = code.2082;
      *code.2081 = 84;
      code.1821 = code;
      code.2083 = code.1821;
      code.2084 = code.2083 + 1;
      code = code.2084;
      *code.2083 = 36;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27074>;
      <D.27069>:
      code.1821 = code;
      code.2085 = code.1821;
      code.2086 = code.2085 + 1;
      code = code.2086;
      *code.2085 = 148;
      code.1821 = code;
      code.2087 = code.1821;
      code.2088 = code.2087 + 1;
      code = code.2088;
      *code.2087 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2089 = code.1821;
            code.2090 = code.2089 + 1;
            code = code.2090;
            D.27081 = imb.b[0];
            *code.2089 = D.27081;
            code.1821 = code;
            code.2091 = code.1821;
            code.2092 = code.2091 + 1;
            code = code.2092;
            D.27084 = imb.b[1];
            *code.2091 = D.27084;
            code.1821 = code;
            code.2093 = code.1821;
            code.2094 = code.2093 + 1;
            code = code.2094;
            D.27087 = imb.b[2];
            *code.2093 = D.27087;
            code.1821 = code;
            code.2095 = code.1821;
            code.2096 = code.2095 + 1;
            code = code.2096;
            D.27090 = imb.b[3];
            *code.2095 = D.27090;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27074>:
      <D.27067>:
      goto <D.22949>;
      <D.27060>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.27091>; else goto <D.27092>;
      <D.27091>:
      code.1821 = code;
      code.2097 = code.1821;
      code.2098 = code.2097 + 1;
      code = code.2098;
      *code.2097 = 17;
      goto <D.22949>;
      <D.27092>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.27095>; else goto <D.27096>;
      <D.27095>:
      code.1821 = code;
      code.2099 = code.1821;
      code.2100 = code.2099 + 1;
      code = code.2100;
      *code.2099 = 81;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27099>;
      <D.27096>:
      code.1821 = code;
      code.2101 = code.1821;
      code.2102 = code.2101 + 1;
      code = code.2102;
      *code.2101 = 145;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2103 = code.1821;
            code.2104 = code.2103 + 1;
            code = code.2104;
            D.27104 = imb.b[0];
            *code.2103 = D.27104;
            code.1821 = code;
            code.2105 = code.1821;
            code.2106 = code.2105 + 1;
            code = code.2106;
            D.27107 = imb.b[1];
            *code.2105 = D.27107;
            code.1821 = code;
            code.2107 = code.1821;
            code.2108 = code.2107 + 1;
            code = code.2108;
            D.27110 = imb.b[2];
            *code.2107 = D.27110;
            code.1821 = code;
            code.2109 = code.1821;
            code.2110 = code.2109 + 1;
            code = code.2110;
            D.27113 = imb.b[3];
            *code.2109 = D.27113;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27099>:
      <D.22949>:
      jump_cmpxchg_failed = code;
      if (1 != 0) goto <D.27114>; else goto <D.27115>;
      <D.27114>:
      code.1821 = code;
      code.2111 = code.1821;
      code.2112 = code.2111 + 1;
      code = code.2112;
      D.26768 = 117;
      *code.2111 = D.26768;
      goto <D.27118>;
      <D.27115>:
      code.1821 = code;
      code.2113 = code.1821;
      code.2114 = code.2113 + 1;
      code = code.2114;
      D.26772 = 117;
      *code.2113 = D.26772;
      <D.27118>:
      code.1821 = code;
      *code.1821 = 255;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      code.1821 = code;
      code.2115 = code.1821;
      code.2116 = code.2115 + 1;
      code = code.2116;
      *code.2115 = 88;
      code.1821 = code;
      code.2117 = code.1821;
      code.2118 = code.2117 + 1;
      code = code.2118;
      *code.2117 = 195;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_tid + 1;
        size = 0;
        D.27125 = MEM[(unsigned char *)jump_tid];
        D.27126 = (int) D.27125;
        switch (D.27126) <default: <D.22978>, case 15: <D.22957>, case 112: <D.22962>, case 113: <D.22963>, case 114: <D.22964>, case 115: <D.22965>, case 116: <D.22966>, case 117: <D.22967>, case 118: <D.22968>, case 119: <D.22969>, case 120: <D.22970>, case 121: <D.22971>, case 122: <D.22972>, case 123: <D.22973>, case 124: <D.22974>, case 125: <D.22975>, case 126: <D.22976>, case 127: <D.22977>, case 224: <D.22958>, case 225: <D.22959>, case 226: <D.22960>, case 232: <D.22954>, case 233: <D.22955>, case 235: <D.22961>>
        <D.22954>:
        <D.22955>:
        size = size + 1;
        goto <D.22956>;
        <D.22957>:
        D.27127 = *pos;
        D.27128 = D.27127 + 144;
        if (D.27128 > 31) goto <D.27129>; else goto <D.27130>;
        <D.27129>:
        __assert_fail ("0", "tramp-x86.c", 898, &__PRETTY_FUNCTION__);
        <D.27130>:
        size = size + 1;
        pos = pos + 1;
        goto <D.22956>;
        <D.22958>:
        <D.22959>:
        <D.22960>:
        <D.22961>:
        <D.22962>:
        <D.22963>:
        <D.22964>:
        <D.22965>:
        <D.22966>:
        <D.22967>:
        <D.22968>:
        <D.22969>:
        <D.22970>:
        <D.22971>:
        <D.22972>:
        <D.22973>:
        <D.22974>:
        <D.22975>:
        <D.22976>:
        <D.22977>:
        goto <D.22956>;
        <D.22978>:
        __assert_fail ("0", "tramp-x86.c", 898, &__PRETTY_FUNCTION__);
        <D.22956>:
        code.1821 = code;
        code.2119 = (int) code.1821;
        pos.2120 = (int) pos;
        disp = code.2119 - pos.2120;
        if (size != 0) goto <D.27133>; else goto <D.27134>;
        <D.27133>:
        {
          union x86_imm_buf imb;

          try
            {
              D.27135 = disp + -4;
              imb.val = D.27135;
              pos.2121 = pos;
              pos = pos.2121 + 1;
              D.27137 = imb.b[0];
              *pos.2121 = D.27137;
              pos.2122 = pos;
              pos = pos.2122 + 1;
              D.27139 = imb.b[1];
              *pos.2122 = D.27139;
              pos.2123 = pos;
              pos = pos.2123 + 1;
              D.27141 = imb.b[2];
              *pos.2123 = D.27141;
              pos.2124 = pos;
              pos = pos.2124 + 1;
              D.27143 = imb.b[3];
              *pos.2124 = D.27143;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27144>;
        <D.27134>:
        disp.2125 = (unsigned int) disp;
        D.27146 = disp.2125 + 127;
        if (D.27146 <= 255) goto <D.27147>; else goto <D.27148>;
        <D.27147>:
        D.27149 = (unsigned char) disp;
        D.27150 = D.27149 + 255;
        *pos = D.27150;
        pos = pos + 1;
        goto <D.27151>;
        <D.27148>:
        __assert_fail ("0", "tramp-x86.c", 898, &__PRETTY_FUNCTION__);
        <D.27151>:
        <D.27144>:
      }
      code.1821 = code;
      code.2126 = code.1821;
      code.2127 = code.2126 + 1;
      code = code.2127;
      *code.2126 = 57;
      if (0 != 0) goto <D.27154>; else goto <D.27155>;
      <D.27154>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.27156>; else goto <D.27157>;
      <D.27156>:
      code.1821 = code;
      code.2128 = code.1821;
      code.2129 = code.2128 + 1;
      code = code.2129;
      *code.2128 = 20;
      code.1821 = code;
      code.2130 = code.1821;
      code.2131 = code.2130 + 1;
      code = code.2131;
      *code.2130 = 36;
      goto <D.27162>;
      <D.27157>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.27163>; else goto <D.27164>;
      <D.27163>:
      code.1821 = code;
      code.2132 = code.1821;
      code.2133 = code.2132 + 1;
      code = code.2133;
      *code.2132 = 84;
      code.1821 = code;
      code.2134 = code.1821;
      code.2135 = code.2134 + 1;
      code = code.2135;
      *code.2134 = 36;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27169>;
      <D.27164>:
      code.1821 = code;
      code.2136 = code.1821;
      code.2137 = code.2136 + 1;
      code = code.2137;
      *code.2136 = 148;
      code.1821 = code;
      code.2138 = code.1821;
      code.2139 = code.2138 + 1;
      code = code.2139;
      *code.2138 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2140 = code.1821;
            code.2141 = code.2140 + 1;
            code = code.2141;
            D.27176 = imb.b[0];
            *code.2140 = D.27176;
            code.1821 = code;
            code.2142 = code.1821;
            code.2143 = code.2142 + 1;
            code = code.2143;
            D.27179 = imb.b[1];
            *code.2142 = D.27179;
            code.1821 = code;
            code.2144 = code.1821;
            code.2145 = code.2144 + 1;
            code = code.2145;
            D.27182 = imb.b[2];
            *code.2144 = D.27182;
            code.1821 = code;
            code.2146 = code.1821;
            code.2147 = code.2146 + 1;
            code = code.2147;
            D.27185 = imb.b[3];
            *code.2146 = D.27185;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27169>:
      <D.27162>:
      goto <D.22981>;
      <D.27155>:
      owner_offset.1813 = owner_offset;
      if (owner_offset.1813 == 0) goto <D.27186>; else goto <D.27187>;
      <D.27186>:
      code.1821 = code;
      code.2148 = code.1821;
      code.2149 = code.2148 + 1;
      code = code.2149;
      *code.2148 = 17;
      goto <D.22981>;
      <D.27187>:
      owner_offset.1813 = owner_offset;
      owner_offset.1986 = (unsigned int) owner_offset.1813;
      D.26922 = owner_offset.1986 + 128;
      if (D.26922 <= 255) goto <D.27190>; else goto <D.27191>;
      <D.27190>:
      code.1821 = code;
      code.2150 = code.1821;
      code.2151 = code.2150 + 1;
      code = code.2151;
      *code.2150 = 81;
      code.1821 = code;
      owner_offset.1813 = owner_offset;
      D.26929 = (unsigned char) owner_offset.1813;
      *code.1821 = D.26929;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27194>;
      <D.27191>:
      code.1821 = code;
      code.2152 = code.1821;
      code.2153 = code.2152 + 1;
      code = code.2153;
      *code.2152 = 145;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.1813 = owner_offset;
            imb.val = owner_offset.1813;
            code.1821 = code;
            code.2154 = code.1821;
            code.2155 = code.2154 + 1;
            code = code.2155;
            D.27199 = imb.b[0];
            *code.2154 = D.27199;
            code.1821 = code;
            code.2156 = code.1821;
            code.2157 = code.2156 + 1;
            code = code.2157;
            D.27202 = imb.b[1];
            *code.2156 = D.27202;
            code.1821 = code;
            code.2158 = code.1821;
            code.2159 = code.2158 + 1;
            code = code.2159;
            D.27205 = imb.b[2];
            *code.2158 = D.27205;
            code.1821 = code;
            code.2160 = code.1821;
            code.2161 = code.2160 + 1;
            code = code.2161;
            D.27208 = imb.b[3];
            *code.2160 = D.27208;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27194>:
      <D.22981>:
      jump_other_owner = code;
      if (1 != 0) goto <D.27209>; else goto <D.27210>;
      <D.27209>:
      code.1821 = code;
      code.2162 = code.1821;
      code.2163 = code.2162 + 1;
      code = code.2163;
      D.26768 = 117;
      *code.2162 = D.26768;
      goto <D.27213>;
      <D.27210>:
      code.1821 = code;
      code.2164 = code.1821;
      code.2165 = code.2164 + 1;
      code = code.2165;
      D.26772 = 117;
      *code.2164 = D.26772;
      <D.27213>:
      code.1821 = code;
      *code.1821 = 255;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      code.1821 = code;
      code.2166 = code.1821;
      code.2167 = code.2166 + 1;
      code = code.2167;
      *code.2166 = 255;
      if (0 != 0) goto <D.27218>; else goto <D.27219>;
      <D.27218>:
      nest_offset.1815 = nest_offset;
      if (nest_offset.1815 == 0) goto <D.27220>; else goto <D.27221>;
      <D.27220>:
      code.1821 = code;
      code.2168 = code.1821;
      code.2169 = code.2168 + 1;
      code = code.2169;
      *code.2168 = 4;
      code.1821 = code;
      code.2170 = code.1821;
      code.2171 = code.2170 + 1;
      code = code.2171;
      *code.2170 = 36;
      goto <D.27226>;
      <D.27221>:
      nest_offset.1815 = nest_offset;
      nest_offset.2172 = (unsigned int) nest_offset.1815;
      D.27228 = nest_offset.2172 + 128;
      if (D.27228 <= 255) goto <D.27229>; else goto <D.27230>;
      <D.27229>:
      code.1821 = code;
      code.2173 = code.1821;
      code.2174 = code.2173 + 1;
      code = code.2174;
      *code.2173 = 68;
      code.1821 = code;
      code.2175 = code.1821;
      code.2176 = code.2175 + 1;
      code = code.2176;
      *code.2175 = 36;
      code.1821 = code;
      nest_offset.1815 = nest_offset;
      D.27235 = (unsigned char) nest_offset.1815;
      *code.1821 = D.27235;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27236>;
      <D.27230>:
      code.1821 = code;
      code.2177 = code.1821;
      code.2178 = code.2177 + 1;
      code = code.2178;
      *code.2177 = 132;
      code.1821 = code;
      code.2179 = code.1821;
      code.2180 = code.2179 + 1;
      code = code.2180;
      *code.2179 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.1815 = nest_offset;
            imb.val = nest_offset.1815;
            code.1821 = code;
            code.2181 = code.1821;
            code.2182 = code.2181 + 1;
            code = code.2182;
            D.27243 = imb.b[0];
            *code.2181 = D.27243;
            code.1821 = code;
            code.2183 = code.1821;
            code.2184 = code.2183 + 1;
            code = code.2184;
            D.27246 = imb.b[1];
            *code.2183 = D.27246;
            code.1821 = code;
            code.2185 = code.1821;
            code.2186 = code.2185 + 1;
            code = code.2186;
            D.27249 = imb.b[2];
            *code.2185 = D.27249;
            code.1821 = code;
            code.2187 = code.1821;
            code.2188 = code.2187 + 1;
            code = code.2188;
            D.27252 = imb.b[3];
            *code.2187 = D.27252;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27236>:
      <D.27226>:
      goto <D.22984>;
      <D.27219>:
      nest_offset.1815 = nest_offset;
      if (nest_offset.1815 == 0) goto <D.27253>; else goto <D.27254>;
      <D.27253>:
      code.1821 = code;
      code.2189 = code.1821;
      code.2190 = code.2189 + 1;
      code = code.2190;
      *code.2189 = 1;
      goto <D.22984>;
      <D.27254>:
      nest_offset.1815 = nest_offset;
      nest_offset.2172 = (unsigned int) nest_offset.1815;
      D.27228 = nest_offset.2172 + 128;
      if (D.27228 <= 255) goto <D.27257>; else goto <D.27258>;
      <D.27257>:
      code.1821 = code;
      code.2191 = code.1821;
      code.2192 = code.2191 + 1;
      code = code.2192;
      *code.2191 = 65;
      code.1821 = code;
      nest_offset.1815 = nest_offset;
      D.27235 = (unsigned char) nest_offset.1815;
      *code.1821 = D.27235;
      code.1821 = code;
      code.1830 = code.1821 + 1;
      code = code.1830;
      goto <D.27261>;
      <D.27258>:
      code.1821 = code;
      code.2193 = code.1821;
      code.2194 = code.2193 + 1;
      code = code.2194;
      *code.2193 = 129;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.1815 = nest_offset;
            imb.val = nest_offset.1815;
            code.1821 = code;
            code.2195 = code.1821;
            code.2196 = code.2195 + 1;
            code = code.2196;
            D.27266 = imb.b[0];
            *code.2195 = D.27266;
            code.1821 = code;
            code.2197 = code.1821;
            code.2198 = code.2197 + 1;
            code = code.2198;
            D.27269 = imb.b[1];
            *code.2197 = D.27269;
            code.1821 = code;
            code.2199 = code.1821;
            code.2200 = code.2199 + 1;
            code = code.2200;
            D.27272 = imb.b[2];
            *code.2199 = D.27272;
            code.1821 = code;
            code.2201 = code.1821;
            code.2202 = code.2201 + 1;
            code = code.2202;
            D.27275 = imb.b[3];
            *code.2201 = D.27275;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27261>:
      <D.22984>:
      code.1821 = code;
      code.2203 = code.1821;
      code.2204 = code.2203 + 1;
      code = code.2204;
      *code.2203 = 195;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_obj_null + 1;
        size = 0;
        D.27278 = MEM[(unsigned char *)jump_obj_null];
        D.27279 = (int) D.27278;
        switch (D.27279) <default: <D.23013>, case 15: <D.22992>, case 112: <D.22997>, case 113: <D.22998>, case 114: <D.22999>, case 115: <D.23000>, case 116: <D.23001>, case 117: <D.23002>, case 118: <D.23003>, case 119: <D.23004>, case 120: <D.23005>, case 121: <D.23006>, case 122: <D.23007>, case 123: <D.23008>, case 124: <D.23009>, case 125: <D.23010>, case 126: <D.23011>, case 127: <D.23012>, case 224: <D.22993>, case 225: <D.22994>, case 226: <D.22995>, case 232: <D.22989>, case 233: <D.22990>, case 235: <D.22996>>
        <D.22989>:
        <D.22990>:
        size = size + 1;
        goto <D.22991>;
        <D.22992>:
        D.27280 = *pos;
        D.27281 = D.27280 + 144;
        if (D.27281 > 31) goto <D.27282>; else goto <D.27283>;
        <D.27282>:
        __assert_fail ("0", "tramp-x86.c", 910, &__PRETTY_FUNCTION__);
        <D.27283>:
        size = size + 1;
        pos = pos + 1;
        goto <D.22991>;
        <D.22993>:
        <D.22994>:
        <D.22995>:
        <D.22996>:
        <D.22997>:
        <D.22998>:
        <D.22999>:
        <D.23000>:
        <D.23001>:
        <D.23002>:
        <D.23003>:
        <D.23004>:
        <D.23005>:
        <D.23006>:
        <D.23007>:
        <D.23008>:
        <D.23009>:
        <D.23010>:
        <D.23011>:
        <D.23012>:
        goto <D.22991>;
        <D.23013>:
        __assert_fail ("0", "tramp-x86.c", 910, &__PRETTY_FUNCTION__);
        <D.22991>:
        code.1821 = code;
        code.2119 = (int) code.1821;
        pos.2205 = (int) pos;
        disp = code.2119 - pos.2205;
        if (size != 0) goto <D.27285>; else goto <D.27286>;
        <D.27285>:
        {
          union x86_imm_buf imb;

          try
            {
              D.27287 = disp + -4;
              imb.val = D.27287;
              pos.2206 = pos;
              pos = pos.2206 + 1;
              D.27289 = imb.b[0];
              *pos.2206 = D.27289;
              pos.2207 = pos;
              pos = pos.2207 + 1;
              D.27291 = imb.b[1];
              *pos.2207 = D.27291;
              pos.2208 = pos;
              pos = pos.2208 + 1;
              D.27293 = imb.b[2];
              *pos.2208 = D.27293;
              pos.2209 = pos;
              pos = pos.2209 + 1;
              D.27295 = imb.b[3];
              *pos.2209 = D.27295;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27296>;
        <D.27286>:
        disp.2210 = (unsigned int) disp;
        D.27298 = disp.2210 + 127;
        if (D.27298 <= 255) goto <D.27299>; else goto <D.27300>;
        <D.27299>:
        D.27301 = (unsigned char) disp;
        D.27302 = D.27301 + 255;
        *pos = D.27302;
        pos = pos + 1;
        goto <D.27303>;
        <D.27300>:
        __assert_fail ("0", "tramp-x86.c", 910, &__PRETTY_FUNCTION__);
        <D.27303>:
        <D.27296>:
      }
      if (jump_sync_thin_hash != 0B) goto <D.27304>; else goto <D.27305>;
      <D.27304>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_sync_thin_hash + 1;
        size = 0;
        D.27306 = MEM[(unsigned char *)jump_sync_thin_hash];
        D.27307 = (int) D.27306;
        switch (D.27307) <default: <D.23042>, case 15: <D.23021>, case 112: <D.23026>, case 113: <D.23027>, case 114: <D.23028>, case 115: <D.23029>, case 116: <D.23030>, case 117: <D.23031>, case 118: <D.23032>, case 119: <D.23033>, case 120: <D.23034>, case 121: <D.23035>, case 122: <D.23036>, case 123: <D.23037>, case 124: <D.23038>, case 125: <D.23039>, case 126: <D.23040>, case 127: <D.23041>, case 224: <D.23022>, case 225: <D.23023>, case 226: <D.23024>, case 232: <D.23018>, case 233: <D.23019>, case 235: <D.23025>>
        <D.23018>:
        <D.23019>:
        size = size + 1;
        goto <D.23020>;
        <D.23021>:
        D.27308 = *pos;
        D.27309 = D.27308 + 144;
        if (D.27309 > 31) goto <D.27310>; else goto <D.27311>;
        <D.27310>:
        __assert_fail ("0", "tramp-x86.c", 912, &__PRETTY_FUNCTION__);
        <D.27311>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23020>;
        <D.23022>:
        <D.23023>:
        <D.23024>:
        <D.23025>:
        <D.23026>:
        <D.23027>:
        <D.23028>:
        <D.23029>:
        <D.23030>:
        <D.23031>:
        <D.23032>:
        <D.23033>:
        <D.23034>:
        <D.23035>:
        <D.23036>:
        <D.23037>:
        <D.23038>:
        <D.23039>:
        <D.23040>:
        <D.23041>:
        goto <D.23020>;
        <D.23042>:
        __assert_fail ("0", "tramp-x86.c", 912, &__PRETTY_FUNCTION__);
        <D.23020>:
        code.1821 = code;
        code.2119 = (int) code.1821;
        pos.2211 = (int) pos;
        disp = code.2119 - pos.2211;
        if (size != 0) goto <D.27313>; else goto <D.27314>;
        <D.27313>:
        {
          union x86_imm_buf imb;

          try
            {
              D.27315 = disp + -4;
              imb.val = D.27315;
              pos.2212 = pos;
              pos = pos.2212 + 1;
              D.27317 = imb.b[0];
              *pos.2212 = D.27317;
              pos.2213 = pos;
              pos = pos.2213 + 1;
              D.27319 = imb.b[1];
              *pos.2213 = D.27319;
              pos.2214 = pos;
              pos = pos.2214 + 1;
              D.27321 = imb.b[2];
              *pos.2214 = D.27321;
              pos.2215 = pos;
              pos = pos.2215 + 1;
              D.27323 = imb.b[3];
              *pos.2215 = D.27323;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27324>;
        <D.27314>:
        disp.2216 = (unsigned int) disp;
        D.27326 = disp.2216 + 127;
        if (D.27326 <= 255) goto <D.27327>; else goto <D.27328>;
        <D.27327>:
        D.27329 = (unsigned char) disp;
        D.27330 = D.27329 + 255;
        *pos = D.27330;
        pos = pos + 1;
        goto <D.27331>;
        <D.27328>:
        __assert_fail ("0", "tramp-x86.c", 912, &__PRETTY_FUNCTION__);
        <D.27331>:
        <D.27324>:
      }
      <D.27305>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_sync_null + 1;
        size = 0;
        D.27332 = MEM[(unsigned char *)jump_sync_null];
        D.27333 = (int) D.27332;
        switch (D.27333) <default: <D.23071>, case 15: <D.23050>, case 112: <D.23055>, case 113: <D.23056>, case 114: <D.23057>, case 115: <D.23058>, case 116: <D.23059>, case 117: <D.23060>, case 118: <D.23061>, case 119: <D.23062>, case 120: <D.23063>, case 121: <D.23064>, case 122: <D.23065>, case 123: <D.23066>, case 124: <D.23067>, case 125: <D.23068>, case 126: <D.23069>, case 127: <D.23070>, case 224: <D.23051>, case 225: <D.23052>, case 226: <D.23053>, case 232: <D.23047>, case 233: <D.23048>, case 235: <D.23054>>
        <D.23047>:
        <D.23048>:
        size = size + 1;
        goto <D.23049>;
        <D.23050>:
        D.27334 = *pos;
        D.27335 = D.27334 + 144;
        if (D.27335 > 31) goto <D.27336>; else goto <D.27337>;
        <D.27336>:
        __assert_fail ("0", "tramp-x86.c", 913, &__PRETTY_FUNCTION__);
        <D.27337>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23049>;
        <D.23051>:
        <D.23052>:
        <D.23053>:
        <D.23054>:
        <D.23055>:
        <D.23056>:
        <D.23057>:
        <D.23058>:
        <D.23059>:
        <D.23060>:
        <D.23061>:
        <D.23062>:
        <D.23063>:
        <D.23064>:
        <D.23065>:
        <D.23066>:
        <D.23067>:
        <D.23068>:
        <D.23069>:
        <D.23070>:
        goto <D.23049>;
        <D.23071>:
        __assert_fail ("0", "tramp-x86.c", 913, &__PRETTY_FUNCTION__);
        <D.23049>:
        code.1821 = code;
        code.2119 = (int) code.1821;
        pos.2217 = (int) pos;
        disp = code.2119 - pos.2217;
        if (size != 0) goto <D.27339>; else goto <D.27340>;
        <D.27339>:
        {
          union x86_imm_buf imb;

          try
            {
              D.27341 = disp + -4;
              imb.val = D.27341;
              pos.2218 = pos;
              pos = pos.2218 + 1;
              D.27343 = imb.b[0];
              *pos.2218 = D.27343;
              pos.2219 = pos;
              pos = pos.2219 + 1;
              D.27345 = imb.b[1];
              *pos.2219 = D.27345;
              pos.2220 = pos;
              pos = pos.2220 + 1;
              D.27347 = imb.b[2];
              *pos.2220 = D.27347;
              pos.2221 = pos;
              pos = pos.2221 + 1;
              D.27349 = imb.b[3];
              *pos.2221 = D.27349;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27350>;
        <D.27340>:
        disp.2222 = (unsigned int) disp;
        D.27352 = disp.2222 + 127;
        if (D.27352 <= 255) goto <D.27353>; else goto <D.27354>;
        <D.27353>:
        D.27355 = (unsigned char) disp;
        D.27356 = D.27355 + 255;
        *pos = D.27356;
        pos = pos + 1;
        goto <D.27357>;
        <D.27354>:
        __assert_fail ("0", "tramp-x86.c", 913, &__PRETTY_FUNCTION__);
        <D.27357>:
        <D.27350>:
      }
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_other_owner + 1;
        size = 0;
        D.27358 = MEM[(unsigned char *)jump_other_owner];
        D.27359 = (int) D.27358;
        switch (D.27359) <default: <D.23100>, case 15: <D.23079>, case 112: <D.23084>, case 113: <D.23085>, case 114: <D.23086>, case 115: <D.23087>, case 116: <D.23088>, case 117: <D.23089>, case 118: <D.23090>, case 119: <D.23091>, case 120: <D.23092>, case 121: <D.23093>, case 122: <D.23094>, case 123: <D.23095>, case 124: <D.23096>, case 125: <D.23097>, case 126: <D.23098>, case 127: <D.23099>, case 224: <D.23080>, case 225: <D.23081>, case 226: <D.23082>, case 232: <D.23076>, case 233: <D.23077>, case 235: <D.23083>>
        <D.23076>:
        <D.23077>:
        size = size + 1;
        goto <D.23078>;
        <D.23079>:
        D.27360 = *pos;
        D.27361 = D.27360 + 144;
        if (D.27361 > 31) goto <D.27362>; else goto <D.27363>;
        <D.27362>:
        __assert_fail ("0", "tramp-x86.c", 914, &__PRETTY_FUNCTION__);
        <D.27363>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23078>;
        <D.23080>:
        <D.23081>:
        <D.23082>:
        <D.23083>:
        <D.23084>:
        <D.23085>:
        <D.23086>:
        <D.23087>:
        <D.23088>:
        <D.23089>:
        <D.23090>:
        <D.23091>:
        <D.23092>:
        <D.23093>:
        <D.23094>:
        <D.23095>:
        <D.23096>:
        <D.23097>:
        <D.23098>:
        <D.23099>:
        goto <D.23078>;
        <D.23100>:
        __assert_fail ("0", "tramp-x86.c", 914, &__PRETTY_FUNCTION__);
        <D.23078>:
        code.1821 = code;
        code.2119 = (int) code.1821;
        pos.2223 = (int) pos;
        disp = code.2119 - pos.2223;
        if (size != 0) goto <D.27365>; else goto <D.27366>;
        <D.27365>:
        {
          union x86_imm_buf imb;

          try
            {
              D.27367 = disp + -4;
              imb.val = D.27367;
              pos.2224 = pos;
              pos = pos.2224 + 1;
              D.27369 = imb.b[0];
              *pos.2224 = D.27369;
              pos.2225 = pos;
              pos = pos.2225 + 1;
              D.27371 = imb.b[1];
              *pos.2225 = D.27371;
              pos.2226 = pos;
              pos = pos.2226 + 1;
              D.27373 = imb.b[2];
              *pos.2226 = D.27373;
              pos.2227 = pos;
              pos = pos.2227 + 1;
              D.27375 = imb.b[3];
              *pos.2227 = D.27375;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27376>;
        <D.27366>:
        disp.2228 = (unsigned int) disp;
        D.27378 = disp.2228 + 127;
        if (D.27378 <= 255) goto <D.27379>; else goto <D.27380>;
        <D.27379>:
        D.27381 = (unsigned char) disp;
        D.27382 = D.27381 + 255;
        *pos = D.27382;
        pos = pos + 1;
        goto <D.27383>;
        <D.27380>:
        __assert_fail ("0", "tramp-x86.c", 914, &__PRETTY_FUNCTION__);
        <D.27383>:
        <D.27376>:
      }
      code.1821 = code;
      code.2229 = code.1821;
      code.2230 = code.2229 + 1;
      code = code.2230;
      *code.2229 = 80;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_cmpxchg_failed + 1;
        size = 0;
        D.27386 = MEM[(unsigned char *)jump_cmpxchg_failed];
        D.27387 = (int) D.27386;
        switch (D.27387) <default: <D.23129>, case 15: <D.23108>, case 112: <D.23113>, case 113: <D.23114>, case 114: <D.23115>, case 115: <D.23116>, case 116: <D.23117>, case 117: <D.23118>, case 118: <D.23119>, case 119: <D.23120>, case 120: <D.23121>, case 121: <D.23122>, case 122: <D.23123>, case 123: <D.23124>, case 124: <D.23125>, case 125: <D.23126>, case 126: <D.23127>, case 127: <D.23128>, case 224: <D.23109>, case 225: <D.23110>, case 226: <D.23111>, case 232: <D.23105>, case 233: <D.23106>, case 235: <D.23112>>
        <D.23105>:
        <D.23106>:
        size = size + 1;
        goto <D.23107>;
        <D.23108>:
        D.27388 = *pos;
        D.27389 = D.27388 + 144;
        if (D.27389 > 31) goto <D.27390>; else goto <D.27391>;
        <D.27390>:
        __assert_fail ("0", "tramp-x86.c", 917, &__PRETTY_FUNCTION__);
        <D.27391>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23107>;
        <D.23109>:
        <D.23110>:
        <D.23111>:
        <D.23112>:
        <D.23113>:
        <D.23114>:
        <D.23115>:
        <D.23116>:
        <D.23117>:
        <D.23118>:
        <D.23119>:
        <D.23120>:
        <D.23121>:
        <D.23122>:
        <D.23123>:
        <D.23124>:
        <D.23125>:
        <D.23126>:
        <D.23127>:
        <D.23128>:
        goto <D.23107>;
        <D.23129>:
        __assert_fail ("0", "tramp-x86.c", 917, &__PRETTY_FUNCTION__);
        <D.23107>:
        code.1821 = code;
        code.2119 = (int) code.1821;
        pos.2231 = (int) pos;
        disp = code.2119 - pos.2231;
        if (size != 0) goto <D.27393>; else goto <D.27394>;
        <D.27393>:
        {
          union x86_imm_buf imb;

          try
            {
              D.27395 = disp + -4;
              imb.val = D.27395;
              pos.2232 = pos;
              pos = pos.2232 + 1;
              D.27397 = imb.b[0];
              *pos.2232 = D.27397;
              pos.2233 = pos;
              pos = pos.2233 + 1;
              D.27399 = imb.b[1];
              *pos.2233 = D.27399;
              pos.2234 = pos;
              pos = pos.2234 + 1;
              D.27401 = imb.b[2];
              *pos.2234 = D.27401;
              pos.2235 = pos;
              pos = pos.2235 + 1;
              D.27403 = imb.b[3];
              *pos.2235 = D.27403;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27404>;
        <D.27394>:
        disp.2236 = (unsigned int) disp;
        D.27406 = disp.2236 + 127;
        if (D.27406 <= 255) goto <D.27407>; else goto <D.27408>;
        <D.27407>:
        D.27409 = (unsigned char) disp;
        D.27410 = D.27409 + 255;
        *pos = D.27410;
        pos = pos + 1;
        goto <D.27411>;
        <D.27408>:
        __assert_fail ("0", "tramp-x86.c", 917, &__PRETTY_FUNCTION__);
        <D.27411>:
        <D.27404>:
      }
      if (aot != 0) goto <D.27412>; else goto <D.27413>;
      <D.27412>:
      code.1821 = code;
      buf.1820 = buf;
      code.2237 = mono_arch_emit_load_aotconst (buf.1820, code.1821, &ji, 32, "generic_trampoline_monitor_enter");
      code = code.2237;
      code.1821 = code;
      code.2238 = code.1821;
      code.2239 = code.2238 + 1;
      code = code.2239;
      *code.2238 = 255;
      code.1821 = code;
      code.2240 = code.1821;
      code.2241 = code.2240 + 1;
      code = code.2241;
      *code.2240 = 224;
      goto <D.27419>;
      <D.27413>:
      {
        int t;

        tramp.2242 = (int) tramp;
        code.1821 = code;
        code.2119 = (int) code.1821;
        D.27421 = tramp.2242 - code.2119;
        t = D.27421 + -2;
        t.2243 = (unsigned int) t;
        D.27423 = t.2243 + 128;
        if (D.27423 <= 255) goto <D.27424>; else goto <D.27425>;
        <D.27424>:
        code.1821 = code;
        code.2244 = code.1821;
        code.2245 = code.2244 + 1;
        code = code.2245;
        *code.2244 = 235;
        code.1821 = code;
        D.27428 = (unsigned char) t;
        *code.1821 = D.27428;
        code.1821 = code;
        code.1830 = code.1821 + 1;
        code = code.1830;
        goto <D.27429>;
        <D.27425>:
        tramp.2242 = (int) tramp;
        code.1821 = code;
        code.2119 = (int) code.1821;
        D.27421 = tramp.2242 - code.2119;
        t = D.27421 + -5;
        code.1821 = code;
        code.2246 = code.1821;
        code.2247 = code.2246 + 1;
        code = code.2247;
        *code.2246 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.1821 = code;
              code.2248 = code.1821;
              code.2249 = code.2248 + 1;
              code = code.2249;
              D.27434 = imb.b[0];
              *code.2248 = D.27434;
              code.1821 = code;
              code.2250 = code.1821;
              code.2251 = code.2250 + 1;
              code = code.2251;
              D.27437 = imb.b[1];
              *code.2250 = D.27437;
              code.1821 = code;
              code.2252 = code.1821;
              code.2253 = code.2252 + 1;
              code = code.2253;
              D.27440 = imb.b[2];
              *code.2252 = D.27440;
              code.1821 = code;
              code.2254 = code.1821;
              code.2255 = code.2254 + 1;
              code = code.2255;
              D.27443 = imb.b[3];
              *code.2254 = D.27443;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.27429>:
      }
      <D.27419>:
      goto <D.27444>;
      <D.26663>:
      code.1821 = code;
      code.2256 = code.1821;
      code.2257 = code.2256 + 1;
      code = code.2257;
      *code.2256 = 80;
      if (aot != 0) goto <D.27447>; else goto <D.27448>;
      <D.27447>:
      code.1821 = code;
      buf.1820 = buf;
      code.2258 = mono_arch_emit_load_aotconst (buf.1820, code.1821, &ji, 32, "generic_trampoline_monitor_enter");
      code = code.2258;
      code.1821 = code;
      code.2259 = code.1821;
      code.2260 = code.2259 + 1;
      code = code.2260;
      *code.2259 = 255;
      code.1821 = code;
      code.2261 = code.1821;
      code.2262 = code.2261 + 1;
      code = code.2262;
      *code.2261 = 224;
      goto <D.27454>;
      <D.27448>:
      {
        int t;

        tramp.2242 = (int) tramp;
        code.1821 = code;
        code.2119 = (int) code.1821;
        D.27421 = tramp.2242 - code.2119;
        t = D.27421 + -2;
        t.2263 = (unsigned int) t;
        D.27456 = t.2263 + 128;
        if (D.27456 <= 255) goto <D.27457>; else goto <D.27458>;
        <D.27457>:
        code.1821 = code;
        code.2264 = code.1821;
        code.2265 = code.2264 + 1;
        code = code.2265;
        *code.2264 = 235;
        code.1821 = code;
        D.27461 = (unsigned char) t;
        *code.1821 = D.27461;
        code.1821 = code;
        code.1830 = code.1821 + 1;
        code = code.1830;
        goto <D.27462>;
        <D.27458>:
        tramp.2242 = (int) tramp;
        code.1821 = code;
        code.2119 = (int) code.1821;
        D.27421 = tramp.2242 - code.2119;
        t = D.27421 + -5;
        code.1821 = code;
        code.2266 = code.1821;
        code.2267 = code.2266 + 1;
        code = code.2267;
        *code.2266 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.1821 = code;
              code.2268 = code.1821;
              code.2269 = code.2268 + 1;
              code = code.2269;
              D.27467 = imb.b[0];
              *code.2268 = D.27467;
              code.1821 = code;
              code.2270 = code.1821;
              code.2271 = code.2270 + 1;
              code = code.2271;
              D.27470 = imb.b[1];
              *code.2270 = D.27470;
              code.1821 = code;
              code.2272 = code.1821;
              code.2273 = code.2272 + 1;
              code = code.2273;
              D.27473 = imb.b[2];
              *code.2272 = D.27473;
              code.1821 = code;
              code.2274 = code.1821;
              code.2275 = code.2274 + 1;
              code = code.2275;
              D.27476 = imb.b[3];
              *code.2274 = D.27476;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.27462>:
      }
      <D.27454>:
      <D.27444>:
      code.1821 = code;
      code.2119 = (int) code.1821;
      buf.1820 = buf;
      buf.2276 = (int) buf.1820;
      D.27478 = code.2119 - buf.2276;
      buf.1820 = buf;
      mono_arch_flush_icache (buf.1820, D.27478);
      code.1821 = code;
      code.2119 = (int) code.1821;
      buf.1820 = buf;
      buf.2276 = (int) buf.1820;
      D.27478 = code.2119 - buf.2276;
      D.27479 = D.27478 > tramp_size;
      D.27480 = (long int) D.27479;
      D.27481 = __builtin_expect (D.27480, 0);
      if (D.27481 != 0) goto <D.27482>; else goto <D.27483>;
      <D.27482>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 939, "code - buf <= tramp_size");
      <D.27483>:
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      if (info != 0B) goto <D.27484>; else goto <D.27485>;
      <D.27484>:
      ji.2277 = ji;
      code.1821 = code;
      code.2119 = (int) code.1821;
      buf.1820 = buf;
      buf.2276 = (int) buf.1820;
      D.27478 = code.2119 - buf.2276;
      D.27487 = (unsigned int) D.27478;
      buf.1820 = buf;
      D.27488 = mono_tramp_info_create ("monitor_enter_trampoline", buf.1820, D.27487, ji.2277, unwind_ops);
      *info = D.27488;
      <D.27485>:
      D.27489 = buf;
      return D.27489;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
      owner_offset = {CLOBBER};
      nest_offset = {CLOBBER};
      dummy = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_arch_create_monitor_exit_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  int owner_offset.2278;
  unsigned int owner_offset.2279;
  unsigned int D.27502;
  _Bool D.27503;
  long int D.27504;
  long int D.27505;
  int nest_offset.2280;
  unsigned int nest_offset.2281;
  unsigned int D.27510;
  _Bool D.27511;
  long int D.27512;
  long int D.27513;
  int entry_count_offset.2282;
  unsigned int entry_count_offset.2283;
  unsigned int D.27518;
  _Bool D.27519;
  long int D.27520;
  long int D.27521;
  int owner_offset.2284;
  int nest_offset.2285;
  int entry_count_offset.2286;
  void * buf.2287;
  guint8 * buf.2288;
  int D.27529;
  guint8 * code.2289;
  guint8 * code.2290;
  guint8 * code.2291;
  guint8 * code.2292;
  guint8 * code.2293;
  guint8 * code.2294;
  guint8 * code.2295;
  unsigned char D.27541;
  guint8 * code.2296;
  guint8 * code.2297;
  unsigned char D.27545;
  guint8 * code.2298;
  guint8 * code.2299;
  guint8 * code.2300;
  guint8 * code.2301;
  guint8 * code.2302;
  guint8 * code.2303;
  guint8 * code.2304;
  guint8 * code.2305;
  guint8 * code.2306;
  guint8 * code.2307;
  guint8 * code.2308;
  guint8 * code.2309;
  guint8 * code.2310;
  guint8 * code.2311;
  guint8 * code.2312;
  guint8 * code.2313;
  guint8 * code.2314;
  guint8 * code.2315;
  guint8 * code.2316;
  guint8 * code.2317;
  guint8 * code.2318;
  unsigned char D.27575;
  guint8 * code.2319;
  guint8 * code.2320;
  unsigned char D.27578;
  guint8 * code.2321;
  guint8 * code.2322;
  unsigned char D.27581;
  guint8 * code.2323;
  guint8 * code.2324;
  unsigned char D.27584;
  guint8 * code.2325;
  guint8 * code.2326;
  guint8 * code.2327;
  guint8 * code.2328;
  guint8 * code.2329;
  guint8 * code.2330;
  guint8 * code.2331;
  guint8 * code.2332;
  unsigned char D.27598;
  guint8 * code.2333;
  guint8 * code.2334;
  unsigned char D.27601;
  guint8 * code.2335;
  guint8 * code.2336;
  unsigned char D.27604;
  guint8 * code.2337;
  guint8 * code.2338;
  unsigned char D.27607;
  int D.27608;
  guint8 * code.2339;
  guint8 * code.2340;
  guint8 * code.2341;
  guint8 * code.2342;
  guint8 * code.2343;
  guint8 * code.2344;
  guint8 * code.2345;
  guint8 * code.2346;
  unsigned char D.27622;
  guint8 * code.2347;
  guint8 * code.2348;
  unsigned char D.27625;
  guint8 * code.2349;
  guint8 * code.2350;
  unsigned char D.27628;
  guint8 * code.2351;
  guint8 * code.2352;
  unsigned char D.27631;
  guint8 * code.2353;
  guint8 * code.2354;
  unsigned char D.27636;
  guint8 * code.2355;
  guint8 * code.2356;
  unsigned char D.27640;
  guint8 * code.2357;
  guint8 * code.2358;
  guint8 * code.2359;
  guint8 * code.2360;
  unsigned char D.27647;
  guint8 * code.2361;
  guint8 * code.2362;
  unsigned char D.27650;
  guint8 * code.2363;
  guint8 * code.2364;
  unsigned char D.27653;
  guint8 * code.2365;
  guint8 * code.2366;
  unsigned char D.27656;
  guint8 * code.2367;
  guint8 * code.2368;
  guint8 * code.2369;
  guint8 * code.2370;
  guint8 * code.2371;
  guint8 * code.2372;
  guint8 * code.2373;
  guint8 * code.2374;
  guint8 * code.2375;
  guint8 * code.2376;
  unsigned char D.27670;
  guint8 * code.2377;
  guint8 * code.2378;
  unsigned char D.27673;
  guint8 * code.2379;
  guint8 * code.2380;
  unsigned char D.27676;
  guint8 * code.2381;
  guint8 * code.2382;
  unsigned char D.27679;
  guint8 * code.2383;
  guint8 * code.2384;
  guint8 * code.2385;
  guint8 * code.2386;
  guint8 * code.2387;
  guint8 * code.2388;
  guint8 * code.2389;
  guint8 * code.2390;
  guint8 * code.2391;
  guint8 * code.2392;
  guint8 * code.2393;
  guint8 * code.2394;
  guint8 * code.2395;
  guint8 * code.2396;
  guint8 * code.2397;
  guint8 * code.2398;
  guint8 * code.2399;
  guint8 * code.2400;
  guint8 * code.2401;
  guint8 * code.2402;
  guint8 * code.2403;
  guint8 * code.2404;
  guint8 * code.2405;
  guint8 * code.2406;
  int D.27713;
  guint8 * code.2407;
  guint8 * code.2408;
  guint8 * code.2409;
  guint8 * code.2410;
  guint8 * code.2411;
  guint8 * code.2412;
  guint8 * code.2413;
  guint8 * code.2414;
  guint8 * code.2415;
  guint8 * code.2416;
  guint8 * code.2417;
  guint8 * code.2418;
  guint8 * code.2419;
  guint8 * code.2420;
  guint8 * code.2421;
  guint8 * code.2422;
  guint8 * code.2423;
  guint8 * code.2424;
  guint8 * code.2425;
  guint8 * code.2426;
  guint8 * code.2427;
  unsigned char D.27743;
  guint8 * code.2428;
  guint8 * code.2429;
  unsigned char D.27746;
  guint8 * code.2430;
  guint8 * code.2431;
  unsigned char D.27749;
  guint8 * code.2432;
  guint8 * code.2433;
  unsigned char D.27752;
  guint8 * code.2434;
  guint8 * code.2435;
  guint8 * code.2436;
  guint8 * code.2437;
  guint8 * code.2438;
  guint8 * code.2439;
  guint8 * code.2440;
  guint8 * code.2441;
  unsigned char D.27766;
  guint8 * code.2442;
  guint8 * code.2443;
  unsigned char D.27769;
  guint8 * code.2444;
  guint8 * code.2445;
  unsigned char D.27772;
  guint8 * code.2446;
  guint8 * code.2447;
  unsigned char D.27775;
  guint8 * code.2448;
  guint8 * code.2449;
  guint8 * code.2450;
  guint8 * code.2451;
  guint8 * code.2452;
  guint8 * code.2453;
  unsigned int owner_offset.2454;
  unsigned int D.27788;
  guint8 * code.2455;
  guint8 * code.2456;
  guint8 * code.2457;
  guint8 * code.2458;
  unsigned char D.27795;
  guint8 * code.2459;
  guint8 * code.2460;
  guint8 * code.2461;
  guint8 * code.2462;
  guint8 * code.2463;
  guint8 * code.2464;
  unsigned char D.27803;
  guint8 * code.2465;
  guint8 * code.2466;
  unsigned char D.27806;
  guint8 * code.2467;
  guint8 * code.2468;
  unsigned char D.27809;
  guint8 * code.2469;
  guint8 * code.2470;
  unsigned char D.27812;
  guint8 * code.2471;
  guint8 * code.2472;
  guint8 * code.2473;
  guint8 * code.2474;
  guint8 * code.2475;
  guint8 * code.2476;
  guint8 * code.2477;
  guint8 * code.2478;
  unsigned char D.27826;
  guint8 * code.2479;
  guint8 * code.2480;
  unsigned char D.27829;
  guint8 * code.2481;
  guint8 * code.2482;
  unsigned char D.27832;
  guint8 * code.2483;
  guint8 * code.2484;
  unsigned char D.27835;
  guint8 * code.2485;
  guint8 * code.2486;
  guint8 * code.2487;
  guint8 * code.2488;
  guint8 * code.2489;
  guint8 * code.2490;
  guint8 * code.2491;
  guint8 * code.2492;
  guint8 * code.2493;
  guint8 * code.2494;
  unsigned int nest_offset.2495;
  unsigned int D.27857;
  guint8 * code.2496;
  guint8 * code.2497;
  guint8 * code.2498;
  guint8 * code.2499;
  unsigned char D.27864;
  guint8 * code.2500;
  guint8 * code.2501;
  guint8 * code.2502;
  guint8 * code.2503;
  guint8 * code.2504;
  guint8 * code.2505;
  unsigned char D.27872;
  guint8 * code.2506;
  guint8 * code.2507;
  unsigned char D.27875;
  guint8 * code.2508;
  guint8 * code.2509;
  unsigned char D.27878;
  guint8 * code.2510;
  guint8 * code.2511;
  unsigned char D.27881;
  guint8 * code.2512;
  guint8 * code.2513;
  guint8 * code.2514;
  guint8 * code.2515;
  guint8 * code.2516;
  guint8 * code.2517;
  guint8 * code.2518;
  guint8 * code.2519;
  unsigned char D.27895;
  guint8 * code.2520;
  guint8 * code.2521;
  unsigned char D.27898;
  guint8 * code.2522;
  guint8 * code.2523;
  unsigned char D.27901;
  guint8 * code.2524;
  guint8 * code.2525;
  unsigned char D.27904;
  guint8 * code.2526;
  guint8 * code.2527;
  guint8 * code.2528;
  guint8 * code.2529;
  guint8 * code.2530;
  guint8 * code.2531;
  guint8 * code.2532;
  guint8 * code.2533;
  guint8 * code.2534;
  guint8 * code.2535;
  guint8 * code.2536;
  guint8 * code.2537;
  guint8 * code.2538;
  guint8 * code.2539;
  guint8 * code.2540;
  guint8 * code.2541;
  unsigned char D.27930;
  guint8 * code.2542;
  guint8 * code.2543;
  unsigned char D.27933;
  guint8 * code.2544;
  guint8 * code.2545;
  unsigned char D.27936;
  guint8 * code.2546;
  guint8 * code.2547;
  unsigned char D.27939;
  guint8 * code.2548;
  guint8 * code.2549;
  guint8 * code.2550;
  guint8 * code.2551;
  guint8 * code.2552;
  guint8 * code.2553;
  guint8 * code.2554;
  guint8 * code.2555;
  unsigned char D.27953;
  guint8 * code.2556;
  guint8 * code.2557;
  unsigned char D.27956;
  guint8 * code.2558;
  guint8 * code.2559;
  unsigned char D.27959;
  guint8 * code.2560;
  guint8 * code.2561;
  unsigned char D.27962;
  guint8 * code.2562;
  guint8 * code.2563;
  unsigned char D.27965;
  guint8 * code.2564;
  guint8 * code.2565;
  unsigned char D.27968;
  guint8 * code.2566;
  guint8 * code.2567;
  unsigned char D.27971;
  guint8 * code.2568;
  guint8 * code.2569;
  unsigned char D.27974;
  guint8 * code.2570;
  guint8 * code.2571;
  guint8 * code.2572;
  guint8 * code.2573;
  guint8 * code.2574;
  guint8 * code.2575;
  guint8 * code.2576;
  guint8 * code.2577;
  guint8 * code.2578;
  guint8 * code.2579;
  unsigned int entry_count_offset.2580;
  unsigned int D.27996;
  guint8 * code.2581;
  guint8 * code.2582;
  guint8 * code.2583;
  guint8 * code.2584;
  unsigned char D.28003;
  guint8 * code.2585;
  guint8 * code.2586;
  guint8 * code.2587;
  guint8 * code.2588;
  guint8 * code.2589;
  guint8 * code.2590;
  unsigned char D.28011;
  guint8 * code.2591;
  guint8 * code.2592;
  unsigned char D.28014;
  guint8 * code.2593;
  guint8 * code.2594;
  unsigned char D.28017;
  guint8 * code.2595;
  guint8 * code.2596;
  unsigned char D.28020;
  guint8 * code.2597;
  guint8 * code.2598;
  guint8 * code.2599;
  guint8 * code.2600;
  guint8 * code.2601;
  guint8 * code.2602;
  guint8 * code.2603;
  guint8 * code.2604;
  unsigned char D.28034;
  guint8 * code.2605;
  guint8 * code.2606;
  unsigned char D.28037;
  guint8 * code.2607;
  guint8 * code.2608;
  unsigned char D.28040;
  guint8 * code.2609;
  guint8 * code.2610;
  unsigned char D.28043;
  guint8 * code.2611;
  guint8 * code.2612;
  guint8 * code.2613;
  guint8 * code.2614;
  guint8 * code.2615;
  guint8 * code.2616;
  guint8 * code.2617;
  guint8 * code.2618;
  guint8 * code.2619;
  guint8 * code.2620;
  guint8 * code.2621;
  guint8 * code.2622;
  guint8 * code.2623;
  guint8 * code.2624;
  guint8 * code.2625;
  guint8 * code.2626;
  unsigned char D.28069;
  guint8 * code.2627;
  guint8 * code.2628;
  unsigned char D.28072;
  guint8 * code.2629;
  guint8 * code.2630;
  unsigned char D.28075;
  guint8 * code.2631;
  guint8 * code.2632;
  unsigned char D.28078;
  guint8 * code.2633;
  guint8 * code.2634;
  guint8 * code.2635;
  guint8 * code.2636;
  guint8 * code.2637;
  guint8 * code.2638;
  guint8 * code.2639;
  guint8 * code.2640;
  unsigned char D.28092;
  guint8 * code.2641;
  guint8 * code.2642;
  unsigned char D.28095;
  guint8 * code.2643;
  guint8 * code.2644;
  unsigned char D.28098;
  guint8 * code.2645;
  guint8 * code.2646;
  unsigned char D.28101;
  guint8 * code.2647;
  guint8 * code.2648;
  unsigned char D.28104;
  guint8 * code.2649;
  guint8 * code.2650;
  unsigned char D.28107;
  guint8 * code.2651;
  guint8 * code.2652;
  unsigned char D.28110;
  guint8 * code.2653;
  guint8 * code.2654;
  unsigned char D.28113;
  guint8 * code.2655;
  guint8 * code.2656;
  guint8 * code.2657;
  guint8 * code.2658;
  guint8 * code.2659;
  guint8 * code.2660;
  guint8 * code.2661;
  guint8 * code.2662;
  guint8 * code.2663;
  guint8 * code.2664;
  guint8 * code.2665;
  guint8 * code.2666;
  guint8 * code.2667;
  guint8 * code.2668;
  guint8 * code.2669;
  guint8 * code.2670;
  guint8 * code.2671;
  guint8 * code.2672;
  guint8 * code.2673;
  guint8 * code.2674;
  unsigned char D.28147;
  guint8 * code.2675;
  guint8 * code.2676;
  unsigned char D.28150;
  guint8 * code.2677;
  guint8 * code.2678;
  unsigned char D.28153;
  guint8 * code.2679;
  guint8 * code.2680;
  unsigned char D.28156;
  guint8 * code.2681;
  guint8 * code.2682;
  guint8 * code.2683;
  guint8 * code.2684;
  guint8 * code.2685;
  guint8 * code.2686;
  guint8 * code.2687;
  guint8 * code.2688;
  unsigned char D.28170;
  guint8 * code.2689;
  guint8 * code.2690;
  unsigned char D.28173;
  guint8 * code.2691;
  guint8 * code.2692;
  unsigned char D.28176;
  guint8 * code.2693;
  guint8 * code.2694;
  unsigned char D.28179;
  guint8 * code.2695;
  guint8 * code.2696;
  guint8 * code.2697;
  guint8 * code.2698;
  guint8 * code.2699;
  guint8 * code.2700;
  guint8 * code.2701;
  guint8 * code.2702;
  guint8 * code.2703;
  guint8 * code.2704;
  guint8 * code.2705;
  guint8 * code.2706;
  guint8 * code.2707;
  guint8 * code.2708;
  guint8 * code.2709;
  guint8 * code.2710;
  guint8 * code.2711;
  guint8 * code.2712;
  unsigned char D.28209;
  guint8 * code.2713;
  guint8 * code.2714;
  unsigned char D.28212;
  guint8 * code.2715;
  guint8 * code.2716;
  unsigned char D.28215;
  guint8 * code.2717;
  guint8 * code.2718;
  unsigned char D.28218;
  guint8 * code.2719;
  guint8 * code.2720;
  guint8 * code.2721;
  guint8 * code.2722;
  guint8 * code.2723;
  guint8 * code.2724;
  guint8 * code.2725;
  guint8 * code.2726;
  unsigned char D.28232;
  guint8 * code.2727;
  guint8 * code.2728;
  unsigned char D.28235;
  guint8 * code.2729;
  guint8 * code.2730;
  unsigned char D.28238;
  guint8 * code.2731;
  guint8 * code.2732;
  unsigned char D.28241;
  guint8 * code.2733;
  guint8 * code.2734;
  guint8 * code.2735;
  guint8 * code.2736;
  guint8 * code.2737;
  guint8 * code.2738;
  guint8 * code.2739;
  guint8 * code.2740;
  guint8 * code.2741;
  guint8 * code.2742;
  guint8 * code.2743;
  guint8 * code.2744;
  guint8 * code.2745;
  guint8 * code.2746;
  guint8 * code.2747;
  guint8 * code.2748;
  guint8 * code.2749;
  unsigned char D.28268;
  guint8 * code.2750;
  guint8 * code.2751;
  unsigned char D.28271;
  guint8 * code.2752;
  guint8 * code.2753;
  unsigned char D.28274;
  guint8 * code.2754;
  guint8 * code.2755;
  unsigned char D.28277;
  guint8 * code.2756;
  guint8 * code.2757;
  guint8 * code.2758;
  guint8 * code.2759;
  guint8 * code.2760;
  guint8 * code.2761;
  guint8 * code.2762;
  guint8 * code.2763;
  unsigned char D.28291;
  guint8 * code.2764;
  guint8 * code.2765;
  unsigned char D.28294;
  guint8 * code.2766;
  guint8 * code.2767;
  unsigned char D.28297;
  guint8 * code.2768;
  guint8 * code.2769;
  unsigned char D.28300;
  guint8 * code.2770;
  guint8 * code.2771;
  unsigned char D.28303;
  guint8 * code.2772;
  guint8 * code.2773;
  unsigned char D.28306;
  guint8 * code.2774;
  guint8 * code.2775;
  unsigned char D.28309;
  guint8 * code.2776;
  guint8 * code.2777;
  unsigned char D.28312;
  guint8 * code.2778;
  guint8 * code.2779;
  unsigned char D.28315;
  int D.28316;
  unsigned char D.28317;
  unsigned char D.28318;
  int code.2780;
  int pos.2781;
  int D.28325;
  unsigned char * pos.2782;
  unsigned char D.28327;
  unsigned char * pos.2783;
  unsigned char D.28329;
  unsigned char * pos.2784;
  unsigned char D.28331;
  unsigned char * pos.2785;
  unsigned char D.28333;
  unsigned int disp.2786;
  unsigned int D.28336;
  unsigned char D.28339;
  unsigned char D.28340;
  guint8 * code.2787;
  guint8 * code.2788;
  guint8 * code.2789;
  guint8 * code.2790;
  guint8 * code.2791;
  guint8 * code.2792;
  guint8 * code.2793;
  guint8 * code.2794;
  guint8 * code.2795;
  guint8 * code.2796;
  guint8 * code.2797;
  guint8 * code.2798;
  guint8 * code.2799;
  guint8 * code.2800;
  guint8 * code.2801;
  guint8 * code.2802;
  unsigned char D.28366;
  guint8 * code.2803;
  guint8 * code.2804;
  unsigned char D.28369;
  guint8 * code.2805;
  guint8 * code.2806;
  unsigned char D.28372;
  guint8 * code.2807;
  guint8 * code.2808;
  unsigned char D.28375;
  guint8 * code.2809;
  guint8 * code.2810;
  guint8 * code.2811;
  guint8 * code.2812;
  guint8 * code.2813;
  guint8 * code.2814;
  guint8 * code.2815;
  guint8 * code.2816;
  unsigned char D.28389;
  guint8 * code.2817;
  guint8 * code.2818;
  unsigned char D.28392;
  guint8 * code.2819;
  guint8 * code.2820;
  unsigned char D.28395;
  guint8 * code.2821;
  guint8 * code.2822;
  unsigned char D.28398;
  guint8 * code.2823;
  guint8 * code.2824;
  unsigned char D.28401;
  int D.28402;
  unsigned char D.28403;
  unsigned char D.28404;
  int pos.2825;
  int D.28410;
  unsigned char * pos.2826;
  unsigned char D.28412;
  unsigned char * pos.2827;
  unsigned char D.28414;
  unsigned char * pos.2828;
  unsigned char D.28416;
  unsigned char * pos.2829;
  unsigned char D.28418;
  unsigned int disp.2830;
  unsigned int D.28421;
  unsigned char D.28424;
  unsigned char D.28425;
  unsigned char D.28429;
  int D.28430;
  unsigned char D.28431;
  unsigned char D.28432;
  int pos.2831;
  int D.28438;
  unsigned char * pos.2832;
  unsigned char D.28440;
  unsigned char * pos.2833;
  unsigned char D.28442;
  unsigned char * pos.2834;
  unsigned char D.28444;
  unsigned char * pos.2835;
  unsigned char D.28446;
  unsigned int disp.2836;
  unsigned int D.28449;
  unsigned char D.28452;
  unsigned char D.28453;
  unsigned char D.28455;
  int D.28456;
  unsigned char D.28457;
  unsigned char D.28458;
  int pos.2837;
  int D.28464;
  unsigned char * pos.2838;
  unsigned char D.28466;
  unsigned char * pos.2839;
  unsigned char D.28468;
  unsigned char * pos.2840;
  unsigned char D.28470;
  unsigned char * pos.2841;
  unsigned char D.28472;
  unsigned int disp.2842;
  unsigned int D.28475;
  unsigned char D.28478;
  unsigned char D.28479;
  unsigned char D.28481;
  int D.28482;
  unsigned char D.28483;
  unsigned char D.28484;
  int pos.2843;
  int D.28490;
  unsigned char * pos.2844;
  unsigned char D.28492;
  unsigned char * pos.2845;
  unsigned char D.28494;
  unsigned char * pos.2846;
  unsigned char D.28496;
  unsigned char * pos.2847;
  unsigned char D.28498;
  unsigned int disp.2848;
  unsigned int D.28501;
  unsigned char D.28504;
  unsigned char D.28505;
  unsigned char D.28507;
  int D.28508;
  unsigned char D.28509;
  unsigned char D.28510;
  int pos.2849;
  int D.28516;
  unsigned char * pos.2850;
  unsigned char D.28518;
  unsigned char * pos.2851;
  unsigned char D.28520;
  unsigned char * pos.2852;
  unsigned char D.28522;
  unsigned char * pos.2853;
  unsigned char D.28524;
  unsigned int disp.2854;
  unsigned int D.28527;
  unsigned char D.28530;
  unsigned char D.28531;
  guint8 * code.2855;
  guint8 * code.2856;
  guint8 * code.2857;
  guint8 * code.2858;
  guint8 * code.2859;
  guint8 * code.2860;
  guint8 * code.2861;
  int tramp.2862;
  int D.28544;
  unsigned int t.2863;
  unsigned int D.28546;
  guint8 * code.2864;
  guint8 * code.2865;
  unsigned char D.28551;
  guint8 * code.2866;
  guint8 * code.2867;
  guint8 * code.2868;
  guint8 * code.2869;
  unsigned char D.28557;
  guint8 * code.2870;
  guint8 * code.2871;
  unsigned char D.28560;
  guint8 * code.2872;
  guint8 * code.2873;
  unsigned char D.28563;
  guint8 * code.2874;
  guint8 * code.2875;
  unsigned char D.28566;
  int buf.2876;
  int D.28568;
  _Bool D.28569;
  long int D.28570;
  long int D.28571;
  struct MonoJumpInfo * ji.2877;
  unsigned int D.28577;
  struct MonoTrampInfo * D.28578;
  void * D.28579;
  guint8 * tramp;
  guint8 * code;
  guint8 * buf;
  guint8 * jump_obj_null;
  guint8 * jump_have_waiters;
  guint8 * jump_sync_null;
  guint8 * jump_not_owned;
  guint8 * jump_sync_thin_hash;
  guint8 * jump_next;
  int tramp_size;
  int owner_offset;
  int nest_offset;
  int entry_count_offset;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  static const char __PRETTY_FUNCTION__[41] = "mono_arch_create_monitor_exit_trampoline";

  try
    {
      tramp = mono_get_trampoline_code (11);
      jump_sync_thin_hash = 0B;
      ji = 0B;
      unwind_ops = 0B;
      if (0 != 0) goto <D.27498>; else goto <D.27499>;
      <D.27498>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 961, "MONO_ARCH_MONITOR_OBJECT_REG == X86_EAX");
      <D.27499>:
      mono_monitor_threads_sync_members_offset (&owner_offset, &nest_offset, &entry_count_offset);
      owner_offset.2278 = owner_offset;
      owner_offset.2279 = (unsigned int) owner_offset.2278;
      D.27502 = owner_offset.2279 & 255;
      D.27503 = D.27502 != 4;
      D.27504 = (long int) D.27503;
      D.27505 = __builtin_expect (D.27504, 0);
      if (D.27505 != 0) goto <D.27506>; else goto <D.27507>;
      <D.27506>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 964, "MONO_THREADS_SYNC_MEMBER_SIZE (owner_offset) == sizeof (gpointer)");
      <D.27507>:
      nest_offset.2280 = nest_offset;
      nest_offset.2281 = (unsigned int) nest_offset.2280;
      D.27510 = nest_offset.2281 & 255;
      D.27511 = D.27510 != 4;
      D.27512 = (long int) D.27511;
      D.27513 = __builtin_expect (D.27512, 0);
      if (D.27513 != 0) goto <D.27514>; else goto <D.27515>;
      <D.27514>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 965, "MONO_THREADS_SYNC_MEMBER_SIZE (nest_offset) == sizeof (guint32)");
      <D.27515>:
      entry_count_offset.2282 = entry_count_offset;
      entry_count_offset.2283 = (unsigned int) entry_count_offset.2282;
      D.27518 = entry_count_offset.2283 & 255;
      D.27519 = D.27518 != 4;
      D.27520 = (long int) D.27519;
      D.27521 = __builtin_expect (D.27520, 0);
      if (D.27521 != 0) goto <D.27522>; else goto <D.27523>;
      <D.27522>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 966, "MONO_THREADS_SYNC_MEMBER_SIZE (entry_count_offset) == sizeof (gint32)");
      <D.27523>:
      owner_offset.2278 = owner_offset;
      owner_offset.2284 = owner_offset.2278 >> 8;
      owner_offset = owner_offset.2284;
      nest_offset.2280 = nest_offset;
      nest_offset.2285 = nest_offset.2280 >> 8;
      nest_offset = nest_offset.2285;
      entry_count_offset.2282 = entry_count_offset;
      entry_count_offset.2286 = entry_count_offset.2282 >> 8;
      entry_count_offset = entry_count_offset.2286;
      tramp_size = 96;
      buf.2287 = mono_global_codeman_reserve (tramp_size);
      buf = buf.2287;
      buf.2288 = buf;
      code = buf.2288;
      D.27529 = mono_thread_get_tls_offset ();
      if (D.27529 != -1) goto <D.27530>; else goto <D.27531>;
      <D.27530>:
      code.2289 = code;
      code.2290 = code.2289;
      code.2291 = code.2290 + 1;
      code = code.2291;
      *code.2290 = 133;
      code.2289 = code;
      code.2292 = code.2289;
      code.2293 = code.2292 + 1;
      code = code.2293;
      *code.2292 = 192;
      jump_obj_null = code;
      if (1 != 0) goto <D.27537>; else goto <D.27538>;
      <D.27537>:
      code.2289 = code;
      code.2294 = code.2289;
      code.2295 = code.2294 + 1;
      code = code.2295;
      D.27541 = 116;
      *code.2294 = D.27541;
      goto <D.27542>;
      <D.27538>:
      code.2289 = code;
      code.2296 = code.2289;
      code.2297 = code.2296 + 1;
      code = code.2297;
      D.27545 = 116;
      *code.2296 = D.27545;
      <D.27542>:
      code.2289 = code;
      *code.2289 = 255;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      switch (4) <default: <D.23158>, case 1: <D.23154>, case 2: <D.23156>, case 4: <D.23157>>
      <D.23154>:
      code.2289 = code;
      code.2299 = code.2289;
      code.2300 = code.2299 + 1;
      code = code.2300;
      *code.2299 = 138;
      goto <D.23155>;
      <D.23156>:
      code.2289 = code;
      code.2301 = code.2289;
      code.2302 = code.2301 + 1;
      code = code.2302;
      *code.2301 = 102;
      <D.23157>:
      code.2289 = code;
      code.2303 = code.2289;
      code.2304 = code.2303 + 1;
      code = code.2304;
      *code.2303 = 139;
      goto <D.23155>;
      <D.23158>:
      __assert_fail ("0", "tramp-x86.c", 984, &__PRETTY_FUNCTION__);
      <D.23155>:
      if (0 != 0) goto <D.27553>; else goto <D.27554>;
      <D.27553>:
      if (0 != 0) goto <D.27555>; else goto <D.27556>;
      <D.27555>:
      code.2289 = code;
      code.2305 = code.2289;
      code.2306 = code.2305 + 1;
      code = code.2306;
      *code.2305 = 12;
      code.2289 = code;
      code.2307 = code.2289;
      code.2308 = code.2307 + 1;
      code = code.2308;
      *code.2307 = 36;
      goto <D.27561>;
      <D.27556>:
      if (1 != 0) goto <D.27562>; else goto <D.27563>;
      <D.27562>:
      code.2289 = code;
      code.2309 = code.2289;
      code.2310 = code.2309 + 1;
      code = code.2310;
      *code.2309 = 76;
      code.2289 = code;
      code.2311 = code.2289;
      code.2312 = code.2311 + 1;
      code = code.2312;
      *code.2311 = 36;
      code.2289 = code;
      *code.2289 = 4;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27568>;
      <D.27563>:
      code.2289 = code;
      code.2313 = code.2289;
      code.2314 = code.2313 + 1;
      code = code.2314;
      *code.2313 = 140;
      code.2289 = code;
      code.2315 = code.2289;
      code.2316 = code.2315 + 1;
      code = code.2316;
      *code.2315 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.2289 = code;
            code.2317 = code.2289;
            code.2318 = code.2317 + 1;
            code = code.2318;
            D.27575 = imb.b[0];
            *code.2317 = D.27575;
            code.2289 = code;
            code.2319 = code.2289;
            code.2320 = code.2319 + 1;
            code = code.2320;
            D.27578 = imb.b[1];
            *code.2319 = D.27578;
            code.2289 = code;
            code.2321 = code.2289;
            code.2322 = code.2321 + 1;
            code = code.2322;
            D.27581 = imb.b[2];
            *code.2321 = D.27581;
            code.2289 = code;
            code.2323 = code.2289;
            code.2324 = code.2323 + 1;
            code = code.2324;
            D.27584 = imb.b[3];
            *code.2323 = D.27584;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27568>:
      <D.27561>:
      goto <D.23161>;
      <D.27554>:
      if (0 != 0) goto <D.27585>; else goto <D.27586>;
      <D.27585>:
      code.2289 = code;
      code.2325 = code.2289;
      code.2326 = code.2325 + 1;
      code = code.2326;
      *code.2325 = 8;
      goto <D.23161>;
      <D.27586>:
      if (1 != 0) goto <D.27589>; else goto <D.27590>;
      <D.27589>:
      code.2289 = code;
      code.2327 = code.2289;
      code.2328 = code.2327 + 1;
      code = code.2328;
      *code.2327 = 72;
      code.2289 = code;
      *code.2289 = 4;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27593>;
      <D.27590>:
      code.2289 = code;
      code.2329 = code.2289;
      code.2330 = code.2329 + 1;
      code = code.2330;
      *code.2329 = 136;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.2289 = code;
            code.2331 = code.2289;
            code.2332 = code.2331 + 1;
            code = code.2332;
            D.27598 = imb.b[0];
            *code.2331 = D.27598;
            code.2289 = code;
            code.2333 = code.2289;
            code.2334 = code.2333 + 1;
            code = code.2334;
            D.27601 = imb.b[1];
            *code.2333 = D.27601;
            code.2289 = code;
            code.2335 = code.2289;
            code.2336 = code.2335 + 1;
            code = code.2336;
            D.27604 = imb.b[2];
            *code.2335 = D.27604;
            code.2289 = code;
            code.2337 = code.2289;
            code.2338 = code.2337 + 1;
            code = code.2338;
            D.27607 = imb.b[3];
            *code.2337 = D.27607;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27593>:
      <D.23161>:
      D.27608 = mono_gc_is_moving ();
      if (D.27608 != 0) goto <D.27609>; else goto <D.27610>;
      <D.27609>:
      if (0 != 0) goto <D.27611>; else goto <D.27612>;
      <D.27611>:
      code.2289 = code;
      code.2339 = code.2289;
      code.2340 = code.2339 + 1;
      code = code.2340;
      *code.2339 = 169;
      goto <D.27615>;
      <D.27612>:
      code.2289 = code;
      code.2341 = code.2289;
      code.2342 = code.2341 + 1;
      code = code.2342;
      *code.2341 = 247;
      code.2289 = code;
      code.2343 = code.2289;
      code.2344 = code.2343 + 1;
      code = code.2344;
      *code.2343 = 193;
      <D.27615>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 1;
            code.2289 = code;
            code.2345 = code.2289;
            code.2346 = code.2345 + 1;
            code = code.2346;
            D.27622 = imb.b[0];
            *code.2345 = D.27622;
            code.2289 = code;
            code.2347 = code.2289;
            code.2348 = code.2347 + 1;
            code = code.2348;
            D.27625 = imb.b[1];
            *code.2347 = D.27625;
            code.2289 = code;
            code.2349 = code.2289;
            code.2350 = code.2349 + 1;
            code = code.2350;
            D.27628 = imb.b[2];
            *code.2349 = D.27628;
            code.2289 = code;
            code.2351 = code.2289;
            code.2352 = code.2351 + 1;
            code = code.2352;
            D.27631 = imb.b[3];
            *code.2351 = D.27631;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      jump_sync_thin_hash = code;
      if (1 != 0) goto <D.27632>; else goto <D.27633>;
      <D.27632>:
      code.2289 = code;
      code.2353 = code.2289;
      code.2354 = code.2353 + 1;
      code = code.2354;
      D.27636 = 117;
      *code.2353 = D.27636;
      goto <D.27637>;
      <D.27633>:
      code.2289 = code;
      code.2355 = code.2289;
      code.2356 = code.2355 + 1;
      code = code.2356;
      D.27640 = 117;
      *code.2355 = D.27640;
      <D.27637>:
      code.2289 = code;
      *code.2289 = 255;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      if (0 != 0) goto <D.27641>; else goto <D.27642>;
      <D.27641>:
      code.2289 = code;
      code.2357 = code.2289;
      code.2358 = code.2357 + 1;
      code = code.2358;
      *code.2357 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = -4;
            code.2289 = code;
            code.2359 = code.2289;
            code.2360 = code.2359 + 1;
            code = code.2360;
            D.27647 = imb.b[0];
            *code.2359 = D.27647;
            code.2289 = code;
            code.2361 = code.2289;
            code.2362 = code.2361 + 1;
            code = code.2362;
            D.27650 = imb.b[1];
            *code.2361 = D.27650;
            code.2289 = code;
            code.2363 = code.2289;
            code.2364 = code.2363 + 1;
            code = code.2364;
            D.27653 = imb.b[2];
            *code.2363 = D.27653;
            code.2289 = code;
            code.2365 = code.2289;
            code.2366 = code.2365 + 1;
            code = code.2366;
            D.27656 = imb.b[3];
            *code.2365 = D.27656;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23165>;
      <D.27642>:
      if (1 != 0) goto <D.27657>; else goto <D.27658>;
      <D.27657>:
      code.2289 = code;
      code.2367 = code.2289;
      code.2368 = code.2367 + 1;
      code = code.2368;
      *code.2367 = 131;
      code.2289 = code;
      code.2369 = code.2289;
      code.2370 = code.2369 + 1;
      code = code.2370;
      *code.2369 = 225;
      code.2289 = code;
      *code.2289 = 252;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27663>;
      <D.27658>:
      code.2289 = code;
      code.2371 = code.2289;
      code.2372 = code.2371 + 1;
      code = code.2372;
      *code.2371 = 129;
      code.2289 = code;
      code.2373 = code.2289;
      code.2374 = code.2373 + 1;
      code = code.2374;
      *code.2373 = 225;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = -4;
            code.2289 = code;
            code.2375 = code.2289;
            code.2376 = code.2375 + 1;
            code = code.2376;
            D.27670 = imb.b[0];
            *code.2375 = D.27670;
            code.2289 = code;
            code.2377 = code.2289;
            code.2378 = code.2377 + 1;
            code = code.2378;
            D.27673 = imb.b[1];
            *code.2377 = D.27673;
            code.2289 = code;
            code.2379 = code.2289;
            code.2380 = code.2379 + 1;
            code = code.2380;
            D.27676 = imb.b[2];
            *code.2379 = D.27676;
            code.2289 = code;
            code.2381 = code.2289;
            code.2382 = code.2381 + 1;
            code = code.2382;
            D.27679 = imb.b[3];
            *code.2381 = D.27679;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27663>:
      <D.23165>:
      <D.27610>:
      code.2289 = code;
      code.2383 = code.2289;
      code.2384 = code.2383 + 1;
      code = code.2384;
      *code.2383 = 133;
      code.2289 = code;
      code.2385 = code.2289;
      code.2386 = code.2385 + 1;
      code = code.2386;
      *code.2385 = 201;
      jump_sync_null = code;
      if (1 != 0) goto <D.27684>; else goto <D.27685>;
      <D.27684>:
      code.2289 = code;
      code.2387 = code.2289;
      code.2388 = code.2387 + 1;
      code = code.2388;
      D.27541 = 116;
      *code.2387 = D.27541;
      goto <D.27688>;
      <D.27685>:
      code.2289 = code;
      code.2389 = code.2289;
      code.2390 = code.2389 + 1;
      code = code.2390;
      D.27545 = 116;
      *code.2389 = D.27545;
      <D.27688>:
      code.2289 = code;
      *code.2289 = 255;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      if (aot != 0) goto <D.27691>; else goto <D.27692>;
      <D.27691>:
      switch (4) <default: <D.23171>, case 1: <D.23167>, case 2: <D.23169>, case 4: <D.23170>>
      <D.23167>:
      code.2289 = code;
      code.2391 = code.2289;
      code.2392 = code.2391 + 1;
      code = code.2392;
      *code.2391 = 138;
      goto <D.23168>;
      <D.23169>:
      code.2289 = code;
      code.2393 = code.2289;
      code.2394 = code.2393 + 1;
      code = code.2394;
      *code.2393 = 102;
      <D.23170>:
      code.2289 = code;
      code.2395 = code.2289;
      code.2396 = code.2395 + 1;
      code = code.2396;
      *code.2395 = 139;
      goto <D.23168>;
      <D.23171>:
      __assert_fail ("0", "tramp-x86.c", 1007, &__PRETTY_FUNCTION__);
      <D.23168>:
      code.2289 = code;
      code.2397 = code.2289;
      code.2398 = code.2397 + 1;
      code = code.2398;
      *code.2397 = 208;
      code.2289 = code;
      buf.2288 = buf;
      code.2399 = mono_arch_emit_load_aotconst (buf.2288, code.2289, &ji, 48, 0B);
      code = code.2399;
      code.2289 = code;
      code.2400 = mono_x86_emit_tls_get_reg (code.2289, 0, 0);
      code = code.2400;
      if (0 != 0) goto <D.27703>; else goto <D.27704>;
      <D.27703>:
      code.2289 = code;
      code.2401 = code.2289;
      code.2402 = code.2401 + 1;
      code = code.2402;
      *code.2401 = 134;
      goto <D.27707>;
      <D.27704>:
      code.2289 = code;
      code.2403 = code.2289;
      code.2404 = code.2403 + 1;
      code = code.2404;
      *code.2403 = 135;
      <D.27707>:
      code.2289 = code;
      code.2405 = code.2289;
      code.2406 = code.2405 + 1;
      code = code.2406;
      *code.2405 = 208;
      goto <D.27712>;
      <D.27692>:
      D.27713 = mono_thread_get_tls_offset ();
      code.2289 = code;
      code.2407 = mono_x86_emit_tls_get (code.2289, 2, D.27713);
      code = code.2407;
      <D.27712>:
      switch (4) <default: <D.23176>, case 1: <D.23172>, case 2: <D.23174>, case 4: <D.23175>>
      <D.23172>:
      code.2289 = code;
      code.2408 = code.2289;
      code.2409 = code.2408 + 1;
      code = code.2409;
      *code.2408 = 138;
      goto <D.23173>;
      <D.23174>:
      code.2289 = code;
      code.2410 = code.2289;
      code.2411 = code.2410 + 1;
      code = code.2411;
      *code.2410 = 102;
      <D.23175>:
      code.2289 = code;
      code.2412 = code.2289;
      code.2413 = code.2412 + 1;
      code = code.2413;
      *code.2412 = 139;
      goto <D.23173>;
      <D.23176>:
      __assert_fail ("0", "tramp-x86.c", 1015, &__PRETTY_FUNCTION__);
      <D.23173>:
      if (0 != 0) goto <D.27721>; else goto <D.27722>;
      <D.27721>:
      if (0 != 0) goto <D.27723>; else goto <D.27724>;
      <D.27723>:
      code.2289 = code;
      code.2414 = code.2289;
      code.2415 = code.2414 + 1;
      code = code.2415;
      *code.2414 = 20;
      code.2289 = code;
      code.2416 = code.2289;
      code.2417 = code.2416 + 1;
      code = code.2417;
      *code.2416 = 36;
      goto <D.27729>;
      <D.27724>:
      if (1 != 0) goto <D.27730>; else goto <D.27731>;
      <D.27730>:
      code.2289 = code;
      code.2418 = code.2289;
      code.2419 = code.2418 + 1;
      code = code.2419;
      *code.2418 = 84;
      code.2289 = code;
      code.2420 = code.2289;
      code.2421 = code.2420 + 1;
      code = code.2421;
      *code.2420 = 36;
      code.2289 = code;
      *code.2289 = 40;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27736>;
      <D.27731>:
      code.2289 = code;
      code.2422 = code.2289;
      code.2423 = code.2422 + 1;
      code = code.2423;
      *code.2422 = 148;
      code.2289 = code;
      code.2424 = code.2289;
      code.2425 = code.2424 + 1;
      code = code.2425;
      *code.2424 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2289 = code;
            code.2426 = code.2289;
            code.2427 = code.2426 + 1;
            code = code.2427;
            D.27743 = imb.b[0];
            *code.2426 = D.27743;
            code.2289 = code;
            code.2428 = code.2289;
            code.2429 = code.2428 + 1;
            code = code.2429;
            D.27746 = imb.b[1];
            *code.2428 = D.27746;
            code.2289 = code;
            code.2430 = code.2289;
            code.2431 = code.2430 + 1;
            code = code.2431;
            D.27749 = imb.b[2];
            *code.2430 = D.27749;
            code.2289 = code;
            code.2432 = code.2289;
            code.2433 = code.2432 + 1;
            code = code.2433;
            D.27752 = imb.b[3];
            *code.2432 = D.27752;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27736>:
      <D.27729>:
      goto <D.23178>;
      <D.27722>:
      if (0 != 0) goto <D.27753>; else goto <D.27754>;
      <D.27753>:
      code.2289 = code;
      code.2434 = code.2289;
      code.2435 = code.2434 + 1;
      code = code.2435;
      *code.2434 = 18;
      goto <D.23178>;
      <D.27754>:
      if (1 != 0) goto <D.27757>; else goto <D.27758>;
      <D.27757>:
      code.2289 = code;
      code.2436 = code.2289;
      code.2437 = code.2436 + 1;
      code = code.2437;
      *code.2436 = 82;
      code.2289 = code;
      *code.2289 = 40;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27761>;
      <D.27758>:
      code.2289 = code;
      code.2438 = code.2289;
      code.2439 = code.2438 + 1;
      code = code.2439;
      *code.2438 = 146;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2289 = code;
            code.2440 = code.2289;
            code.2441 = code.2440 + 1;
            code = code.2441;
            D.27766 = imb.b[0];
            *code.2440 = D.27766;
            code.2289 = code;
            code.2442 = code.2289;
            code.2443 = code.2442 + 1;
            code = code.2443;
            D.27769 = imb.b[1];
            *code.2442 = D.27769;
            code.2289 = code;
            code.2444 = code.2289;
            code.2445 = code.2444 + 1;
            code = code.2445;
            D.27772 = imb.b[2];
            *code.2444 = D.27772;
            code.2289 = code;
            code.2446 = code.2289;
            code.2447 = code.2446 + 1;
            code = code.2447;
            D.27775 = imb.b[3];
            *code.2446 = D.27775;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27761>:
      <D.23178>:
      code.2289 = code;
      code.2448 = code.2289;
      code.2449 = code.2448 + 1;
      code = code.2449;
      *code.2448 = 57;
      if (0 != 0) goto <D.27778>; else goto <D.27779>;
      <D.27778>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.27780>; else goto <D.27781>;
      <D.27780>:
      code.2289 = code;
      code.2450 = code.2289;
      code.2451 = code.2450 + 1;
      code = code.2451;
      *code.2450 = 20;
      code.2289 = code;
      code.2452 = code.2289;
      code.2453 = code.2452 + 1;
      code = code.2453;
      *code.2452 = 36;
      goto <D.27786>;
      <D.27781>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.27789>; else goto <D.27790>;
      <D.27789>:
      code.2289 = code;
      code.2455 = code.2289;
      code.2456 = code.2455 + 1;
      code = code.2456;
      *code.2455 = 84;
      code.2289 = code;
      code.2457 = code.2289;
      code.2458 = code.2457 + 1;
      code = code.2458;
      *code.2457 = 36;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27796>;
      <D.27790>:
      code.2289 = code;
      code.2459 = code.2289;
      code.2460 = code.2459 + 1;
      code = code.2460;
      *code.2459 = 148;
      code.2289 = code;
      code.2461 = code.2289;
      code.2462 = code.2461 + 1;
      code = code.2462;
      *code.2461 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2463 = code.2289;
            code.2464 = code.2463 + 1;
            code = code.2464;
            D.27803 = imb.b[0];
            *code.2463 = D.27803;
            code.2289 = code;
            code.2465 = code.2289;
            code.2466 = code.2465 + 1;
            code = code.2466;
            D.27806 = imb.b[1];
            *code.2465 = D.27806;
            code.2289 = code;
            code.2467 = code.2289;
            code.2468 = code.2467 + 1;
            code = code.2468;
            D.27809 = imb.b[2];
            *code.2467 = D.27809;
            code.2289 = code;
            code.2469 = code.2289;
            code.2470 = code.2469 + 1;
            code = code.2470;
            D.27812 = imb.b[3];
            *code.2469 = D.27812;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27796>:
      <D.27786>:
      goto <D.23181>;
      <D.27779>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.27813>; else goto <D.27814>;
      <D.27813>:
      code.2289 = code;
      code.2471 = code.2289;
      code.2472 = code.2471 + 1;
      code = code.2472;
      *code.2471 = 17;
      goto <D.23181>;
      <D.27814>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.27817>; else goto <D.27818>;
      <D.27817>:
      code.2289 = code;
      code.2473 = code.2289;
      code.2474 = code.2473 + 1;
      code = code.2474;
      *code.2473 = 81;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27821>;
      <D.27818>:
      code.2289 = code;
      code.2475 = code.2289;
      code.2476 = code.2475 + 1;
      code = code.2476;
      *code.2475 = 145;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2477 = code.2289;
            code.2478 = code.2477 + 1;
            code = code.2478;
            D.27826 = imb.b[0];
            *code.2477 = D.27826;
            code.2289 = code;
            code.2479 = code.2289;
            code.2480 = code.2479 + 1;
            code = code.2480;
            D.27829 = imb.b[1];
            *code.2479 = D.27829;
            code.2289 = code;
            code.2481 = code.2289;
            code.2482 = code.2481 + 1;
            code = code.2482;
            D.27832 = imb.b[2];
            *code.2481 = D.27832;
            code.2289 = code;
            code.2483 = code.2289;
            code.2484 = code.2483 + 1;
            code = code.2484;
            D.27835 = imb.b[3];
            *code.2483 = D.27835;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27821>:
      <D.23181>:
      jump_not_owned = code;
      if (1 != 0) goto <D.27836>; else goto <D.27837>;
      <D.27836>:
      code.2289 = code;
      code.2485 = code.2289;
      code.2486 = code.2485 + 1;
      code = code.2486;
      D.27636 = 117;
      *code.2485 = D.27636;
      goto <D.27840>;
      <D.27837>:
      code.2289 = code;
      code.2487 = code.2289;
      code.2488 = code.2487 + 1;
      code = code.2488;
      D.27640 = 117;
      *code.2487 = D.27640;
      <D.27840>:
      code.2289 = code;
      *code.2289 = 255;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      if (1 != 0) goto <D.27843>; else goto <D.27844>;
      <D.27843>:
      code.2289 = code;
      code.2489 = code.2289;
      code.2490 = code.2489 + 1;
      code = code.2490;
      *code.2489 = 131;
      if (0 != 0) goto <D.27847>; else goto <D.27848>;
      <D.27847>:
      nest_offset.2280 = nest_offset;
      if (nest_offset.2280 == 0) goto <D.27849>; else goto <D.27850>;
      <D.27849>:
      code.2289 = code;
      code.2491 = code.2289;
      code.2492 = code.2491 + 1;
      code = code.2492;
      *code.2491 = 60;
      code.2289 = code;
      code.2493 = code.2289;
      code.2494 = code.2493 + 1;
      code = code.2494;
      *code.2493 = 36;
      goto <D.27855>;
      <D.27850>:
      nest_offset.2280 = nest_offset;
      nest_offset.2495 = (unsigned int) nest_offset.2280;
      D.27857 = nest_offset.2495 + 128;
      if (D.27857 <= 255) goto <D.27858>; else goto <D.27859>;
      <D.27858>:
      code.2289 = code;
      code.2496 = code.2289;
      code.2497 = code.2496 + 1;
      code = code.2497;
      *code.2496 = 124;
      code.2289 = code;
      code.2498 = code.2289;
      code.2499 = code.2498 + 1;
      code = code.2499;
      *code.2498 = 36;
      code.2289 = code;
      nest_offset.2280 = nest_offset;
      D.27864 = (unsigned char) nest_offset.2280;
      *code.2289 = D.27864;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27865>;
      <D.27859>:
      code.2289 = code;
      code.2500 = code.2289;
      code.2501 = code.2500 + 1;
      code = code.2501;
      *code.2500 = 188;
      code.2289 = code;
      code.2502 = code.2289;
      code.2503 = code.2502 + 1;
      code = code.2503;
      *code.2502 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.2280 = nest_offset;
            imb.val = nest_offset.2280;
            code.2289 = code;
            code.2504 = code.2289;
            code.2505 = code.2504 + 1;
            code = code.2505;
            D.27872 = imb.b[0];
            *code.2504 = D.27872;
            code.2289 = code;
            code.2506 = code.2289;
            code.2507 = code.2506 + 1;
            code = code.2507;
            D.27875 = imb.b[1];
            *code.2506 = D.27875;
            code.2289 = code;
            code.2508 = code.2289;
            code.2509 = code.2508 + 1;
            code = code.2509;
            D.27878 = imb.b[2];
            *code.2508 = D.27878;
            code.2289 = code;
            code.2510 = code.2289;
            code.2511 = code.2510 + 1;
            code = code.2511;
            D.27881 = imb.b[3];
            *code.2510 = D.27881;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27865>:
      <D.27855>:
      goto <D.23184>;
      <D.27848>:
      nest_offset.2280 = nest_offset;
      if (nest_offset.2280 == 0) goto <D.27882>; else goto <D.27883>;
      <D.27882>:
      code.2289 = code;
      code.2512 = code.2289;
      code.2513 = code.2512 + 1;
      code = code.2513;
      *code.2512 = 57;
      goto <D.23184>;
      <D.27883>:
      nest_offset.2280 = nest_offset;
      nest_offset.2495 = (unsigned int) nest_offset.2280;
      D.27857 = nest_offset.2495 + 128;
      if (D.27857 <= 255) goto <D.27886>; else goto <D.27887>;
      <D.27886>:
      code.2289 = code;
      code.2514 = code.2289;
      code.2515 = code.2514 + 1;
      code = code.2515;
      *code.2514 = 121;
      code.2289 = code;
      nest_offset.2280 = nest_offset;
      D.27864 = (unsigned char) nest_offset.2280;
      *code.2289 = D.27864;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27890>;
      <D.27887>:
      code.2289 = code;
      code.2516 = code.2289;
      code.2517 = code.2516 + 1;
      code = code.2517;
      *code.2516 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.2280 = nest_offset;
            imb.val = nest_offset.2280;
            code.2289 = code;
            code.2518 = code.2289;
            code.2519 = code.2518 + 1;
            code = code.2519;
            D.27895 = imb.b[0];
            *code.2518 = D.27895;
            code.2289 = code;
            code.2520 = code.2289;
            code.2521 = code.2520 + 1;
            code = code.2521;
            D.27898 = imb.b[1];
            *code.2520 = D.27898;
            code.2289 = code;
            code.2522 = code.2289;
            code.2523 = code.2522 + 1;
            code = code.2523;
            D.27901 = imb.b[2];
            *code.2522 = D.27901;
            code.2289 = code;
            code.2524 = code.2289;
            code.2525 = code.2524 + 1;
            code = code.2525;
            D.27904 = imb.b[3];
            *code.2524 = D.27904;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27890>:
      <D.23184>:
      code.2289 = code;
      *code.2289 = 1;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27905>;
      <D.27844>:
      code.2289 = code;
      code.2526 = code.2289;
      code.2527 = code.2526 + 1;
      code = code.2527;
      *code.2526 = 129;
      if (0 != 0) goto <D.27908>; else goto <D.27909>;
      <D.27908>:
      nest_offset.2280 = nest_offset;
      if (nest_offset.2280 == 0) goto <D.27910>; else goto <D.27911>;
      <D.27910>:
      code.2289 = code;
      code.2528 = code.2289;
      code.2529 = code.2528 + 1;
      code = code.2529;
      *code.2528 = 60;
      code.2289 = code;
      code.2530 = code.2289;
      code.2531 = code.2530 + 1;
      code = code.2531;
      *code.2530 = 36;
      goto <D.27916>;
      <D.27911>:
      nest_offset.2280 = nest_offset;
      nest_offset.2495 = (unsigned int) nest_offset.2280;
      D.27857 = nest_offset.2495 + 128;
      if (D.27857 <= 255) goto <D.27917>; else goto <D.27918>;
      <D.27917>:
      code.2289 = code;
      code.2532 = code.2289;
      code.2533 = code.2532 + 1;
      code = code.2533;
      *code.2532 = 124;
      code.2289 = code;
      code.2534 = code.2289;
      code.2535 = code.2534 + 1;
      code = code.2535;
      *code.2534 = 36;
      code.2289 = code;
      nest_offset.2280 = nest_offset;
      D.27864 = (unsigned char) nest_offset.2280;
      *code.2289 = D.27864;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27923>;
      <D.27918>:
      code.2289 = code;
      code.2536 = code.2289;
      code.2537 = code.2536 + 1;
      code = code.2537;
      *code.2536 = 188;
      code.2289 = code;
      code.2538 = code.2289;
      code.2539 = code.2538 + 1;
      code = code.2539;
      *code.2538 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.2280 = nest_offset;
            imb.val = nest_offset.2280;
            code.2289 = code;
            code.2540 = code.2289;
            code.2541 = code.2540 + 1;
            code = code.2541;
            D.27930 = imb.b[0];
            *code.2540 = D.27930;
            code.2289 = code;
            code.2542 = code.2289;
            code.2543 = code.2542 + 1;
            code = code.2543;
            D.27933 = imb.b[1];
            *code.2542 = D.27933;
            code.2289 = code;
            code.2544 = code.2289;
            code.2545 = code.2544 + 1;
            code = code.2545;
            D.27936 = imb.b[2];
            *code.2544 = D.27936;
            code.2289 = code;
            code.2546 = code.2289;
            code.2547 = code.2546 + 1;
            code = code.2547;
            D.27939 = imb.b[3];
            *code.2546 = D.27939;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27923>:
      <D.27916>:
      goto <D.23187>;
      <D.27909>:
      nest_offset.2280 = nest_offset;
      if (nest_offset.2280 == 0) goto <D.27940>; else goto <D.27941>;
      <D.27940>:
      code.2289 = code;
      code.2548 = code.2289;
      code.2549 = code.2548 + 1;
      code = code.2549;
      *code.2548 = 57;
      goto <D.23187>;
      <D.27941>:
      nest_offset.2280 = nest_offset;
      nest_offset.2495 = (unsigned int) nest_offset.2280;
      D.27857 = nest_offset.2495 + 128;
      if (D.27857 <= 255) goto <D.27944>; else goto <D.27945>;
      <D.27944>:
      code.2289 = code;
      code.2550 = code.2289;
      code.2551 = code.2550 + 1;
      code = code.2551;
      *code.2550 = 121;
      code.2289 = code;
      nest_offset.2280 = nest_offset;
      D.27864 = (unsigned char) nest_offset.2280;
      *code.2289 = D.27864;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.27948>;
      <D.27945>:
      code.2289 = code;
      code.2552 = code.2289;
      code.2553 = code.2552 + 1;
      code = code.2553;
      *code.2552 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.2280 = nest_offset;
            imb.val = nest_offset.2280;
            code.2289 = code;
            code.2554 = code.2289;
            code.2555 = code.2554 + 1;
            code = code.2555;
            D.27953 = imb.b[0];
            *code.2554 = D.27953;
            code.2289 = code;
            code.2556 = code.2289;
            code.2557 = code.2556 + 1;
            code = code.2557;
            D.27956 = imb.b[1];
            *code.2556 = D.27956;
            code.2289 = code;
            code.2558 = code.2289;
            code.2559 = code.2558 + 1;
            code = code.2559;
            D.27959 = imb.b[2];
            *code.2558 = D.27959;
            code.2289 = code;
            code.2560 = code.2289;
            code.2561 = code.2560 + 1;
            code = code.2561;
            D.27962 = imb.b[3];
            *code.2560 = D.27962;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27948>:
      <D.23187>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 1;
            code.2289 = code;
            code.2562 = code.2289;
            code.2563 = code.2562 + 1;
            code = code.2563;
            D.27965 = imb.b[0];
            *code.2562 = D.27965;
            code.2289 = code;
            code.2564 = code.2289;
            code.2565 = code.2564 + 1;
            code = code.2565;
            D.27968 = imb.b[1];
            *code.2564 = D.27968;
            code.2289 = code;
            code.2566 = code.2289;
            code.2567 = code.2566 + 1;
            code = code.2567;
            D.27971 = imb.b[2];
            *code.2566 = D.27971;
            code.2289 = code;
            code.2568 = code.2289;
            code.2569 = code.2568 + 1;
            code = code.2569;
            D.27974 = imb.b[3];
            *code.2568 = D.27974;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27905>:
      jump_next = code;
      if (1 != 0) goto <D.27975>; else goto <D.27976>;
      <D.27975>:
      code.2289 = code;
      code.2570 = code.2289;
      code.2571 = code.2570 + 1;
      code = code.2571;
      D.27636 = 117;
      *code.2570 = D.27636;
      goto <D.27979>;
      <D.27976>:
      code.2289 = code;
      code.2572 = code.2289;
      code.2573 = code.2572 + 1;
      code = code.2573;
      D.27640 = 117;
      *code.2572 = D.27640;
      <D.27979>:
      code.2289 = code;
      *code.2289 = 255;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      if (1 != 0) goto <D.27982>; else goto <D.27983>;
      <D.27982>:
      code.2289 = code;
      code.2574 = code.2289;
      code.2575 = code.2574 + 1;
      code = code.2575;
      *code.2574 = 131;
      if (0 != 0) goto <D.27986>; else goto <D.27987>;
      <D.27986>:
      entry_count_offset.2282 = entry_count_offset;
      if (entry_count_offset.2282 == 0) goto <D.27988>; else goto <D.27989>;
      <D.27988>:
      code.2289 = code;
      code.2576 = code.2289;
      code.2577 = code.2576 + 1;
      code = code.2577;
      *code.2576 = 60;
      code.2289 = code;
      code.2578 = code.2289;
      code.2579 = code.2578 + 1;
      code = code.2579;
      *code.2578 = 36;
      goto <D.27994>;
      <D.27989>:
      entry_count_offset.2282 = entry_count_offset;
      entry_count_offset.2580 = (unsigned int) entry_count_offset.2282;
      D.27996 = entry_count_offset.2580 + 128;
      if (D.27996 <= 255) goto <D.27997>; else goto <D.27998>;
      <D.27997>:
      code.2289 = code;
      code.2581 = code.2289;
      code.2582 = code.2581 + 1;
      code = code.2582;
      *code.2581 = 124;
      code.2289 = code;
      code.2583 = code.2289;
      code.2584 = code.2583 + 1;
      code = code.2584;
      *code.2583 = 36;
      code.2289 = code;
      entry_count_offset.2282 = entry_count_offset;
      D.28003 = (unsigned char) entry_count_offset.2282;
      *code.2289 = D.28003;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28004>;
      <D.27998>:
      code.2289 = code;
      code.2585 = code.2289;
      code.2586 = code.2585 + 1;
      code = code.2586;
      *code.2585 = 188;
      code.2289 = code;
      code.2587 = code.2289;
      code.2588 = code.2587 + 1;
      code = code.2588;
      *code.2587 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            entry_count_offset.2282 = entry_count_offset;
            imb.val = entry_count_offset.2282;
            code.2289 = code;
            code.2589 = code.2289;
            code.2590 = code.2589 + 1;
            code = code.2590;
            D.28011 = imb.b[0];
            *code.2589 = D.28011;
            code.2289 = code;
            code.2591 = code.2289;
            code.2592 = code.2591 + 1;
            code = code.2592;
            D.28014 = imb.b[1];
            *code.2591 = D.28014;
            code.2289 = code;
            code.2593 = code.2289;
            code.2594 = code.2593 + 1;
            code = code.2594;
            D.28017 = imb.b[2];
            *code.2593 = D.28017;
            code.2289 = code;
            code.2595 = code.2289;
            code.2596 = code.2595 + 1;
            code = code.2596;
            D.28020 = imb.b[3];
            *code.2595 = D.28020;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28004>:
      <D.27994>:
      goto <D.23191>;
      <D.27987>:
      entry_count_offset.2282 = entry_count_offset;
      if (entry_count_offset.2282 == 0) goto <D.28021>; else goto <D.28022>;
      <D.28021>:
      code.2289 = code;
      code.2597 = code.2289;
      code.2598 = code.2597 + 1;
      code = code.2598;
      *code.2597 = 57;
      goto <D.23191>;
      <D.28022>:
      entry_count_offset.2282 = entry_count_offset;
      entry_count_offset.2580 = (unsigned int) entry_count_offset.2282;
      D.27996 = entry_count_offset.2580 + 128;
      if (D.27996 <= 255) goto <D.28025>; else goto <D.28026>;
      <D.28025>:
      code.2289 = code;
      code.2599 = code.2289;
      code.2600 = code.2599 + 1;
      code = code.2600;
      *code.2599 = 121;
      code.2289 = code;
      entry_count_offset.2282 = entry_count_offset;
      D.28003 = (unsigned char) entry_count_offset.2282;
      *code.2289 = D.28003;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28029>;
      <D.28026>:
      code.2289 = code;
      code.2601 = code.2289;
      code.2602 = code.2601 + 1;
      code = code.2602;
      *code.2601 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            entry_count_offset.2282 = entry_count_offset;
            imb.val = entry_count_offset.2282;
            code.2289 = code;
            code.2603 = code.2289;
            code.2604 = code.2603 + 1;
            code = code.2604;
            D.28034 = imb.b[0];
            *code.2603 = D.28034;
            code.2289 = code;
            code.2605 = code.2289;
            code.2606 = code.2605 + 1;
            code = code.2606;
            D.28037 = imb.b[1];
            *code.2605 = D.28037;
            code.2289 = code;
            code.2607 = code.2289;
            code.2608 = code.2607 + 1;
            code = code.2608;
            D.28040 = imb.b[2];
            *code.2607 = D.28040;
            code.2289 = code;
            code.2609 = code.2289;
            code.2610 = code.2609 + 1;
            code = code.2610;
            D.28043 = imb.b[3];
            *code.2609 = D.28043;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28029>:
      <D.23191>:
      code.2289 = code;
      *code.2289 = 0;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28044>;
      <D.27983>:
      code.2289 = code;
      code.2611 = code.2289;
      code.2612 = code.2611 + 1;
      code = code.2612;
      *code.2611 = 129;
      if (0 != 0) goto <D.28047>; else goto <D.28048>;
      <D.28047>:
      entry_count_offset.2282 = entry_count_offset;
      if (entry_count_offset.2282 == 0) goto <D.28049>; else goto <D.28050>;
      <D.28049>:
      code.2289 = code;
      code.2613 = code.2289;
      code.2614 = code.2613 + 1;
      code = code.2614;
      *code.2613 = 60;
      code.2289 = code;
      code.2615 = code.2289;
      code.2616 = code.2615 + 1;
      code = code.2616;
      *code.2615 = 36;
      goto <D.28055>;
      <D.28050>:
      entry_count_offset.2282 = entry_count_offset;
      entry_count_offset.2580 = (unsigned int) entry_count_offset.2282;
      D.27996 = entry_count_offset.2580 + 128;
      if (D.27996 <= 255) goto <D.28056>; else goto <D.28057>;
      <D.28056>:
      code.2289 = code;
      code.2617 = code.2289;
      code.2618 = code.2617 + 1;
      code = code.2618;
      *code.2617 = 124;
      code.2289 = code;
      code.2619 = code.2289;
      code.2620 = code.2619 + 1;
      code = code.2620;
      *code.2619 = 36;
      code.2289 = code;
      entry_count_offset.2282 = entry_count_offset;
      D.28003 = (unsigned char) entry_count_offset.2282;
      *code.2289 = D.28003;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28062>;
      <D.28057>:
      code.2289 = code;
      code.2621 = code.2289;
      code.2622 = code.2621 + 1;
      code = code.2622;
      *code.2621 = 188;
      code.2289 = code;
      code.2623 = code.2289;
      code.2624 = code.2623 + 1;
      code = code.2624;
      *code.2623 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            entry_count_offset.2282 = entry_count_offset;
            imb.val = entry_count_offset.2282;
            code.2289 = code;
            code.2625 = code.2289;
            code.2626 = code.2625 + 1;
            code = code.2626;
            D.28069 = imb.b[0];
            *code.2625 = D.28069;
            code.2289 = code;
            code.2627 = code.2289;
            code.2628 = code.2627 + 1;
            code = code.2628;
            D.28072 = imb.b[1];
            *code.2627 = D.28072;
            code.2289 = code;
            code.2629 = code.2289;
            code.2630 = code.2629 + 1;
            code = code.2630;
            D.28075 = imb.b[2];
            *code.2629 = D.28075;
            code.2289 = code;
            code.2631 = code.2289;
            code.2632 = code.2631 + 1;
            code = code.2632;
            D.28078 = imb.b[3];
            *code.2631 = D.28078;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28062>:
      <D.28055>:
      goto <D.23194>;
      <D.28048>:
      entry_count_offset.2282 = entry_count_offset;
      if (entry_count_offset.2282 == 0) goto <D.28079>; else goto <D.28080>;
      <D.28079>:
      code.2289 = code;
      code.2633 = code.2289;
      code.2634 = code.2633 + 1;
      code = code.2634;
      *code.2633 = 57;
      goto <D.23194>;
      <D.28080>:
      entry_count_offset.2282 = entry_count_offset;
      entry_count_offset.2580 = (unsigned int) entry_count_offset.2282;
      D.27996 = entry_count_offset.2580 + 128;
      if (D.27996 <= 255) goto <D.28083>; else goto <D.28084>;
      <D.28083>:
      code.2289 = code;
      code.2635 = code.2289;
      code.2636 = code.2635 + 1;
      code = code.2636;
      *code.2635 = 121;
      code.2289 = code;
      entry_count_offset.2282 = entry_count_offset;
      D.28003 = (unsigned char) entry_count_offset.2282;
      *code.2289 = D.28003;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28087>;
      <D.28084>:
      code.2289 = code;
      code.2637 = code.2289;
      code.2638 = code.2637 + 1;
      code = code.2638;
      *code.2637 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            entry_count_offset.2282 = entry_count_offset;
            imb.val = entry_count_offset.2282;
            code.2289 = code;
            code.2639 = code.2289;
            code.2640 = code.2639 + 1;
            code = code.2640;
            D.28092 = imb.b[0];
            *code.2639 = D.28092;
            code.2289 = code;
            code.2641 = code.2289;
            code.2642 = code.2641 + 1;
            code = code.2642;
            D.28095 = imb.b[1];
            *code.2641 = D.28095;
            code.2289 = code;
            code.2643 = code.2289;
            code.2644 = code.2643 + 1;
            code = code.2644;
            D.28098 = imb.b[2];
            *code.2643 = D.28098;
            code.2289 = code;
            code.2645 = code.2289;
            code.2646 = code.2645 + 1;
            code = code.2646;
            D.28101 = imb.b[3];
            *code.2645 = D.28101;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28087>:
      <D.23194>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2289 = code;
            code.2647 = code.2289;
            code.2648 = code.2647 + 1;
            code = code.2648;
            D.28104 = imb.b[0];
            *code.2647 = D.28104;
            code.2289 = code;
            code.2649 = code.2289;
            code.2650 = code.2649 + 1;
            code = code.2650;
            D.28107 = imb.b[1];
            *code.2649 = D.28107;
            code.2289 = code;
            code.2651 = code.2289;
            code.2652 = code.2651 + 1;
            code = code.2652;
            D.28110 = imb.b[2];
            *code.2651 = D.28110;
            code.2289 = code;
            code.2653 = code.2289;
            code.2654 = code.2653 + 1;
            code = code.2654;
            D.28113 = imb.b[3];
            *code.2653 = D.28113;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28044>:
      jump_have_waiters = code;
      if (1 != 0) goto <D.28114>; else goto <D.28115>;
      <D.28114>:
      code.2289 = code;
      code.2655 = code.2289;
      code.2656 = code.2655 + 1;
      code = code.2656;
      D.27636 = 117;
      *code.2655 = D.27636;
      goto <D.28118>;
      <D.28115>:
      code.2289 = code;
      code.2657 = code.2289;
      code.2658 = code.2657 + 1;
      code = code.2658;
      D.27640 = 117;
      *code.2657 = D.27640;
      <D.28118>:
      code.2289 = code;
      *code.2289 = 255;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      if (0 != 0) goto <D.28121>; else goto <D.28122>;
      <D.28121>:
      code.2289 = code;
      code.2659 = code.2289;
      code.2660 = code.2659 + 1;
      code = code.2660;
      *code.2659 = 198;
      if (0 != 0) goto <D.28125>; else goto <D.28126>;
      <D.28125>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.28127>; else goto <D.28128>;
      <D.28127>:
      code.2289 = code;
      code.2661 = code.2289;
      code.2662 = code.2661 + 1;
      code = code.2662;
      *code.2661 = 4;
      code.2289 = code;
      code.2663 = code.2289;
      code.2664 = code.2663 + 1;
      code = code.2664;
      *code.2663 = 36;
      goto <D.28133>;
      <D.28128>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.28134>; else goto <D.28135>;
      <D.28134>:
      code.2289 = code;
      code.2665 = code.2289;
      code.2666 = code.2665 + 1;
      code = code.2666;
      *code.2665 = 68;
      code.2289 = code;
      code.2667 = code.2289;
      code.2668 = code.2667 + 1;
      code = code.2668;
      *code.2667 = 36;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28140>;
      <D.28135>:
      code.2289 = code;
      code.2669 = code.2289;
      code.2670 = code.2669 + 1;
      code = code.2670;
      *code.2669 = 132;
      code.2289 = code;
      code.2671 = code.2289;
      code.2672 = code.2671 + 1;
      code = code.2672;
      *code.2671 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2673 = code.2289;
            code.2674 = code.2673 + 1;
            code = code.2674;
            D.28147 = imb.b[0];
            *code.2673 = D.28147;
            code.2289 = code;
            code.2675 = code.2289;
            code.2676 = code.2675 + 1;
            code = code.2676;
            D.28150 = imb.b[1];
            *code.2675 = D.28150;
            code.2289 = code;
            code.2677 = code.2289;
            code.2678 = code.2677 + 1;
            code = code.2678;
            D.28153 = imb.b[2];
            *code.2677 = D.28153;
            code.2289 = code;
            code.2679 = code.2289;
            code.2680 = code.2679 + 1;
            code = code.2680;
            D.28156 = imb.b[3];
            *code.2679 = D.28156;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28140>:
      <D.28133>:
      goto <D.23198>;
      <D.28126>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      code.2289 = code;
      code.2681 = code.2289;
      code.2682 = code.2681 + 1;
      code = code.2682;
      *code.2681 = 1;
      goto <D.23198>;
      <D.28158>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.28161>; else goto <D.28162>;
      <D.28161>:
      code.2289 = code;
      code.2683 = code.2289;
      code.2684 = code.2683 + 1;
      code = code.2684;
      *code.2683 = 65;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28165>;
      <D.28162>:
      code.2289 = code;
      code.2685 = code.2289;
      code.2686 = code.2685 + 1;
      code = code.2686;
      *code.2685 = 129;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2687 = code.2289;
            code.2688 = code.2687 + 1;
            code = code.2688;
            D.28170 = imb.b[0];
            *code.2687 = D.28170;
            code.2289 = code;
            code.2689 = code.2289;
            code.2690 = code.2689 + 1;
            code = code.2690;
            D.28173 = imb.b[1];
            *code.2689 = D.28173;
            code.2289 = code;
            code.2691 = code.2289;
            code.2692 = code.2691 + 1;
            code = code.2692;
            D.28176 = imb.b[2];
            *code.2691 = D.28176;
            code.2289 = code;
            code.2693 = code.2289;
            code.2694 = code.2693 + 1;
            code = code.2694;
            D.28179 = imb.b[3];
            *code.2693 = D.28179;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28165>:
      <D.23198>:
      code.2289 = code;
      *code.2289 = 0;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28180>;
      <D.28122>:
      if (0 != 0) goto <D.28181>; else goto <D.28182>;
      <D.28181>:
      code.2289 = code;
      code.2695 = code.2289;
      code.2696 = code.2695 + 1;
      code = code.2696;
      *code.2695 = 102;
      code.2289 = code;
      code.2697 = code.2289;
      code.2698 = code.2697 + 1;
      code = code.2698;
      *code.2697 = 199;
      if (0 != 0) goto <D.28187>; else goto <D.28188>;
      <D.28187>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.28189>; else goto <D.28190>;
      <D.28189>:
      code.2289 = code;
      code.2699 = code.2289;
      code.2700 = code.2699 + 1;
      code = code.2700;
      *code.2699 = 4;
      code.2289 = code;
      code.2701 = code.2289;
      code.2702 = code.2701 + 1;
      code = code.2702;
      *code.2701 = 36;
      goto <D.28195>;
      <D.28190>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.28196>; else goto <D.28197>;
      <D.28196>:
      code.2289 = code;
      code.2703 = code.2289;
      code.2704 = code.2703 + 1;
      code = code.2704;
      *code.2703 = 68;
      code.2289 = code;
      code.2705 = code.2289;
      code.2706 = code.2705 + 1;
      code = code.2706;
      *code.2705 = 36;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28202>;
      <D.28197>:
      code.2289 = code;
      code.2707 = code.2289;
      code.2708 = code.2707 + 1;
      code = code.2708;
      *code.2707 = 132;
      code.2289 = code;
      code.2709 = code.2289;
      code.2710 = code.2709 + 1;
      code = code.2710;
      *code.2709 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2711 = code.2289;
            code.2712 = code.2711 + 1;
            code = code.2712;
            D.28209 = imb.b[0];
            *code.2711 = D.28209;
            code.2289 = code;
            code.2713 = code.2289;
            code.2714 = code.2713 + 1;
            code = code.2714;
            D.28212 = imb.b[1];
            *code.2713 = D.28212;
            code.2289 = code;
            code.2715 = code.2289;
            code.2716 = code.2715 + 1;
            code = code.2716;
            D.28215 = imb.b[2];
            *code.2715 = D.28215;
            code.2289 = code;
            code.2717 = code.2289;
            code.2718 = code.2717 + 1;
            code = code.2718;
            D.28218 = imb.b[3];
            *code.2717 = D.28218;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28202>:
      <D.28195>:
      goto <D.23201>;
      <D.28188>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.28219>; else goto <D.28220>;
      <D.28219>:
      code.2289 = code;
      code.2719 = code.2289;
      code.2720 = code.2719 + 1;
      code = code.2720;
      *code.2719 = 1;
      goto <D.23201>;
      <D.28220>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.28223>; else goto <D.28224>;
      <D.28223>:
      code.2289 = code;
      code.2721 = code.2289;
      code.2722 = code.2721 + 1;
      code = code.2722;
      *code.2721 = 65;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28227>;
      <D.28224>:
      code.2289 = code;
      code.2723 = code.2289;
      code.2724 = code.2723 + 1;
      code = code.2724;
      *code.2723 = 129;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2725 = code.2289;
            code.2726 = code.2725 + 1;
            code = code.2726;
            D.28232 = imb.b[0];
            *code.2725 = D.28232;
            code.2289 = code;
            code.2727 = code.2289;
            code.2728 = code.2727 + 1;
            code = code.2728;
            D.28235 = imb.b[1];
            *code.2727 = D.28235;
            code.2289 = code;
            code.2729 = code.2289;
            code.2730 = code.2729 + 1;
            code = code.2730;
            D.28238 = imb.b[2];
            *code.2729 = D.28238;
            code.2289 = code;
            code.2731 = code.2289;
            code.2732 = code.2731 + 1;
            code = code.2732;
            D.28241 = imb.b[3];
            *code.2731 = D.28241;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28227>:
      <D.23201>:
      code.2289 = code;
      MEM[(short int *)code.2289] = 0;
      code.2289 = code;
      code.2733 = code.2289 + 2;
      code = code.2733;
      goto <D.28243>;
      <D.28182>:
      code.2289 = code;
      code.2734 = code.2289;
      code.2735 = code.2734 + 1;
      code = code.2735;
      *code.2734 = 199;
      if (0 != 0) goto <D.28246>; else goto <D.28247>;
      <D.28246>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.28248>; else goto <D.28249>;
      <D.28248>:
      code.2289 = code;
      code.2736 = code.2289;
      code.2737 = code.2736 + 1;
      code = code.2737;
      *code.2736 = 4;
      code.2289 = code;
      code.2738 = code.2289;
      code.2739 = code.2738 + 1;
      code = code.2739;
      *code.2738 = 36;
      goto <D.28254>;
      <D.28249>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.28255>; else goto <D.28256>;
      <D.28255>:
      code.2289 = code;
      code.2740 = code.2289;
      code.2741 = code.2740 + 1;
      code = code.2741;
      *code.2740 = 68;
      code.2289 = code;
      code.2742 = code.2289;
      code.2743 = code.2742 + 1;
      code = code.2743;
      *code.2742 = 36;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28261>;
      <D.28256>:
      code.2289 = code;
      code.2744 = code.2289;
      code.2745 = code.2744 + 1;
      code = code.2745;
      *code.2744 = 132;
      code.2289 = code;
      code.2746 = code.2289;
      code.2747 = code.2746 + 1;
      code = code.2747;
      *code.2746 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2748 = code.2289;
            code.2749 = code.2748 + 1;
            code = code.2749;
            D.28268 = imb.b[0];
            *code.2748 = D.28268;
            code.2289 = code;
            code.2750 = code.2289;
            code.2751 = code.2750 + 1;
            code = code.2751;
            D.28271 = imb.b[1];
            *code.2750 = D.28271;
            code.2289 = code;
            code.2752 = code.2289;
            code.2753 = code.2752 + 1;
            code = code.2753;
            D.28274 = imb.b[2];
            *code.2752 = D.28274;
            code.2289 = code;
            code.2754 = code.2289;
            code.2755 = code.2754 + 1;
            code = code.2755;
            D.28277 = imb.b[3];
            *code.2754 = D.28277;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28261>:
      <D.28254>:
      goto <D.23204>;
      <D.28247>:
      owner_offset.2278 = owner_offset;
      if (owner_offset.2278 == 0) goto <D.28278>; else goto <D.28279>;
      <D.28278>:
      code.2289 = code;
      code.2756 = code.2289;
      code.2757 = code.2756 + 1;
      code = code.2757;
      *code.2756 = 1;
      goto <D.23204>;
      <D.28279>:
      owner_offset.2278 = owner_offset;
      owner_offset.2454 = (unsigned int) owner_offset.2278;
      D.27788 = owner_offset.2454 + 128;
      if (D.27788 <= 255) goto <D.28282>; else goto <D.28283>;
      <D.28282>:
      code.2289 = code;
      code.2758 = code.2289;
      code.2759 = code.2758 + 1;
      code = code.2759;
      *code.2758 = 65;
      code.2289 = code;
      owner_offset.2278 = owner_offset;
      D.27795 = (unsigned char) owner_offset.2278;
      *code.2289 = D.27795;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28286>;
      <D.28283>:
      code.2289 = code;
      code.2760 = code.2289;
      code.2761 = code.2760 + 1;
      code = code.2761;
      *code.2760 = 129;
      {
        union x86_imm_buf imb;

        try
          {
            owner_offset.2278 = owner_offset;
            imb.val = owner_offset.2278;
            code.2289 = code;
            code.2762 = code.2289;
            code.2763 = code.2762 + 1;
            code = code.2763;
            D.28291 = imb.b[0];
            *code.2762 = D.28291;
            code.2289 = code;
            code.2764 = code.2289;
            code.2765 = code.2764 + 1;
            code = code.2765;
            D.28294 = imb.b[1];
            *code.2764 = D.28294;
            code.2289 = code;
            code.2766 = code.2289;
            code.2767 = code.2766 + 1;
            code = code.2767;
            D.28297 = imb.b[2];
            *code.2766 = D.28297;
            code.2289 = code;
            code.2768 = code.2289;
            code.2769 = code.2768 + 1;
            code = code.2769;
            D.28300 = imb.b[3];
            *code.2768 = D.28300;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28286>:
      <D.23204>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2289 = code;
            code.2770 = code.2289;
            code.2771 = code.2770 + 1;
            code = code.2771;
            D.28303 = imb.b[0];
            *code.2770 = D.28303;
            code.2289 = code;
            code.2772 = code.2289;
            code.2773 = code.2772 + 1;
            code = code.2773;
            D.28306 = imb.b[1];
            *code.2772 = D.28306;
            code.2289 = code;
            code.2774 = code.2289;
            code.2775 = code.2774 + 1;
            code = code.2775;
            D.28309 = imb.b[2];
            *code.2774 = D.28309;
            code.2289 = code;
            code.2776 = code.2289;
            code.2777 = code.2776 + 1;
            code = code.2777;
            D.28312 = imb.b[3];
            *code.2776 = D.28312;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28243>:
      <D.28180>:
      code.2289 = code;
      code.2778 = code.2289;
      code.2779 = code.2778 + 1;
      code = code.2779;
      *code.2778 = 195;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_next + 1;
        size = 0;
        D.28315 = MEM[(unsigned char *)jump_next];
        D.28316 = (int) D.28315;
        switch (D.28316) <default: <D.23234>, case 15: <D.23213>, case 112: <D.23218>, case 113: <D.23219>, case 114: <D.23220>, case 115: <D.23221>, case 116: <D.23222>, case 117: <D.23223>, case 118: <D.23224>, case 119: <D.23225>, case 120: <D.23226>, case 121: <D.23227>, case 122: <D.23228>, case 123: <D.23229>, case 124: <D.23230>, case 125: <D.23231>, case 126: <D.23232>, case 127: <D.23233>, case 224: <D.23214>, case 225: <D.23215>, case 226: <D.23216>, case 232: <D.23210>, case 233: <D.23211>, case 235: <D.23217>>
        <D.23210>:
        <D.23211>:
        size = size + 1;
        goto <D.23212>;
        <D.23213>:
        D.28317 = *pos;
        D.28318 = D.28317 + 144;
        if (D.28318 > 31) goto <D.28319>; else goto <D.28320>;
        <D.28319>:
        __assert_fail ("0", "tramp-x86.c", 1038, &__PRETTY_FUNCTION__);
        <D.28320>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23212>;
        <D.23214>:
        <D.23215>:
        <D.23216>:
        <D.23217>:
        <D.23218>:
        <D.23219>:
        <D.23220>:
        <D.23221>:
        <D.23222>:
        <D.23223>:
        <D.23224>:
        <D.23225>:
        <D.23226>:
        <D.23227>:
        <D.23228>:
        <D.23229>:
        <D.23230>:
        <D.23231>:
        <D.23232>:
        <D.23233>:
        goto <D.23212>;
        <D.23234>:
        __assert_fail ("0", "tramp-x86.c", 1038, &__PRETTY_FUNCTION__);
        <D.23212>:
        code.2289 = code;
        code.2780 = (int) code.2289;
        pos.2781 = (int) pos;
        disp = code.2780 - pos.2781;
        if (size != 0) goto <D.28323>; else goto <D.28324>;
        <D.28323>:
        {
          union x86_imm_buf imb;

          try
            {
              D.28325 = disp + -4;
              imb.val = D.28325;
              pos.2782 = pos;
              pos = pos.2782 + 1;
              D.28327 = imb.b[0];
              *pos.2782 = D.28327;
              pos.2783 = pos;
              pos = pos.2783 + 1;
              D.28329 = imb.b[1];
              *pos.2783 = D.28329;
              pos.2784 = pos;
              pos = pos.2784 + 1;
              D.28331 = imb.b[2];
              *pos.2784 = D.28331;
              pos.2785 = pos;
              pos = pos.2785 + 1;
              D.28333 = imb.b[3];
              *pos.2785 = D.28333;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28334>;
        <D.28324>:
        disp.2786 = (unsigned int) disp;
        D.28336 = disp.2786 + 127;
        if (D.28336 <= 255) goto <D.28337>; else goto <D.28338>;
        <D.28337>:
        D.28339 = (unsigned char) disp;
        D.28340 = D.28339 + 255;
        *pos = D.28340;
        pos = pos + 1;
        goto <D.28341>;
        <D.28338>:
        __assert_fail ("0", "tramp-x86.c", 1038, &__PRETTY_FUNCTION__);
        <D.28341>:
        <D.28334>:
      }
      code.2289 = code;
      code.2787 = code.2289;
      code.2788 = code.2787 + 1;
      code = code.2788;
      *code.2787 = 255;
      if (0 != 0) goto <D.28344>; else goto <D.28345>;
      <D.28344>:
      nest_offset.2280 = nest_offset;
      if (nest_offset.2280 == 0) goto <D.28346>; else goto <D.28347>;
      <D.28346>:
      code.2289 = code;
      code.2789 = code.2289;
      code.2790 = code.2789 + 1;
      code = code.2790;
      *code.2789 = 12;
      code.2289 = code;
      code.2791 = code.2289;
      code.2792 = code.2791 + 1;
      code = code.2792;
      *code.2791 = 36;
      goto <D.28352>;
      <D.28347>:
      nest_offset.2280 = nest_offset;
      nest_offset.2495 = (unsigned int) nest_offset.2280;
      D.27857 = nest_offset.2495 + 128;
      if (D.27857 <= 255) goto <D.28353>; else goto <D.28354>;
      <D.28353>:
      code.2289 = code;
      code.2793 = code.2289;
      code.2794 = code.2793 + 1;
      code = code.2794;
      *code.2793 = 76;
      code.2289 = code;
      code.2795 = code.2289;
      code.2796 = code.2795 + 1;
      code = code.2796;
      *code.2795 = 36;
      code.2289 = code;
      nest_offset.2280 = nest_offset;
      D.27864 = (unsigned char) nest_offset.2280;
      *code.2289 = D.27864;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28359>;
      <D.28354>:
      code.2289 = code;
      code.2797 = code.2289;
      code.2798 = code.2797 + 1;
      code = code.2798;
      *code.2797 = 140;
      code.2289 = code;
      code.2799 = code.2289;
      code.2800 = code.2799 + 1;
      code = code.2800;
      *code.2799 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.2280 = nest_offset;
            imb.val = nest_offset.2280;
            code.2289 = code;
            code.2801 = code.2289;
            code.2802 = code.2801 + 1;
            code = code.2802;
            D.28366 = imb.b[0];
            *code.2801 = D.28366;
            code.2289 = code;
            code.2803 = code.2289;
            code.2804 = code.2803 + 1;
            code = code.2804;
            D.28369 = imb.b[1];
            *code.2803 = D.28369;
            code.2289 = code;
            code.2805 = code.2289;
            code.2806 = code.2805 + 1;
            code = code.2806;
            D.28372 = imb.b[2];
            *code.2805 = D.28372;
            code.2289 = code;
            code.2807 = code.2289;
            code.2808 = code.2807 + 1;
            code = code.2808;
            D.28375 = imb.b[3];
            *code.2807 = D.28375;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28359>:
      <D.28352>:
      goto <D.23237>;
      <D.28345>:
      nest_offset.2280 = nest_offset;
      if (nest_offset.2280 == 0) goto <D.28376>; else goto <D.28377>;
      <D.28376>:
      code.2289 = code;
      code.2809 = code.2289;
      code.2810 = code.2809 + 1;
      code = code.2810;
      *code.2809 = 9;
      goto <D.23237>;
      <D.28377>:
      nest_offset.2280 = nest_offset;
      nest_offset.2495 = (unsigned int) nest_offset.2280;
      D.27857 = nest_offset.2495 + 128;
      if (D.27857 <= 255) goto <D.28380>; else goto <D.28381>;
      <D.28380>:
      code.2289 = code;
      code.2811 = code.2289;
      code.2812 = code.2811 + 1;
      code = code.2812;
      *code.2811 = 73;
      code.2289 = code;
      nest_offset.2280 = nest_offset;
      D.27864 = (unsigned char) nest_offset.2280;
      *code.2289 = D.27864;
      code.2289 = code;
      code.2298 = code.2289 + 1;
      code = code.2298;
      goto <D.28384>;
      <D.28381>:
      code.2289 = code;
      code.2813 = code.2289;
      code.2814 = code.2813 + 1;
      code = code.2814;
      *code.2813 = 137;
      {
        union x86_imm_buf imb;

        try
          {
            nest_offset.2280 = nest_offset;
            imb.val = nest_offset.2280;
            code.2289 = code;
            code.2815 = code.2289;
            code.2816 = code.2815 + 1;
            code = code.2816;
            D.28389 = imb.b[0];
            *code.2815 = D.28389;
            code.2289 = code;
            code.2817 = code.2289;
            code.2818 = code.2817 + 1;
            code = code.2818;
            D.28392 = imb.b[1];
            *code.2817 = D.28392;
            code.2289 = code;
            code.2819 = code.2289;
            code.2820 = code.2819 + 1;
            code = code.2820;
            D.28395 = imb.b[2];
            *code.2819 = D.28395;
            code.2289 = code;
            code.2821 = code.2289;
            code.2822 = code.2821 + 1;
            code = code.2822;
            D.28398 = imb.b[3];
            *code.2821 = D.28398;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28384>:
      <D.23237>:
      code.2289 = code;
      code.2823 = code.2289;
      code.2824 = code.2823 + 1;
      code = code.2824;
      *code.2823 = 195;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_obj_null + 1;
        size = 0;
        D.28401 = MEM[(unsigned char *)jump_obj_null];
        D.28402 = (int) D.28401;
        switch (D.28402) <default: <D.23266>, case 15: <D.23245>, case 112: <D.23250>, case 113: <D.23251>, case 114: <D.23252>, case 115: <D.23253>, case 116: <D.23254>, case 117: <D.23255>, case 118: <D.23256>, case 119: <D.23257>, case 120: <D.23258>, case 121: <D.23259>, case 122: <D.23260>, case 123: <D.23261>, case 124: <D.23262>, case 125: <D.23263>, case 126: <D.23264>, case 127: <D.23265>, case 224: <D.23246>, case 225: <D.23247>, case 226: <D.23248>, case 232: <D.23242>, case 233: <D.23243>, case 235: <D.23249>>
        <D.23242>:
        <D.23243>:
        size = size + 1;
        goto <D.23244>;
        <D.23245>:
        D.28403 = *pos;
        D.28404 = D.28403 + 144;
        if (D.28404 > 31) goto <D.28405>; else goto <D.28406>;
        <D.28405>:
        __assert_fail ("0", "tramp-x86.c", 1044, &__PRETTY_FUNCTION__);
        <D.28406>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23244>;
        <D.23246>:
        <D.23247>:
        <D.23248>:
        <D.23249>:
        <D.23250>:
        <D.23251>:
        <D.23252>:
        <D.23253>:
        <D.23254>:
        <D.23255>:
        <D.23256>:
        <D.23257>:
        <D.23258>:
        <D.23259>:
        <D.23260>:
        <D.23261>:
        <D.23262>:
        <D.23263>:
        <D.23264>:
        <D.23265>:
        goto <D.23244>;
        <D.23266>:
        __assert_fail ("0", "tramp-x86.c", 1044, &__PRETTY_FUNCTION__);
        <D.23244>:
        code.2289 = code;
        code.2780 = (int) code.2289;
        pos.2825 = (int) pos;
        disp = code.2780 - pos.2825;
        if (size != 0) goto <D.28408>; else goto <D.28409>;
        <D.28408>:
        {
          union x86_imm_buf imb;

          try
            {
              D.28410 = disp + -4;
              imb.val = D.28410;
              pos.2826 = pos;
              pos = pos.2826 + 1;
              D.28412 = imb.b[0];
              *pos.2826 = D.28412;
              pos.2827 = pos;
              pos = pos.2827 + 1;
              D.28414 = imb.b[1];
              *pos.2827 = D.28414;
              pos.2828 = pos;
              pos = pos.2828 + 1;
              D.28416 = imb.b[2];
              *pos.2828 = D.28416;
              pos.2829 = pos;
              pos = pos.2829 + 1;
              D.28418 = imb.b[3];
              *pos.2829 = D.28418;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28419>;
        <D.28409>:
        disp.2830 = (unsigned int) disp;
        D.28421 = disp.2830 + 127;
        if (D.28421 <= 255) goto <D.28422>; else goto <D.28423>;
        <D.28422>:
        D.28424 = (unsigned char) disp;
        D.28425 = D.28424 + 255;
        *pos = D.28425;
        pos = pos + 1;
        goto <D.28426>;
        <D.28423>:
        __assert_fail ("0", "tramp-x86.c", 1044, &__PRETTY_FUNCTION__);
        <D.28426>:
        <D.28419>:
      }
      if (jump_sync_thin_hash != 0B) goto <D.28427>; else goto <D.28428>;
      <D.28427>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_sync_thin_hash + 1;
        size = 0;
        D.28429 = MEM[(unsigned char *)jump_sync_thin_hash];
        D.28430 = (int) D.28429;
        switch (D.28430) <default: <D.23295>, case 15: <D.23274>, case 112: <D.23279>, case 113: <D.23280>, case 114: <D.23281>, case 115: <D.23282>, case 116: <D.23283>, case 117: <D.23284>, case 118: <D.23285>, case 119: <D.23286>, case 120: <D.23287>, case 121: <D.23288>, case 122: <D.23289>, case 123: <D.23290>, case 124: <D.23291>, case 125: <D.23292>, case 126: <D.23293>, case 127: <D.23294>, case 224: <D.23275>, case 225: <D.23276>, case 226: <D.23277>, case 232: <D.23271>, case 233: <D.23272>, case 235: <D.23278>>
        <D.23271>:
        <D.23272>:
        size = size + 1;
        goto <D.23273>;
        <D.23274>:
        D.28431 = *pos;
        D.28432 = D.28431 + 144;
        if (D.28432 > 31) goto <D.28433>; else goto <D.28434>;
        <D.28433>:
        __assert_fail ("0", "tramp-x86.c", 1046, &__PRETTY_FUNCTION__);
        <D.28434>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23273>;
        <D.23275>:
        <D.23276>:
        <D.23277>:
        <D.23278>:
        <D.23279>:
        <D.23280>:
        <D.23281>:
        <D.23282>:
        <D.23283>:
        <D.23284>:
        <D.23285>:
        <D.23286>:
        <D.23287>:
        <D.23288>:
        <D.23289>:
        <D.23290>:
        <D.23291>:
        <D.23292>:
        <D.23293>:
        <D.23294>:
        goto <D.23273>;
        <D.23295>:
        __assert_fail ("0", "tramp-x86.c", 1046, &__PRETTY_FUNCTION__);
        <D.23273>:
        code.2289 = code;
        code.2780 = (int) code.2289;
        pos.2831 = (int) pos;
        disp = code.2780 - pos.2831;
        if (size != 0) goto <D.28436>; else goto <D.28437>;
        <D.28436>:
        {
          union x86_imm_buf imb;

          try
            {
              D.28438 = disp + -4;
              imb.val = D.28438;
              pos.2832 = pos;
              pos = pos.2832 + 1;
              D.28440 = imb.b[0];
              *pos.2832 = D.28440;
              pos.2833 = pos;
              pos = pos.2833 + 1;
              D.28442 = imb.b[1];
              *pos.2833 = D.28442;
              pos.2834 = pos;
              pos = pos.2834 + 1;
              D.28444 = imb.b[2];
              *pos.2834 = D.28444;
              pos.2835 = pos;
              pos = pos.2835 + 1;
              D.28446 = imb.b[3];
              *pos.2835 = D.28446;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28447>;
        <D.28437>:
        disp.2836 = (unsigned int) disp;
        D.28449 = disp.2836 + 127;
        if (D.28449 <= 255) goto <D.28450>; else goto <D.28451>;
        <D.28450>:
        D.28452 = (unsigned char) disp;
        D.28453 = D.28452 + 255;
        *pos = D.28453;
        pos = pos + 1;
        goto <D.28454>;
        <D.28451>:
        __assert_fail ("0", "tramp-x86.c", 1046, &__PRETTY_FUNCTION__);
        <D.28454>:
        <D.28447>:
      }
      <D.28428>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_have_waiters + 1;
        size = 0;
        D.28455 = MEM[(unsigned char *)jump_have_waiters];
        D.28456 = (int) D.28455;
        switch (D.28456) <default: <D.23324>, case 15: <D.23303>, case 112: <D.23308>, case 113: <D.23309>, case 114: <D.23310>, case 115: <D.23311>, case 116: <D.23312>, case 117: <D.23313>, case 118: <D.23314>, case 119: <D.23315>, case 120: <D.23316>, case 121: <D.23317>, case 122: <D.23318>, case 123: <D.23319>, case 124: <D.23320>, case 125: <D.23321>, case 126: <D.23322>, case 127: <D.23323>, case 224: <D.23304>, case 225: <D.23305>, case 226: <D.23306>, case 232: <D.23300>, case 233: <D.23301>, case 235: <D.23307>>
        <D.23300>:
        <D.23301>:
        size = size + 1;
        goto <D.23302>;
        <D.23303>:
        D.28457 = *pos;
        D.28458 = D.28457 + 144;
        if (D.28458 > 31) goto <D.28459>; else goto <D.28460>;
        <D.28459>:
        __assert_fail ("0", "tramp-x86.c", 1047, &__PRETTY_FUNCTION__);
        <D.28460>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23302>;
        <D.23304>:
        <D.23305>:
        <D.23306>:
        <D.23307>:
        <D.23308>:
        <D.23309>:
        <D.23310>:
        <D.23311>:
        <D.23312>:
        <D.23313>:
        <D.23314>:
        <D.23315>:
        <D.23316>:
        <D.23317>:
        <D.23318>:
        <D.23319>:
        <D.23320>:
        <D.23321>:
        <D.23322>:
        <D.23323>:
        goto <D.23302>;
        <D.23324>:
        __assert_fail ("0", "tramp-x86.c", 1047, &__PRETTY_FUNCTION__);
        <D.23302>:
        code.2289 = code;
        code.2780 = (int) code.2289;
        pos.2837 = (int) pos;
        disp = code.2780 - pos.2837;
        if (size != 0) goto <D.28462>; else goto <D.28463>;
        <D.28462>:
        {
          union x86_imm_buf imb;

          try
            {
              D.28464 = disp + -4;
              imb.val = D.28464;
              pos.2838 = pos;
              pos = pos.2838 + 1;
              D.28466 = imb.b[0];
              *pos.2838 = D.28466;
              pos.2839 = pos;
              pos = pos.2839 + 1;
              D.28468 = imb.b[1];
              *pos.2839 = D.28468;
              pos.2840 = pos;
              pos = pos.2840 + 1;
              D.28470 = imb.b[2];
              *pos.2840 = D.28470;
              pos.2841 = pos;
              pos = pos.2841 + 1;
              D.28472 = imb.b[3];
              *pos.2841 = D.28472;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28473>;
        <D.28463>:
        disp.2842 = (unsigned int) disp;
        D.28475 = disp.2842 + 127;
        if (D.28475 <= 255) goto <D.28476>; else goto <D.28477>;
        <D.28476>:
        D.28478 = (unsigned char) disp;
        D.28479 = D.28478 + 255;
        *pos = D.28479;
        pos = pos + 1;
        goto <D.28480>;
        <D.28477>:
        __assert_fail ("0", "tramp-x86.c", 1047, &__PRETTY_FUNCTION__);
        <D.28480>:
        <D.28473>:
      }
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_not_owned + 1;
        size = 0;
        D.28481 = MEM[(unsigned char *)jump_not_owned];
        D.28482 = (int) D.28481;
        switch (D.28482) <default: <D.23353>, case 15: <D.23332>, case 112: <D.23337>, case 113: <D.23338>, case 114: <D.23339>, case 115: <D.23340>, case 116: <D.23341>, case 117: <D.23342>, case 118: <D.23343>, case 119: <D.23344>, case 120: <D.23345>, case 121: <D.23346>, case 122: <D.23347>, case 123: <D.23348>, case 124: <D.23349>, case 125: <D.23350>, case 126: <D.23351>, case 127: <D.23352>, case 224: <D.23333>, case 225: <D.23334>, case 226: <D.23335>, case 232: <D.23329>, case 233: <D.23330>, case 235: <D.23336>>
        <D.23329>:
        <D.23330>:
        size = size + 1;
        goto <D.23331>;
        <D.23332>:
        D.28483 = *pos;
        D.28484 = D.28483 + 144;
        if (D.28484 > 31) goto <D.28485>; else goto <D.28486>;
        <D.28485>:
        __assert_fail ("0", "tramp-x86.c", 1048, &__PRETTY_FUNCTION__);
        <D.28486>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23331>;
        <D.23333>:
        <D.23334>:
        <D.23335>:
        <D.23336>:
        <D.23337>:
        <D.23338>:
        <D.23339>:
        <D.23340>:
        <D.23341>:
        <D.23342>:
        <D.23343>:
        <D.23344>:
        <D.23345>:
        <D.23346>:
        <D.23347>:
        <D.23348>:
        <D.23349>:
        <D.23350>:
        <D.23351>:
        <D.23352>:
        goto <D.23331>;
        <D.23353>:
        __assert_fail ("0", "tramp-x86.c", 1048, &__PRETTY_FUNCTION__);
        <D.23331>:
        code.2289 = code;
        code.2780 = (int) code.2289;
        pos.2843 = (int) pos;
        disp = code.2780 - pos.2843;
        if (size != 0) goto <D.28488>; else goto <D.28489>;
        <D.28488>:
        {
          union x86_imm_buf imb;

          try
            {
              D.28490 = disp + -4;
              imb.val = D.28490;
              pos.2844 = pos;
              pos = pos.2844 + 1;
              D.28492 = imb.b[0];
              *pos.2844 = D.28492;
              pos.2845 = pos;
              pos = pos.2845 + 1;
              D.28494 = imb.b[1];
              *pos.2845 = D.28494;
              pos.2846 = pos;
              pos = pos.2846 + 1;
              D.28496 = imb.b[2];
              *pos.2846 = D.28496;
              pos.2847 = pos;
              pos = pos.2847 + 1;
              D.28498 = imb.b[3];
              *pos.2847 = D.28498;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28499>;
        <D.28489>:
        disp.2848 = (unsigned int) disp;
        D.28501 = disp.2848 + 127;
        if (D.28501 <= 255) goto <D.28502>; else goto <D.28503>;
        <D.28502>:
        D.28504 = (unsigned char) disp;
        D.28505 = D.28504 + 255;
        *pos = D.28505;
        pos = pos + 1;
        goto <D.28506>;
        <D.28503>:
        __assert_fail ("0", "tramp-x86.c", 1048, &__PRETTY_FUNCTION__);
        <D.28506>:
        <D.28499>:
      }
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_sync_null + 1;
        size = 0;
        D.28507 = MEM[(unsigned char *)jump_sync_null];
        D.28508 = (int) D.28507;
        switch (D.28508) <default: <D.23382>, case 15: <D.23361>, case 112: <D.23366>, case 113: <D.23367>, case 114: <D.23368>, case 115: <D.23369>, case 116: <D.23370>, case 117: <D.23371>, case 118: <D.23372>, case 119: <D.23373>, case 120: <D.23374>, case 121: <D.23375>, case 122: <D.23376>, case 123: <D.23377>, case 124: <D.23378>, case 125: <D.23379>, case 126: <D.23380>, case 127: <D.23381>, case 224: <D.23362>, case 225: <D.23363>, case 226: <D.23364>, case 232: <D.23358>, case 233: <D.23359>, case 235: <D.23365>>
        <D.23358>:
        <D.23359>:
        size = size + 1;
        goto <D.23360>;
        <D.23361>:
        D.28509 = *pos;
        D.28510 = D.28509 + 144;
        if (D.28510 > 31) goto <D.28511>; else goto <D.28512>;
        <D.28511>:
        __assert_fail ("0", "tramp-x86.c", 1049, &__PRETTY_FUNCTION__);
        <D.28512>:
        size = size + 1;
        pos = pos + 1;
        goto <D.23360>;
        <D.23362>:
        <D.23363>:
        <D.23364>:
        <D.23365>:
        <D.23366>:
        <D.23367>:
        <D.23368>:
        <D.23369>:
        <D.23370>:
        <D.23371>:
        <D.23372>:
        <D.23373>:
        <D.23374>:
        <D.23375>:
        <D.23376>:
        <D.23377>:
        <D.23378>:
        <D.23379>:
        <D.23380>:
        <D.23381>:
        goto <D.23360>;
        <D.23382>:
        __assert_fail ("0", "tramp-x86.c", 1049, &__PRETTY_FUNCTION__);
        <D.23360>:
        code.2289 = code;
        code.2780 = (int) code.2289;
        pos.2849 = (int) pos;
        disp = code.2780 - pos.2849;
        if (size != 0) goto <D.28514>; else goto <D.28515>;
        <D.28514>:
        {
          union x86_imm_buf imb;

          try
            {
              D.28516 = disp + -4;
              imb.val = D.28516;
              pos.2850 = pos;
              pos = pos.2850 + 1;
              D.28518 = imb.b[0];
              *pos.2850 = D.28518;
              pos.2851 = pos;
              pos = pos.2851 + 1;
              D.28520 = imb.b[1];
              *pos.2851 = D.28520;
              pos.2852 = pos;
              pos = pos.2852 + 1;
              D.28522 = imb.b[2];
              *pos.2852 = D.28522;
              pos.2853 = pos;
              pos = pos.2853 + 1;
              D.28524 = imb.b[3];
              *pos.2853 = D.28524;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28525>;
        <D.28515>:
        disp.2854 = (unsigned int) disp;
        D.28527 = disp.2854 + 127;
        if (D.28527 <= 255) goto <D.28528>; else goto <D.28529>;
        <D.28528>:
        D.28530 = (unsigned char) disp;
        D.28531 = D.28530 + 255;
        *pos = D.28531;
        pos = pos + 1;
        goto <D.28532>;
        <D.28529>:
        __assert_fail ("0", "tramp-x86.c", 1049, &__PRETTY_FUNCTION__);
        <D.28532>:
        <D.28525>:
      }
      <D.27531>:
      code.2289 = code;
      code.2855 = code.2289;
      code.2856 = code.2855 + 1;
      code = code.2856;
      *code.2855 = 80;
      if (aot != 0) goto <D.28535>; else goto <D.28536>;
      <D.28535>:
      code.2289 = code;
      buf.2288 = buf;
      code.2857 = mono_arch_emit_load_aotconst (buf.2288, code.2289, &ji, 32, "generic_trampoline_monitor_exit");
      code = code.2857;
      code.2289 = code;
      code.2858 = code.2289;
      code.2859 = code.2858 + 1;
      code = code.2859;
      *code.2858 = 255;
      code.2289 = code;
      code.2860 = code.2289;
      code.2861 = code.2860 + 1;
      code = code.2861;
      *code.2860 = 224;
      goto <D.28542>;
      <D.28536>:
      {
        int t;

        tramp.2862 = (int) tramp;
        code.2289 = code;
        code.2780 = (int) code.2289;
        D.28544 = tramp.2862 - code.2780;
        t = D.28544 + -2;
        t.2863 = (unsigned int) t;
        D.28546 = t.2863 + 128;
        if (D.28546 <= 255) goto <D.28547>; else goto <D.28548>;
        <D.28547>:
        code.2289 = code;
        code.2864 = code.2289;
        code.2865 = code.2864 + 1;
        code = code.2865;
        *code.2864 = 235;
        code.2289 = code;
        D.28551 = (unsigned char) t;
        *code.2289 = D.28551;
        code.2289 = code;
        code.2298 = code.2289 + 1;
        code = code.2298;
        goto <D.28552>;
        <D.28548>:
        tramp.2862 = (int) tramp;
        code.2289 = code;
        code.2780 = (int) code.2289;
        D.28544 = tramp.2862 - code.2780;
        t = D.28544 + -5;
        code.2289 = code;
        code.2866 = code.2289;
        code.2867 = code.2866 + 1;
        code = code.2867;
        *code.2866 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.2289 = code;
              code.2868 = code.2289;
              code.2869 = code.2868 + 1;
              code = code.2869;
              D.28557 = imb.b[0];
              *code.2868 = D.28557;
              code.2289 = code;
              code.2870 = code.2289;
              code.2871 = code.2870 + 1;
              code = code.2871;
              D.28560 = imb.b[1];
              *code.2870 = D.28560;
              code.2289 = code;
              code.2872 = code.2289;
              code.2873 = code.2872 + 1;
              code = code.2873;
              D.28563 = imb.b[2];
              *code.2872 = D.28563;
              code.2289 = code;
              code.2874 = code.2289;
              code.2875 = code.2874 + 1;
              code = code.2875;
              D.28566 = imb.b[3];
              *code.2874 = D.28566;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28552>:
      }
      <D.28542>:
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      code.2289 = code;
      code.2780 = (int) code.2289;
      buf.2288 = buf;
      buf.2876 = (int) buf.2288;
      D.28568 = code.2780 - buf.2876;
      buf.2288 = buf;
      mono_arch_flush_icache (buf.2288, D.28568);
      code.2289 = code;
      code.2780 = (int) code.2289;
      buf.2288 = buf;
      buf.2876 = (int) buf.2288;
      D.28568 = code.2780 - buf.2876;
      D.28569 = D.28568 > tramp_size;
      D.28570 = (long int) D.28569;
      D.28571 = __builtin_expect (D.28570, 0);
      if (D.28571 != 0) goto <D.28572>; else goto <D.28573>;
      <D.28572>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 1064, "code - buf <= tramp_size");
      <D.28573>:
      if (info != 0B) goto <D.28574>; else goto <D.28575>;
      <D.28574>:
      ji.2877 = ji;
      code.2289 = code;
      code.2780 = (int) code.2289;
      buf.2288 = buf;
      buf.2876 = (int) buf.2288;
      D.28568 = code.2780 - buf.2876;
      D.28577 = (unsigned int) D.28568;
      buf.2288 = buf;
      D.28578 = mono_tramp_info_create ("monitor_exit_trampoline", buf.2288, D.28577, ji.2877, unwind_ops);
      *info = D.28578;
      <D.28575>:
      D.28579 = buf;
      return D.28579;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
      owner_offset = {CLOBBER};
      nest_offset = {CLOBBER};
      entry_count_offset = {CLOBBER};
      ji = {CLOBBER};
    }
}


mono_arch_invalidate_method (struct MonoJitInfo * ji, void * func, void * func_arg)
{
  unsigned int _imm.2878;
  unsigned int D.28589;
  guint8 * code.2879;
  unsigned char D.28593;
  guint8 * code.2880;
  guint8 * code.2881;
  unsigned char D.28597;
  guint8 * code.2882;
  unsigned char D.28599;
  guint8 * code.2883;
  unsigned char D.28601;
  guint8 * code.2884;
  unsigned char D.28603;
  int func.2885;
  int code.2886;
  guint8 * code.2887;
  guint8 * code.2888;
  unsigned char D.28608;
  guint8 * code.2889;
  unsigned char D.28610;
  guint8 * code.2890;
  unsigned char D.28612;
  guint8 * code.2891;
  unsigned char D.28614;
  guint8 * code;

  code = ji->code_start;
  {
    int _imm;

    _imm = (int) func_arg;
    _imm.2878 = (unsigned int) _imm;
    D.28589 = _imm.2878 + 128;
    if (D.28589 <= 255) goto <D.28590>; else goto <D.28591>;
    <D.28590>:
    code.2879 = code;
    code = code.2879 + 1;
    *code.2879 = 106;
    D.28593 = (unsigned char) _imm;
    *code = D.28593;
    code = code + 1;
    goto <D.28594>;
    <D.28591>:
    code.2880 = code;
    code = code.2880 + 1;
    *code.2880 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.2881 = code;
          code = code.2881 + 1;
          D.28597 = imb.b[0];
          *code.2881 = D.28597;
          code.2882 = code;
          code = code.2882 + 1;
          D.28599 = imb.b[1];
          *code.2882 = D.28599;
          code.2883 = code;
          code = code.2883 + 1;
          D.28601 = imb.b[2];
          *code.2883 = D.28601;
          code.2884 = code;
          code = code.2884 + 1;
          D.28603 = imb.b[3];
          *code.2884 = D.28603;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.28594>:
  }
  {
    int _x86_offset;

    func.2885 = (int) func;
    code.2886 = (int) code;
    _x86_offset = func.2885 - code.2886;
    _x86_offset = _x86_offset + -5;
    code.2887 = code;
    code = code.2887 + 1;
    *code.2887 = 232;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _x86_offset;
          code.2888 = code;
          code = code.2888 + 1;
          D.28608 = imb.b[0];
          *code.2888 = D.28608;
          code.2889 = code;
          code = code.2889 + 1;
          D.28610 = imb.b[1];
          *code.2889 = D.28610;
          code.2890 = code;
          code = code.2890 + 1;
          D.28612 = imb.b[2];
          *code.2890 = D.28612;
          code.2891 = code;
          code = code.2891 + 1;
          D.28614 = imb.b[3];
          *code.2891 = D.28614;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
}


mono_arch_create_handler_block_trampoline ()
{
  void * buf.2892;
  guint8 * buf.2893;
  int D.28617;
  int D.28620;
  guint8 * code.2894;
  guint8 * code.2895;
  guint8 * code.2896;
  guint8 * code.2897;
  guint8 * code.2898;
  guint8 * code.2899;
  guint8 * code.2900;
  guint8 * code.2901;
  guint8 * code.2902;
  guint8 * code.2903;
  guint8 * code.2904;
  guint8 * code.2905;
  guint8 * code.2906;
  guint8 * code.2907;
  guint8 * code.2908;
  guint8 * code.2909;
  guint8 * code.2910;
  guint8 * code.2911;
  guint8 * code.2912;
  guint8 * code.2913;
  guint8 * code.2914;
  guint8 * code.2915;
  guint8 * code.2916;
  unsigned char D.28652;
  guint8 * code.2917;
  guint8 * code.2918;
  unsigned char D.28655;
  guint8 * code.2919;
  guint8 * code.2920;
  unsigned char D.28658;
  guint8 * code.2921;
  guint8 * code.2922;
  unsigned char D.28661;
  guint8 * code.2923;
  guint8 * code.2924;
  guint8 * code.2925;
  guint8 * code.2926;
  guint8 * code.2927;
  guint8 * code.2928;
  guint8 * code.2929;
  guint8 * code.2930;
  unsigned char D.28675;
  guint8 * code.2931;
  guint8 * code.2932;
  unsigned char D.28678;
  guint8 * code.2933;
  guint8 * code.2934;
  unsigned char D.28681;
  guint8 * code.2935;
  guint8 * code.2936;
  unsigned char D.28684;
  guint8 * code.2937;
  guint8 * code.2938;
  guint8 * code.2939;
  guint8 * code.2940;
  unsigned char D.28691;
  guint8 * code.2941;
  guint8 * code.2942;
  unsigned char D.28694;
  guint8 * code.2943;
  guint8 * code.2944;
  unsigned char D.28697;
  guint8 * code.2945;
  guint8 * code.2946;
  unsigned char D.28700;
  guint8 * code.2947;
  guint8 * code.2948;
  guint8 * code.2949;
  guint8 * code.2950;
  guint8 * code.2951;
  guint8 * code.2952;
  guint8 * code.2953;
  guint8 * code.2954;
  guint8 * code.2955;
  guint8 * code.2956;
  unsigned char D.28714;
  guint8 * code.2957;
  guint8 * code.2958;
  unsigned char D.28717;
  guint8 * code.2959;
  guint8 * code.2960;
  unsigned char D.28720;
  guint8 * code.2961;
  guint8 * code.2962;
  unsigned char D.28723;
  guint8 * code.2963;
  guint8 * code.2964;
  int tramp.2965;
  int code.2966;
  int D.28728;
  unsigned int t.2967;
  unsigned int D.28730;
  guint8 * code.2968;
  guint8 * code.2969;
  unsigned char D.28735;
  guint8 * code.2970;
  guint8 * code.2971;
  guint8 * code.2972;
  guint8 * code.2973;
  unsigned char D.28741;
  guint8 * code.2974;
  guint8 * code.2975;
  unsigned char D.28744;
  guint8 * code.2976;
  guint8 * code.2977;
  unsigned char D.28747;
  guint8 * code.2978;
  guint8 * code.2979;
  unsigned char D.28750;
  guint8 * code.2980;
  guint8 * code.2981;
  guint8 * code.2982;
  guint8 * code.2983;
  unsigned char D.28758;
  guint8 * code.2984;
  guint8 * code.2985;
  unsigned char D.28761;
  guint8 * code.2986;
  guint8 * code.2987;
  unsigned char D.28764;
  guint8 * code.2988;
  guint8 * code.2989;
  unsigned char D.28767;
  guint8 * code.2990;
  guint8 * code.2991;
  guint8 * code.2992;
  guint8 * code.2993;
  guint8 * code.2994;
  guint8 * code.2995;
  guint8 * code.2996;
  guint8 * code.2997;
  guint8 * code.2998;
  guint8 * code.2999;
  unsigned char D.28781;
  guint8 * code.3000;
  guint8 * code.3001;
  unsigned char D.28784;
  guint8 * code.3002;
  guint8 * code.3003;
  unsigned char D.28787;
  guint8 * code.3004;
  guint8 * code.3005;
  unsigned char D.28790;
  guint8 * code.3006;
  guint8 * code.3007;
  unsigned int _imm.3008;
  unsigned int D.28794;
  guint8 * code.3009;
  guint8 * code.3010;
  unsigned char D.28799;
  guint8 * code.3011;
  guint8 * code.3012;
  guint8 * code.3013;
  guint8 * code.3014;
  unsigned char D.28805;
  guint8 * code.3015;
  guint8 * code.3016;
  unsigned char D.28808;
  guint8 * code.3017;
  guint8 * code.3018;
  unsigned char D.28811;
  guint8 * code.3019;
  guint8 * code.3020;
  unsigned char D.28814;
  int handler_block_trampoline_helper.3021;
  int D.28816;
  unsigned int t.3022;
  unsigned int D.28818;
  guint8 * code.3023;
  guint8 * code.3024;
  unsigned char D.28823;
  int D.28825;
  guint8 * code.3025;
  guint8 * code.3026;
  guint8 * code.3027;
  guint8 * code.3028;
  unsigned char D.28830;
  guint8 * code.3029;
  guint8 * code.3030;
  unsigned char D.28833;
  guint8 * code.3031;
  guint8 * code.3032;
  unsigned char D.28836;
  guint8 * code.3033;
  guint8 * code.3034;
  unsigned char D.28839;
  int buf.3035;
  int D.28841;
  _Bool D.28842;
  long int D.28843;
  long int D.28844;
  int D.28847;
  void * D.28850;
  guint8 * tramp;
  guint8 * code;
  guint8 * buf;
  int tramp_size;
  static const char __PRETTY_FUNCTION__[42] = "mono_arch_create_handler_block_trampoline";

  try
    {
      tramp = mono_get_trampoline_code (13);
      tramp_size = 64;
      buf.2892 = mono_global_codeman_reserve (tramp_size);
      buf = buf.2892;
      buf.2893 = buf;
      code = buf.2893;
      D.28617 = mono_get_jit_tls_offset ();
      if (D.28617 != -1) goto <D.28618>; else goto <D.28619>;
      <D.28618>:
      D.28620 = mono_get_jit_tls_offset ();
      code.2894 = code;
      code.2895 = mono_x86_emit_tls_get (code.2894, 0, D.28620);
      code = code.2895;
      switch (4) <default: <D.23411>, case 1: <D.23407>, case 2: <D.23409>, case 4: <D.23410>>
      <D.23407>:
      code.2894 = code;
      code.2896 = code.2894;
      code.2897 = code.2896 + 1;
      code = code.2897;
      *code.2896 = 138;
      goto <D.23408>;
      <D.23409>:
      code.2894 = code;
      code.2898 = code.2894;
      code.2899 = code.2898 + 1;
      code = code.2899;
      *code.2898 = 102;
      <D.23410>:
      code.2894 = code;
      code.2900 = code.2894;
      code.2901 = code.2900 + 1;
      code = code.2901;
      *code.2900 = 139;
      goto <D.23408>;
      <D.23411>:
      __assert_fail ("0", "tramp-x86.c", 1121, &__PRETTY_FUNCTION__);
      <D.23408>:
      if (0 != 0) goto <D.28629>; else goto <D.28630>;
      <D.28629>:
      if (0 != 0) goto <D.28631>; else goto <D.28632>;
      <D.28631>:
      code.2894 = code;
      code.2902 = code.2894;
      code.2903 = code.2902 + 1;
      code = code.2903;
      *code.2902 = 4;
      code.2894 = code;
      code.2904 = code.2894;
      code.2905 = code.2904 + 1;
      code = code.2905;
      *code.2904 = 36;
      goto <D.28637>;
      <D.28632>:
      if (0 != 0) goto <D.28638>; else goto <D.28639>;
      <D.28638>:
      code.2894 = code;
      code.2906 = code.2894;
      code.2907 = code.2906 + 1;
      code = code.2907;
      *code.2906 = 68;
      code.2894 = code;
      code.2908 = code.2894;
      code.2909 = code.2908 + 1;
      code = code.2909;
      *code.2908 = 36;
      code.2894 = code;
      *code.2894 = 184;
      code.2894 = code;
      code.2910 = code.2894 + 1;
      code = code.2910;
      goto <D.28645>;
      <D.28639>:
      code.2894 = code;
      code.2911 = code.2894;
      code.2912 = code.2911 + 1;
      code = code.2912;
      *code.2911 = 132;
      code.2894 = code;
      code.2913 = code.2894;
      code.2914 = code.2913 + 1;
      code = code.2914;
      *code.2913 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 184;
            code.2894 = code;
            code.2915 = code.2894;
            code.2916 = code.2915 + 1;
            code = code.2916;
            D.28652 = imb.b[0];
            *code.2915 = D.28652;
            code.2894 = code;
            code.2917 = code.2894;
            code.2918 = code.2917 + 1;
            code = code.2918;
            D.28655 = imb.b[1];
            *code.2917 = D.28655;
            code.2894 = code;
            code.2919 = code.2894;
            code.2920 = code.2919 + 1;
            code = code.2920;
            D.28658 = imb.b[2];
            *code.2919 = D.28658;
            code.2894 = code;
            code.2921 = code.2894;
            code.2922 = code.2921 + 1;
            code = code.2922;
            D.28661 = imb.b[3];
            *code.2921 = D.28661;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28645>:
      <D.28637>:
      goto <D.23414>;
      <D.28630>:
      if (0 != 0) goto <D.28662>; else goto <D.28663>;
      <D.28662>:
      code.2894 = code;
      code.2923 = code.2894;
      code.2924 = code.2923 + 1;
      code = code.2924;
      *code.2923 = 0;
      goto <D.23414>;
      <D.28663>:
      if (0 != 0) goto <D.28666>; else goto <D.28667>;
      <D.28666>:
      code.2894 = code;
      code.2925 = code.2894;
      code.2926 = code.2925 + 1;
      code = code.2926;
      *code.2925 = 64;
      code.2894 = code;
      *code.2894 = 184;
      code.2894 = code;
      code.2910 = code.2894 + 1;
      code = code.2910;
      goto <D.28670>;
      <D.28667>:
      code.2894 = code;
      code.2927 = code.2894;
      code.2928 = code.2927 + 1;
      code = code.2928;
      *code.2927 = 128;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 184;
            code.2894 = code;
            code.2929 = code.2894;
            code.2930 = code.2929 + 1;
            code = code.2930;
            D.28675 = imb.b[0];
            *code.2929 = D.28675;
            code.2894 = code;
            code.2931 = code.2894;
            code.2932 = code.2931 + 1;
            code = code.2932;
            D.28678 = imb.b[1];
            *code.2931 = D.28678;
            code.2894 = code;
            code.2933 = code.2894;
            code.2934 = code.2933 + 1;
            code = code.2934;
            D.28681 = imb.b[2];
            *code.2933 = D.28681;
            code.2894 = code;
            code.2935 = code.2894;
            code.2936 = code.2935 + 1;
            code = code.2936;
            D.28684 = imb.b[3];
            *code.2935 = D.28684;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28670>:
      <D.23414>:
      if (0 != 0) goto <D.28685>; else goto <D.28686>;
      <D.28685>:
      code.2894 = code;
      code.2937 = code.2894;
      code.2938 = code.2937 + 1;
      code = code.2938;
      *code.2937 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2894 = code;
            code.2939 = code.2894;
            code.2940 = code.2939 + 1;
            code = code.2940;
            D.28691 = imb.b[0];
            *code.2939 = D.28691;
            code.2894 = code;
            code.2941 = code.2894;
            code.2942 = code.2941 + 1;
            code = code.2942;
            D.28694 = imb.b[1];
            *code.2941 = D.28694;
            code.2894 = code;
            code.2943 = code.2894;
            code.2944 = code.2943 + 1;
            code = code.2944;
            D.28697 = imb.b[2];
            *code.2943 = D.28697;
            code.2894 = code;
            code.2945 = code.2894;
            code.2946 = code.2945 + 1;
            code = code.2946;
            D.28700 = imb.b[3];
            *code.2945 = D.28700;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23417>;
      <D.28686>:
      if (1 != 0) goto <D.28701>; else goto <D.28702>;
      <D.28701>:
      code.2894 = code;
      code.2947 = code.2894;
      code.2948 = code.2947 + 1;
      code = code.2948;
      *code.2947 = 131;
      code.2894 = code;
      code.2949 = code.2894;
      code.2950 = code.2949 + 1;
      code = code.2950;
      *code.2949 = 236;
      code.2894 = code;
      *code.2894 = 8;
      code.2894 = code;
      code.2910 = code.2894 + 1;
      code = code.2910;
      goto <D.28707>;
      <D.28702>:
      code.2894 = code;
      code.2951 = code.2894;
      code.2952 = code.2951 + 1;
      code = code.2952;
      *code.2951 = 129;
      code.2894 = code;
      code.2953 = code.2894;
      code.2954 = code.2953 + 1;
      code = code.2954;
      *code.2953 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2894 = code;
            code.2955 = code.2894;
            code.2956 = code.2955 + 1;
            code = code.2956;
            D.28714 = imb.b[0];
            *code.2955 = D.28714;
            code.2894 = code;
            code.2957 = code.2894;
            code.2958 = code.2957 + 1;
            code = code.2958;
            D.28717 = imb.b[1];
            *code.2957 = D.28717;
            code.2894 = code;
            code.2959 = code.2894;
            code.2960 = code.2959 + 1;
            code = code.2960;
            D.28720 = imb.b[2];
            *code.2959 = D.28720;
            code.2894 = code;
            code.2961 = code.2894;
            code.2962 = code.2961 + 1;
            code = code.2962;
            D.28723 = imb.b[3];
            *code.2961 = D.28723;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28707>:
      <D.23417>:
      code.2894 = code;
      code.2963 = code.2894;
      code.2964 = code.2963 + 1;
      code = code.2964;
      *code.2963 = 80;
      {
        int t;

        tramp.2965 = (int) tramp;
        code.2894 = code;
        code.2966 = (int) code.2894;
        D.28728 = tramp.2965 - code.2966;
        t = D.28728 + -2;
        t.2967 = (unsigned int) t;
        D.28730 = t.2967 + 128;
        if (D.28730 <= 255) goto <D.28731>; else goto <D.28732>;
        <D.28731>:
        code.2894 = code;
        code.2968 = code.2894;
        code.2969 = code.2968 + 1;
        code = code.2969;
        *code.2968 = 235;
        code.2894 = code;
        D.28735 = (unsigned char) t;
        *code.2894 = D.28735;
        code.2894 = code;
        code.2910 = code.2894 + 1;
        code = code.2910;
        goto <D.28736>;
        <D.28732>:
        tramp.2965 = (int) tramp;
        code.2894 = code;
        code.2966 = (int) code.2894;
        D.28728 = tramp.2965 - code.2966;
        t = D.28728 + -5;
        code.2894 = code;
        code.2970 = code.2894;
        code.2971 = code.2970 + 1;
        code = code.2971;
        *code.2970 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.2894 = code;
              code.2972 = code.2894;
              code.2973 = code.2972 + 1;
              code = code.2973;
              D.28741 = imb.b[0];
              *code.2972 = D.28741;
              code.2894 = code;
              code.2974 = code.2894;
              code.2975 = code.2974 + 1;
              code = code.2975;
              D.28744 = imb.b[1];
              *code.2974 = D.28744;
              code.2894 = code;
              code.2976 = code.2894;
              code.2977 = code.2976 + 1;
              code = code.2977;
              D.28747 = imb.b[2];
              *code.2976 = D.28747;
              code.2894 = code;
              code.2978 = code.2894;
              code.2979 = code.2978 + 1;
              code = code.2979;
              D.28750 = imb.b[3];
              *code.2978 = D.28750;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28736>:
      }
      goto <D.28751>;
      <D.28619>:
      if (0 != 0) goto <D.28752>; else goto <D.28753>;
      <D.28752>:
      code.2894 = code;
      code.2980 = code.2894;
      code.2981 = code.2980 + 1;
      code = code.2981;
      *code.2980 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2894 = code;
            code.2982 = code.2894;
            code.2983 = code.2982 + 1;
            code = code.2983;
            D.28758 = imb.b[0];
            *code.2982 = D.28758;
            code.2894 = code;
            code.2984 = code.2894;
            code.2985 = code.2984 + 1;
            code = code.2985;
            D.28761 = imb.b[1];
            *code.2984 = D.28761;
            code.2894 = code;
            code.2986 = code.2894;
            code.2987 = code.2986 + 1;
            code = code.2987;
            D.28764 = imb.b[2];
            *code.2986 = D.28764;
            code.2894 = code;
            code.2988 = code.2894;
            code.2989 = code.2988 + 1;
            code = code.2989;
            D.28767 = imb.b[3];
            *code.2988 = D.28767;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23422>;
      <D.28753>:
      if (1 != 0) goto <D.28768>; else goto <D.28769>;
      <D.28768>:
      code.2894 = code;
      code.2990 = code.2894;
      code.2991 = code.2990 + 1;
      code = code.2991;
      *code.2990 = 131;
      code.2894 = code;
      code.2992 = code.2894;
      code.2993 = code.2992 + 1;
      code = code.2993;
      *code.2992 = 236;
      code.2894 = code;
      *code.2894 = 8;
      code.2894 = code;
      code.2910 = code.2894 + 1;
      code = code.2910;
      goto <D.28774>;
      <D.28769>:
      code.2894 = code;
      code.2994 = code.2894;
      code.2995 = code.2994 + 1;
      code = code.2995;
      *code.2994 = 129;
      code.2894 = code;
      code.2996 = code.2894;
      code.2997 = code.2996 + 1;
      code = code.2997;
      *code.2996 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2894 = code;
            code.2998 = code.2894;
            code.2999 = code.2998 + 1;
            code = code.2999;
            D.28781 = imb.b[0];
            *code.2998 = D.28781;
            code.2894 = code;
            code.3000 = code.2894;
            code.3001 = code.3000 + 1;
            code = code.3001;
            D.28784 = imb.b[1];
            *code.3000 = D.28784;
            code.2894 = code;
            code.3002 = code.2894;
            code.3003 = code.3002 + 1;
            code = code.3003;
            D.28787 = imb.b[2];
            *code.3002 = D.28787;
            code.2894 = code;
            code.3004 = code.2894;
            code.3005 = code.3004 + 1;
            code = code.3005;
            D.28790 = imb.b[3];
            *code.3004 = D.28790;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28774>:
      <D.23422>:
      code.2894 = code;
      code.3006 = code.2894;
      code.3007 = code.3006 + 1;
      code = code.3007;
      *code.3006 = 84;
      {
        int _imm;

        _imm = (int) tramp;
        _imm.3008 = (unsigned int) _imm;
        D.28794 = _imm.3008 + 128;
        if (D.28794 <= 255) goto <D.28795>; else goto <D.28796>;
        <D.28795>:
        code.2894 = code;
        code.3009 = code.2894;
        code.3010 = code.3009 + 1;
        code = code.3010;
        *code.3009 = 106;
        code.2894 = code;
        D.28799 = (unsigned char) _imm;
        *code.2894 = D.28799;
        code.2894 = code;
        code.2910 = code.2894 + 1;
        code = code.2910;
        goto <D.28800>;
        <D.28796>:
        code.2894 = code;
        code.3011 = code.2894;
        code.3012 = code.3011 + 1;
        code = code.3012;
        *code.3011 = 104;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _imm;
              code.2894 = code;
              code.3013 = code.2894;
              code.3014 = code.3013 + 1;
              code = code.3014;
              D.28805 = imb.b[0];
              *code.3013 = D.28805;
              code.2894 = code;
              code.3015 = code.2894;
              code.3016 = code.3015 + 1;
              code = code.3016;
              D.28808 = imb.b[1];
              *code.3015 = D.28808;
              code.2894 = code;
              code.3017 = code.2894;
              code.3018 = code.3017 + 1;
              code = code.3018;
              D.28811 = imb.b[2];
              *code.3017 = D.28811;
              code.2894 = code;
              code.3019 = code.2894;
              code.3020 = code.3019 + 1;
              code = code.3020;
              D.28814 = imb.b[3];
              *code.3019 = D.28814;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28800>:
      }
      {
        int t;

        handler_block_trampoline_helper.3021 = (int) handler_block_trampoline_helper;
        D.28816 = handler_block_trampoline_helper.3021 + -2;
        code.2894 = code;
        code.2966 = (int) code.2894;
        t = D.28816 - code.2966;
        t.3022 = (unsigned int) t;
        D.28818 = t.3022 + 128;
        if (D.28818 <= 255) goto <D.28819>; else goto <D.28820>;
        <D.28819>:
        code.2894 = code;
        code.3023 = code.2894;
        code.3024 = code.3023 + 1;
        code = code.3024;
        *code.3023 = 235;
        code.2894 = code;
        D.28823 = (unsigned char) t;
        *code.2894 = D.28823;
        code.2894 = code;
        code.2910 = code.2894 + 1;
        code = code.2910;
        goto <D.28824>;
        <D.28820>:
        handler_block_trampoline_helper.3021 = (int) handler_block_trampoline_helper;
        D.28825 = handler_block_trampoline_helper.3021 + -5;
        code.2894 = code;
        code.2966 = (int) code.2894;
        t = D.28825 - code.2966;
        code.2894 = code;
        code.3025 = code.2894;
        code.3026 = code.3025 + 1;
        code = code.3026;
        *code.3025 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.2894 = code;
              code.3027 = code.2894;
              code.3028 = code.3027 + 1;
              code = code.3028;
              D.28830 = imb.b[0];
              *code.3027 = D.28830;
              code.2894 = code;
              code.3029 = code.2894;
              code.3030 = code.3029 + 1;
              code = code.3030;
              D.28833 = imb.b[1];
              *code.3029 = D.28833;
              code.2894 = code;
              code.3031 = code.2894;
              code.3032 = code.3031 + 1;
              code = code.3032;
              D.28836 = imb.b[2];
              *code.3031 = D.28836;
              code.2894 = code;
              code.3033 = code.2894;
              code.3034 = code.3033 + 1;
              code = code.3034;
              D.28839 = imb.b[3];
              *code.3033 = D.28839;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28824>:
      }
      <D.28751>:
      nacl_global_codeman_validate (&buf, tramp_size, &code);
      code.2894 = code;
      code.2966 = (int) code.2894;
      buf.2893 = buf;
      buf.3035 = (int) buf.2893;
      D.28841 = code.2966 - buf.3035;
      buf.2893 = buf;
      mono_arch_flush_icache (buf.2893, D.28841);
      code.2894 = code;
      code.2966 = (int) code.2894;
      buf.2893 = buf;
      buf.3035 = (int) buf.2893;
      D.28841 = code.2966 - buf.3035;
      D.28842 = D.28841 > tramp_size;
      D.28843 = (long int) D.28842;
      D.28844 = __builtin_expect (D.28843, 0);
      if (D.28844 != 0) goto <D.28845>; else goto <D.28846>;
      <D.28845>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 1138, "code - buf <= tramp_size");
      <D.28846>:
      D.28847 = mono_jit_map_is_enabled ();
      if (D.28847 != 0) goto <D.28848>; else goto <D.28849>;
      <D.28848>:
      code.2894 = code;
      code.2966 = (int) code.2894;
      buf.2893 = buf;
      buf.3035 = (int) buf.2893;
      D.28841 = code.2966 - buf.3035;
      buf.2893 = buf;
      mono_emit_jit_tramp (buf.2893, D.28841, "handler_block_trampoline");
      <D.28849>:
      D.28850 = buf;
      return D.28850;
    }
  finally
    {
      code = {CLOBBER};
      buf = {CLOBBER};
    }
}


handler_block_trampoline_helper (void * * ptr)
{
  unsigned int mono_jit_tls_id.3036;
  void * D.28854;
  struct MonoJitTlsData * jit_tls;

  mono_jit_tls_id.3036 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.3036);
  D.28854 = jit_tls->handler_block_return_address;
  *ptr = D.28854;
}


mono_arch_get_call_target (guint8 * code)
{
  guint8 * D.28855;
  unsigned char D.28856;
  guint8 * D.28859;

  D.28855 = code + 4294967291;
  D.28856 = *D.28855;
  if (D.28856 == 232) goto <D.28857>; else goto <D.28858>;
  <D.28857>:
  {
    guint32 disp;
    guint8 * target;

    disp = MEM[(guint32 *)code + 4294967292B];
    target = code + disp;
    D.28859 = target;
    return D.28859;
  }
  <D.28858>:
  D.28859 = 0B;
  return D.28859;
}


mono_arch_get_plt_info_offset (guint8 * plt_entry, mgreg_t * regs, guint8 * code)
{
  guint32 D.28861;

  D.28861 = MEM[(guint32 *)plt_entry + 6B];
  return D.28861;
}


mono_arch_get_gsharedvt_arg_trampoline (struct MonoDomain * domain, void * arg, void * addr)
{
  void * code.3037;
  guint8 * code.3038;
  guint8 * code.3039;
  guint8 * code.3040;
  int arg.3041;
  guint8 * code.3042;
  guint8 * code.3043;
  unsigned char D.28870;
  guint8 * code.3044;
  guint8 * code.3045;
  unsigned char D.28873;
  guint8 * code.3046;
  guint8 * code.3047;
  unsigned char D.28876;
  guint8 * code.3048;
  guint8 * code.3049;
  unsigned char D.28879;
  int addr.3050;
  int code.3051;
  int D.28882;
  unsigned int t.3052;
  unsigned int D.28884;
  guint8 * code.3053;
  guint8 * code.3054;
  unsigned char D.28889;
  guint8 * code.3055;
  guint8 * code.3056;
  guint8 * code.3057;
  guint8 * code.3058;
  guint8 * code.3059;
  unsigned char D.28896;
  guint8 * code.3060;
  guint8 * code.3061;
  unsigned char D.28899;
  guint8 * code.3062;
  guint8 * code.3063;
  unsigned char D.28902;
  guint8 * code.3064;
  guint8 * code.3065;
  unsigned char D.28905;
  guint8 * start.3066;
  int start.3067;
  int D.28908;
  _Bool D.28909;
  long int D.28910;
  long int D.28911;
  void * D.28914;
  guint8 * code;
  guint8 * start;
  int buf_len;

  try
    {
      buf_len = 10;
      code.3037 = mono_domain_code_reserve (domain, buf_len);
      code = code.3037;
      code.3038 = code;
      start = code.3038;
      code.3038 = code;
      code.3039 = code.3038;
      code.3040 = code.3039 + 1;
      code = code.3040;
      *code.3039 = 184;
      {
        union x86_imm_buf imb;

        try
          {
            arg.3041 = (int) arg;
            imb.val = arg.3041;
            code.3038 = code;
            code.3042 = code.3038;
            code.3043 = code.3042 + 1;
            code = code.3043;
            D.28870 = imb.b[0];
            *code.3042 = D.28870;
            code.3038 = code;
            code.3044 = code.3038;
            code.3045 = code.3044 + 1;
            code = code.3045;
            D.28873 = imb.b[1];
            *code.3044 = D.28873;
            code.3038 = code;
            code.3046 = code.3038;
            code.3047 = code.3046 + 1;
            code = code.3047;
            D.28876 = imb.b[2];
            *code.3046 = D.28876;
            code.3038 = code;
            code.3048 = code.3038;
            code.3049 = code.3048 + 1;
            code = code.3049;
            D.28879 = imb.b[3];
            *code.3048 = D.28879;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      {
        int t;

        addr.3050 = (int) addr;
        code.3038 = code;
        code.3051 = (int) code.3038;
        D.28882 = addr.3050 - code.3051;
        t = D.28882 + -2;
        t.3052 = (unsigned int) t;
        D.28884 = t.3052 + 128;
        if (D.28884 <= 255) goto <D.28885>; else goto <D.28886>;
        <D.28885>:
        code.3038 = code;
        code.3053 = code.3038;
        code.3054 = code.3053 + 1;
        code = code.3054;
        *code.3053 = 235;
        code.3038 = code;
        D.28889 = (unsigned char) t;
        *code.3038 = D.28889;
        code.3038 = code;
        code.3055 = code.3038 + 1;
        code = code.3055;
        goto <D.28891>;
        <D.28886>:
        addr.3050 = (int) addr;
        code.3038 = code;
        code.3051 = (int) code.3038;
        D.28882 = addr.3050 - code.3051;
        t = D.28882 + -5;
        code.3038 = code;
        code.3056 = code.3038;
        code.3057 = code.3056 + 1;
        code = code.3057;
        *code.3056 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = t;
              code.3038 = code;
              code.3058 = code.3038;
              code.3059 = code.3058 + 1;
              code = code.3059;
              D.28896 = imb.b[0];
              *code.3058 = D.28896;
              code.3038 = code;
              code.3060 = code.3038;
              code.3061 = code.3060 + 1;
              code = code.3061;
              D.28899 = imb.b[1];
              *code.3060 = D.28899;
              code.3038 = code;
              code.3062 = code.3038;
              code.3063 = code.3062 + 1;
              code = code.3063;
              D.28902 = imb.b[2];
              *code.3062 = D.28902;
              code.3038 = code;
              code.3064 = code.3038;
              code.3065 = code.3064 + 1;
              code = code.3065;
              D.28905 = imb.b[3];
              *code.3064 = D.28905;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28891>:
      }
      code.3038 = code;
      code.3051 = (int) code.3038;
      start.3066 = start;
      start.3067 = (int) start.3066;
      D.28908 = code.3051 - start.3067;
      D.28909 = D.28908 > buf_len;
      D.28910 = (long int) D.28909;
      D.28911 = __builtin_expect (D.28910, 0);
      if (D.28911 != 0) goto <D.28912>; else goto <D.28913>;
      <D.28912>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "tramp-x86.c", 1182, "(code - start) <= buf_len");
      <D.28913>:
      nacl_domain_code_validate (domain, &start, buf_len, &code);
      code.3038 = code;
      code.3051 = (int) code.3038;
      start.3066 = start;
      start.3067 = (int) start.3066;
      D.28908 = code.3051 - start.3067;
      start.3066 = start;
      mono_arch_flush_icache (start.3066, D.28908);
      D.28914 = start;
      return D.28914;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_get_gsharedvt_trampoline (struct MonoTrampInfo * * info, gboolean aot)
{
  void * D.28919;

  if (info != 0B) goto <D.28917>; else goto <D.28918>;
  <D.28917>:
  *info = 0B;
  <D.28918>:
  D.28919 = 0B;
  return D.28919;
}


