mono_arch_regname (int reg)
{
  const char * D.29364;

  switch (reg) <default: <D.29365>, case 0: <D.23681>, case 1: <D.23683>, case 2: <D.23684>, case 3: <D.23682>, case 4: <D.23685>, case 5: <D.23686>, case 6: <D.23688>, case 7: <D.23687>>
  <D.23681>:
  D.29364 = "%eax";
  return D.29364;
  <D.23682>:
  D.29364 = "%ebx";
  return D.29364;
  <D.23683>:
  D.29364 = "%ecx";
  return D.29364;
  <D.23684>:
  D.29364 = "%edx";
  return D.29364;
  <D.23685>:
  D.29364 = "%esp";
  return D.29364;
  <D.23686>:
  D.29364 = "%ebp";
  return D.29364;
  <D.23687>:
  D.29364 = "%edi";
  return D.29364;
  <D.23688>:
  D.29364 = "%esi";
  return D.29364;
  <D.29365>:
  D.29364 = "unknown";
  return D.29364;
}


mono_arch_fregname (int reg)
{
  const char * D.29367;

  switch (reg) <default: <D.23700>, case 0: <D.23692>, case 1: <D.23693>, case 2: <D.23694>, case 3: <D.23695>, case 4: <D.23696>, case 5: <D.23697>, case 6: <D.23698>, case 7: <D.23699>>
  <D.23692>:
  D.29367 = "%fr0";
  return D.29367;
  <D.23693>:
  D.29367 = "%fr1";
  return D.29367;
  <D.23694>:
  D.29367 = "%fr2";
  return D.29367;
  <D.23695>:
  D.29367 = "%fr3";
  return D.29367;
  <D.23696>:
  D.29367 = "%fr4";
  return D.29367;
  <D.23697>:
  D.29367 = "%fr5";
  return D.29367;
  <D.23698>:
  D.29367 = "%fr6";
  return D.29367;
  <D.23699>:
  D.29367 = "%fr7";
  return D.29367;
  <D.23700>:
  D.29367 = "unknown";
  return D.29367;
}


mono_arch_xregname (int reg)
{
  const char * D.29369;

  switch (reg) <default: <D.23712>, case 0: <D.23704>, case 1: <D.23705>, case 2: <D.23706>, case 3: <D.23707>, case 4: <D.23708>, case 5: <D.23709>, case 6: <D.23710>, case 7: <D.23711>>
  <D.23704>:
  D.29369 = "%xmm0";
  return D.29369;
  <D.23705>:
  D.29369 = "%xmm1";
  return D.29369;
  <D.23706>:
  D.29369 = "%xmm2";
  return D.29369;
  <D.23707>:
  D.29369 = "%xmm3";
  return D.29369;
  <D.23708>:
  D.29369 = "%xmm4";
  return D.29369;
  <D.23709>:
  D.29369 = "%xmm5";
  return D.29369;
  <D.23710>:
  D.29369 = "%xmm6";
  return D.29369;
  <D.23711>:
  D.29369 = "%xmm7";
  return D.29369;
  <D.23712>:
  D.29369 = "unknown";
  return D.29369;
}


mono_x86_patch (unsigned char * code, void * target)
{
  unsigned char D.29371;
  int D.29372;
  unsigned char D.29373;
  unsigned char D.29374;
  int target.0;
  int pos.1;
  int D.29381;
  unsigned char * pos.2;
  unsigned char D.29383;
  unsigned char * pos.3;
  unsigned char D.29385;
  unsigned char * pos.4;
  unsigned char D.29387;
  unsigned char * pos.5;
  unsigned char D.29389;
  unsigned int disp.6;
  unsigned int D.29392;
  unsigned char D.29395;
  unsigned char D.29396;
  static const char __PRETTY_FUNCTION__[15] = "mono_x86_patch";

  {
    unsigned char * pos;
    int disp;
    int size;

    pos = code + 1;
    size = 0;
    D.29371 = *code;
    D.29372 = (int) D.29371;
    switch (D.29372) <default: <D.23745>, case 15: <D.23723>, case 112: <D.23729>, case 113: <D.23730>, case 114: <D.23731>, case 115: <D.23732>, case 116: <D.23733>, case 117: <D.23734>, case 118: <D.23735>, case 119: <D.23736>, case 120: <D.23737>, case 121: <D.23738>, case 122: <D.23739>, case 123: <D.23740>, case 124: <D.23741>, case 125: <D.23742>, case 126: <D.23743>, case 127: <D.23744>, case 224: <D.23725>, case 225: <D.23726>, case 226: <D.23727>, case 232: <D.23720>, case 233: <D.23721>, case 235: <D.23728>>
    <D.23720>:
    <D.23721>:
    size = size + 1;
    goto <D.23722>;
    <D.23723>:
    D.29373 = *pos;
    D.29374 = D.29373 + 144;
    if (D.29374 > 31) goto <D.29375>; else goto <D.29376>;
    <D.29375>:
    __assert_fail ("0", "mini-x86.c", 186, &__PRETTY_FUNCTION__);
    <D.29376>:
    size = size + 1;
    pos = pos + 1;
    goto <D.23722>;
    <D.23725>:
    <D.23726>:
    <D.23727>:
    <D.23728>:
    <D.23729>:
    <D.23730>:
    <D.23731>:
    <D.23732>:
    <D.23733>:
    <D.23734>:
    <D.23735>:
    <D.23736>:
    <D.23737>:
    <D.23738>:
    <D.23739>:
    <D.23740>:
    <D.23741>:
    <D.23742>:
    <D.23743>:
    <D.23744>:
    goto <D.23722>;
    <D.23745>:
    __assert_fail ("0", "mini-x86.c", 186, &__PRETTY_FUNCTION__);
    <D.23722>:
    target.0 = (int) target;
    pos.1 = (int) pos;
    disp = target.0 - pos.1;
    if (size != 0) goto <D.29379>; else goto <D.29380>;
    <D.29379>:
    {
      union x86_imm_buf imb;

      try
        {
          D.29381 = disp + -4;
          imb.val = D.29381;
          pos.2 = pos;
          pos = pos.2 + 1;
          D.29383 = imb.b[0];
          *pos.2 = D.29383;
          pos.3 = pos;
          pos = pos.3 + 1;
          D.29385 = imb.b[1];
          *pos.3 = D.29385;
          pos.4 = pos;
          pos = pos.4 + 1;
          D.29387 = imb.b[2];
          *pos.4 = D.29387;
          pos.5 = pos;
          pos = pos.5 + 1;
          D.29389 = imb.b[3];
          *pos.5 = D.29389;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.29390>;
    <D.29380>:
    disp.6 = (unsigned int) disp;
    D.29392 = disp.6 + 127;
    if (D.29392 <= 255) goto <D.29393>; else goto <D.29394>;
    <D.29393>:
    D.29395 = (unsigned char) disp;
    D.29396 = D.29395 + 255;
    *pos = D.29396;
    pos = pos + 1;
    goto <D.29397>;
    <D.29394>:
    __assert_fail ("0", "mini-x86.c", 186, &__PRETTY_FUNCTION__);
    <D.29397>:
    <D.29390>:
  }
}


mono_arch_get_argument_info (struct MonoGenericSharingContext * gsctx, struct MonoMethodSignature * csig, int param_count, struct MonoJitArgumentInfo * arg_info)
{
  short unsigned int D.29399;
  int D.29400;
  int D.29401;
  unsigned int D.29402;
  unsigned int D.29403;
  unsigned int D.29404;
  unsigned int len.7;
  unsigned int D.29406;
  unsigned int len.8;
  short unsigned int D.29408;
  int D.29409;
  int D.29412;
  unsigned int args_size.9;
  unsigned int D.29416;
  unsigned char D.29417;
  unsigned char D.29418;
  short unsigned int D.29427;
  <unnamed-unsigned:1> D.29428;
  int D.29429;
  struct MonoType * D.29430;
  unsigned int align.10;
  unsigned int D.29432;
  unsigned int args_size.11;
  unsigned int D.29434;
  unsigned int D.29435;
  unsigned int D.29436;
  int pad.12;
  unsigned int k.13;
  unsigned int D.29439;
  struct MonoJitArgumentInfo * D.29440;
  unsigned char D.29441;
  sizetype k.14;
  sizetype D.29443;
  sizetype D.29444;
  struct MonoJitArgumentInfo * D.29445;
  short unsigned int D.29446;
  int mono_do_x86_stack_align.15;
  unsigned char D.29459;
  short unsigned int D.29461;
  short unsigned int D.29462;
  int pad.16;
  int D.29465;
  int len;
  int k;
  int args_size;
  int size;
  int pad;
  guint32 align;
  int offset;
  struct CallInfo * cinfo;

  try
    {
      args_size = 0;
      offset = 8;
      D.29399 = csig->param_count;
      D.29400 = (int) D.29399;
      D.29401 = D.29400 + 1;
      D.29402 = (unsigned int) D.29401;
      D.29403 = D.29402 * 28;
      D.29404 = D.29403 + 120;
      len = (int) D.29404;
      len.7 = (unsigned int) len;
      D.29406 = len.7 * 4;
      cinfo = __builtin_alloca (D.29406);
      len.8 = (unsigned int) len;
      memset (cinfo, 0, len.8);
      cinfo = get_call_info_internal (gsctx, cinfo, csig);
      D.29408 = (short unsigned int) offset;
      arg_info->offset = D.29408;
      D.29409 = cinfo->vtype_retaddr;
      if (D.29409 != 0) goto <D.29410>; else goto <D.29411>;
      <D.29410>:
      D.29412 = cinfo->vret_arg_index;
      if (D.29412 == 0) goto <D.29413>; else goto <D.29414>;
      <D.29413>:
      args_size.9 = (unsigned int) args_size;
      D.29416 = args_size.9 + 4;
      args_size = (int) D.29416;
      offset = offset + 4;
      <D.29414>:
      <D.29411>:
      D.29417 = BIT_FIELD_REF <*csig, 8, 80>;
      D.29418 = D.29417 & 64;
      if (D.29418 != 0) goto <D.29419>; else goto <D.29420>;
      <D.29419>:
      args_size.9 = (unsigned int) args_size;
      D.29416 = args_size.9 + 4;
      args_size = (int) D.29416;
      offset = offset + 4;
      <D.29420>:
      D.29409 = cinfo->vtype_retaddr;
      if (D.29409 != 0) goto <D.29421>; else goto <D.29422>;
      <D.29421>:
      D.29412 = cinfo->vret_arg_index;
      if (D.29412 == 1) goto <D.29423>; else goto <D.29424>;
      <D.29423>:
      D.29417 = BIT_FIELD_REF <*csig, 8, 80>;
      D.29418 = D.29417 & 64;
      if (D.29418 != 0) goto <D.29425>; else goto <D.29426>;
      <D.29425>:
      args_size.9 = (unsigned int) args_size;
      D.29416 = args_size.9 + 4;
      args_size = (int) D.29416;
      offset = offset + 4;
      <D.29426>:
      <D.29424>:
      <D.29422>:
      D.29427 = (short unsigned int) args_size;
      arg_info->size = D.29427;
      k = 0;
      goto <D.23922>;
      <D.23921>:
      D.29428 = csig->pinvoke;
      D.29429 = (int) D.29428;
      D.29430 = csig->params[k];
      size = mini_type_stack_size_full (0B, D.29430, &align, D.29429);
      align = 1;
      align.10 = align;
      align.10 = align;
      D.29432 = align.10 + 4294967295;
      args_size.11 = (unsigned int) args_size;
      D.29434 = D.29432 & args_size.11;
      D.29435 = align.10 - D.29434;
      align.10 = align;
      D.29432 = align.10 + 4294967295;
      D.29436 = D.29435 & D.29432;
      pad = (int) D.29436;
      pad.12 = pad;
      args_size = pad.12 + args_size;
      k.13 = (unsigned int) k;
      D.29439 = k.13 * 6;
      D.29440 = arg_info + D.29439;
      D.29441 = (unsigned char) pad;
      D.29440->pad = D.29441;
      args_size = args_size + size;
      k.14 = (sizetype) k;
      D.29443 = k.14 + 1;
      D.29444 = D.29443 * 6;
      D.29445 = arg_info + D.29444;
      D.29445->pad = 0;
      k.14 = (sizetype) k;
      D.29443 = k.14 + 1;
      D.29444 = D.29443 * 6;
      D.29445 = arg_info + D.29444;
      D.29446 = (short unsigned int) size;
      D.29445->size = D.29446;
      offset = offset + pad;
      k.14 = (sizetype) k;
      D.29443 = k.14 + 1;
      D.29444 = D.29443 * 6;
      D.29445 = arg_info + D.29444;
      D.29408 = (short unsigned int) offset;
      D.29445->offset = D.29408;
      offset = offset + size;
      if (k == 0) goto <D.29447>; else goto <D.29448>;
      <D.29447>:
      D.29409 = cinfo->vtype_retaddr;
      if (D.29409 != 0) goto <D.29449>; else goto <D.29450>;
      <D.29449>:
      D.29412 = cinfo->vret_arg_index;
      if (D.29412 == 1) goto <D.29451>; else goto <D.29452>;
      <D.29451>:
      D.29417 = BIT_FIELD_REF <*csig, 8, 80>;
      D.29418 = D.29417 & 64;
      if (D.29418 == 0) goto <D.29453>; else goto <D.29454>;
      <D.29453>:
      args_size.9 = (unsigned int) args_size;
      D.29416 = args_size.9 + 4;
      args_size = (int) D.29416;
      offset = offset + 4;
      <D.29454>:
      <D.29452>:
      <D.29450>:
      <D.29448>:
      k = k + 1;
      <D.23922>:
      if (k < param_count) goto <D.23921>; else goto <D.23923>;
      <D.23923>:
      mono_do_x86_stack_align.15 = mono_do_x86_stack_align;
      if (mono_do_x86_stack_align.15 != 0) goto <D.29458>; else goto <D.29455>;
      <D.29458>:
      D.29417 = BIT_FIELD_REF <*csig, 8, 80>;
      D.29459 = D.29417 & 63;
      if (D.29459 != 2) goto <D.29460>; else goto <D.29455>;
      <D.29460>:
      D.29461 = BIT_FIELD_REF <*csig, 16, 80>;
      D.29462 = D.29461 & 319;
      if (D.29462 != 259) goto <D.29463>; else goto <D.29455>;
      <D.29463>:
      align = 16;
      goto <D.29456>;
      <D.29455>:
      align = 4;
      <D.29456>:
      align.10 = align;
      align.10 = align;
      D.29432 = align.10 + 4294967295;
      args_size.11 = (unsigned int) args_size;
      D.29434 = D.29432 & args_size.11;
      D.29435 = align.10 - D.29434;
      align.10 = align;
      D.29432 = align.10 + 4294967295;
      D.29436 = D.29435 & D.29432;
      pad = (int) D.29436;
      pad.16 = pad;
      args_size = pad.16 + args_size;
      k.13 = (unsigned int) k;
      D.29439 = k.13 * 6;
      D.29440 = arg_info + D.29439;
      D.29441 = (unsigned char) pad;
      D.29440->pad = D.29441;
      D.29465 = args_size;
      return D.29465;
    }
  finally
    {
      align = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.29470;
  int D.29475;
  void * D.29477;
  unsigned int D.29478;

  D.29470 = __builtin_constant_p (__len);
  if (D.29470 != 0) goto <D.29471>; else goto <D.29472>;
  <D.29471>:
  if (__len == 0) goto <D.29473>; else goto <D.29474>;
  <D.29473>:
  D.29475 = __builtin_constant_p (__ch);
  if (D.29475 == 0) goto <D.29468>; else goto <D.29476>;
  <D.29476>:
  if (__ch != 0) goto <D.29468>; else goto <D.29469>;
  <D.29468>:
  __warn_memset_zero_len ();
  D.29477 = __dest;
  return D.29477;
  <D.29469>:
  <D.29474>:
  <D.29472>:
  D.29478 = __builtin_object_size (__dest, 0);
  D.29477 = __builtin___memset_chk (__dest, __ch, __len, D.29478);
  return D.29477;
}


get_call_info_internal (struct MonoGenericSharingContext * gsctx, struct CallInfo * cinfo, struct MonoMethodSignature * sig)
{
  <unnamed-unsigned:1> D.29480;
  int D.29481;
  short unsigned int D.29482;
  int D.29483;
  <unnamed-unsigned:1> D.29484;
  struct MonoType * D.29485;
  unsigned char D.29486;
  int D.29487;
  int D.29488;
  int D.29491;
  struct ArgInfo * D.29494;
  <unnamed type> D.29495;
  int D.29498;
  _Bool D.29499;
  long int D.29500;
  long int D.29501;
  int D.29507;
  unsigned char D.29510;
  unsigned char D.29511;
  struct MonoType * D.29514;
  struct MonoType * D.29515;
  int D.29516;
  struct ArgInfo[1] * D.29519;
  struct ArgInfo * D.29521;
  unsigned int stack_size.17;
  int stack_size.18;
  short unsigned int D.29528;
  short unsigned int D.29529;
  struct ArgInfo * D.29534;
  unsigned int D.29535;
  unsigned int D.29536;
  short int D.29539;
  unsigned int D.29540;
  struct MonoType * D.29543;
  unsigned char D.29544;
  unsigned char D.29545;
  unsigned char D.29548;
  int D.29549;
  int D.29550;
  int D.29553;
  <unnamed type> D.29556;
  _Bool D.29557;
  long int D.29558;
  long int D.29559;
  int D.29562;
  _Bool D.29563;
  long int D.29564;
  long int D.29565;
  unsigned int D.29570;
  int D.29575;
  int mono_do_x86_stack_align.19;
  unsigned int D.29581;
  unsigned int D.29584;
  unsigned int D.29585;
  unsigned int stack_size.20;
  unsigned int gr.21;
  unsigned int fr.22;
  struct CallInfo * D.29589;
  guint32 i;
  guint32 gr;
  guint32 fr;
  guint32 pstart;
  const guint32 * param_regs;
  struct MonoType * ret_type;
  int n;
  guint32 stack_size;
  gboolean is_pinvoke;

  try
    {
      D.29480 = sig->hasthis;
      D.29481 = (int) D.29480;
      D.29482 = sig->param_count;
      D.29483 = (int) D.29482;
      n = D.29481 + D.29483;
      stack_size = 0;
      D.29484 = sig->pinvoke;
      is_pinvoke = (gboolean) D.29484;
      gr = 0;
      fr = 0;
      cinfo->nargs = n;
      param_regs = callconv_param_regs (sig);
      D.29485 = sig->ret;
      ret_type = mini_type_get_underlying_type (gsctx, D.29485);
      D.29486 = ret_type->type;
      D.29487 = (int) D.29486;
      switch (D.29487) <default: <D.23863>, case 1: <D.23862>, case 2: <D.23832>, case 3: <D.23837>, case 4: <D.23833>, case 5: <D.23834>, case 6: <D.23835>, case 7: <D.23836>, case 8: <D.23838>, case 9: <D.23839>, case 10: <D.23851>, case 11: <D.23850>, case 12: <D.23852>, case 13: <D.23853>, case 14: <D.23848>, case 15: <D.23842>, case 17: <D.23855>, case 18: <D.23844>, case 19: <D.23860>, case 20: <D.23847>, case 21: <D.23854>, case 22: <D.23856>, case 24: <D.23840>, case 25: <D.23841>, case 27: <D.23843>, case 28: <D.23845>, case 29: <D.23846>, case 30: <D.23861>>
      <D.23832>:
      <D.23833>:
      <D.23834>:
      <D.23835>:
      <D.23836>:
      <D.23837>:
      <D.23838>:
      <D.23839>:
      <D.23840>:
      <D.23841>:
      <D.23842>:
      <D.23843>:
      <D.23844>:
      <D.23845>:
      <D.23846>:
      <D.23847>:
      <D.23848>:
      cinfo->ret.storage = 0;
      cinfo->ret.reg = 0;
      goto <D.23849>;
      <D.23850>:
      <D.23851>:
      cinfo->ret.storage = 0;
      cinfo->ret.reg = 0;
      cinfo->ret.is_pair = 1;
      goto <D.23849>;
      <D.23852>:
      cinfo->ret.storage = 5;
      goto <D.23849>;
      <D.23853>:
      cinfo->ret.storage = 6;
      goto <D.23849>;
      <D.23854>:
      D.29488 = mono_type_generic_inst_is_valuetype (ret_type);
      if (D.29488 == 0) goto <D.29489>; else goto <D.29490>;
      <D.29489>:
      cinfo->ret.storage = 0;
      cinfo->ret.reg = 0;
      goto <D.23849>;
      <D.29490>:
      D.29491 = mini_is_gsharedvt_type_gsctx (gsctx, ret_type);
      if (D.29491 != 0) goto <D.29492>; else goto <D.29493>;
      <D.29492>:
      cinfo->ret.storage = 3;
      cinfo->vtype_retaddr = 1;
      goto <D.23849>;
      <D.29493>:
      <D.23855>:
      <D.23856>:
      {
        guint32 tmp_gr;
        guint32 tmp_fr;
        guint32 tmp_stacksize;

        try
          {
            tmp_gr = 0;
            tmp_fr = 0;
            tmp_stacksize = 0;
            D.29494 = &cinfo->ret;
            add_valuetype (gsctx, sig, D.29494, ret_type, 1, &tmp_gr, 0B, &tmp_fr, &tmp_stacksize);
            D.29495 = cinfo->ret.storage;
            if (D.29495 == 3) goto <D.29496>; else goto <D.29497>;
            <D.29496>:
            cinfo->vtype_retaddr = 1;
            <D.29497>:
            goto <D.23849>;
          }
        finally
          {
            tmp_gr = {CLOBBER};
            tmp_fr = {CLOBBER};
            tmp_stacksize = {CLOBBER};
          }
      }
      <D.23860>:
      <D.23861>:
      D.29498 = mini_is_gsharedvt_type_gsctx (gsctx, ret_type);
      D.29499 = D.29498 == 0;
      D.29500 = (long int) D.29499;
      D.29501 = __builtin_expect (D.29500, 0);
      if (D.29501 != 0) goto <D.29502>; else goto <D.29503>;
      <D.29502>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 454, "mini_is_gsharedvt_type_gsctx (gsctx, ret_type)");
      <D.29503>:
      cinfo->ret.storage = 3;
      cinfo->vtype_retaddr = 1;
      goto <D.23849>;
      <D.23862>:
      cinfo->ret.storage = 8;
      goto <D.23849>;
      <D.23863>:
      D.29486 = ret_type->type;
      D.29487 = (int) D.29486;
      monoeg_g_log (0B, 4, "Can\'t handle as return value 0x%x", D.29487);
      <D.23864>:
      goto <D.23864>;
      <D.23849>:
      pstart = 0;
      D.29507 = cinfo->vtype_retaddr;
      if (D.29507 != 0) goto <D.29508>; else goto <D.29504>;
      <D.29508>:
      if (is_pinvoke == 0) goto <D.29509>; else goto <D.29504>;
      <D.29509>:
      D.29510 = BIT_FIELD_REF <*sig, 8, 80>;
      D.29511 = D.29510 & 64;
      if (D.29511 != 0) goto <D.29505>; else goto <D.29512>;
      <D.29512>:
      D.29482 = sig->param_count;
      if (D.29482 != 0) goto <D.29513>; else goto <D.29504>;
      <D.29513>:
      D.29514 = sig->params[0];
      D.29515 = mini_type_get_underlying_type (gsctx, D.29514);
      D.29516 = mono_type_is_reference (D.29515);
      if (D.29516 != 0) goto <D.29505>; else goto <D.29504>;
      <D.29505>:
      D.29510 = BIT_FIELD_REF <*sig, 8, 80>;
      D.29511 = D.29510 & 64;
      if (D.29511 != 0) goto <D.29517>; else goto <D.29518>;
      <D.29517>:
      D.29519 = &cinfo->args;
      add_general (&gr, param_regs, &stack_size, D.29519);
      goto <D.29520>;
      <D.29518>:
      D.29480 = sig->hasthis;
      D.29481 = (int) D.29480;
      D.29521 = &cinfo->args[D.29481];
      add_general (&gr, param_regs, &stack_size, D.29521);
      pstart = 1;
      <D.29520>:
      stack_size.17 = stack_size;
      stack_size.18 = (int) stack_size.17;
      cinfo->vret_arg_offset = stack_size.18;
      D.29494 = &cinfo->ret;
      add_general (&gr, 0B, &stack_size, D.29494);
      cinfo->vret_arg_index = 1;
      goto <D.29506>;
      <D.29504>:
      D.29510 = BIT_FIELD_REF <*sig, 8, 80>;
      D.29511 = D.29510 & 64;
      if (D.29511 != 0) goto <D.29524>; else goto <D.29525>;
      <D.29524>:
      D.29519 = &cinfo->args;
      add_general (&gr, param_regs, &stack_size, D.29519);
      <D.29525>:
      D.29507 = cinfo->vtype_retaddr;
      if (D.29507 != 0) goto <D.29526>; else goto <D.29527>;
      <D.29526>:
      D.29494 = &cinfo->ret;
      add_general (&gr, 0B, &stack_size, D.29494);
      <D.29527>:
      <D.29506>:
      D.29528 = BIT_FIELD_REF <*sig, 16, 80>;
      D.29529 = D.29528 & 319;
      if (D.29529 == 5) goto <D.29530>; else goto <D.29531>;
      <D.29530>:
      if (n == 0) goto <D.29532>; else goto <D.29533>;
      <D.29532>:
      fr = 0;
      D.29534 = &cinfo->sig_cookie;
      add_general (&gr, param_regs, &stack_size, D.29534);
      <D.29533>:
      <D.29531>:
      i = pstart;
      goto <D.23898>;
      <D.23897>:
      {
        struct ArgInfo * ainfo;
        struct MonoType * ptype;

        D.29480 = sig->hasthis;
        D.29535 = (unsigned int) D.29480;
        D.29536 = D.29535 + i;
        ainfo = &cinfo->args[D.29536];
        D.29528 = BIT_FIELD_REF <*sig, 16, 80>;
        D.29529 = D.29528 & 319;
        if (D.29529 == 5) goto <D.29537>; else goto <D.29538>;
        <D.29537>:
        D.29539 = sig->sentinelpos;
        D.29540 = (unsigned int) D.29539;
        if (D.29540 == i) goto <D.29541>; else goto <D.29542>;
        <D.29541>:
        fr = 0;
        D.29534 = &cinfo->sig_cookie;
        add_general (&gr, param_regs, &stack_size, D.29534);
        <D.29542>:
        <D.29538>:
        D.29543 = sig->params[i];
        D.29544 = BIT_FIELD_REF <*D.29543, 8, 56>;
        D.29545 = D.29544 & 64;
        if (D.29545 != 0) goto <D.29546>; else goto <D.29547>;
        <D.29546>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        // predicted unlikely by continue predictor.
        goto <D.23867>;
        <D.29547>:
        D.29543 = sig->params[i];
        ptype = mini_type_get_underlying_type (gsctx, D.29543);
        D.29548 = ptype->type;
        D.29549 = (int) D.29548;
        switch (D.29549) <default: <D.23895>, case 2: <D.23868>, case 3: <D.23874>, case 4: <D.23869>, case 5: <D.23870>, case 6: <D.23872>, case 7: <D.23873>, case 8: <D.23875>, case 9: <D.23876>, case 10: <D.23890>, case 11: <D.23889>, case 12: <D.23891>, case 13: <D.23892>, case 14: <D.23883>, case 15: <D.23879>, case 17: <D.23887>, case 18: <D.23881>, case 19: <D.23893>, case 20: <D.23885>, case 21: <D.23886>, case 22: <D.23888>, case 24: <D.23877>, case 25: <D.23878>, case 27: <D.23880>, case 28: <D.23882>, case 29: <D.23884>, case 30: <D.23894>>
        <D.23868>:
        <D.23869>:
        <D.23870>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        goto <D.23871>;
        <D.23872>:
        <D.23873>:
        <D.23874>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        goto <D.23871>;
        <D.23875>:
        <D.23876>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        goto <D.23871>;
        <D.23877>:
        <D.23878>:
        <D.23879>:
        <D.23880>:
        <D.23881>:
        <D.23882>:
        <D.23883>:
        <D.23884>:
        <D.23885>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        goto <D.23871>;
        <D.23886>:
        D.29550 = mono_type_generic_inst_is_valuetype (ptype);
        if (D.29550 == 0) goto <D.29551>; else goto <D.29552>;
        <D.29551>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        goto <D.23871>;
        <D.29552>:
        D.29553 = mini_is_gsharedvt_type_gsctx (gsctx, ptype);
        if (D.29553 != 0) goto <D.29554>; else goto <D.29555>;
        <D.29554>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        D.29556 = ainfo->storage;
        D.29557 = D.29556 != 3;
        D.29558 = (long int) D.29557;
        D.29559 = __builtin_expect (D.29558, 0);
        if (D.29559 != 0) goto <D.29560>; else goto <D.29561>;
        <D.29560>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 555, "ainfo->storage == ArgOnStack");
        <D.29561>:
        ainfo->storage = 7;
        goto <D.23871>;
        <D.29555>:
        <D.23887>:
        <D.23888>:
        add_valuetype (gsctx, sig, ainfo, ptype, 0, &gr, param_regs, &fr, &stack_size);
        goto <D.23871>;
        <D.23889>:
        <D.23890>:
        add_general_pair (&gr, param_regs, &stack_size, ainfo);
        goto <D.23871>;
        <D.23891>:
        add_float (&fr, &stack_size, ainfo, 0);
        goto <D.23871>;
        <D.23892>:
        add_float (&fr, &stack_size, ainfo, 1);
        goto <D.23871>;
        <D.23893>:
        <D.23894>:
        D.29562 = mini_is_gsharedvt_type_gsctx (gsctx, ptype);
        D.29563 = D.29562 == 0;
        D.29564 = (long int) D.29563;
        D.29565 = __builtin_expect (D.29564, 0);
        if (D.29565 != 0) goto <D.29566>; else goto <D.29567>;
        <D.29566>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 577, "mini_is_gsharedvt_type_gsctx (gsctx, ptype)");
        <D.29567>:
        add_general (&gr, param_regs, &stack_size, ainfo);
        D.29556 = ainfo->storage;
        D.29557 = D.29556 != 3;
        D.29558 = (long int) D.29557;
        D.29559 = __builtin_expect (D.29558, 0);
        if (D.29559 != 0) goto <D.29568>; else goto <D.29569>;
        <D.29568>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 579, "ainfo->storage == ArgOnStack");
        <D.29569>:
        ainfo->storage = 7;
        goto <D.23871>;
        <D.23895>:
        D.29548 = ptype->type;
        D.29549 = (int) D.29548;
        monoeg_g_log (0B, 4, "unexpected type 0x%x", D.29549);
        <D.23896>:
        goto <D.23896>;
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 584);
        <D.23871>:
      }
      <D.23867>:
      i = i + 1;
      <D.23898>:
      D.29482 = sig->param_count;
      D.29570 = (unsigned int) D.29482;
      if (D.29570 > i) goto <D.23897>; else goto <D.23899>;
      <D.23899>:
      D.29528 = BIT_FIELD_REF <*sig, 16, 80>;
      D.29529 = D.29528 & 319;
      if (D.29529 == 5) goto <D.29571>; else goto <D.29572>;
      <D.29571>:
      if (n > 0) goto <D.29573>; else goto <D.29574>;
      <D.29573>:
      D.29539 = sig->sentinelpos;
      D.29575 = (int) D.29539;
      D.29482 = sig->param_count;
      D.29483 = (int) D.29482;
      if (D.29575 == D.29483) goto <D.29576>; else goto <D.29577>;
      <D.29576>:
      fr = 0;
      D.29534 = &cinfo->sig_cookie;
      add_general (&gr, param_regs, &stack_size, D.29534);
      <D.29577>:
      <D.29574>:
      <D.29572>:
      mono_do_x86_stack_align.19 = mono_do_x86_stack_align;
      if (mono_do_x86_stack_align.19 != 0) goto <D.29579>; else goto <D.29580>;
      <D.29579>:
      stack_size.17 = stack_size;
      D.29581 = stack_size.17 & 15;
      if (D.29581 != 0) goto <D.29582>; else goto <D.29583>;
      <D.29582>:
      cinfo->need_stack_align = 1;
      stack_size.17 = stack_size;
      D.29581 = stack_size.17 & 15;
      D.29584 = 16 - D.29581;
      cinfo->stack_align_amount = D.29584;
      D.29585 = cinfo->stack_align_amount;
      stack_size.17 = stack_size;
      stack_size.20 = D.29585 + stack_size.17;
      stack_size = stack_size.20;
      <D.29583>:
      <D.29580>:
      stack_size.17 = stack_size;
      cinfo->stack_usage = stack_size.17;
      gr.21 = gr;
      cinfo->reg_usage = gr.21;
      fr.22 = fr;
      cinfo->freg_usage = fr.22;
      D.29589 = cinfo;
      return D.29589;
    }
  finally
    {
      gr = {CLOBBER};
      fr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


callconv_param_regs (struct MonoMethodSignature * sig)
{
  unsigned char D.29593;
  unsigned char D.29594;
  const guint32 * D.29597;
  <unnamed-unsigned:6> D.29598;
  int D.29599;

  D.29593 = BIT_FIELD_REF <*sig, 8, 88>;
  D.29594 = D.29593 & 1;
  if (D.29594 == 0) goto <D.29595>; else goto <D.29596>;
  <D.29595>:
  D.29597 = 0B;
  return D.29597;
  <D.29596>:
  D.29598 = sig->call_convention;
  D.29599 = (int) D.29598;
  switch (D.29599) <default: <D.23786>, case 3: <D.23785>>
  <D.23785>:
  D.29597 = &thiscall_param_regs;
  return D.29597;
  <D.23786>:
  D.29597 = 0B;
  return D.29597;
}


add_valuetype (struct MonoGenericSharingContext * gsctx, struct MonoMethodSignature * sig, struct ArgInfo * ainfo, struct MonoType * type, gboolean is_return, guint32 * gr, const guint32 * param_regs, guint32 * fr, guint32 * stack_size)
{
  <unnamed-unsigned:1> D.29601;
  int D.29602;
  struct MonoType * D.29603;
  int D.29604;
  unsigned int D.29607;
  unsigned int D.29608;
  const guint32 * D.29609;
  unsigned int D.29610;
  _Bool D.29615;
  long int D.29616;
  long int D.29617;
  signed char D.29620;
  unsigned int D.29621;
  unsigned int D.29622;
  short int D.29623;
  unsigned int D.29624;
  unsigned int D.29625;
  unsigned int D.29626;
  long long unsigned int D.29627;
  long long unsigned int D.29628;
  long long unsigned int D.29629;
  long long unsigned int D.29630;
  int D.29631;
  guint32 size;
  struct MonoClass * klass;

  klass = mono_class_from_mono_type (type);
  D.29601 = sig->pinvoke;
  D.29602 = (int) D.29601;
  D.29603 = &klass->byval_arg;
  D.29604 = mini_type_stack_size_full (gsctx, D.29603, 0B, D.29602);
  size = (guint32) D.29604;
  if (param_regs != 0B) goto <D.29605>; else goto <D.29606>;
  <D.29605>:
  D.29607 = *gr;
  D.29608 = D.29607 * 4;
  D.29609 = param_regs + D.29608;
  D.29610 = *D.29609;
  if (D.29610 != 8) goto <D.29611>; else goto <D.29612>;
  <D.29611>:
  if (is_return == 0) goto <D.29613>; else goto <D.29614>;
  <D.29613>:
  D.29615 = size > 4;
  D.29616 = (long int) D.29615;
  D.29617 = __builtin_expect (D.29616, 0);
  if (D.29617 != 0) goto <D.29618>; else goto <D.29619>;
  <D.29618>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 355, "size <= 4");
  <D.29619>:
  ainfo->storage = 4;
  D.29607 = *gr;
  D.29608 = D.29607 * 4;
  D.29609 = param_regs + D.29608;
  D.29610 = *D.29609;
  D.29620 = (signed char) D.29610;
  ainfo->reg = D.29620;
  D.29607 = *gr;
  D.29621 = D.29607 + 1;
  *gr = D.29621;
  return;
  <D.29614>:
  <D.29612>:
  <D.29606>:
  D.29622 = *stack_size;
  D.29623 = (short int) D.29622;
  ainfo->offset = D.29623;
  ainfo->storage = 3;
  D.29622 = *stack_size;
  D.29624 = size + 3;
  D.29625 = D.29624 & 4294967292;
  D.29626 = D.29622 + D.29625;
  *stack_size = D.29626;
  D.29627 = (long long unsigned int) size;
  D.29628 = D.29627 + 3;
  D.29629 = D.29628 & 4294967292;
  D.29630 = D.29629 / 4;
  D.29631 = (int) D.29630;
  ainfo->nslots = D.29631;
}


add_general_pair (guint32 * gr, const guint32 * param_regs, guint32 * stack_size, struct ArgInfo * ainfo)
{
  unsigned int D.29633;
  short int D.29634;
  int iftmp.23;
  unsigned int D.29639;
  unsigned int D.29640;
  const guint32 * D.29641;
  unsigned int D.29642;
  _Bool D.29644;
  long int D.29645;
  long int D.29646;
  unsigned int D.29649;

  D.29633 = *stack_size;
  D.29634 = (short int) D.29633;
  ainfo->offset = D.29634;
  if (param_regs != 0B) goto <D.29638>; else goto <D.29636>;
  <D.29638>:
  D.29639 = *gr;
  D.29640 = D.29639 * 4;
  D.29641 = param_regs + D.29640;
  D.29642 = *D.29641;
  if (D.29642 != 8) goto <D.29643>; else goto <D.29636>;
  <D.29643>:
  iftmp.23 = 1;
  goto <D.29637>;
  <D.29636>:
  iftmp.23 = 0;
  <D.29637>:
  D.29644 = iftmp.23 != 0;
  D.29645 = (long int) D.29644;
  D.29646 = __builtin_expect (D.29645, 0);
  if (D.29646 != 0) goto <D.29647>; else goto <D.29648>;
  <D.29647>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 274, "!param_regs || param_regs[*gr] == X86_NREG");
  <D.29648>:
  ainfo->storage = 3;
  D.29633 = *stack_size;
  D.29649 = D.29633 + 8;
  *stack_size = D.29649;
  ainfo->nslots = 2;
}


add_float (guint32 * gr, guint32 * stack_size, struct ArgInfo * ainfo, gboolean is_double)
{
  unsigned int D.29650;
  short int D.29651;
  guint32 iftmp.24;
  unsigned int D.29658;
  int iftmp.25;
  unsigned int D.29667;
  signed char D.29668;
  unsigned int D.29669;

  D.29650 = *stack_size;
  D.29651 = (short int) D.29650;
  ainfo->offset = D.29651;
  if (1 != 0) goto <D.29652>; else goto <D.29653>;
  <D.29652>:
  ainfo->storage = 3;
  D.29650 = *stack_size;
  if (is_double != 0) goto <D.29655>; else goto <D.29656>;
  <D.29655>:
  iftmp.24 = 8;
  goto <D.29657>;
  <D.29656>:
  iftmp.24 = 4;
  <D.29657>:
  D.29658 = D.29650 + iftmp.24;
  *stack_size = D.29658;
  if (is_double != 0) goto <D.29660>; else goto <D.29661>;
  <D.29660>:
  iftmp.25 = 2;
  goto <D.29662>;
  <D.29661>:
  iftmp.25 = 1;
  <D.29662>:
  ainfo->nslots = iftmp.25;
  goto <D.29663>;
  <D.29653>:
  if (is_double != 0) goto <D.29664>; else goto <D.29665>;
  <D.29664>:
  ainfo->storage = 2;
  goto <D.29666>;
  <D.29665>:
  ainfo->storage = 1;
  <D.29666>:
  D.29667 = *gr;
  D.29668 = (signed char) D.29667;
  ainfo->reg = D.29668;
  D.29667 = *gr;
  D.29669 = D.29667 + 1;
  *gr = D.29669;
  <D.29663>:
}


add_general (guint32 * gr, const guint32 * param_regs, guint32 * stack_size, struct ArgInfo * ainfo)
{
  unsigned int D.29670;
  short int D.29671;
  unsigned int D.29676;
  unsigned int D.29677;
  const guint32 * D.29678;
  unsigned int D.29679;
  unsigned int D.29680;
  signed char D.29681;
  unsigned int D.29682;

  D.29670 = *stack_size;
  D.29671 = (short int) D.29670;
  ainfo->offset = D.29671;
  if (param_regs == 0B) goto <D.29672>; else goto <D.29675>;
  <D.29675>:
  D.29676 = *gr;
  D.29677 = D.29676 * 4;
  D.29678 = param_regs + D.29677;
  D.29679 = *D.29678;
  if (D.29679 == 8) goto <D.29672>; else goto <D.29673>;
  <D.29672>:
  ainfo->storage = 3;
  ainfo->nslots = 1;
  D.29670 = *stack_size;
  D.29680 = D.29670 + 4;
  *stack_size = D.29680;
  goto <D.29674>;
  <D.29673>:
  ainfo->storage = 0;
  D.29676 = *gr;
  D.29677 = D.29676 * 4;
  D.29678 = param_regs + D.29677;
  D.29679 = *D.29678;
  D.29681 = (signed char) D.29679;
  ainfo->reg = D.29681;
  D.29676 = *gr;
  D.29682 = D.29676 + 1;
  *gr = D.29682;
  <D.29674>:
}


mono_arch_tail_call_supported (struct MonoCompile * cfg, struct MonoMethodSignature * caller_sig, struct MonoMethodSignature * callee_sig)
{
  unsigned char D.29683;
  unsigned char D.29684;
  gboolean D.29687;
  unsigned int D.29688;
  unsigned int D.29689;
  _Bool D.29690;
  struct MonoType * D.29691;
  int D.29694;
  <unnamed type> D.29697;
  struct MonoType * callee_ret;
  struct CallInfo * c1;
  struct CallInfo * c2;
  gboolean res;

  D.29683 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.29684 = D.29683 & 192;
  if (D.29684 == 64) goto <D.29685>; else goto <D.29686>;
  <D.29685>:
  D.29687 = 0;
  return D.29687;
  <D.29686>:
  c1 = get_call_info (0B, 0B, caller_sig);
  c2 = get_call_info (0B, 0B, callee_sig);
  D.29688 = c1->stack_usage;
  D.29689 = c2->stack_usage;
  D.29690 = D.29688 >= D.29689;
  res = (gboolean) D.29690;
  D.29691 = callee_sig->ret;
  callee_ret = mini_replace_type (D.29691);
  if (callee_ret != 0B) goto <D.29692>; else goto <D.29693>;
  <D.29692>:
  D.29694 = mono_type_is_struct (callee_ret);
  if (D.29694 != 0) goto <D.29695>; else goto <D.29696>;
  <D.29695>:
  D.29697 = c2->ret.storage;
  if (D.29697 != 4) goto <D.29698>; else goto <D.29699>;
  <D.29698>:
  res = 0;
  <D.29699>:
  <D.29696>:
  <D.29693>:
  monoeg_g_free (c1);
  monoeg_g_free (c2);
  D.29687 = res;
  return D.29687;
}


get_call_info (struct MonoGenericSharingContext * gsctx, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  <unnamed-unsigned:1> D.29701;
  int D.29702;
  short unsigned int D.29703;
  int D.29704;
  unsigned int n.26;
  unsigned int D.29708;
  unsigned int D.29709;
  struct CallInfo * D.29711;
  int n;
  struct CallInfo * cinfo;

  D.29701 = sig->hasthis;
  D.29702 = (int) D.29701;
  D.29703 = sig->param_count;
  D.29704 = (int) D.29703;
  n = D.29702 + D.29704;
  if (mp != 0B) goto <D.29705>; else goto <D.29706>;
  <D.29705>:
  n.26 = (unsigned int) n;
  D.29708 = n.26 * 28;
  D.29709 = D.29708 + 120;
  cinfo = mono_mempool_alloc0 (mp, D.29709);
  goto <D.29710>;
  <D.29706>:
  n.26 = (unsigned int) n;
  D.29708 = n.26 * 28;
  D.29709 = D.29708 + 120;
  cinfo = monoeg_malloc0 (D.29709);
  <D.29710>:
  D.29711 = get_call_info_internal (gsctx, cinfo, sig);
  return D.29711;
}


mono_arch_cpu_init ()
{
  short unsigned int fpcw.27;
  short unsigned int fpcw.28;
  short unsigned int fpcw.29;
  guint16 fpcw;

  try
    {
      __asm__ __volatile__("fnstcw %0
" : "=m" fpcw);
      fpcw.27 = fpcw;
      fpcw.28 = fpcw.27 & 64767;
      fpcw = fpcw.28;
      fpcw.27 = fpcw;
      fpcw.29 = fpcw.27 | 512;
      fpcw = fpcw.29;
      __asm__ __volatile__("fldcw %0
" :  : "m" fpcw);
      __asm__ __volatile__("fnstcw %0
" : "=m" fpcw);
    }
  finally
    {
      fpcw = {CLOBBER};
    }
}


mono_arch_init ()
{
  int D.29716;
  unsigned int D.29717;
  void * ss_trigger_page.30;
  int D.29719;
  unsigned int D.29720;
  void * bp_trigger_page.31;
  int D.29722;
  unsigned int D.29723;
  void * bp_trigger_page.32;

  InitializeCriticalSection (&mini_arch_mutex);
  D.29716 = mono_pagesize ();
  D.29717 = (unsigned int) D.29716;
  ss_trigger_page.30 = mono_valloc (0B, D.29717, 1);
  ss_trigger_page = ss_trigger_page.30;
  D.29719 = mono_pagesize ();
  D.29720 = (unsigned int) D.29719;
  bp_trigger_page.31 = mono_valloc (0B, D.29720, 257);
  bp_trigger_page = bp_trigger_page.31;
  D.29722 = mono_pagesize ();
  D.29723 = (unsigned int) D.29722;
  bp_trigger_page.32 = bp_trigger_page;
  mono_mprotect (bp_trigger_page.32, D.29723, 0);
  mono_aot_register_jit_icall ("mono_x86_throw_exception", mono_x86_throw_exception);
  mono_aot_register_jit_icall ("mono_x86_throw_corlib_exception", mono_x86_throw_corlib_exception);
}


mono_arch_cleanup ()
{
  void * ss_trigger_page.33;
  int D.29728;
  unsigned int D.29729;
  void * bp_trigger_page.34;
  int D.29733;
  unsigned int D.29734;

  ss_trigger_page.33 = ss_trigger_page;
  if (ss_trigger_page.33 != 0B) goto <D.29726>; else goto <D.29727>;
  <D.29726>:
  D.29728 = mono_pagesize ();
  D.29729 = (unsigned int) D.29728;
  ss_trigger_page.33 = ss_trigger_page;
  mono_vfree (ss_trigger_page.33, D.29729);
  <D.29727>:
  bp_trigger_page.34 = bp_trigger_page;
  if (bp_trigger_page.34 != 0B) goto <D.29731>; else goto <D.29732>;
  <D.29731>:
  D.29733 = mono_pagesize ();
  D.29734 = (unsigned int) D.29733;
  bp_trigger_page.34 = bp_trigger_page;
  mono_vfree (bp_trigger_page.34, D.29734);
  <D.29732>:
  DeleteCriticalSection (&mini_arch_mutex);
}


mono_arch_cpu_optimizations (guint32 * exclude_mask)
{
  int mono_hwcap_x86_has_cmov.35;
  int mono_hwcap_x86_has_fcmov.36;
  unsigned int D.29742;
  unsigned int D.29743;
  unsigned int D.29745;
  int mono_hwcap_x86_has_sse2.37;
  unsigned int D.29750;
  unsigned int D.29753;
  guint32 D.29754;
  guint32 opts;

  opts = 0;
  *exclude_mask = 0;
  mono_hwcap_x86_has_cmov.35 = mono_hwcap_x86_has_cmov;
  if (mono_hwcap_x86_has_cmov.35 != 0) goto <D.29736>; else goto <D.29737>;
  <D.29736>:
  opts = opts | 256;
  mono_hwcap_x86_has_fcmov.36 = mono_hwcap_x86_has_fcmov;
  if (mono_hwcap_x86_has_fcmov.36 != 0) goto <D.29739>; else goto <D.29740>;
  <D.29739>:
  opts = opts | 16384;
  goto <D.29741>;
  <D.29740>:
  D.29742 = *exclude_mask;
  D.29743 = D.29742 | 16384;
  *exclude_mask = D.29743;
  <D.29741>:
  goto <D.29744>;
  <D.29737>:
  D.29742 = *exclude_mask;
  D.29745 = D.29742 | 256;
  *exclude_mask = D.29745;
  <D.29744>:
  mono_hwcap_x86_has_sse2.37 = mono_hwcap_x86_has_sse2;
  if (mono_hwcap_x86_has_sse2.37 != 0) goto <D.29747>; else goto <D.29748>;
  <D.29747>:
  opts = opts | 8388608;
  goto <D.29749>;
  <D.29748>:
  D.29742 = *exclude_mask;
  D.29750 = D.29742 | 8388608;
  *exclude_mask = D.29750;
  <D.29749>:
  mono_hwcap_x86_has_sse2.37 = mono_hwcap_x86_has_sse2;
  if (mono_hwcap_x86_has_sse2.37 == 0) goto <D.29751>; else goto <D.29752>;
  <D.29751>:
  D.29742 = *exclude_mask;
  D.29753 = D.29742 | 67108864;
  *exclude_mask = D.29753;
  <D.29752>:
  D.29754 = opts;
  return D.29754;
}


mono_arch_cpu_enumerate_simd_versions ()
{
  int mono_hwcap_x86_has_sse1.38;
  int mono_hwcap_x86_has_sse2.39;
  int mono_hwcap_x86_has_sse3.40;
  int mono_hwcap_x86_has_ssse3.41;
  int mono_hwcap_x86_has_sse41.42;
  int mono_hwcap_x86_has_sse42.43;
  int mono_hwcap_x86_has_sse4a.44;
  guint32 D.29777;
  guint32 sse_opts;

  sse_opts = 0;
  mono_hwcap_x86_has_sse1.38 = mono_hwcap_x86_has_sse1;
  if (mono_hwcap_x86_has_sse1.38 != 0) goto <D.29757>; else goto <D.29758>;
  <D.29757>:
  sse_opts = sse_opts | 1;
  <D.29758>:
  mono_hwcap_x86_has_sse2.39 = mono_hwcap_x86_has_sse2;
  if (mono_hwcap_x86_has_sse2.39 != 0) goto <D.29760>; else goto <D.29761>;
  <D.29760>:
  sse_opts = sse_opts | 2;
  <D.29761>:
  mono_hwcap_x86_has_sse3.40 = mono_hwcap_x86_has_sse3;
  if (mono_hwcap_x86_has_sse3.40 != 0) goto <D.29763>; else goto <D.29764>;
  <D.29763>:
  sse_opts = sse_opts | 4;
  <D.29764>:
  mono_hwcap_x86_has_ssse3.41 = mono_hwcap_x86_has_ssse3;
  if (mono_hwcap_x86_has_ssse3.41 != 0) goto <D.29766>; else goto <D.29767>;
  <D.29766>:
  sse_opts = sse_opts | 8;
  <D.29767>:
  mono_hwcap_x86_has_sse41.42 = mono_hwcap_x86_has_sse41;
  if (mono_hwcap_x86_has_sse41.42 != 0) goto <D.29769>; else goto <D.29770>;
  <D.29769>:
  sse_opts = sse_opts | 16;
  <D.29770>:
  mono_hwcap_x86_has_sse42.43 = mono_hwcap_x86_has_sse42;
  if (mono_hwcap_x86_has_sse42.43 != 0) goto <D.29772>; else goto <D.29773>;
  <D.29772>:
  sse_opts = sse_opts | 32;
  <D.29773>:
  mono_hwcap_x86_has_sse4a.44 = mono_hwcap_x86_has_sse4a;
  if (mono_hwcap_x86_has_sse4a.44 != 0) goto <D.29775>; else goto <D.29776>;
  <D.29775>:
  sse_opts = sse_opts | 64;
  <D.29776>:
  D.29777 = sse_opts;
  return D.29777;
}


mono_arch_is_int_overflow (void * sigctx, void * info)
{
  int D.29779;
  unsigned char D.29780;
  guint8 * D.29783;
  unsigned char D.29784;
  unsigned char D.29785;
  unsigned char D.29788;
  int D.29789;
  int D.29790;
  int D.29793;
  int D.29794;
  gboolean D.29797;
  struct MonoContext ctx;
  guint8 * ip;

  try
    {
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.29779 = ctx.eip;
      ip = (guint8 *) D.29779;
      D.29780 = *ip;
      if (D.29780 == 247) goto <D.29781>; else goto <D.29782>;
      <D.29781>:
      D.29783 = ip + 1;
      D.29784 = *D.29783;
      D.29785 = D.29784 >> 6;
      if (D.29785 == 3) goto <D.29786>; else goto <D.29787>;
      <D.29786>:
      D.29783 = ip + 1;
      D.29784 = *D.29783;
      D.29788 = D.29784 >> 3;
      D.29789 = (int) D.29788;
      D.29790 = D.29789 & 7;
      if (D.29790 == 7) goto <D.29791>; else goto <D.29792>;
      <D.29791>:
      {
        gint32 reg;

        D.29783 = ip + 1;
        D.29784 = *D.29783;
        D.29793 = (int) D.29784;
        D.29794 = D.29793 & 7;
        switch (D.29794) <default: <D.23965>, case 0: <D.23958>, case 1: <D.23960>, case 2: <D.23961>, case 3: <D.23962>, case 6: <D.23963>, case 7: <D.23964>>
        <D.23958>:
        reg = ctx.eax;
        goto <D.23959>;
        <D.23960>:
        reg = ctx.ecx;
        goto <D.23959>;
        <D.23961>:
        reg = ctx.edx;
        goto <D.23959>;
        <D.23962>:
        reg = ctx.ebx;
        goto <D.23959>;
        <D.23963>:
        reg = ctx.esi;
        goto <D.23959>;
        <D.23964>:
        reg = ctx.edi;
        goto <D.23959>;
        <D.23965>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 896);
        reg = -1;
        <D.23959>:
        if (reg == -1) goto <D.29795>; else goto <D.29796>;
        <D.29795>:
        D.29797 = 1;
        return D.29797;
        <D.29796>:
      }
      <D.29792>:
      <D.29787>:
      <D.29782>:
      D.29797 = 0;
      return D.29797;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_arch_get_allocatable_int_vars (struct MonoCompile * cfg)
{
  struct MonoInst * * D.29800;
  unsigned int i.45;
  unsigned int D.29802;
  struct MonoInst * * D.29803;
  struct MonoMethodVar * D.29804;
  unsigned int D.29805;
  unsigned int D.29806;
  unsigned int D.29807;
  unsigned char D.29812;
  int D.29813;
  int D.29814;
  short unsigned int D.29816;
  short unsigned int D.29817;
  struct MonoType * D.29818;
  int D.29819;
  unsigned char D.29822;
  struct MonoMethodVar * D.29825;
  int D.29826;
  _Bool D.29827;
  long int D.29828;
  long int D.29829;
  unsigned int i.46;
  unsigned int D.29833;
  _Bool D.29834;
  long int D.29835;
  long int D.29836;
  unsigned int D.29839;
  struct GList * D.29840;
  struct GList * vars;
  int i;

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

    D.29800 = cfg->varinfo;
    i.45 = (unsigned int) i;
    D.29802 = i.45 * 4;
    D.29803 = D.29800 + D.29802;
    ins = *D.29803;
    D.29804 = cfg->vars;
    i.45 = (unsigned int) i;
    D.29805 = i.45 * 56;
    vmv = D.29804 + D.29805;
    D.29806 = vmv->range.first_use.abs_pos;
    D.29807 = vmv->range.last_use.abs_pos;
    if (D.29806 >= D.29807) goto <D.29808>; else goto <D.29809>;
    <D.29808>:
    // predicted unlikely by continue predictor.
    goto <D.23973>;
    <D.29809>:
    D.29812 = ins->flags;
    D.29813 = (int) D.29812;
    D.29814 = D.29813 & 22;
    if (D.29814 != 0) goto <D.29810>; else goto <D.29815>;
    <D.29815>:
    D.29816 = ins->opcode;
    D.29817 = D.29816 + 65207;
    if (D.29817 > 1) goto <D.29810>; else goto <D.29811>;
    <D.29810>:
    // predicted unlikely by continue predictor.
    goto <D.23973>;
    <D.29811>:
    D.29818 = ins->data.op[1].vtype;
    D.29819 = mono_is_regsize_var (D.29818);
    if (D.29819 != 0) goto <D.29820>; else goto <D.29821>;
    <D.29820>:
    D.29818 = ins->data.op[1].vtype;
    D.29822 = D.29818->type;
    if (D.29822 != 4) goto <D.29823>; else goto <D.29824>;
    <D.29823>:
    D.29804 = cfg->vars;
    i.45 = (unsigned int) i;
    D.29805 = i.45 * 56;
    D.29825 = D.29804 + D.29805;
    D.29826 = D.29825->reg;
    D.29827 = D.29826 != -1;
    D.29828 = (long int) D.29827;
    D.29829 = __builtin_expect (D.29828, 0);
    if (D.29829 != 0) goto <D.29830>; else goto <D.29831>;
    <D.29830>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 928, "MONO_VARINFO (cfg, i)->reg == -1");
    <D.29831>:
    i.46 = (unsigned int) i;
    D.29833 = vmv->idx;
    D.29834 = i.46 != D.29833;
    D.29835 = (long int) D.29834;
    D.29836 = __builtin_expect (D.29835, 0);
    if (D.29836 != 0) goto <D.29837>; else goto <D.29838>;
    <D.29837>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 929, "i == vmv->idx");
    <D.29838>:
    vars = monoeg_g_list_prepend (vars, vmv);
    <D.29824>:
    <D.29821>:
  }
  <D.23973>:
  i = i + 1;
  <D.23975>:
  i.46 = (unsigned int) i;
  D.29839 = cfg->num_varinfo;
  if (i.46 < D.29839) goto <D.23974>; else goto <D.23976>;
  <D.23976>:
  vars = mono_varlist_sort (cfg, vars, 0);
  D.29840 = vars;
  return D.29840;
}


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

  regs = 0B;
  regs = monoeg_g_list_prepend (regs, 3B);
  regs = monoeg_g_list_prepend (regs, 6B);
  regs = monoeg_g_list_prepend (regs, 7B);
  D.29842 = regs;
  return D.29842;
}


mono_arch_regalloc_cost (struct MonoCompile * cfg, struct MonoMethodVar * vmv)
{
  struct MonoInst * * D.29844;
  unsigned int D.29845;
  unsigned int D.29846;
  struct MonoInst * * D.29847;
  struct MonoMethod * D.29848;
  unsigned char D.29849;
  unsigned char D.29850;
  guint32 D.29853;
  short unsigned int D.29854;
  _Bool D.29855;
  guint32 iftmp.47;
  struct MonoInst * ins;

  D.29844 = cfg->varinfo;
  D.29845 = vmv->idx;
  D.29846 = D.29845 * 4;
  D.29847 = D.29844 + D.29846;
  ins = *D.29847;
  D.29848 = cfg->method;
  D.29849 = BIT_FIELD_REF <*D.29848, 8, 168>;
  D.29850 = D.29849 & 1;
  if (D.29850 != 0) goto <D.29851>; else goto <D.29852>;
  <D.29851>:
  D.29854 = ins->opcode;
  D.29855 = D.29854 == 330;
  D.29853 = (guint32) D.29855;
  return D.29853;
  <D.29852>:
  D.29854 = ins->opcode;
  if (D.29854 == 330) goto <D.29857>; else goto <D.29858>;
  <D.29857>:
  iftmp.47 = 3;
  goto <D.29859>;
  <D.29858>:
  iftmp.47 = 2;
  <D.29859>:
  D.29853 = iftmp.47;
  return D.29853;
}


mono_arch_allocate_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29861;
  struct MonoMemPool * D.29862;
  struct MonoGenericSharingContext * D.29863;
  unsigned char D.29864;
  unsigned char D.29865;
  unsigned int D.29868;
  unsigned int D.29869;
  unsigned char D.29870;
  unsigned char D.29871;
  unsigned int D.29875;
  unsigned int D.29878;
  unsigned int D.29881;
  <unnamed type> D.29884;
  struct MonoInst * D.29885;
  int D.29886;
  unsigned int locals_stack_size.48;
  gchar * D.29890;
  unsigned int locals_stack_align.49;
  unsigned int offset.50;
  unsigned int D.29895;
  unsigned int D.29896;
  unsigned int D.29897;
  unsigned int D.29898;
  int D.29899;
  unsigned int D.29900;
  unsigned int D.29901;
  int D.29902;
  unsigned int offset.51;
  unsigned int D.29906;
  unsigned int D.29907;
  unsigned int i.52;
  unsigned int D.29909;
  gint32 * D.29910;
  int D.29911;
  struct MonoInst * * D.29914;
  struct MonoInst * * D.29915;
  int D.29916;
  int D.29917;
  unsigned int i.53;
  unsigned int D.29919;
  struct MonoInst * D.29920;
  unsigned int D.29923;
  int D.29924;
  short int D.29925;
  int D.29926;
  int D.29927;
  unsigned int D.29928;
  _Bool D.29929;
  long int D.29930;
  long int D.29931;
  signed char D.29935;
  int D.29936;
  int D.29937;
  unsigned char D.29938;
  unsigned char D.29939;
  <unnamed type> D.29942;
  _Bool D.29943;
  long int D.29944;
  long int D.29945;
  short int D.29948;
  int D.29949;
  int D.29950;
  struct MonoInst * * D.29951;
  struct MonoInst * * D.29952;
  short unsigned int D.29953;
  short int D.29956;
  int D.29957;
  int D.29958;
  short unsigned int D.29959;
  int D.29960;
  <unnamed-unsigned:1> D.29961;
  int D.29962;
  int D.29963;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  struct MonoInst * inst;
  guint32 locals_stack_size;
  guint32 locals_stack_align;
  int i;
  int offset;
  gint32 * offsets;
  struct CallInfo * cinfo;

  try
    {
      header = cfg->header;
      D.29861 = cfg->method;
      sig = mono_method_signature (D.29861);
      D.29862 = cfg->mempool;
      D.29863 = cfg->generic_sharing_context;
      cinfo = get_call_info (D.29863, D.29862, sig);
      cfg->frame_reg = 5;
      offset = 0;
      D.29864 = BIT_FIELD_REF <*cfg, 8, 3432>;
      D.29865 = D.29864 & 24;
      if (D.29865 != 0) goto <D.29866>; else goto <D.29867>;
      <D.29866>:
      D.29868 = cfg->used_int_regs;
      D.29869 = D.29868 | 200;
      cfg->used_int_regs = D.29869;
      <D.29867>:
      D.29861 = cfg->method;
      D.29870 = BIT_FIELD_REF <*D.29861, 8, 168>;
      D.29871 = D.29870 & 1;
      if (D.29871 != 0) goto <D.29872>; else goto <D.29873>;
      <D.29872>:
      goto <D.29874>;
      <D.29873>:
      D.29868 = cfg->used_int_regs;
      D.29875 = D.29868 & 8;
      if (D.29875 != 0) goto <D.29876>; else goto <D.29877>;
      <D.29876>:
      offset = offset + 4;
      <D.29877>:
      D.29868 = cfg->used_int_regs;
      D.29878 = D.29868 & 128;
      if (D.29878 != 0) goto <D.29879>; else goto <D.29880>;
      <D.29879>:
      offset = offset + 4;
      <D.29880>:
      D.29868 = cfg->used_int_regs;
      D.29881 = D.29868 & 64;
      if (D.29881 != 0) goto <D.29882>; else goto <D.29883>;
      <D.29882>:
      offset = offset + 4;
      <D.29883>:
      <D.29874>:
      D.29884 = cinfo->ret.storage;
      switch (D.29884) <default: <D.24012>, case 4: <D.24010>>
      <D.24010>:
      offset = offset + 8;
      D.29885 = cfg->ret;
      D.29885->opcode = 367;
      D.29885 = cfg->ret;
      D.29885->sreg1 = 5;
      D.29885 = cfg->ret;
      D.29886 = -offset;
      D.29885->data.op[0].const_val = D.29886;
      goto <D.24011>;
      <D.24012>:
      goto <D.24011>;
      <D.24011>:
      offsets = mono_allocate_stack_slots (cfg, 1, &locals_stack_size, &locals_stack_align);
      locals_stack_size.48 = locals_stack_size;
      if (locals_stack_size.48 > 1048576) goto <D.29888>; else goto <D.29889>;
      <D.29888>:
      {
        char * mname;

        D.29861 = cfg->method;
        mname = mono_method_full_name (D.29861, 1);
        cfg->exception_type = 3;
        D.29890 = monoeg_g_strdup_printf ("Method %s stack is too big.", mname);
        cfg->exception_message = D.29890;
        monoeg_g_free (mname);
        return;
      }
      <D.29889>:
      locals_stack_align.49 = locals_stack_align;
      if (locals_stack_align.49 != 0) goto <D.29892>; else goto <D.29893>;
      <D.29892>:
      {
        int prev_offset;

        prev_offset = offset;
        locals_stack_align.49 = locals_stack_align;
        offset.50 = (unsigned int) offset;
        D.29895 = locals_stack_align.49 + offset.50;
        D.29896 = D.29895 + 4294967295;
        offset = (int) D.29896;
        locals_stack_align.49 = locals_stack_align;
        D.29897 = -locals_stack_align.49;
        offset.50 = (unsigned int) offset;
        D.29898 = D.29897 & offset.50;
        offset = (int) D.29898;
        goto <D.24016>;
        <D.24015>:
        prev_offset = prev_offset + 4;
        D.29899 = -prev_offset;
        mini_gc_set_slot_type_from_fp (cfg, D.29899, 0);
        <D.24016>:
        if (prev_offset < offset) goto <D.24015>; else goto <D.24017>;
        <D.24017>:
      }
      <D.29893>:
      offset.50 = (unsigned int) offset;
      locals_stack_size.48 = locals_stack_size;
      D.29900 = offset.50 + locals_stack_size.48;
      D.29901 = -D.29900;
      D.29902 = (int) D.29901;
      cfg->locals_min_stack_offset = D.29902;
      D.29886 = -offset;
      cfg->locals_max_stack_offset = D.29886;
      locals_stack_align.49 = locals_stack_align;
      if (locals_stack_align.49 > 8) goto <D.29903>; else goto <D.29904>;
      <D.29903>:
      offset.51 = (unsigned int) offset;
      D.29906 = offset.51 + 8;
      offset = (int) D.29906;
      <D.29904>:
      D.29907 = cfg->locals_start;
      i = (int) D.29907;
      goto <D.24020>;
      <D.24019>:
      i.52 = (unsigned int) i;
      D.29909 = i.52 * 4;
      D.29910 = offsets + D.29909;
      D.29911 = *D.29910;
      if (D.29911 != -1) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      {
        struct MonoInst * inst;

        D.29914 = cfg->varinfo;
        i.52 = (unsigned int) i;
        D.29909 = i.52 * 4;
        D.29915 = D.29914 + D.29909;
        inst = *D.29915;
        inst->opcode = 367;
        inst->sreg1 = 5;
        i.52 = (unsigned int) i;
        D.29909 = i.52 * 4;
        D.29910 = offsets + D.29909;
        D.29911 = *D.29910;
        D.29916 = D.29911 + offset;
        D.29917 = -D.29916;
        inst->data.op[0].const_val = D.29917;
      }
      <D.29913>:
      i = i + 1;
      <D.24020>:
      i.53 = (unsigned int) i;
      D.29919 = cfg->num_varinfo;
      if (i.53 < D.29919) goto <D.24019>; else goto <D.24021>;
      <D.24021>:
      offset.50 = (unsigned int) offset;
      locals_stack_size.48 = locals_stack_size;
      D.29900 = offset.50 + locals_stack_size.48;
      offset = (int) D.29900;
      D.29884 = cinfo->ret.storage;
      switch (D.29884) <default: <D.24029>, case 0: <D.24025>, case 3: <D.24022>, case 4: <D.24024>, case 5: <D.24027>, case 6: <D.24028>, case 8: <D.24026>>
      <D.24022>:
      D.29920 = cfg->vret_addr;
      if (D.29920 != 0B) goto <D.29921>; else goto <D.29922>;
      <D.29921>:
      D.29920 = cfg->vret_addr;
      D.29920->opcode = 367;
      D.29920 = cfg->vret_addr;
      D.29923 = cfg->frame_reg;
      D.29924 = (int) D.29923;
      D.29920->sreg1 = D.29924;
      D.29920 = cfg->vret_addr;
      D.29925 = cinfo->ret.offset;
      D.29926 = (int) D.29925;
      D.29927 = D.29926 + 8;
      D.29920->data.op[0].const_val = D.29927;
      D.29928 = cfg->verbose_level;
      D.29929 = D.29928 > 1;
      D.29930 = (long int) D.29929;
      D.29931 = __builtin_expect (D.29930, 0);
      if (D.29931 != 0) goto <D.29932>; else goto <D.29933>;
      <D.29932>:
      printf ("vret_addr =");
      D.29920 = cfg->vret_addr;
      mono_print_ins (D.29920);
      <D.29933>:
      goto <D.29934>;
      <D.29922>:
      D.29885 = cfg->ret;
      D.29885->opcode = 367;
      D.29885 = cfg->ret;
      D.29885->sreg1 = 5;
      D.29885 = cfg->ret;
      D.29925 = cinfo->ret.offset;
      D.29926 = (int) D.29925;
      D.29927 = D.29926 + 8;
      D.29885->data.op[0].const_val = D.29927;
      <D.29934>:
      goto <D.24023>;
      <D.24024>:
      goto <D.24023>;
      <D.24025>:
      D.29885 = cfg->ret;
      D.29885->opcode = 366;
      D.29885 = cfg->ret;
      D.29935 = cinfo->ret.reg;
      D.29936 = (int) D.29935;
      D.29885->data.op[0].const_val = D.29936;
      D.29885 = cfg->ret;
      D.29935 = cinfo->ret.reg;
      D.29937 = (int) D.29935;
      D.29885->dreg = D.29937;
      goto <D.24023>;
      <D.24026>:
      <D.24027>:
      <D.24028>:
      goto <D.24023>;
      <D.24029>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 1178);
      <D.24023>:
      D.29938 = BIT_FIELD_REF <*sig, 8, 80>;
      D.29939 = D.29938 & 63;
      if (D.29939 == 5) goto <D.29940>; else goto <D.29941>;
      <D.29940>:
      D.29942 = cinfo->sig_cookie.storage;
      D.29943 = D.29942 != 3;
      D.29944 = (long int) D.29943;
      D.29945 = __builtin_expect (D.29944, 0);
      if (D.29945 != 0) goto <D.29946>; else goto <D.29947>;
      <D.29946>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 1182, "cinfo->sig_cookie.storage == ArgOnStack");
      <D.29947>:
      D.29948 = cinfo->sig_cookie.offset;
      D.29949 = (int) D.29948;
      D.29950 = D.29949 + 8;
      cfg->sig_cookie = D.29950;
      <D.29941>:
      i = 0;
      goto <D.24032>;
      <D.24031>:
      {
        struct ArgInfo * ainfo;

        ainfo = &cinfo->args[i];
        D.29951 = cfg->args;
        i.52 = (unsigned int) i;
        D.29909 = i.52 * 4;
        D.29952 = D.29951 + D.29909;
        inst = *D.29952;
        D.29953 = inst->opcode;
        if (D.29953 != 366) goto <D.29954>; else goto <D.29955>;
        <D.29954>:
        inst->opcode = 367;
        inst->sreg1 = 5;
        <D.29955>:
        D.29956 = ainfo->offset;
        D.29957 = (int) D.29956;
        D.29958 = D.29957 + 8;
        inst->data.op[0].const_val = D.29958;
      }
      i = i + 1;
      <D.24032>:
      D.29959 = sig->param_count;
      D.29960 = (int) D.29959;
      D.29961 = sig->hasthis;
      D.29962 = (int) D.29961;
      D.29963 = D.29960 + D.29962;
      if (D.29963 > i) goto <D.24031>; else goto <D.24033>;
      <D.24033>:
      cfg->stack_offset = offset;
    }
  finally
    {
      locals_stack_size = {CLOBBER};
      locals_stack_align = {CLOBBER};
    }
}


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

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


mono_arch_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29971;
  struct MonoMemPool * D.29972;
  struct MonoGenericSharingContext * D.29973;
  struct MonoType * D.29974;
  <unnamed type> D.29975;
  int D.29982;
  int D.29984;
  struct MonoClass * D.29985;
  struct MonoType * D.29986;
  struct MonoInst * D.29987;
  unsigned char D.29988;
  unsigned char D.29989;
  int optimize_for_xen.54;
  struct MonoType * sig_ret;
  struct MonoMethodSignature * sig;
  struct CallInfo * cinfo;

  D.29971 = cfg->method;
  sig = mono_method_signature (D.29971);
  D.29972 = cfg->mempool;
  D.29973 = cfg->generic_sharing_context;
  cinfo = get_call_info (D.29973, D.29972, sig);
  D.29974 = sig->ret;
  sig_ret = mini_replace_type (D.29974);
  D.29975 = cinfo->ret.storage;
  if (D.29975 == 4) goto <D.29976>; else goto <D.29977>;
  <D.29976>:
  cfg->ret_var_is_local = 1;
  <D.29977>:
  D.29975 = cinfo->ret.storage;
  if (D.29975 != 4) goto <D.29980>; else goto <D.29981>;
  <D.29980>:
  D.29982 = mono_type_is_struct (sig_ret);
  if (D.29982 != 0) goto <D.29978>; else goto <D.29983>;
  <D.29983>:
  D.29984 = mini_is_gsharedvt_variable_type (cfg, sig_ret);
  if (D.29984 != 0) goto <D.29978>; else goto <D.29979>;
  <D.29978>:
  D.29985 = mono_defaults.int_class;
  D.29986 = &D.29985->byval_arg;
  D.29987 = mono_compile_create_var (cfg, D.29986, 330);
  cfg->vret_addr = D.29987;
  <D.29979>:
  <D.29981>:
  D.29971 = cfg->method;
  D.29988 = BIT_FIELD_REF <*D.29971, 8, 168>;
  D.29989 = D.29988 & 1;
  if (D.29989 != 0) goto <D.29990>; else goto <D.29991>;
  <D.29990>:
  cfg->create_lmf_var = 1;
  optimize_for_xen.54 = optimize_for_xen;
  if (optimize_for_xen.54 == 0) goto <D.29993>; else goto <D.29994>;
  <D.29993>:
  cfg->lmf_ir = 1;
  cfg->lmf_ir_mono_lmf = 1;
  <D.29994>:
  <D.29991>:
  cfg->arch_eh_jit_info = 1;
}


mono_arch_emit_call (struct MonoCompile * cfg, struct MonoCallInst * call)
{
  short unsigned int D.29995;
  int D.29996;
  <unnamed-unsigned:1> D.29997;
  int D.29998;
  struct MonoType * D.29999;
  struct MonoMemPool * D.30000;
  struct MonoGenericSharingContext * D.30001;
  short unsigned int D.30002;
  short unsigned int D.30003;
  short int D.30006;
  int D.30007;
  unsigned char D.30008;
  unsigned char D.30009;
  _Bool D.30010;
  int D.30011;
  int D.30012;
  int D.30015;
  struct MonoInst * D.30016;
  int D.30017;
  int D.30018;
  const unsigned char * D.30019;
  unsigned int D.30020;
  int D.30021;
  struct MonoBasicBlock * D.30022;
  struct MonoInst * D.30023;
  unsigned int i.55;
  unsigned int D.30028;
  unsigned int i.56;
  int D.30032;
  <unnamed type> D.30035;
  struct MonoInst * D.30038;
  int D.30041;
  int D.30042;
  sizetype i.57;
  int D.30048;
  int D.30051;
  int D.30056;
  struct MonoInst * D.30057;
  int D.30058;
  int D.30059;
  int D.30060;
  int D.30066;
  struct MonoClass * D.30068;
  struct MonoInst * * D.30069;
  unsigned int D.30070;
  struct MonoInst * * D.30071;
  const unsigned char * D.30072;
  int D.30073;
  unsigned char D.30074;
  _Bool D.30075;
  long int D.30076;
  long int D.30077;
  <unnamed type> D.30080;
  struct MonoClass * D.30083;
  void * D.30084;
  void * D.30085;
  int D.30093;
  _Bool D.30095;
  long int D.30096;
  long int D.30097;
  unsigned char D.30100;
  <unnamed-unsigned:1> D.30104;
  int D.30105;
  struct MonoType * D.30106;
  int D.30107;
  int size.58;
  void * D.30111;
  unsigned int sp_offset.59;
  unsigned int D.30118;
  unsigned char D.30119;
  unsigned char D.30120;
  int D.30125;
  struct MonoInst * D.30126;
  int D.30127;
  int D.30128;
  int D.30135;
  struct MonoInst * D.30136;
  int D.30137;
  int D.30138;
  unsigned char D.30143;
  int D.30146;
  int D.30147;
  int D.30148;
  struct MonoInst * D.30149;
  int D.30150;
  int D.30151;
  int D.30152;
  signed char D.30156;
  int D.30157;
  unsigned char D.30161;
  unsigned char D.30162;
  struct MonoInst * D.30171;
  unsigned char D.30172;
  unsigned char D.30174;
  unsigned char D.30175;
  struct MonoType * D.30178;
  struct MonoClass * D.30180;
  struct MonoType * D.30181;
  int D.30183;
  int D.30192;
  int D.30199;
  struct MonoInst * D.30200;
  int D.30201;
  int D.30202;
  int D.30203;
  unsigned int D.30204;
  int D.30205;
  signed char D.30209;
  int D.30210;
  int D.30211;
  int D.30217;
  struct MonoInst * D.30218;
  int D.30219;
  int D.30220;
  unsigned int D.30226;
  unsigned int D.30227;
  int D.30228;
  int D.30229;
  struct MonoType * sig_ret;
  struct MonoInst * arg;
  struct MonoInst * in;
  struct MonoMethodSignature * sig;
  int i;
  int j;
  int n;
  struct CallInfo * cinfo;
  int sentinelpos;
  int sp_offset;

  sentinelpos = 0;
  sp_offset = 0;
  sig = call->signature;
  D.29995 = sig->param_count;
  D.29996 = (int) D.29995;
  D.29997 = sig->hasthis;
  D.29998 = (int) D.29997;
  n = D.29996 + D.29998;
  D.29999 = sig->ret;
  sig_ret = mini_replace_type (D.29999);
  D.30000 = cfg->mempool;
  D.30001 = cfg->generic_sharing_context;
  cinfo = get_call_info (D.30001, D.30000, sig);
  D.30002 = BIT_FIELD_REF <*sig, 16, 80>;
  D.30003 = D.30002 & 319;
  if (D.30003 == 5) goto <D.30004>; else goto <D.30005>;
  <D.30004>:
  D.30006 = sig->sentinelpos;
  D.30007 = (int) D.30006;
  D.30008 = BIT_FIELD_REF <*sig, 8, 80>;
  D.30009 = D.30008 & 64;
  D.30010 = D.30009 != 0;
  D.30011 = (int) D.30010;
  sentinelpos = D.30007 + D.30011;
  <D.30005>:
  D.30012 = cinfo->need_stack_align;
  if (D.30012 != 0) goto <D.30013>; else goto <D.30014>;
  <D.30013>:
  D.30000 = cfg->mempool;
  arg = mono_mempool_alloc (D.30000, 48);
  arg->data.op[1].const_val = 0;
  D.30015 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30015;
  arg->prev = 0B;
  D.30016 = arg->prev;
  arg->next = D.30016;
  arg->opcode = 434;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30017 = arg->sreg3;
  arg->sreg2 = D.30017;
  D.30018 = arg->sreg2;
  arg->sreg1 = D.30018;
  D.30019 = cfg->ip;
  arg->cil_code = D.30019;
  arg->dreg = 4;
  arg->sreg1 = 4;
  D.30020 = cinfo->stack_align_amount;
  D.30021 = (int) D.30020;
  arg->data.op[1].const_val = D.30021;
  D.30022 = cfg->cbb;
  D.30023 = D.30022->last_ins;
  if (D.30023 != 0B) goto <D.30024>; else goto <D.30025>;
  <D.30024>:
  D.30022 = cfg->cbb;
  D.30023 = D.30022->last_ins;
  D.30023->next = arg;
  D.30022 = cfg->cbb;
  D.30023 = D.30022->last_ins;
  arg->prev = D.30023;
  D.30022 = cfg->cbb;
  D.30022->last_ins = arg;
  goto <D.30026>;
  <D.30025>:
  D.30022 = cfg->cbb;
  D.30022 = cfg->cbb;
  D.30022->last_ins = arg;
  D.30023 = D.30022->last_ins;
  D.30022->code = D.30023;
  <D.30026>:
  i = 0;
  goto <D.24083>;
  <D.24082>:
  sp_offset = sp_offset + 4;
  emit_gc_param_slot_def (cfg, sp_offset, 0B);
  i.55 = (unsigned int) i;
  D.30028 = i.55 + 4;
  i = (int) D.30028;
  <D.24083>:
  i.56 = (unsigned int) i;
  D.30020 = cinfo->stack_align_amount;
  if (i.56 < D.30020) goto <D.24082>; else goto <D.24084>;
  <D.24084>:
  <D.30014>:
  if (sig_ret != 0B) goto <D.30030>; else goto <D.30031>;
  <D.30030>:
  D.30032 = mono_type_is_struct (sig_ret);
  if (D.30032 != 0) goto <D.30033>; else goto <D.30034>;
  <D.30033>:
  D.30035 = cinfo->ret.storage;
  if (D.30035 == 4) goto <D.30036>; else goto <D.30037>;
  <D.30036>:
  call->vret_in_reg = 1;
  D.30038 = call->vret_var;
  if (D.30038 != 0B) goto <D.30039>; else goto <D.30040>;
  <D.30039>:
  D.30038 = call->vret_var;
  D.30038->opcode = 316;
  D.30038 = call->vret_var;
  D.30038->dreg = -1;
  D.30038 = call->vret_var;
  D.30038 = call->vret_var;
  D.30038 = call->vret_var;
  D.30038->sreg3 = -1;
  D.30041 = D.30038->sreg3;
  D.30038->sreg2 = D.30041;
  D.30042 = D.30038->sreg2;
  D.30038->sreg1 = D.30042;
  <D.30040>:
  <D.30037>:
  <D.30034>:
  <D.30031>:
  D.30002 = BIT_FIELD_REF <*sig, 16, 80>;
  D.30003 = D.30002 & 319;
  if (D.30003 == 5) goto <D.30043>; else goto <D.30044>;
  <D.30043>:
  if (n == sentinelpos) goto <D.30045>; else goto <D.30046>;
  <D.30045>:
  emit_sig_cookie (cfg, call, cinfo);
  sp_offset = sp_offset + 4;
  emit_gc_param_slot_def (cfg, sp_offset, 0B);
  <D.30046>:
  <D.30044>:
  i = n + -1;
  goto <D.24103>;
  <D.24102>:
  {
    struct ArgInfo * ainfo;
    struct MonoType * orig_type;
    struct MonoType * t;
    int argsize;

    i.57 = (sizetype) i;
    ainfo = &cinfo->args[i.57];
    D.30048 = cinfo->vtype_retaddr;
    if (D.30048 != 0) goto <D.30049>; else goto <D.30050>;
    <D.30049>:
    D.30051 = cinfo->vret_arg_index;
    if (D.30051 == 1) goto <D.30052>; else goto <D.30053>;
    <D.30052>:
    if (i == 0) goto <D.30054>; else goto <D.30055>;
    <D.30054>:
    {
      struct MonoInst * vtarg;

      D.30000 = cfg->mempool;
      vtarg = mono_mempool_alloc (D.30000, 48);
      vtarg->data.op[1].const_val = 0;
      D.30056 = vtarg->data.op[1].const_val;
      vtarg->data.op[0].const_val = D.30056;
      vtarg->prev = 0B;
      D.30057 = vtarg->prev;
      vtarg->next = D.30057;
      vtarg->opcode = 1034;
      vtarg->flags = 0;
      vtarg->type = 0;
      vtarg->dreg = -1;
      vtarg->sreg3 = -1;
      D.30058 = vtarg->sreg3;
      vtarg->sreg2 = D.30058;
      D.30059 = vtarg->sreg2;
      vtarg->sreg1 = D.30059;
      D.30019 = cfg->ip;
      vtarg->cil_code = D.30019;
      vtarg->type = 5;
      D.30038 = call->vret_var;
      D.30060 = D.30038->dreg;
      vtarg->sreg1 = D.30060;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      if (D.30023 != 0B) goto <D.30061>; else goto <D.30062>;
      <D.30061>:
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      D.30023->next = vtarg;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      vtarg->prev = D.30023;
      D.30022 = cfg->cbb;
      D.30022->last_ins = vtarg;
      goto <D.30063>;
      <D.30062>:
      D.30022 = cfg->cbb;
      D.30022 = cfg->cbb;
      D.30022->last_ins = vtarg;
      D.30023 = D.30022->last_ins;
      D.30022->code = D.30023;
      <D.30063>:
      sp_offset = sp_offset + 4;
      emit_gc_param_slot_def (cfg, sp_offset, 0B);
    }
    <D.30055>:
    <D.30053>:
    <D.30050>:
    D.29997 = sig->hasthis;
    D.29998 = (int) D.29997;
    if (D.29998 <= i) goto <D.30064>; else goto <D.30065>;
    <D.30064>:
    D.29997 = sig->hasthis;
    D.29998 = (int) D.29997;
    D.30066 = i - D.29998;
    t = sig->params[D.30066];
    goto <D.30067>;
    <D.30065>:
    D.30068 = mono_defaults.int_class;
    t = &D.30068->byval_arg;
    <D.30067>:
    orig_type = t;
    D.30001 = cfg->generic_sharing_context;
    t = mini_type_get_underlying_type (D.30001, t);
    D.30000 = cfg->mempool;
    arg = mono_mempool_alloc (D.30000, 48);
    arg->data.op[1].const_val = 0;
    D.30015 = arg->data.op[1].const_val;
    arg->data.op[0].const_val = D.30015;
    arg->prev = 0B;
    D.30016 = arg->prev;
    arg->next = D.30016;
    arg->opcode = 1034;
    arg->flags = 0;
    arg->type = 0;
    arg->dreg = -1;
    arg->sreg3 = -1;
    D.30017 = arg->sreg3;
    arg->sreg2 = D.30017;
    D.30018 = arg->sreg2;
    arg->sreg1 = D.30018;
    D.30019 = cfg->ip;
    arg->cil_code = D.30019;
    D.30069 = call->args;
    i.55 = (unsigned int) i;
    D.30070 = i.55 * 4;
    D.30071 = D.30069 + D.30070;
    in = *D.30071;
    D.30072 = in->cil_code;
    arg->cil_code = D.30072;
    D.30073 = in->dreg;
    arg->sreg1 = D.30073;
    D.30074 = in->type;
    arg->type = D.30074;
    D.30073 = in->dreg;
    D.30075 = D.30073 == -1;
    D.30076 = (long int) D.30075;
    D.30077 = __builtin_expect (D.30076, 0);
    if (D.30077 != 0) goto <D.30078>; else goto <D.30079>;
    <D.30078>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 1496, "in->dreg != -1");
    <D.30079>:
    D.30080 = ainfo->storage;
    if (D.30080 == 7) goto <D.30081>; else goto <D.30082>;
    <D.30081>:
    arg->opcode = 333;
    D.30073 = in->dreg;
    arg->sreg1 = D.30073;
    D.30083 = in->klass;
    arg->klass = D.30083;
    D.30000 = cfg->mempool;
    D.30084 = mono_mempool_alloc (D.30000, 28);
    arg->data.op[1].p = D.30084;
    D.30085 = arg->data.op[1].p;
    memcpy (D.30085, ainfo, 28);
    sp_offset = sp_offset + 4;
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    if (D.30023 != 0B) goto <D.30086>; else goto <D.30087>;
    <D.30086>:
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    D.30023->next = arg;
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    arg->prev = D.30023;
    D.30022 = cfg->cbb;
    D.30022->last_ins = arg;
    goto <D.30088>;
    <D.30087>:
    D.30022 = cfg->cbb;
    D.30022 = cfg->cbb;
    D.30022->last_ins = arg;
    D.30023 = D.30022->last_ins;
    D.30022->code = D.30023;
    <D.30088>:
    goto <D.30089>;
    <D.30082>:
    D.29997 = sig->hasthis;
    D.29998 = (int) D.29997;
    if (D.29998 <= i) goto <D.30092>; else goto <D.30090>;
    <D.30092>:
    D.30093 = mono_type_is_struct (t);
    if (D.30093 != 0) goto <D.30094>; else goto <D.30090>;
    <D.30094>:
    {
      guint32 align;
      guint32 size;

      try
        {
          D.30083 = in->klass;
          D.30095 = D.30083 == 0B;
          D.30096 = (long int) D.30095;
          D.30097 = __builtin_expect (D.30096, 0);
          if (D.30097 != 0) goto <D.30098>; else goto <D.30099>;
          <D.30098>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 1510, "in->klass");
          <D.30099>:
          D.30100 = t->type;
          if (D.30100 == 22) goto <D.30101>; else goto <D.30102>;
          <D.30101>:
          size = 12;
          align = 4;
          goto <D.30103>;
          <D.30102>:
          D.30104 = sig->pinvoke;
          D.30105 = (int) D.30104;
          D.30083 = in->klass;
          D.30106 = &D.30083->byval_arg;
          D.30001 = cfg->generic_sharing_context;
          D.30107 = mini_type_stack_size_full (D.30001, D.30106, &align, D.30105);
          size = (guint32) D.30107;
          <D.30103>:
          if (size != 0) goto <D.30108>; else goto <D.30109>;
          <D.30108>:
          arg->opcode = 333;
          D.30073 = in->dreg;
          arg->sreg1 = D.30073;
          D.30083 = in->klass;
          arg->klass = D.30083;
          size.58 = (int) size;
          arg->backend.size = size.58;
          arg->data.op[0].p = call;
          D.30000 = cfg->mempool;
          D.30111 = mono_mempool_alloc (D.30000, 28);
          arg->data.op[1].p = D.30111;
          D.30085 = arg->data.op[1].p;
          memcpy (D.30085, ainfo, 28);
          D.30022 = cfg->cbb;
          D.30023 = D.30022->last_ins;
          if (D.30023 != 0B) goto <D.30112>; else goto <D.30113>;
          <D.30112>:
          D.30022 = cfg->cbb;
          D.30023 = D.30022->last_ins;
          D.30023->next = arg;
          D.30022 = cfg->cbb;
          D.30023 = D.30022->last_ins;
          arg->prev = D.30023;
          D.30022 = cfg->cbb;
          D.30022->last_ins = arg;
          goto <D.30114>;
          <D.30113>:
          D.30022 = cfg->cbb;
          D.30022 = cfg->cbb;
          D.30022->last_ins = arg;
          D.30023 = D.30022->last_ins;
          D.30022->code = D.30023;
          <D.30114>:
          D.30080 = ainfo->storage;
          if (D.30080 != 4) goto <D.30115>; else goto <D.30116>;
          <D.30115>:
          sp_offset.59 = (unsigned int) sp_offset;
          D.30118 = sp_offset.59 + size;
          sp_offset = (int) D.30118;
          emit_gc_param_slot_def (cfg, sp_offset, orig_type);
          <D.30116>:
          <D.30109>:
        }
      finally
        {
          align = {CLOBBER};
        }
    }
    goto <D.30091>;
    <D.30090>:
    argsize = 4;
    D.30080 = ainfo->storage;
    switch (D.30080) <default: <D.24098>, case 0: <D.24097>, case 3: <D.24092>>
    <D.24092>:
    arg->opcode = 1034;
    D.30119 = BIT_FIELD_REF <*t, 8, 56>;
    D.30120 = D.30119 & 64;
    if (D.30120 == 0) goto <D.30121>; else goto <D.30122>;
    <D.30121>:
    D.30100 = t->type;
    if (D.30100 == 12) goto <D.30123>; else goto <D.30124>;
    <D.30123>:
    {
      struct MonoInst * inst;

      D.30000 = cfg->mempool;
      inst = mono_mempool_alloc (D.30000, 48);
      inst->data.op[1].const_val = 0;
      D.30125 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30125;
      inst->prev = 0B;
      D.30126 = inst->prev;
      inst->next = D.30126;
      inst->opcode = 434;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30127 = inst->sreg3;
      inst->sreg2 = D.30127;
      D.30128 = inst->sreg2;
      inst->sreg1 = D.30128;
      D.30019 = cfg->ip;
      inst->cil_code = D.30019;
      inst->dreg = 4;
      inst->sreg1 = 4;
      inst->data.op[1].const_val = 4;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      if (D.30023 != 0B) goto <D.30129>; else goto <D.30130>;
      <D.30129>:
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      D.30023->next = inst;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      inst->prev = D.30023;
      D.30022 = cfg->cbb;
      D.30022->last_ins = inst;
      goto <D.30131>;
      <D.30130>:
      D.30022 = cfg->cbb;
      D.30022 = cfg->cbb;
      D.30022->last_ins = inst;
      D.30023 = D.30022->last_ins;
      D.30022->code = D.30023;
      <D.30131>:
    }
    arg->opcode = 379;
    arg->dreg = 4;
    arg->data.op[0].const_val = 0;
    argsize = 4;
    goto <D.30132>;
    <D.30124>:
    D.30100 = t->type;
    if (D.30100 == 13) goto <D.30133>; else goto <D.30134>;
    <D.30133>:
    {
      struct MonoInst * inst;

      D.30000 = cfg->mempool;
      inst = mono_mempool_alloc (D.30000, 48);
      inst->data.op[1].const_val = 0;
      D.30135 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30135;
      inst->prev = 0B;
      D.30136 = inst->prev;
      inst->next = D.30136;
      inst->opcode = 434;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30137 = inst->sreg3;
      inst->sreg2 = D.30137;
      D.30138 = inst->sreg2;
      inst->sreg1 = D.30138;
      D.30019 = cfg->ip;
      inst->cil_code = D.30019;
      inst->dreg = 4;
      inst->sreg1 = 4;
      inst->data.op[1].const_val = 8;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      if (D.30023 != 0B) goto <D.30139>; else goto <D.30140>;
      <D.30139>:
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      D.30023->next = inst;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      inst->prev = D.30023;
      D.30022 = cfg->cbb;
      D.30022->last_ins = inst;
      goto <D.30141>;
      <D.30140>:
      D.30022 = cfg->cbb;
      D.30022 = cfg->cbb;
      D.30022->last_ins = inst;
      D.30023 = D.30022->last_ins;
      D.30022->code = D.30023;
      <D.30141>:
    }
    arg->opcode = 380;
    arg->dreg = 4;
    arg->data.op[0].const_val = 0;
    argsize = 8;
    goto <D.30142>;
    <D.30134>:
    D.30100 = t->type;
    D.30143 = D.30100 + 246;
    if (D.30143 <= 1) goto <D.30144>; else goto <D.30145>;
    <D.30144>:
    D.30146 = arg->sreg1;
    D.30147 = D.30146 + 1;
    arg->sreg1 = D.30147;
    {
      struct MonoInst * inst;

      D.30000 = cfg->mempool;
      inst = mono_mempool_alloc (D.30000, 48);
      inst->data.op[1].const_val = 0;
      D.30148 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30148;
      inst->prev = 0B;
      D.30149 = inst->prev;
      inst->next = D.30149;
      inst->opcode = 1034;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30150 = inst->sreg3;
      inst->sreg2 = D.30150;
      D.30151 = inst->sreg2;
      inst->sreg1 = D.30151;
      D.30019 = cfg->ip;
      inst->cil_code = D.30019;
      inst->dreg = -1;
      D.30073 = in->dreg;
      D.30152 = D.30073 + 2;
      inst->sreg1 = D.30152;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      if (D.30023 != 0B) goto <D.30153>; else goto <D.30154>;
      <D.30153>:
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      D.30023->next = inst;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      inst->prev = D.30023;
      D.30022 = cfg->cbb;
      D.30022->last_ins = inst;
      goto <D.30155>;
      <D.30154>:
      D.30022 = cfg->cbb;
      D.30022 = cfg->cbb;
      D.30022->last_ins = inst;
      D.30023 = D.30022->last_ins;
      D.30022->code = D.30023;
      <D.30155>:
    }
    sp_offset = sp_offset + 4;
    <D.30145>:
    <D.30142>:
    <D.30132>:
    <D.30122>:
    goto <D.24096>;
    <D.24097>:
    arg->opcode = 428;
    D.30156 = ainfo->reg;
    D.30157 = (int) D.30156;
    arg->dreg = D.30157;
    argsize = 0;
    goto <D.24096>;
    <D.24098>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 1567);
    <D.24096>:
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    if (D.30023 != 0B) goto <D.30158>; else goto <D.30159>;
    <D.30158>:
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    D.30023->next = arg;
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    arg->prev = D.30023;
    D.30022 = cfg->cbb;
    D.30022->last_ins = arg;
    goto <D.30160>;
    <D.30159>:
    D.30022 = cfg->cbb;
    D.30022 = cfg->cbb;
    D.30022->last_ins = arg;
    D.30023 = D.30022->last_ins;
    D.30022->code = D.30023;
    <D.30160>:
    sp_offset = sp_offset + argsize;
    D.30161 = BIT_FIELD_REF <*cfg, 8, 3424>;
    D.30162 = D.30161 & 128;
    if (D.30162 != 0) goto <D.30163>; else goto <D.30164>;
    <D.30163>:
    if (argsize == 4) goto <D.30165>; else goto <D.30166>;
    <D.30165>:
    D.30008 = BIT_FIELD_REF <*sig, 8, 80>;
    D.30009 = D.30008 & 64;
    if (D.30009 != 0) goto <D.30169>; else goto <D.30167>;
    <D.30169>:
    if (i == 0) goto <D.30170>; else goto <D.30167>;
    <D.30170>:
    D.30069 = call->args;
    i.55 = (unsigned int) i;
    D.30070 = i.55 * 4;
    D.30071 = D.30069 + D.30070;
    D.30171 = *D.30071;
    D.30172 = D.30171->type;
    if (D.30172 == 6) goto <D.30173>; else goto <D.30167>;
    <D.30173>:
    D.30174 = BIT_FIELD_REF <*call, 8, 640>;
    D.30175 = D.30174 & 64;
    if (D.30175 != 0) goto <D.30176>; else goto <D.30177>;
    <D.30176>:
    D.30068 = mono_defaults.int_class;
    D.30178 = &D.30068->this_arg;
    emit_gc_param_slot_def (cfg, sp_offset, D.30178);
    goto <D.30179>;
    <D.30177>:
    D.30180 = mono_defaults.object_class;
    D.30181 = &D.30180->byval_arg;
    emit_gc_param_slot_def (cfg, sp_offset, D.30181);
    <D.30179>:
    goto <D.30168>;
    <D.30167>:
    emit_gc_param_slot_def (cfg, sp_offset, orig_type);
    <D.30168>:
    goto <D.30182>;
    <D.30166>:
    j = 0;
    goto <D.24100>;
    <D.24099>:
    D.30183 = sp_offset - j;
    emit_gc_param_slot_def (cfg, D.30183, 0B);
    j = j + 4;
    <D.24100>:
    if (j < argsize) goto <D.24099>; else goto <D.24101>;
    <D.24101>:
    <D.30182>:
    <D.30164>:
    <D.30091>:
    <D.30089>:
    D.30002 = BIT_FIELD_REF <*sig, 16, 80>;
    D.30003 = D.30002 & 319;
    if (D.30003 == 5) goto <D.30184>; else goto <D.30185>;
    <D.30184>:
    if (i == sentinelpos) goto <D.30186>; else goto <D.30187>;
    <D.30186>:
    emit_sig_cookie (cfg, call, cinfo);
    sp_offset = sp_offset + 4;
    emit_gc_param_slot_def (cfg, sp_offset, 0B);
    <D.30187>:
    <D.30185>:
  }
  i = i + -1;
  <D.24103>:
  if (i >= 0) goto <D.24102>; else goto <D.24104>;
  <D.24104>:
  if (sig_ret != 0B) goto <D.30190>; else goto <D.30191>;
  <D.30190>:
  D.30192 = mono_type_is_struct (sig_ret);
  if (D.30192 != 0) goto <D.30188>; else goto <D.30193>;
  <D.30193>:
  D.30048 = cinfo->vtype_retaddr;
  if (D.30048 != 0) goto <D.30188>; else goto <D.30189>;
  <D.30188>:
  {
    struct MonoInst * vtarg;

    D.30035 = cinfo->ret.storage;
    if (D.30035 == 4) goto <D.30194>; else goto <D.30195>;
    <D.30194>:
    goto <D.30196>;
    <D.30195>:
    D.30035 = cinfo->ret.storage;
    if (D.30035 == 0) goto <D.30197>; else goto <D.30198>;
    <D.30197>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 1610);
    D.30000 = cfg->mempool;
    vtarg = mono_mempool_alloc (D.30000, 48);
    vtarg->data.op[1].const_val = 0;
    D.30199 = vtarg->data.op[1].const_val;
    vtarg->data.op[0].const_val = D.30199;
    vtarg->prev = 0B;
    D.30200 = vtarg->prev;
    vtarg->next = D.30200;
    vtarg->opcode = 428;
    vtarg->flags = 0;
    vtarg->type = 0;
    vtarg->dreg = -1;
    vtarg->sreg3 = -1;
    D.30201 = vtarg->sreg3;
    vtarg->sreg2 = D.30201;
    D.30202 = vtarg->sreg2;
    vtarg->sreg1 = D.30202;
    D.30019 = cfg->ip;
    vtarg->cil_code = D.30019;
    D.30203 = call->inst.dreg;
    vtarg->sreg1 = D.30203;
    D.30204 = mono_alloc_ireg (cfg);
    D.30205 = (int) D.30204;
    vtarg->dreg = D.30205;
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    if (D.30023 != 0B) goto <D.30206>; else goto <D.30207>;
    <D.30206>:
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    D.30023->next = vtarg;
    D.30022 = cfg->cbb;
    D.30023 = D.30022->last_ins;
    vtarg->prev = D.30023;
    D.30022 = cfg->cbb;
    D.30022->last_ins = vtarg;
    goto <D.30208>;
    <D.30207>:
    D.30022 = cfg->cbb;
    D.30022 = cfg->cbb;
    D.30022->last_ins = vtarg;
    D.30023 = D.30022->last_ins;
    D.30022->code = D.30023;
    <D.30208>:
    D.30209 = cinfo->ret.reg;
    D.30210 = (int) D.30209;
    D.30211 = vtarg->dreg;
    mono_call_inst_add_outarg_reg (cfg, call, D.30211, D.30210, 0);
    goto <D.30212>;
    <D.30198>:
    D.30048 = cinfo->vtype_retaddr;
    if (D.30048 != 0) goto <D.30213>; else goto <D.30214>;
    <D.30213>:
    D.30051 = cinfo->vret_arg_index;
    if (D.30051 == 0) goto <D.30215>; else goto <D.30216>;
    <D.30215>:
    {
      struct MonoInst * vtarg;

      D.30000 = cfg->mempool;
      vtarg = mono_mempool_alloc (D.30000, 48);
      vtarg->data.op[1].const_val = 0;
      D.30217 = vtarg->data.op[1].const_val;
      vtarg->data.op[0].const_val = D.30217;
      vtarg->prev = 0B;
      D.30218 = vtarg->prev;
      vtarg->next = D.30218;
      vtarg->opcode = 1034;
      vtarg->flags = 0;
      vtarg->type = 0;
      vtarg->dreg = -1;
      vtarg->sreg3 = -1;
      D.30219 = vtarg->sreg3;
      vtarg->sreg2 = D.30219;
      D.30220 = vtarg->sreg2;
      vtarg->sreg1 = D.30220;
      D.30019 = cfg->ip;
      vtarg->cil_code = D.30019;
      vtarg->type = 5;
      D.30038 = call->vret_var;
      D.30060 = D.30038->dreg;
      vtarg->sreg1 = D.30060;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      if (D.30023 != 0B) goto <D.30221>; else goto <D.30222>;
      <D.30221>:
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      D.30023->next = vtarg;
      D.30022 = cfg->cbb;
      D.30023 = D.30022->last_ins;
      vtarg->prev = D.30023;
      D.30022 = cfg->cbb;
      D.30022->last_ins = vtarg;
      goto <D.30223>;
      <D.30222>:
      D.30022 = cfg->cbb;
      D.30022 = cfg->cbb;
      D.30022->last_ins = vtarg;
      D.30023 = D.30022->last_ins;
      D.30022->code = D.30023;
      <D.30223>:
      sp_offset = sp_offset + 4;
      emit_gc_param_slot_def (cfg, sp_offset, 0B);
    }
    <D.30216>:
    <D.30214>:
    <D.30212>:
    <D.30196>:
    D.30035 = cinfo->ret.storage;
    if (D.30035 != 4) goto <D.30224>; else goto <D.30225>;
    <D.30224>:
    D.30226 = cinfo->stack_usage;
    D.30227 = D.30226 + 4294967292;
    cinfo->stack_usage = D.30227;
    <D.30225>:
  }
  <D.30189>:
  <D.30191>:
  D.30226 = cinfo->stack_usage;
  call->stack_usage = D.30226;
  D.30020 = cinfo->stack_align_amount;
  call->stack_align_amount = D.30020;
  D.30228 = cfg->arch.param_area_size;
  D.30229 = MAX_EXPR <D.30228, sp_offset>;
  cfg->arch.param_area_size = D.30229;
}


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

  D.30231 = __builtin_object_size (__dest, 0);
  D.30230 = __builtin___memcpy_chk (__dest, __src, __len, D.30231);
  return D.30230;
}


emit_sig_cookie (struct MonoCompile * cfg, struct MonoCallInst * call, struct CallInfo * cinfo)
{
  struct MonoMethodSignature * D.30233;
  short unsigned int D.30234;
  short int D.30235;
  short unsigned int D.30236;
  short unsigned int D.30237;
  unsigned int D.30238;
  unsigned int D.30239;
  sizetype D.30240;
  struct MonoType * * D.30241;
  struct MonoType *[0:] * D.30242;
  unsigned char D.30243;
  unsigned char D.30244;
  unsigned int D.30247;
  struct MonoMemPool * D.30248;
  int D.30249;
  struct MonoInst * D.30250;
  guint16 iftmp.60;
  int D.30255;
  int D.30256;
  const unsigned char * D.30257;
  int D.30260;
  struct MonoInst * D.30261;
  int D.30262;
  int D.30263;
  int D.30264;
  unsigned int D.30266;
  int D.30267;
  struct MonoBasicBlock * D.30268;
  struct MonoInst * D.30269;
  int D.30273;
  struct MonoInst * D.30274;
  int D.30275;
  int D.30276;
  int D.30281;
  struct MonoInst * D.30282;
  int D.30283;
  int D.30284;
  int tmp_sig.61;
  struct MonoMethodSignature * tmp_sig;
  int sig_reg;

  D.30233 = call->signature;
  tmp_sig = mono_metadata_signature_dup (D.30233);
  D.30234 = tmp_sig->param_count;
  D.30233 = call->signature;
  D.30235 = D.30233->sentinelpos;
  D.30236 = (short unsigned int) D.30235;
  D.30237 = D.30234 - D.30236;
  tmp_sig->param_count = D.30237;
  tmp_sig->sentinelpos = 0;
  D.30234 = tmp_sig->param_count;
  D.30238 = (unsigned int) D.30234;
  D.30239 = D.30238 * 4;
  D.30233 = call->signature;
  D.30233 = call->signature;
  D.30235 = D.30233->sentinelpos;
  D.30240 = (sizetype) D.30235;
  D.30241 = &D.30233->params[D.30240];
  D.30242 = &tmp_sig->params;
  memcpy (D.30242, D.30241, D.30239);
  D.30243 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.30244 = D.30243 & 64;
  if (D.30244 != 0) goto <D.30245>; else goto <D.30246>;
  <D.30245>:
  D.30247 = mono_alloc_ireg (cfg);
  sig_reg = (int) D.30247;
  {
    struct MonoInst * inst;

    D.30248 = cfg->mempool;
    inst = mono_mempool_alloc (D.30248, 48);
    inst->data.op[1].const_val = 0;
    D.30249 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30249;
    inst->prev = 0B;
    D.30250 = inst->prev;
    inst->next = D.30250;
    D.30243 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.30244 = D.30243 & 64;
    if (D.30244 != 0) goto <D.30252>; else goto <D.30253>;
    <D.30252>:
    iftmp.60 = 738;
    goto <D.30254>;
    <D.30253>:
    iftmp.60 = 362;
    <D.30254>:
    inst->opcode = iftmp.60;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30255 = inst->sreg3;
    inst->sreg2 = D.30255;
    D.30256 = inst->sreg2;
    inst->sreg1 = D.30256;
    D.30257 = cfg->ip;
    inst->cil_code = D.30257;
    D.30243 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.30244 = D.30243 & 64;
    if (D.30244 != 0) goto <D.30258>; else goto <D.30259>;
    <D.30258>:
    {
      struct MonoInst * group;
      struct MonoInst * got_loc;

      got_loc = mono_get_got_var (cfg);
      D.30248 = cfg->mempool;
      group = mono_mempool_alloc (D.30248, 48);
      group->data.op[1].const_val = 0;
      D.30260 = group->data.op[1].const_val;
      group->data.op[0].const_val = D.30260;
      group->prev = 0B;
      D.30261 = group->prev;
      group->next = D.30261;
      group->opcode = 737;
      group->flags = 0;
      group->type = 0;
      group->dreg = -1;
      group->sreg3 = -1;
      D.30262 = group->sreg3;
      group->sreg2 = D.30262;
      D.30263 = group->sreg2;
      group->sreg1 = D.30263;
      D.30257 = cfg->ip;
      group->cil_code = D.30257;
      group->data.op[0].src = tmp_sig;
      group->data.op[1].src = 44B;
      D.30264 = got_loc->dreg;
      inst->sreg1 = D.30264;
      inst->data.op[1].p = group;
    }
    goto <D.30265>;
    <D.30259>:
    inst->data.op[0].p = tmp_sig;
    inst->data.op[1].src = 44B;
    <D.30265>:
    inst->type = 3;
    D.30266 = alloc_dreg (cfg, 3);
    D.30267 = (int) D.30266;
    inst->dreg = D.30267;
    inst->dreg = sig_reg;
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    if (D.30269 != 0B) goto <D.30270>; else goto <D.30271>;
    <D.30270>:
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    D.30269->next = inst;
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    inst->prev = D.30269;
    D.30268 = cfg->cbb;
    D.30268->last_ins = inst;
    goto <D.30272>;
    <D.30271>:
    D.30268 = cfg->cbb;
    D.30268 = cfg->cbb;
    D.30268->last_ins = inst;
    D.30269 = D.30268->last_ins;
    D.30268->code = D.30269;
    <D.30272>:
  }
  {
    struct MonoInst * inst;

    D.30248 = cfg->mempool;
    inst = mono_mempool_alloc (D.30248, 48);
    inst->data.op[1].const_val = 0;
    D.30273 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30273;
    inst->prev = 0B;
    D.30274 = inst->prev;
    inst->next = D.30274;
    inst->opcode = 1034;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30275 = inst->sreg3;
    inst->sreg2 = D.30275;
    D.30276 = inst->sreg2;
    inst->sreg1 = D.30276;
    D.30257 = cfg->ip;
    inst->cil_code = D.30257;
    inst->dreg = -1;
    inst->sreg1 = sig_reg;
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    if (D.30269 != 0B) goto <D.30277>; else goto <D.30278>;
    <D.30277>:
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    D.30269->next = inst;
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    inst->prev = D.30269;
    D.30268 = cfg->cbb;
    D.30268->last_ins = inst;
    goto <D.30279>;
    <D.30278>:
    D.30268 = cfg->cbb;
    D.30268 = cfg->cbb;
    D.30268->last_ins = inst;
    D.30269 = D.30268->last_ins;
    D.30268->code = D.30269;
    <D.30279>:
  }
  goto <D.30280>;
  <D.30246>:
  {
    struct MonoInst * inst;

    D.30248 = cfg->mempool;
    inst = mono_mempool_alloc (D.30248, 48);
    inst->data.op[1].const_val = 0;
    D.30281 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30281;
    inst->prev = 0B;
    D.30282 = inst->prev;
    inst->next = D.30282;
    inst->opcode = 1033;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30283 = inst->sreg3;
    inst->sreg2 = D.30283;
    D.30284 = inst->sreg2;
    inst->sreg1 = D.30284;
    D.30257 = cfg->ip;
    inst->cil_code = D.30257;
    inst->dreg = -1;
    inst->sreg1 = -1;
    tmp_sig.61 = (int) tmp_sig;
    inst->data.op[1].const_val = tmp_sig.61;
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    if (D.30269 != 0B) goto <D.30286>; else goto <D.30287>;
    <D.30286>:
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    D.30269->next = inst;
    D.30268 = cfg->cbb;
    D.30269 = D.30268->last_ins;
    inst->prev = D.30269;
    D.30268 = cfg->cbb;
    D.30268->last_ins = inst;
    goto <D.30288>;
    <D.30287>:
    D.30268 = cfg->cbb;
    D.30268 = cfg->cbb;
    D.30268->last_ins = inst;
    D.30269 = D.30268->last_ins;
    D.30268->code = D.30269;
    <D.30288>:
  }
  <D.30280>:
}


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

  switch (stack_type) <default: <D.23638>, case 1: <D.23631>, case 2: <D.23636>, case 3: <D.23632>, case 4: <D.23635>, case 5: <D.23633>, case 6: <D.23634>, case 7: <D.23637>>
  <D.23631>:
  <D.23632>:
  D.30289 = alloc_ireg (cfg);
  return D.30289;
  <D.23633>:
  D.30289 = alloc_ireg_mp (cfg);
  return D.30289;
  <D.23634>:
  D.30289 = alloc_ireg_ref (cfg);
  return D.30289;
  <D.23635>:
  D.30289 = alloc_freg (cfg);
  return D.30289;
  <D.23636>:
  D.30289 = alloc_lreg (cfg);
  return D.30289;
  <D.23637>:
  D.30289 = alloc_ireg (cfg);
  return D.30289;
  <D.23638>:
  monoeg_g_log (0B, 16, "Unknown stack type %x\n", stack_type);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 97);
  D.30289 = 4294967295;
  return D.30289;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.30291;
  unsigned char D.30292;
  unsigned char D.30293;
  guint32 D.30296;
  int vreg;

  D.30291 = alloc_ireg (cfg);
  vreg = (int) D.30291;
  D.30292 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.30293 = D.30292 & 128;
  if (D.30293 != 0) goto <D.30294>; else goto <D.30295>;
  <D.30294>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.30295>:
  D.30296 = (guint32) vreg;
  return D.30296;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.30298;
  unsigned char D.30299;
  unsigned char D.30300;
  guint32 D.30303;
  int vreg;

  D.30298 = alloc_ireg (cfg);
  vreg = (int) D.30298;
  D.30299 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.30300 = D.30299 & 128;
  if (D.30300 != 0) goto <D.30301>; else goto <D.30302>;
  <D.30301>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.30302>:
  D.30303 = (guint32) vreg;
  return D.30303;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.30305;
  guint32 D.30308;
  unsigned int D.30309;
  unsigned int D.30310;
  unsigned int D.30311;

  D.30305 = mono_arch_is_soft_float ();
  if (D.30305 != 0) goto <D.30306>; else goto <D.30307>;
  <D.30306>:
  D.30308 = alloc_lreg (cfg);
  return D.30308;
  <D.30307>:
  D.30309 = cfg->next_vreg;
  D.30310 = D.30309;
  D.30311 = D.30310 + 1;
  cfg->next_vreg = D.30311;
  D.30308 = D.30310;
  return D.30308;
}


mono_arch_is_soft_float ()
{
  gboolean D.30313;

  D.30313 = 0;
  return D.30313;
}


alloc_lreg (struct MonoCompile * cfg)
{
  unsigned int D.30315;
  unsigned int D.30316;
  guint32 D.30317;
  guint32 res;

  res = cfg->next_vreg;
  D.30315 = cfg->next_vreg;
  D.30316 = D.30315 + 3;
  cfg->next_vreg = D.30316;
  D.30317 = res;
  return D.30317;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.30319;
  unsigned int D.30320;
  unsigned int D.30321;
  unsigned int D.30322;

  D.30320 = cfg->next_vreg;
  D.30321 = D.30320;
  D.30322 = D.30321 + 1;
  cfg->next_vreg = D.30322;
  D.30319 = D.30321;
  return D.30319;
}


emit_gc_param_slot_def (struct MonoCompile * cfg, int sp_offset, struct MonoType * t)
{
  unsigned char D.30324;
  unsigned char D.30325;
  struct MonoClass * D.30330;
  struct MonoMemPool * D.30331;
  int D.30332;
  struct MonoInst * D.30333;
  int D.30334;
  int D.30335;
  const unsigned char * D.30336;
  struct MonoBasicBlock * D.30337;
  struct MonoInst * D.30338;

  D.30324 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.30325 = D.30324 & 128;
  if (D.30325 != 0) goto <D.30326>; else goto <D.30327>;
  <D.30326>:
  {
    struct MonoInst * def;

    if (t == 0B) goto <D.30328>; else goto <D.30329>;
    <D.30328>:
    D.30330 = mono_defaults.int_class;
    t = &D.30330->byval_arg;
    <D.30329>:
    D.30331 = cfg->mempool;
    def = mono_mempool_alloc (D.30331, 48);
    def->data.op[1].const_val = 0;
    D.30332 = def->data.op[1].const_val;
    def->data.op[0].const_val = D.30332;
    def->prev = 0B;
    D.30333 = def->prev;
    def->next = D.30333;
    def->opcode = 1003;
    def->flags = 0;
    def->type = 0;
    def->dreg = -1;
    def->sreg3 = -1;
    D.30334 = def->sreg3;
    def->sreg2 = D.30334;
    D.30335 = def->sreg2;
    def->sreg1 = D.30335;
    D.30336 = cfg->ip;
    def->cil_code = D.30336;
    def->data.op[0].const_val = sp_offset;
    def->data.op[1].vtype = t;
    D.30337 = cfg->cbb;
    D.30338 = D.30337->last_ins;
    if (D.30338 != 0B) goto <D.30339>; else goto <D.30340>;
    <D.30339>:
    D.30337 = cfg->cbb;
    D.30338 = D.30337->last_ins;
    D.30338->next = def;
    D.30337 = cfg->cbb;
    D.30338 = D.30337->last_ins;
    def->prev = D.30338;
    D.30337 = cfg->cbb;
    D.30337->last_ins = def;
    goto <D.30341>;
    <D.30340>:
    D.30337 = cfg->cbb;
    D.30337 = cfg->cbb;
    D.30337->last_ins = def;
    D.30338 = D.30337->last_ins;
    D.30337->code = D.30338;
    <D.30341>:
  }
  <D.30327>:
}


mono_arch_emit_outarg_vt (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * src)
{
  <unnamed type> D.30342;
  unsigned int D.30345;
  struct MonoMemPool * D.30346;
  int D.30347;
  struct MonoInst * D.30348;
  int D.30349;
  int D.30350;
  const unsigned char * D.30351;
  int D.30352;
  struct MonoBasicBlock * D.30353;
  struct MonoInst * D.30354;
  int D.30358;
  struct MonoInst * D.30359;
  int D.30360;
  int D.30361;
  int D.30365;
  struct MonoInst * D.30366;
  int D.30367;
  int D.30368;
  signed char D.30372;
  int D.30373;
  int D.30377;
  struct MonoClass * D.30379;
  int D.30380;
  int D.30382;
  struct MonoInst * D.30383;
  int D.30384;
  int D.30385;
  int D.30397;
  struct MonoInst * D.30398;
  int D.30399;
  int D.30400;
  unsigned int size.62;
  unsigned int D.30402;
  int D.30403;
  int D.30404;
  struct MonoCallInst * call;
  struct ArgInfo * ainfo;
  struct MonoInst * arg;
  int size;

  call = ins->data.op[0].p;
  ainfo = ins->data.op[1].p;
  size = ins->backend.size;
  D.30342 = ainfo->storage;
  if (D.30342 == 4) goto <D.30343>; else goto <D.30344>;
  <D.30343>:
  {
    int dreg;

    D.30345 = mono_alloc_ireg (cfg);
    dreg = (int) D.30345;
    switch (size) <default: <D.24125>, case 1: <D.24117>, case 2: <D.24120>, case 3: <D.24124>, case 4: <D.24122>>
    <D.24117>:
    {
      struct MonoInst * inst;

      D.30346 = cfg->mempool;
      inst = mono_mempool_alloc (D.30346, 48);
      inst->data.op[1].const_val = 0;
      D.30347 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30347;
      inst->prev = 0B;
      D.30348 = inst->prev;
      inst->next = D.30348;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30349 = inst->sreg3;
      inst->sreg2 = D.30349;
      D.30350 = inst->sreg2;
      inst->sreg1 = D.30350;
      D.30351 = cfg->ip;
      inst->cil_code = D.30351;
      inst->dreg = dreg;
      D.30352 = src->dreg;
      inst->sreg1 = D.30352;
      inst->data.op[0].const_val = 0;
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      if (D.30354 != 0B) goto <D.30355>; else goto <D.30356>;
      <D.30355>:
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      D.30354->next = inst;
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      inst->prev = D.30354;
      D.30353 = cfg->cbb;
      D.30353->last_ins = inst;
      goto <D.30357>;
      <D.30356>:
      D.30353 = cfg->cbb;
      D.30353 = cfg->cbb;
      D.30353->last_ins = inst;
      D.30354 = D.30353->last_ins;
      D.30353->code = D.30354;
      <D.30357>:
    }
    goto <D.24119>;
    <D.24120>:
    {
      struct MonoInst * inst;

      D.30346 = cfg->mempool;
      inst = mono_mempool_alloc (D.30346, 48);
      inst->data.op[1].const_val = 0;
      D.30358 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30358;
      inst->prev = 0B;
      D.30359 = inst->prev;
      inst->next = D.30359;
      inst->opcode = 395;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30360 = inst->sreg3;
      inst->sreg2 = D.30360;
      D.30361 = inst->sreg2;
      inst->sreg1 = D.30361;
      D.30351 = cfg->ip;
      inst->cil_code = D.30351;
      inst->dreg = dreg;
      D.30352 = src->dreg;
      inst->sreg1 = D.30352;
      inst->data.op[0].const_val = 0;
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      if (D.30354 != 0B) goto <D.30362>; else goto <D.30363>;
      <D.30362>:
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      D.30354->next = inst;
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      inst->prev = D.30354;
      D.30353 = cfg->cbb;
      D.30353->last_ins = inst;
      goto <D.30364>;
      <D.30363>:
      D.30353 = cfg->cbb;
      D.30353 = cfg->cbb;
      D.30353->last_ins = inst;
      D.30354 = D.30353->last_ins;
      D.30353->code = D.30354;
      <D.30364>:
    }
    goto <D.24119>;
    <D.24122>:
    {
      struct MonoInst * inst;

      D.30346 = cfg->mempool;
      inst = mono_mempool_alloc (D.30346, 48);
      inst->data.op[1].const_val = 0;
      D.30365 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30365;
      inst->prev = 0B;
      D.30366 = inst->prev;
      inst->next = D.30366;
      inst->opcode = 391;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30367 = inst->sreg3;
      inst->sreg2 = D.30367;
      D.30368 = inst->sreg2;
      inst->sreg1 = D.30368;
      D.30351 = cfg->ip;
      inst->cil_code = D.30351;
      inst->dreg = dreg;
      D.30352 = src->dreg;
      inst->sreg1 = D.30352;
      inst->data.op[0].const_val = 0;
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      if (D.30354 != 0B) goto <D.30369>; else goto <D.30370>;
      <D.30369>:
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      D.30354->next = inst;
      D.30353 = cfg->cbb;
      D.30354 = D.30353->last_ins;
      inst->prev = D.30354;
      D.30353 = cfg->cbb;
      D.30353->last_ins = inst;
      goto <D.30371>;
      <D.30370>:
      D.30353 = cfg->cbb;
      D.30353 = cfg->cbb;
      D.30353->last_ins = inst;
      D.30354 = D.30353->last_ins;
      D.30353->code = D.30354;
      <D.30371>:
    }
    goto <D.24119>;
    <D.24124>:
    <D.24125>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 1660);
    <D.24119>:
    D.30372 = ainfo->reg;
    D.30373 = (int) D.30372;
    mono_call_inst_add_outarg_reg (cfg, call, dreg, D.30373, 0);
  }
  goto <D.30374>;
  <D.30344>:
  D.30377 = cfg->gsharedvt;
  if (D.30377 != 0) goto <D.30378>; else goto <D.30375>;
  <D.30378>:
  D.30379 = ins->klass;
  D.30380 = mini_is_gsharedvt_klass (cfg, D.30379);
  if (D.30380 != 0) goto <D.30381>; else goto <D.30375>;
  <D.30381>:
  D.30346 = cfg->mempool;
  arg = mono_mempool_alloc (D.30346, 48);
  arg->data.op[1].const_val = 0;
  D.30382 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30382;
  arg->prev = 0B;
  D.30383 = arg->prev;
  arg->next = D.30383;
  arg->opcode = 1034;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30384 = arg->sreg3;
  arg->sreg2 = D.30384;
  D.30385 = arg->sreg2;
  arg->sreg1 = D.30385;
  D.30351 = cfg->ip;
  arg->cil_code = D.30351;
  D.30352 = src->dreg;
  arg->sreg1 = D.30352;
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  if (D.30354 != 0B) goto <D.30386>; else goto <D.30387>;
  <D.30386>:
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  D.30354->next = arg;
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  arg->prev = D.30354;
  D.30353 = cfg->cbb;
  D.30353->last_ins = arg;
  goto <D.30388>;
  <D.30387>:
  D.30353 = cfg->cbb;
  D.30353 = cfg->cbb;
  D.30353->last_ins = arg;
  D.30354 = D.30353->last_ins;
  D.30353->code = D.30354;
  <D.30388>:
  goto <D.30376>;
  <D.30375>:
  if (size <= 4) goto <D.30389>; else goto <D.30390>;
  <D.30389>:
  D.30346 = cfg->mempool;
  arg = mono_mempool_alloc (D.30346, 48);
  arg->data.op[1].const_val = 0;
  D.30382 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30382;
  arg->prev = 0B;
  D.30383 = arg->prev;
  arg->next = D.30383;
  arg->opcode = 1032;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30384 = arg->sreg3;
  arg->sreg2 = D.30384;
  D.30385 = arg->sreg2;
  arg->sreg1 = D.30385;
  D.30351 = cfg->ip;
  arg->cil_code = D.30351;
  D.30352 = src->dreg;
  arg->sreg1 = D.30352;
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  if (D.30354 != 0B) goto <D.30391>; else goto <D.30392>;
  <D.30391>:
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  D.30354->next = arg;
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  arg->prev = D.30354;
  D.30353 = cfg->cbb;
  D.30353->last_ins = arg;
  goto <D.30393>;
  <D.30392>:
  D.30353 = cfg->cbb;
  D.30353 = cfg->cbb;
  D.30353->last_ins = arg;
  D.30354 = D.30353->last_ins;
  D.30353->code = D.30354;
  <D.30393>:
  goto <D.30394>;
  <D.30390>:
  if (size <= 20) goto <D.30395>; else goto <D.30396>;
  <D.30395>:
  {
    struct MonoInst * inst;

    D.30346 = cfg->mempool;
    inst = mono_mempool_alloc (D.30346, 48);
    inst->data.op[1].const_val = 0;
    D.30397 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30397;
    inst->prev = 0B;
    D.30398 = inst->prev;
    inst->next = D.30398;
    inst->opcode = 434;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30399 = inst->sreg3;
    inst->sreg2 = D.30399;
    D.30400 = inst->sreg2;
    inst->sreg1 = D.30400;
    D.30351 = cfg->ip;
    inst->cil_code = D.30351;
    inst->dreg = 4;
    inst->sreg1 = 4;
    size.62 = (unsigned int) size;
    D.30402 = size.62 + 3;
    D.30403 = (int) D.30402;
    D.30404 = D.30403 & -4;
    inst->data.op[1].const_val = D.30404;
    D.30353 = cfg->cbb;
    D.30354 = D.30353->last_ins;
    if (D.30354 != 0B) goto <D.30405>; else goto <D.30406>;
    <D.30405>:
    D.30353 = cfg->cbb;
    D.30354 = D.30353->last_ins;
    D.30354->next = inst;
    D.30353 = cfg->cbb;
    D.30354 = D.30353->last_ins;
    inst->prev = D.30354;
    D.30353 = cfg->cbb;
    D.30353->last_ins = inst;
    goto <D.30407>;
    <D.30406>:
    D.30353 = cfg->cbb;
    D.30353 = cfg->cbb;
    D.30353->last_ins = inst;
    D.30354 = D.30353->last_ins;
    D.30353->code = D.30354;
    <D.30407>:
  }
  D.30352 = src->dreg;
  mini_emit_memcpy (cfg, 4, 0, D.30352, 0, size, 4);
  goto <D.30408>;
  <D.30396>:
  D.30346 = cfg->mempool;
  arg = mono_mempool_alloc (D.30346, 48);
  arg->data.op[1].const_val = 0;
  D.30382 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30382;
  arg->prev = 0B;
  D.30383 = arg->prev;
  arg->next = D.30383;
  arg->opcode = 1035;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30384 = arg->sreg3;
  arg->sreg2 = D.30384;
  D.30385 = arg->sreg2;
  arg->sreg1 = D.30385;
  D.30351 = cfg->ip;
  arg->cil_code = D.30351;
  D.30352 = src->dreg;
  arg->sreg1 = D.30352;
  arg->data.op[0].const_val = 0;
  arg->data.op[1].const_val = size;
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  if (D.30354 != 0B) goto <D.30409>; else goto <D.30410>;
  <D.30409>:
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  D.30354->next = arg;
  D.30353 = cfg->cbb;
  D.30354 = D.30353->last_ins;
  arg->prev = D.30354;
  D.30353 = cfg->cbb;
  D.30353->last_ins = arg;
  goto <D.30411>;
  <D.30410>:
  D.30353 = cfg->cbb;
  D.30353 = cfg->cbb;
  D.30353->last_ins = arg;
  D.30354 = D.30353->last_ins;
  D.30353->code = D.30354;
  <D.30411>:
  <D.30408>:
  <D.30394>:
  <D.30376>:
  <D.30374>:
}


mono_arch_emit_setret (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoInst * val)
{
  struct MonoMethodSignature * D.30412;
  struct MonoType * D.30413;
  struct MonoGenericSharingContext * D.30414;
  unsigned char D.30415;
  unsigned char D.30416;
  unsigned char D.30419;
  struct MonoMemPool * D.30424;
  int D.30425;
  struct MonoInst * D.30426;
  int D.30427;
  int D.30428;
  const unsigned char * D.30429;
  struct MonoInst * D.30430;
  int D.30431;
  int D.30432;
  struct MonoBasicBlock * D.30433;
  struct MonoInst * D.30434;
  int D.30442;
  struct MonoInst * D.30443;
  int D.30444;
  int D.30445;
  unsigned char D.30449;
  int D.30454;
  struct MonoInst * D.30455;
  int D.30456;
  int D.30457;
  int D.30462;
  struct MonoInst * D.30463;
  int D.30464;
  int D.30465;
  int D.30466;
  int D.30470;
  struct MonoInst * D.30471;
  int D.30472;
  int D.30473;
  int D.30474;
  int D.30478;
  struct MonoInst * D.30479;
  int D.30480;
  int D.30481;
  struct MonoType * ret;

  D.30412 = mono_method_signature (method);
  D.30413 = D.30412->ret;
  D.30414 = cfg->generic_sharing_context;
  ret = mini_type_get_underlying_type (D.30414, D.30413);
  D.30415 = BIT_FIELD_REF <*ret, 8, 56>;
  D.30416 = D.30415 & 64;
  if (D.30416 == 0) goto <D.30417>; else goto <D.30418>;
  <D.30417>:
  D.30419 = ret->type;
  if (D.30419 == 12) goto <D.30420>; else goto <D.30421>;
  <D.30420>:
  if (0 != 0) goto <D.30422>; else goto <D.30423>;
  <D.30422>:
  {
    struct MonoInst * inst;

    D.30424 = cfg->mempool;
    inst = mono_mempool_alloc (D.30424, 48);
    inst->data.op[1].const_val = 0;
    D.30425 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30425;
    inst->prev = 0B;
    D.30426 = inst->prev;
    inst->next = D.30426;
    inst->opcode = 430;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30427 = inst->sreg3;
    inst->sreg2 = D.30427;
    D.30428 = inst->sreg2;
    inst->sreg1 = D.30428;
    D.30429 = cfg->ip;
    inst->cil_code = D.30429;
    D.30430 = cfg->ret;
    D.30431 = D.30430->dreg;
    inst->dreg = D.30431;
    D.30432 = val->dreg;
    inst->sreg1 = D.30432;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    if (D.30434 != 0B) goto <D.30435>; else goto <D.30436>;
    <D.30435>:
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    D.30434->next = inst;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    inst->prev = D.30434;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    goto <D.30437>;
    <D.30436>:
    D.30433 = cfg->cbb;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    D.30434 = D.30433->last_ins;
    D.30433->code = D.30434;
    <D.30437>:
  }
  <D.30423>:
  return;
  <D.30421>:
  D.30419 = ret->type;
  if (D.30419 == 13) goto <D.30438>; else goto <D.30439>;
  <D.30438>:
  if (0 != 0) goto <D.30440>; else goto <D.30441>;
  <D.30440>:
  {
    struct MonoInst * inst;

    D.30424 = cfg->mempool;
    inst = mono_mempool_alloc (D.30424, 48);
    inst->data.op[1].const_val = 0;
    D.30442 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30442;
    inst->prev = 0B;
    D.30443 = inst->prev;
    inst->next = D.30443;
    inst->opcode = 430;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30444 = inst->sreg3;
    inst->sreg2 = D.30444;
    D.30445 = inst->sreg2;
    inst->sreg1 = D.30445;
    D.30429 = cfg->ip;
    inst->cil_code = D.30429;
    D.30430 = cfg->ret;
    D.30431 = D.30430->dreg;
    inst->dreg = D.30431;
    D.30432 = val->dreg;
    inst->sreg1 = D.30432;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    if (D.30434 != 0B) goto <D.30446>; else goto <D.30447>;
    <D.30446>:
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    D.30434->next = inst;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    inst->prev = D.30434;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    goto <D.30448>;
    <D.30447>:
    D.30433 = cfg->cbb;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    D.30434 = D.30433->last_ins;
    D.30433->code = D.30434;
    <D.30448>:
  }
  <D.30441>:
  return;
  <D.30439>:
  D.30419 = ret->type;
  D.30449 = D.30419 + 246;
  if (D.30449 <= 1) goto <D.30450>; else goto <D.30451>;
  <D.30450>:
  if (0 != 0) goto <D.30452>; else goto <D.30453>;
  <D.30452>:
  {
    struct MonoInst * inst;

    D.30424 = cfg->mempool;
    inst = mono_mempool_alloc (D.30424, 48);
    inst->data.op[1].const_val = 0;
    D.30454 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30454;
    inst->prev = 0B;
    D.30455 = inst->prev;
    inst->next = D.30455;
    inst->opcode = 429;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30456 = inst->sreg3;
    inst->sreg2 = D.30456;
    D.30457 = inst->sreg2;
    inst->sreg1 = D.30457;
    D.30429 = cfg->ip;
    inst->cil_code = D.30429;
    D.30430 = cfg->ret;
    D.30431 = D.30430->dreg;
    inst->dreg = D.30431;
    D.30432 = val->dreg;
    inst->sreg1 = D.30432;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    if (D.30434 != 0B) goto <D.30458>; else goto <D.30459>;
    <D.30458>:
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    D.30434->next = inst;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    inst->prev = D.30434;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    goto <D.30460>;
    <D.30459>:
    D.30433 = cfg->cbb;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    D.30434 = D.30433->last_ins;
    D.30433->code = D.30434;
    <D.30460>:
  }
  goto <D.30461>;
  <D.30453>:
  {
    struct MonoInst * inst;

    D.30424 = cfg->mempool;
    inst = mono_mempool_alloc (D.30424, 48);
    inst->data.op[1].const_val = 0;
    D.30462 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30462;
    inst->prev = 0B;
    D.30463 = inst->prev;
    inst->next = D.30463;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30464 = inst->sreg3;
    inst->sreg2 = D.30464;
    D.30465 = inst->sreg2;
    inst->sreg1 = D.30465;
    D.30429 = cfg->ip;
    inst->cil_code = D.30429;
    inst->dreg = 0;
    D.30432 = val->dreg;
    D.30466 = D.30432 + 1;
    inst->sreg1 = D.30466;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    if (D.30434 != 0B) goto <D.30467>; else goto <D.30468>;
    <D.30467>:
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    D.30434->next = inst;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    inst->prev = D.30434;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    goto <D.30469>;
    <D.30468>:
    D.30433 = cfg->cbb;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    D.30434 = D.30433->last_ins;
    D.30433->code = D.30434;
    <D.30469>:
  }
  {
    struct MonoInst * inst;

    D.30424 = cfg->mempool;
    inst = mono_mempool_alloc (D.30424, 48);
    inst->data.op[1].const_val = 0;
    D.30470 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30470;
    inst->prev = 0B;
    D.30471 = inst->prev;
    inst->next = D.30471;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30472 = inst->sreg3;
    inst->sreg2 = D.30472;
    D.30473 = inst->sreg2;
    inst->sreg1 = D.30473;
    D.30429 = cfg->ip;
    inst->cil_code = D.30429;
    inst->dreg = 2;
    D.30432 = val->dreg;
    D.30474 = D.30432 + 2;
    inst->sreg1 = D.30474;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    if (D.30434 != 0B) goto <D.30475>; else goto <D.30476>;
    <D.30475>:
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    D.30434->next = inst;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    inst->prev = D.30434;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    goto <D.30477>;
    <D.30476>:
    D.30433 = cfg->cbb;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    D.30434 = D.30433->last_ins;
    D.30433->code = D.30434;
    <D.30477>:
  }
  <D.30461>:
  return;
  <D.30451>:
  <D.30418>:
  {
    struct MonoInst * inst;

    D.30424 = cfg->mempool;
    inst = mono_mempool_alloc (D.30424, 48);
    inst->data.op[1].const_val = 0;
    D.30478 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30478;
    inst->prev = 0B;
    D.30479 = inst->prev;
    inst->next = D.30479;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30480 = inst->sreg3;
    inst->sreg2 = D.30480;
    D.30481 = inst->sreg2;
    inst->sreg1 = D.30481;
    D.30429 = cfg->ip;
    inst->cil_code = D.30429;
    D.30430 = cfg->ret;
    D.30431 = D.30430->dreg;
    inst->dreg = D.30431;
    D.30432 = val->dreg;
    inst->sreg1 = D.30432;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    if (D.30434 != 0B) goto <D.30482>; else goto <D.30483>;
    <D.30482>:
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    D.30434->next = inst;
    D.30433 = cfg->cbb;
    D.30434 = D.30433->last_ins;
    inst->prev = D.30434;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    goto <D.30484>;
    <D.30483>:
    D.30433 = cfg->cbb;
    D.30433 = cfg->cbb;
    D.30433->last_ins = inst;
    D.30434 = D.30433->last_ins;
    D.30433->code = D.30434;
    <D.30484>:
  }
}


mono_arch_instrument_prolog (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments)
{
  guchar * code.63;
  guchar * code.64;
  unsigned char D.30492;
  guchar * code.65;
  unsigned char D.30494;
  guchar * code.66;
  unsigned char D.30496;
  guchar * code.67;
  unsigned char D.30498;
  guchar * code.68;
  guchar * code.69;
  guchar * code.70;
  guchar * code.71;
  guchar * code.72;
  unsigned char D.30507;
  guchar * code.73;
  unsigned char D.30509;
  guchar * code.74;
  unsigned char D.30511;
  guchar * code.75;
  unsigned char D.30513;
  guchar * code.76;
  unsigned char D.30515;
  unsigned char D.30516;
  struct MonoMethod * D.30519;
  unsigned int _imm.77;
  unsigned int D.30521;
  guchar * code.78;
  unsigned char D.30525;
  guchar * code.79;
  guchar * code.80;
  unsigned char D.30529;
  guchar * code.81;
  unsigned char D.30531;
  guchar * code.82;
  unsigned char D.30533;
  guchar * code.83;
  unsigned char D.30535;
  guchar * code.84;
  int func.85;
  guchar * code.86;
  unsigned char D.30539;
  guchar * code.87;
  unsigned char D.30541;
  guchar * code.88;
  unsigned char D.30543;
  guchar * code.89;
  unsigned char D.30545;
  guchar * code.90;
  guchar * code.91;
  int code.92;
  unsigned char * D.30550;
  int D.30551;
  int D.30552;
  unsigned int _imm.93;
  unsigned int D.30554;
  guchar * code.94;
  unsigned char D.30558;
  guchar * code.95;
  guchar * code.96;
  unsigned char D.30562;
  guchar * code.97;
  unsigned char D.30564;
  guchar * code.98;
  unsigned char D.30566;
  guchar * code.99;
  unsigned char D.30568;
  int code.100;
  guchar * code.101;
  guchar * code.102;
  unsigned char D.30572;
  guchar * code.103;
  unsigned char D.30574;
  guchar * code.104;
  unsigned char D.30576;
  guchar * code.105;
  unsigned char D.30578;
  guchar * code.106;
  guchar * code.107;
  unsigned char D.30583;
  guchar * code.108;
  unsigned char D.30585;
  guchar * code.109;
  unsigned char D.30587;
  guchar * code.110;
  unsigned char D.30589;
  guchar * code.111;
  guchar * code.112;
  guchar * code.113;
  guchar * code.114;
  guchar * code.115;
  unsigned char D.30598;
  guchar * code.116;
  unsigned char D.30600;
  guchar * code.117;
  unsigned char D.30602;
  guchar * code.118;
  unsigned char D.30604;
  void * D.30605;
  guchar * code;

  code = p;
  if (0 != 0) goto <D.30486>; else goto <D.30487>;
  <D.30486>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 1727, "MONO_ARCH_FRAME_ALIGNMENT >= 8");
  <D.30487>:
  if (0 != 0) goto <D.30488>; else goto <D.30489>;
  <D.30488>:
  code.63 = code;
  code = code.63 + 1;
  *code.63 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.64 = code;
        code = code.64 + 1;
        D.30492 = imb.b[0];
        *code.64 = D.30492;
        code.65 = code;
        code = code.65 + 1;
        D.30494 = imb.b[1];
        *code.65 = D.30494;
        code.66 = code;
        code = code.66 + 1;
        D.30496 = imb.b[2];
        *code.66 = D.30496;
        code.67 = code;
        code = code.67 + 1;
        D.30498 = imb.b[3];
        *code.67 = D.30498;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24147>;
  <D.30489>:
  if (1 != 0) goto <D.30499>; else goto <D.30500>;
  <D.30499>:
  code.68 = code;
  code = code.68 + 1;
  *code.68 = 131;
  code.69 = code;
  code = code.69 + 1;
  *code.69 = 236;
  *code = 8;
  code = code + 1;
  goto <D.30503>;
  <D.30500>:
  code.70 = code;
  code = code.70 + 1;
  *code.70 = 129;
  code.71 = code;
  code = code.71 + 1;
  *code.71 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.72 = code;
        code = code.72 + 1;
        D.30507 = imb.b[0];
        *code.72 = D.30507;
        code.73 = code;
        code = code.73 + 1;
        D.30509 = imb.b[1];
        *code.73 = D.30509;
        code.74 = code;
        code = code.74 + 1;
        D.30511 = imb.b[2];
        *code.74 = D.30511;
        code.75 = code;
        code = code.75 + 1;
        D.30513 = imb.b[3];
        *code.75 = D.30513;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30503>:
  <D.24147>:
  code.76 = code;
  code = code.76 + 1;
  *code.76 = 85;
  D.30515 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.30516 = D.30515 & 64;
  if (D.30516 != 0) goto <D.30517>; else goto <D.30518>;
  <D.30517>:
  {
    int _imm;

    D.30519 = cfg->method;
    _imm = (int) D.30519;
    _imm.77 = (unsigned int) _imm;
    D.30521 = _imm.77 + 128;
    if (D.30521 <= 255) goto <D.30522>; else goto <D.30523>;
    <D.30522>:
    code.78 = code;
    code = code.78 + 1;
    *code.78 = 106;
    D.30525 = (unsigned char) _imm;
    *code = D.30525;
    code = code + 1;
    goto <D.30526>;
    <D.30523>:
    code.79 = code;
    code = code.79 + 1;
    *code.79 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.80 = code;
          code = code.80 + 1;
          D.30529 = imb.b[0];
          *code.80 = D.30529;
          code.81 = code;
          code = code.81 + 1;
          D.30531 = imb.b[1];
          *code.81 = D.30531;
          code.82 = code;
          code = code.82 + 1;
          D.30533 = imb.b[2];
          *code.82 = D.30533;
          code.83 = code;
          code = code.83 + 1;
          D.30535 = imb.b[3];
          *code.83 = D.30535;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.30526>:
  }
  code.84 = code;
  code = code.84 + 1;
  *code.84 = 184;
  {
    union x86_imm_buf imb;

    try
      {
        func.85 = (int) func;
        imb.val = func.85;
        code.86 = code;
        code = code.86 + 1;
        D.30539 = imb.b[0];
        *code.86 = D.30539;
        code.87 = code;
        code = code.87 + 1;
        D.30541 = imb.b[1];
        *code.87 = D.30541;
        code.88 = code;
        code = code.88 + 1;
        D.30543 = imb.b[2];
        *code.88 = D.30543;
        code.89 = code;
        code = code.89 + 1;
        D.30545 = imb.b[3];
        *code.89 = D.30545;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  code.90 = code;
  code = code.90 + 1;
  *code.90 = 255;
  code.91 = code;
  code = code.91 + 1;
  *code.91 = 208;
  goto <D.30548>;
  <D.30518>:
  D.30519 = cfg->method;
  code.92 = (int) code;
  D.30550 = cfg->native_code;
  D.30551 = (int) D.30550;
  D.30552 = code.92 - D.30551;
  mono_add_patch_info (cfg, D.30552, 6, D.30519);
  {
    int _imm;

    D.30519 = cfg->method;
    _imm = (int) D.30519;
    _imm.93 = (unsigned int) _imm;
    D.30554 = _imm.93 + 128;
    if (D.30554 <= 255) goto <D.30555>; else goto <D.30556>;
    <D.30555>:
    code.94 = code;
    code = code.94 + 1;
    *code.94 = 106;
    D.30558 = (unsigned char) _imm;
    *code = D.30558;
    code = code + 1;
    goto <D.30559>;
    <D.30556>:
    code.95 = code;
    code = code.95 + 1;
    *code.95 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.96 = code;
          code = code.96 + 1;
          D.30562 = imb.b[0];
          *code.96 = D.30562;
          code.97 = code;
          code = code.97 + 1;
          D.30564 = imb.b[1];
          *code.97 = D.30564;
          code.98 = code;
          code = code.98 + 1;
          D.30566 = imb.b[2];
          *code.98 = D.30566;
          code.99 = code;
          code = code.99 + 1;
          D.30568 = imb.b[3];
          *code.99 = D.30568;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.30559>:
  }
  code.92 = (int) code;
  D.30550 = cfg->native_code;
  D.30551 = (int) D.30550;
  D.30552 = code.92 - D.30551;
  mono_add_patch_info (cfg, D.30552, 1, func);
  {
    int _x86_offset;

    code.100 = (int) code;
    _x86_offset = -code.100;
    _x86_offset = _x86_offset + -5;
    code.101 = code;
    code = code.101 + 1;
    *code.101 = 232;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _x86_offset;
          code.102 = code;
          code = code.102 + 1;
          D.30572 = imb.b[0];
          *code.102 = D.30572;
          code.103 = code;
          code = code.103 + 1;
          D.30574 = imb.b[1];
          *code.103 = D.30574;
          code.104 = code;
          code = code.104 + 1;
          D.30576 = imb.b[2];
          *code.104 = D.30576;
          code.105 = code;
          code = code.105 + 1;
          D.30578 = imb.b[3];
          *code.105 = D.30578;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
  <D.30548>:
  if (0 != 0) goto <D.30579>; else goto <D.30580>;
  <D.30579>:
  code.106 = code;
  code = code.106 + 1;
  *code.106 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16;
        code.107 = code;
        code = code.107 + 1;
        D.30583 = imb.b[0];
        *code.107 = D.30583;
        code.108 = code;
        code = code.108 + 1;
        D.30585 = imb.b[1];
        *code.108 = D.30585;
        code.109 = code;
        code = code.109 + 1;
        D.30587 = imb.b[2];
        *code.109 = D.30587;
        code.110 = code;
        code = code.110 + 1;
        D.30589 = imb.b[3];
        *code.110 = D.30589;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24157>;
  <D.30580>:
  if (1 != 0) goto <D.30590>; else goto <D.30591>;
  <D.30590>:
  code.111 = code;
  code = code.111 + 1;
  *code.111 = 131;
  code.112 = code;
  code = code.112 + 1;
  *code.112 = 196;
  *code = 16;
  code = code + 1;
  goto <D.30594>;
  <D.30591>:
  code.113 = code;
  code = code.113 + 1;
  *code.113 = 129;
  code.114 = code;
  code = code.114 + 1;
  *code.114 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16;
        code.115 = code;
        code = code.115 + 1;
        D.30598 = imb.b[0];
        *code.115 = D.30598;
        code.116 = code;
        code = code.116 + 1;
        D.30600 = imb.b[1];
        *code.116 = D.30600;
        code.117 = code;
        code = code.117 + 1;
        D.30602 = imb.b[2];
        *code.117 = D.30602;
        code.118 = code;
        code = code.118 + 1;
        D.30604 = imb.b[3];
        *code.118 = D.30604;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30594>:
  <D.24157>:
  D.30605 = code;
  return D.30605;
}


mono_arch_instrument_epilog_full (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments, gboolean preserve_argument_registers)
{
  struct MonoMethodSignature * D.30607;
  struct MonoType * D.30608;
  struct MonoGenericSharingContext * D.30609;
  unsigned char D.30610;
  int D.30611;
  int D.24187;
  int iftmp.119;
  int D.24183;
  const char[6] * D.30617;
  unsigned char D.30618;
  int D.30619;
  unsigned char D.30620;
  int D.30621;
  _Bool D.30622;
  _Bool D.30623;
  _Bool D.30624;
  const unsigned char * D.30627;
  unsigned char D.30628;
  int D.30629;
  const unsigned char * D.30630;
  unsigned char D.30631;
  int D.30632;
  _Bool D.30633;
  _Bool D.30634;
  const unsigned char * D.30637;
  unsigned char D.30638;
  int D.30639;
  const unsigned char * D.30640;
  unsigned char D.30641;
  int D.30642;
  _Bool D.30643;
  _Bool D.30644;
  const unsigned char * D.30647;
  unsigned char D.30648;
  int D.30649;
  const unsigned char * D.30650;
  unsigned char D.30651;
  int D.30652;
  const char * D.30654;
  struct MonoClass * D.30656;
  struct MonoClass * D.30657;
  int iftmp.120;
  int iftmp.121;
  int iftmp.122;
  int D.30671;
  int iftmp.123;
  int iftmp.124;
  int iftmp.125;
  guchar * code.126;
  int D.30689;
  guchar * code.127;
  unsigned char D.30691;
  guchar * code.128;
  unsigned char D.30693;
  guchar * code.129;
  unsigned char D.30695;
  guchar * code.130;
  unsigned char D.30697;
  unsigned int stack_usage.131;
  unsigned int D.30699;
  guchar * code.132;
  guchar * code.133;
  unsigned char D.30704;
  unsigned char D.30705;
  guchar * code.134;
  guchar * code.135;
  guchar * code.136;
  unsigned char D.30710;
  guchar * code.137;
  unsigned char D.30712;
  guchar * code.138;
  unsigned char D.30714;
  guchar * code.139;
  unsigned char D.30716;
  guchar * code.140;
  guchar * code.141;
  guchar * code.142;
  guchar * code.143;
  guchar * code.144;
  guchar * code.145;
  guchar * code.146;
  guchar * code.147;
  unsigned char D.30731;
  guchar * code.148;
  unsigned char D.30733;
  guchar * code.149;
  unsigned char D.30735;
  guchar * code.150;
  unsigned char D.30737;
  guchar * code.151;
  guchar * code.152;
  guchar * code.153;
  guchar * code.154;
  guchar * code.155;
  unsigned char D.30746;
  guchar * code.156;
  unsigned char D.30748;
  guchar * code.157;
  unsigned char D.30750;
  guchar * code.158;
  unsigned char D.30752;
  guchar * code.159;
  guchar * code.160;
  guchar * code.161;
  guchar * code.162;
  guchar * code.163;
  guchar * code.164;
  guchar * code.165;
  guchar * code.166;
  unsigned char D.30769;
  guchar * code.167;
  unsigned char D.30771;
  guchar * code.168;
  unsigned char D.30773;
  guchar * code.169;
  unsigned char D.30775;
  guchar * code.170;
  guchar * code.171;
  guchar * code.172;
  guchar * code.173;
  unsigned char D.30785;
  guchar * code.174;
  unsigned char D.30787;
  guchar * code.175;
  unsigned char D.30789;
  guchar * code.176;
  unsigned char D.30791;
  guchar * code.177;
  guchar * code.178;
  unsigned char D.30798;
  guchar * code.179;
  unsigned char D.30800;
  guchar * code.180;
  unsigned char D.30802;
  guchar * code.181;
  unsigned char D.30804;
  guchar * code.182;
  guchar * code.183;
  guchar * code.184;
  guchar * code.185;
  guchar * code.186;
  unsigned char D.30813;
  guchar * code.187;
  unsigned char D.30815;
  guchar * code.188;
  unsigned char D.30817;
  guchar * code.189;
  unsigned char D.30819;
  guchar * code.190;
  guchar * code.191;
  guchar * code.192;
  guchar * code.193;
  guchar * code.194;
  guchar * code.195;
  guchar * code.196;
  guchar * code.197;
  unsigned char D.30836;
  guchar * code.198;
  unsigned char D.30838;
  guchar * code.199;
  unsigned char D.30840;
  guchar * code.200;
  unsigned char D.30842;
  guchar * code.201;
  guchar * code.202;
  guchar * code.203;
  guchar * code.204;
  unsigned char D.30852;
  guchar * code.205;
  unsigned char D.30854;
  guchar * code.206;
  unsigned char D.30856;
  guchar * code.207;
  unsigned char D.30858;
  guchar * code.208;
  guchar * code.209;
  guchar * code.210;
  guchar * code.211;
  guchar * code.212;
  guchar * code.213;
  guchar * code.214;
  guchar * code.215;
  unsigned char D.30877;
  guchar * code.216;
  unsigned char D.30879;
  guchar * code.217;
  unsigned char D.30881;
  guchar * code.218;
  unsigned char D.30883;
  guchar * code.219;
  guchar * code.220;
  guchar * code.221;
  guchar * code.222;
  unsigned char D.30893;
  guchar * code.223;
  unsigned char D.30895;
  guchar * code.224;
  unsigned char D.30897;
  guchar * code.225;
  unsigned char D.30899;
  unsigned char D.30900;
  unsigned char D.30901;
  unsigned int _imm.226;
  unsigned int D.30905;
  guchar * code.227;
  unsigned char D.30909;
  guchar * code.228;
  guchar * code.229;
  unsigned char D.30913;
  guchar * code.230;
  unsigned char D.30915;
  guchar * code.231;
  unsigned char D.30917;
  guchar * code.232;
  unsigned char D.30919;
  guchar * code.233;
  int func.234;
  guchar * code.235;
  unsigned char D.30923;
  guchar * code.236;
  unsigned char D.30925;
  guchar * code.237;
  unsigned char D.30927;
  guchar * code.238;
  unsigned char D.30929;
  guchar * code.239;
  guchar * code.240;
  int code.241;
  unsigned char * D.30934;
  int D.30935;
  int D.30936;
  unsigned int _imm.242;
  unsigned int D.30938;
  guchar * code.243;
  unsigned char D.30942;
  guchar * code.244;
  guchar * code.245;
  unsigned char D.30946;
  guchar * code.246;
  unsigned char D.30948;
  guchar * code.247;
  unsigned char D.30950;
  guchar * code.248;
  unsigned char D.30952;
  int code.249;
  guchar * code.250;
  guchar * code.251;
  unsigned char D.30956;
  guchar * code.252;
  unsigned char D.30958;
  guchar * code.253;
  unsigned char D.30960;
  guchar * code.254;
  unsigned char D.30962;
  guchar * code.255;
  int D.30966;
  guchar * code.256;
  unsigned char D.30968;
  guchar * code.257;
  unsigned char D.30970;
  guchar * code.258;
  unsigned char D.30972;
  guchar * code.259;
  unsigned char D.30974;
  unsigned int arg_size.260;
  unsigned int D.30976;
  guchar * code.261;
  guchar * code.262;
  unsigned char D.30981;
  unsigned char D.30982;
  guchar * code.263;
  guchar * code.264;
  guchar * code.265;
  unsigned char D.30987;
  guchar * code.266;
  unsigned char D.30989;
  guchar * code.267;
  unsigned char D.30991;
  guchar * code.268;
  unsigned char D.30993;
  guchar * code.269;
  guchar * code.270;
  guchar * code.271;
  guchar * code.272;
  guchar * code.273;
  guchar * code.274;
  guchar * code.275;
  guchar * code.276;
  guchar * code.277;
  guchar * code.278;
  guchar * code.279;
  unsigned char D.31013;
  guchar * code.280;
  unsigned char D.31015;
  guchar * code.281;
  unsigned char D.31017;
  guchar * code.282;
  unsigned char D.31019;
  guchar * code.283;
  guchar * code.284;
  guchar * code.285;
  guchar * code.286;
  unsigned char D.31029;
  guchar * code.287;
  unsigned char D.31031;
  guchar * code.288;
  unsigned char D.31033;
  guchar * code.289;
  unsigned char D.31035;
  guchar * code.290;
  guchar * code.291;
  unsigned char D.31040;
  guchar * code.292;
  unsigned char D.31042;
  guchar * code.293;
  unsigned char D.31044;
  guchar * code.294;
  unsigned char D.31046;
  guchar * code.295;
  guchar * code.296;
  guchar * code.297;
  guchar * code.298;
  guchar * code.299;
  unsigned char D.31055;
  guchar * code.300;
  unsigned char D.31057;
  guchar * code.301;
  unsigned char D.31059;
  guchar * code.302;
  unsigned char D.31061;
  guchar * code.303;
  int D.31065;
  guchar * code.304;
  unsigned char D.31067;
  guchar * code.305;
  unsigned char D.31069;
  guchar * code.306;
  unsigned char D.31071;
  guchar * code.307;
  unsigned char D.31073;
  unsigned int D.31074;
  guchar * code.308;
  guchar * code.309;
  unsigned char D.31079;
  guchar * code.310;
  guchar * code.311;
  guchar * code.312;
  unsigned char D.31084;
  guchar * code.313;
  unsigned char D.31086;
  guchar * code.314;
  unsigned char D.31088;
  guchar * code.315;
  unsigned char D.31090;
  void * D.31091;
  guchar * code;
  int arg_size;
  int stack_usage;
  int save_mode;
  struct MonoMethod * method;
  struct MonoType * ret_type;

  code = p;
  arg_size = 0;
  stack_usage = 0;
  save_mode = 0;
  method = cfg->method;
  D.30607 = mono_method_signature (method);
  D.30608 = D.30607->ret;
  D.30609 = cfg->generic_sharing_context;
  ret_type = mini_type_get_underlying_type (D.30609, D.30608);
  D.30610 = ret_type->type;
  D.30611 = (int) D.30610;
  switch (D.30611) <default: <D.24195>, case 1: <D.24178>, case 10: <D.24189>, case 11: <D.24190>, case 12: <D.24191>, case 13: <D.24192>, case 17: <D.24194>, case 21: <D.24193>>
  <D.24178>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.30617 = ".ctor";
      D.30618 = MEM[(const unsigned char *)D.30617];
      D.30619 = (int) D.30618;
      D.30620 = *__s2;
      D.30621 = (int) D.30620;
      __result = D.30619 - D.30621;
      {
        D.30622 = __s1_len != 0;
        D.30623 = __result == 0;
        D.30624 = D.30622 & D.30623;
        if (D.30624 != 0) goto <D.30625>; else goto <D.30626>;
        <D.30625>:
        D.30627 = &MEM[(void *)".ctor" + 1B];
        D.30628 = *D.30627;
        D.30629 = (int) D.30628;
        D.30630 = __s2 + 1;
        D.30631 = *D.30630;
        D.30632 = (int) D.30631;
        __result = D.30629 - D.30632;
        D.30633 = __s1_len > 1;
        D.30623 = __result == 0;
        D.30634 = D.30633 & D.30623;
        if (D.30634 != 0) goto <D.30635>; else goto <D.30636>;
        <D.30635>:
        D.30637 = &MEM[(void *)".ctor" + 2B];
        D.30638 = *D.30637;
        D.30639 = (int) D.30638;
        D.30640 = __s2 + 2;
        D.30641 = *D.30640;
        D.30642 = (int) D.30641;
        __result = D.30639 - D.30642;
        D.30643 = __s1_len > 2;
        D.30623 = __result == 0;
        D.30644 = D.30643 & D.30623;
        if (D.30644 != 0) goto <D.30645>; else goto <D.30646>;
        <D.30645>:
        D.30647 = &MEM[(void *)".ctor" + 3B];
        D.30648 = *D.30647;
        D.30649 = (int) D.30648;
        D.30650 = __s2 + 3;
        D.30651 = *D.30650;
        D.30652 = (int) D.30651;
        __result = D.30649 - D.30652;
        <D.30646>:
        <D.30636>:
        <D.30626>:
      }
      D.24183 = __result;
    }
    iftmp.119 = D.24183;
    goto <D.30653>;
    <D.30616>:
    D.30654 = method->name;
    iftmp.119 = __builtin_strcmp (".ctor", D.30654);
    <D.30653>:
    D.24187 = iftmp.119;
  }
  if (D.24187 != 0) goto <D.30655>; else goto <D.30612>;
  <D.30655>:
  D.30656 = method->klass;
  D.30657 = mono_defaults.string_class;
  if (D.30656 == D.30657) goto <D.30658>; else goto <D.30612>;
  <D.30658>:
  save_mode = 2;
  if (enable_arguments != 0) goto <D.30660>; else goto <D.30661>;
  <D.30660>:
  iftmp.120 = 8;
  goto <D.30662>;
  <D.30661>:
  iftmp.120 = 4;
  <D.30662>:
  stack_usage = iftmp.120;
  goto <D.30613>;
  <D.30612>:
  save_mode = 0;
  <D.30613>:
  goto <D.24188>;
  <D.24189>:
  <D.24190>:
  save_mode = 3;
  if (enable_arguments != 0) goto <D.30664>; else goto <D.30665>;
  <D.30664>:
  iftmp.121 = 16;
  goto <D.30666>;
  <D.30665>:
  iftmp.121 = 8;
  <D.30666>:
  stack_usage = iftmp.121;
  goto <D.24188>;
  <D.24191>:
  <D.24192>:
  save_mode = 4;
  if (enable_arguments != 0) goto <D.30668>; else goto <D.30669>;
  <D.30668>:
  iftmp.122 = 16;
  goto <D.30670>;
  <D.30669>:
  iftmp.122 = 8;
  <D.30670>:
  stack_usage = iftmp.122;
  goto <D.24188>;
  <D.24193>:
  D.30671 = mono_type_generic_inst_is_valuetype (ret_type);
  if (D.30671 == 0) goto <D.30672>; else goto <D.30673>;
  <D.30672>:
  save_mode = 2;
  if (enable_arguments != 0) goto <D.30675>; else goto <D.30676>;
  <D.30675>:
  iftmp.123 = 8;
  goto <D.30677>;
  <D.30676>:
  iftmp.123 = 4;
  <D.30677>:
  stack_usage = iftmp.123;
  goto <D.24188>;
  <D.30673>:
  <D.24194>:
  save_mode = 1;
  if (enable_arguments != 0) goto <D.30679>; else goto <D.30680>;
  <D.30679>:
  iftmp.124 = 4;
  goto <D.30681>;
  <D.30680>:
  iftmp.124 = 0;
  <D.30681>:
  stack_usage = iftmp.124;
  goto <D.24188>;
  <D.24195>:
  save_mode = 2;
  if (enable_arguments != 0) goto <D.30683>; else goto <D.30684>;
  <D.30683>:
  iftmp.125 = 8;
  goto <D.30685>;
  <D.30684>:
  iftmp.125 = 4;
  <D.30685>:
  stack_usage = iftmp.125;
  goto <D.24188>;
  <D.24188>:
  if (0 != 0) goto <D.30686>; else goto <D.30687>;
  <D.30686>:
  code.126 = code;
  code = code.126 + 1;
  *code.126 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        D.30689 = 12 - stack_usage;
        imb.val = D.30689;
        code.127 = code;
        code = code.127 + 1;
        D.30691 = imb.b[0];
        *code.127 = D.30691;
        code.128 = code;
        code = code.128 + 1;
        D.30693 = imb.b[1];
        *code.128 = D.30693;
        code.129 = code;
        code = code.129 + 1;
        D.30695 = imb.b[2];
        *code.129 = D.30695;
        code.130 = code;
        code = code.130 + 1;
        D.30697 = imb.b[3];
        *code.130 = D.30697;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24197>;
  <D.30687>:
  stack_usage.131 = (unsigned int) stack_usage;
  D.30699 = 140 - stack_usage.131;
  if (D.30699 <= 255) goto <D.30700>; else goto <D.30701>;
  <D.30700>:
  code.132 = code;
  code = code.132 + 1;
  *code.132 = 131;
  code.133 = code;
  code = code.133 + 1;
  *code.133 = 236;
  D.30704 = (unsigned char) stack_usage;
  D.30705 = 12 - D.30704;
  *code = D.30705;
  code = code + 1;
  goto <D.30706>;
  <D.30701>:
  code.134 = code;
  code = code.134 + 1;
  *code.134 = 129;
  code.135 = code;
  code = code.135 + 1;
  *code.135 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        D.30689 = 12 - stack_usage;
        imb.val = D.30689;
        code.136 = code;
        code = code.136 + 1;
        D.30710 = imb.b[0];
        *code.136 = D.30710;
        code.137 = code;
        code = code.137 + 1;
        D.30712 = imb.b[1];
        *code.137 = D.30712;
        code.138 = code;
        code = code.138 + 1;
        D.30714 = imb.b[2];
        *code.138 = D.30714;
        code.139 = code;
        code = code.139 + 1;
        D.30716 = imb.b[3];
        *code.139 = D.30716;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30706>:
  <D.24197>:
  switch (save_mode) <default: <D.24220>, case 0: <D.24219>, case 1: <D.24215>, case 2: <D.24201>, case 3: <D.24199>, case 4: <D.24202>>
  <D.24199>:
  code.140 = code;
  code = code.140 + 1;
  *code.140 = 82;
  code.141 = code;
  code = code.141 + 1;
  *code.141 = 80;
  if (enable_arguments != 0) goto <D.30719>; else goto <D.30720>;
  <D.30719>:
  code.142 = code;
  code = code.142 + 1;
  *code.142 = 82;
  code.143 = code;
  code = code.143 + 1;
  *code.143 = 80;
  arg_size = 8;
  <D.30720>:
  goto <D.24200>;
  <D.24201>:
  code.144 = code;
  code = code.144 + 1;
  *code.144 = 80;
  if (enable_arguments != 0) goto <D.30724>; else goto <D.30725>;
  <D.30724>:
  code.145 = code;
  code = code.145 + 1;
  *code.145 = 80;
  arg_size = 4;
  <D.30725>:
  goto <D.24200>;
  <D.24202>:
  if (0 != 0) goto <D.30727>; else goto <D.30728>;
  <D.30727>:
  code.146 = code;
  code = code.146 + 1;
  *code.146 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.147 = code;
        code = code.147 + 1;
        D.30731 = imb.b[0];
        *code.147 = D.30731;
        code.148 = code;
        code = code.148 + 1;
        D.30733 = imb.b[1];
        *code.148 = D.30733;
        code.149 = code;
        code = code.149 + 1;
        D.30735 = imb.b[2];
        *code.149 = D.30735;
        code.150 = code;
        code = code.150 + 1;
        D.30737 = imb.b[3];
        *code.150 = D.30737;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24204>;
  <D.30728>:
  if (1 != 0) goto <D.30738>; else goto <D.30739>;
  <D.30738>:
  code.151 = code;
  code = code.151 + 1;
  *code.151 = 131;
  code.152 = code;
  code = code.152 + 1;
  *code.152 = 236;
  *code = 8;
  code = code + 1;
  goto <D.30742>;
  <D.30739>:
  code.153 = code;
  code = code.153 + 1;
  *code.153 = 129;
  code.154 = code;
  code = code.154 + 1;
  *code.154 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.155 = code;
        code = code.155 + 1;
        D.30746 = imb.b[0];
        *code.155 = D.30746;
        code.156 = code;
        code = code.156 + 1;
        D.30748 = imb.b[1];
        *code.156 = D.30748;
        code.157 = code;
        code = code.157 + 1;
        D.30750 = imb.b[2];
        *code.157 = D.30750;
        code.158 = code;
        code = code.158 + 1;
        D.30752 = imb.b[3];
        *code.158 = D.30752;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30742>:
  <D.24204>:
  code.159 = code;
  code = code.159 + 1;
  *code.159 = 221;
  if (1 != 0) goto <D.30754>; else goto <D.30755>;
  <D.30754>:
  if (1 != 0) goto <D.30756>; else goto <D.30757>;
  <D.30756>:
  code.160 = code;
  code = code.160 + 1;
  *code.160 = 28;
  code.161 = code;
  code = code.161 + 1;
  *code.161 = 36;
  goto <D.30760>;
  <D.30757>:
  if (1 != 0) goto <D.30761>; else goto <D.30762>;
  <D.30761>:
  code.162 = code;
  code = code.162 + 1;
  *code.162 = 92;
  code.163 = code;
  code = code.163 + 1;
  *code.163 = 36;
  *code = 0;
  code = code + 1;
  goto <D.30765>;
  <D.30762>:
  code.164 = code;
  code = code.164 + 1;
  *code.164 = 156;
  code.165 = code;
  code = code.165 + 1;
  *code.165 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.166 = code;
        code = code.166 + 1;
        D.30769 = imb.b[0];
        *code.166 = D.30769;
        code.167 = code;
        code = code.167 + 1;
        D.30771 = imb.b[1];
        *code.167 = D.30771;
        code.168 = code;
        code = code.168 + 1;
        D.30773 = imb.b[2];
        *code.168 = D.30773;
        code.169 = code;
        code = code.169 + 1;
        D.30775 = imb.b[3];
        *code.169 = D.30775;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30765>:
  <D.30760>:
  goto <D.24207>;
  <D.30755>:
  if (1 != 0) goto <D.30776>; else goto <D.30777>;
  <D.30776>:
  code.170 = code;
  code = code.170 + 1;
  *code.170 = 28;
  goto <D.24207>;
  <D.30777>:
  if (1 != 0) goto <D.30779>; else goto <D.30780>;
  <D.30779>:
  code.171 = code;
  code = code.171 + 1;
  *code.171 = 92;
  *code = 0;
  code = code + 1;
  goto <D.30782>;
  <D.30780>:
  code.172 = code;
  code = code.172 + 1;
  *code.172 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.173 = code;
        code = code.173 + 1;
        D.30785 = imb.b[0];
        *code.173 = D.30785;
        code.174 = code;
        code = code.174 + 1;
        D.30787 = imb.b[1];
        *code.174 = D.30787;
        code.175 = code;
        code = code.175 + 1;
        D.30789 = imb.b[2];
        *code.175 = D.30789;
        code.176 = code;
        code = code.176 + 1;
        D.30791 = imb.b[3];
        *code.176 = D.30791;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30782>:
  <D.24207>:
  if (enable_arguments != 0) goto <D.30792>; else goto <D.30793>;
  <D.30792>:
  if (0 != 0) goto <D.30794>; else goto <D.30795>;
  <D.30794>:
  code.177 = code;
  code = code.177 + 1;
  *code.177 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.178 = code;
        code = code.178 + 1;
        D.30798 = imb.b[0];
        *code.178 = D.30798;
        code.179 = code;
        code = code.179 + 1;
        D.30800 = imb.b[1];
        *code.179 = D.30800;
        code.180 = code;
        code = code.180 + 1;
        D.30802 = imb.b[2];
        *code.180 = D.30802;
        code.181 = code;
        code = code.181 + 1;
        D.30804 = imb.b[3];
        *code.181 = D.30804;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24210>;
  <D.30795>:
  if (1 != 0) goto <D.30805>; else goto <D.30806>;
  <D.30805>:
  code.182 = code;
  code = code.182 + 1;
  *code.182 = 131;
  code.183 = code;
  code = code.183 + 1;
  *code.183 = 236;
  *code = 8;
  code = code + 1;
  goto <D.30809>;
  <D.30806>:
  code.184 = code;
  code = code.184 + 1;
  *code.184 = 129;
  code.185 = code;
  code = code.185 + 1;
  *code.185 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.186 = code;
        code = code.186 + 1;
        D.30813 = imb.b[0];
        *code.186 = D.30813;
        code.187 = code;
        code = code.187 + 1;
        D.30815 = imb.b[1];
        *code.187 = D.30815;
        code.188 = code;
        code = code.188 + 1;
        D.30817 = imb.b[2];
        *code.188 = D.30817;
        code.189 = code;
        code = code.189 + 1;
        D.30819 = imb.b[3];
        *code.189 = D.30819;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30809>:
  <D.24210>:
  code.190 = code;
  code = code.190 + 1;
  *code.190 = 221;
  if (1 != 0) goto <D.30821>; else goto <D.30822>;
  <D.30821>:
  if (1 != 0) goto <D.30823>; else goto <D.30824>;
  <D.30823>:
  code.191 = code;
  code = code.191 + 1;
  *code.191 = 28;
  code.192 = code;
  code = code.192 + 1;
  *code.192 = 36;
  goto <D.30827>;
  <D.30824>:
  if (1 != 0) goto <D.30828>; else goto <D.30829>;
  <D.30828>:
  code.193 = code;
  code = code.193 + 1;
  *code.193 = 92;
  code.194 = code;
  code = code.194 + 1;
  *code.194 = 36;
  *code = 0;
  code = code + 1;
  goto <D.30832>;
  <D.30829>:
  code.195 = code;
  code = code.195 + 1;
  *code.195 = 156;
  code.196 = code;
  code = code.196 + 1;
  *code.196 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.197 = code;
        code = code.197 + 1;
        D.30836 = imb.b[0];
        *code.197 = D.30836;
        code.198 = code;
        code = code.198 + 1;
        D.30838 = imb.b[1];
        *code.198 = D.30838;
        code.199 = code;
        code = code.199 + 1;
        D.30840 = imb.b[2];
        *code.199 = D.30840;
        code.200 = code;
        code = code.200 + 1;
        D.30842 = imb.b[3];
        *code.200 = D.30842;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30832>:
  <D.30827>:
  goto <D.24213>;
  <D.30822>:
  if (1 != 0) goto <D.30843>; else goto <D.30844>;
  <D.30843>:
  code.201 = code;
  code = code.201 + 1;
  *code.201 = 28;
  goto <D.24213>;
  <D.30844>:
  if (1 != 0) goto <D.30846>; else goto <D.30847>;
  <D.30846>:
  code.202 = code;
  code = code.202 + 1;
  *code.202 = 92;
  *code = 0;
  code = code + 1;
  goto <D.30849>;
  <D.30847>:
  code.203 = code;
  code = code.203 + 1;
  *code.203 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.204 = code;
        code = code.204 + 1;
        D.30852 = imb.b[0];
        *code.204 = D.30852;
        code.205 = code;
        code = code.205 + 1;
        D.30854 = imb.b[1];
        *code.205 = D.30854;
        code.206 = code;
        code = code.206 + 1;
        D.30856 = imb.b[2];
        *code.206 = D.30856;
        code.207 = code;
        code = code.207 + 1;
        D.30858 = imb.b[3];
        *code.207 = D.30858;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30849>:
  <D.24213>:
  arg_size = 8;
  <D.30793>:
  goto <D.24200>;
  <D.24215>:
  if (enable_arguments != 0) goto <D.30859>; else goto <D.30860>;
  <D.30859>:
  code.208 = code;
  code = code.208 + 1;
  *code.208 = 255;
  if (0 != 0) goto <D.30862>; else goto <D.30863>;
  <D.30862>:
  if (0 != 0) goto <D.30864>; else goto <D.30865>;
  <D.30864>:
  code.209 = code;
  code = code.209 + 1;
  *code.209 = 52;
  code.210 = code;
  code = code.210 + 1;
  *code.210 = 36;
  goto <D.30868>;
  <D.30865>:
  if (1 != 0) goto <D.30869>; else goto <D.30870>;
  <D.30869>:
  code.211 = code;
  code = code.211 + 1;
  *code.211 = 116;
  code.212 = code;
  code = code.212 + 1;
  *code.212 = 36;
  *code = 8;
  code = code + 1;
  goto <D.30873>;
  <D.30870>:
  code.213 = code;
  code = code.213 + 1;
  *code.213 = 180;
  code.214 = code;
  code = code.214 + 1;
  *code.214 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.215 = code;
        code = code.215 + 1;
        D.30877 = imb.b[0];
        *code.215 = D.30877;
        code.216 = code;
        code = code.216 + 1;
        D.30879 = imb.b[1];
        *code.216 = D.30879;
        code.217 = code;
        code = code.217 + 1;
        D.30881 = imb.b[2];
        *code.217 = D.30881;
        code.218 = code;
        code = code.218 + 1;
        D.30883 = imb.b[3];
        *code.218 = D.30883;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30873>:
  <D.30868>:
  goto <D.24217>;
  <D.30863>:
  if (0 != 0) goto <D.30884>; else goto <D.30885>;
  <D.30884>:
  code.219 = code;
  code = code.219 + 1;
  *code.219 = 53;
  goto <D.24217>;
  <D.30885>:
  if (1 != 0) goto <D.30887>; else goto <D.30888>;
  <D.30887>:
  code.220 = code;
  code = code.220 + 1;
  *code.220 = 117;
  *code = 8;
  code = code + 1;
  goto <D.30890>;
  <D.30888>:
  code.221 = code;
  code = code.221 + 1;
  *code.221 = 181;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.222 = code;
        code = code.222 + 1;
        D.30893 = imb.b[0];
        *code.222 = D.30893;
        code.223 = code;
        code = code.223 + 1;
        D.30895 = imb.b[1];
        *code.223 = D.30895;
        code.224 = code;
        code = code.224 + 1;
        D.30897 = imb.b[2];
        *code.224 = D.30897;
        code.225 = code;
        code = code.225 + 1;
        D.30899 = imb.b[3];
        *code.225 = D.30899;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30890>:
  <D.24217>:
  arg_size = 4;
  <D.30860>:
  goto <D.24200>;
  <D.24219>:
  <D.24220>:
  goto <D.24200>;
  <D.24200>:
  D.30900 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.30901 = D.30900 & 64;
  if (D.30901 != 0) goto <D.30902>; else goto <D.30903>;
  <D.30902>:
  {
    int _imm;

    _imm = (int) method;
    _imm.226 = (unsigned int) _imm;
    D.30905 = _imm.226 + 128;
    if (D.30905 <= 255) goto <D.30906>; else goto <D.30907>;
    <D.30906>:
    code.227 = code;
    code = code.227 + 1;
    *code.227 = 106;
    D.30909 = (unsigned char) _imm;
    *code = D.30909;
    code = code + 1;
    goto <D.30910>;
    <D.30907>:
    code.228 = code;
    code = code.228 + 1;
    *code.228 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.229 = code;
          code = code.229 + 1;
          D.30913 = imb.b[0];
          *code.229 = D.30913;
          code.230 = code;
          code = code.230 + 1;
          D.30915 = imb.b[1];
          *code.230 = D.30915;
          code.231 = code;
          code = code.231 + 1;
          D.30917 = imb.b[2];
          *code.231 = D.30917;
          code.232 = code;
          code = code.232 + 1;
          D.30919 = imb.b[3];
          *code.232 = D.30919;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.30910>:
  }
  code.233 = code;
  code = code.233 + 1;
  *code.233 = 184;
  {
    union x86_imm_buf imb;

    try
      {
        func.234 = (int) func;
        imb.val = func.234;
        code.235 = code;
        code = code.235 + 1;
        D.30923 = imb.b[0];
        *code.235 = D.30923;
        code.236 = code;
        code = code.236 + 1;
        D.30925 = imb.b[1];
        *code.236 = D.30925;
        code.237 = code;
        code = code.237 + 1;
        D.30927 = imb.b[2];
        *code.237 = D.30927;
        code.238 = code;
        code = code.238 + 1;
        D.30929 = imb.b[3];
        *code.238 = D.30929;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  code.239 = code;
  code = code.239 + 1;
  *code.239 = 255;
  code.240 = code;
  code = code.240 + 1;
  *code.240 = 208;
  goto <D.30932>;
  <D.30903>:
  code.241 = (int) code;
  D.30934 = cfg->native_code;
  D.30935 = (int) D.30934;
  D.30936 = code.241 - D.30935;
  mono_add_patch_info (cfg, D.30936, 6, method);
  {
    int _imm;

    _imm = (int) method;
    _imm.242 = (unsigned int) _imm;
    D.30938 = _imm.242 + 128;
    if (D.30938 <= 255) goto <D.30939>; else goto <D.30940>;
    <D.30939>:
    code.243 = code;
    code = code.243 + 1;
    *code.243 = 106;
    D.30942 = (unsigned char) _imm;
    *code = D.30942;
    code = code + 1;
    goto <D.30943>;
    <D.30940>:
    code.244 = code;
    code = code.244 + 1;
    *code.244 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.245 = code;
          code = code.245 + 1;
          D.30946 = imb.b[0];
          *code.245 = D.30946;
          code.246 = code;
          code = code.246 + 1;
          D.30948 = imb.b[1];
          *code.246 = D.30948;
          code.247 = code;
          code = code.247 + 1;
          D.30950 = imb.b[2];
          *code.247 = D.30950;
          code.248 = code;
          code = code.248 + 1;
          D.30952 = imb.b[3];
          *code.248 = D.30952;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.30943>:
  }
  code.241 = (int) code;
  D.30934 = cfg->native_code;
  D.30935 = (int) D.30934;
  D.30936 = code.241 - D.30935;
  mono_add_patch_info (cfg, D.30936, 1, func);
  {
    int _x86_offset;

    code.249 = (int) code;
    _x86_offset = -code.249;
    _x86_offset = _x86_offset + -5;
    code.250 = code;
    code = code.250 + 1;
    *code.250 = 232;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _x86_offset;
          code.251 = code;
          code = code.251 + 1;
          D.30956 = imb.b[0];
          *code.251 = D.30956;
          code.252 = code;
          code = code.252 + 1;
          D.30958 = imb.b[1];
          *code.252 = D.30958;
          code.253 = code;
          code = code.253 + 1;
          D.30960 = imb.b[2];
          *code.253 = D.30960;
          code.254 = code;
          code = code.254 + 1;
          D.30962 = imb.b[3];
          *code.254 = D.30962;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
  <D.30932>:
  if (0 != 0) goto <D.30963>; else goto <D.30964>;
  <D.30963>:
  code.255 = code;
  code = code.255 + 1;
  *code.255 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.30966 = arg_size + 4;
        imb.val = D.30966;
        code.256 = code;
        code = code.256 + 1;
        D.30968 = imb.b[0];
        *code.256 = D.30968;
        code.257 = code;
        code = code.257 + 1;
        D.30970 = imb.b[1];
        *code.257 = D.30970;
        code.258 = code;
        code = code.258 + 1;
        D.30972 = imb.b[2];
        *code.258 = D.30972;
        code.259 = code;
        code = code.259 + 1;
        D.30974 = imb.b[3];
        *code.259 = D.30974;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24229>;
  <D.30964>:
  arg_size.260 = (unsigned int) arg_size;
  D.30976 = arg_size.260 + 132;
  if (D.30976 <= 255) goto <D.30977>; else goto <D.30978>;
  <D.30977>:
  code.261 = code;
  code = code.261 + 1;
  *code.261 = 131;
  code.262 = code;
  code = code.262 + 1;
  *code.262 = 196;
  D.30981 = (unsigned char) arg_size;
  D.30982 = D.30981 + 4;
  *code = D.30982;
  code = code + 1;
  goto <D.30983>;
  <D.30978>:
  code.263 = code;
  code = code.263 + 1;
  *code.263 = 129;
  code.264 = code;
  code = code.264 + 1;
  *code.264 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.30966 = arg_size + 4;
        imb.val = D.30966;
        code.265 = code;
        code = code.265 + 1;
        D.30987 = imb.b[0];
        *code.265 = D.30987;
        code.266 = code;
        code = code.266 + 1;
        D.30989 = imb.b[1];
        *code.266 = D.30989;
        code.267 = code;
        code = code.267 + 1;
        D.30991 = imb.b[2];
        *code.267 = D.30991;
        code.268 = code;
        code = code.268 + 1;
        D.30993 = imb.b[3];
        *code.268 = D.30993;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.30983>:
  <D.24229>:
  switch (save_mode) <default: <D.24242>, case 0: <D.24241>, case 2: <D.24233>, case 3: <D.24231>, case 4: <D.24234>>
  <D.24231>:
  code.269 = code;
  code = code.269 + 1;
  *code.269 = 88;
  code.270 = code;
  code = code.270 + 1;
  *code.270 = 90;
  goto <D.24232>;
  <D.24233>:
  code.271 = code;
  code = code.271 + 1;
  *code.271 = 88;
  goto <D.24232>;
  <D.24234>:
  code.272 = code;
  code = code.272 + 1;
  *code.272 = 221;
  if (1 != 0) goto <D.30998>; else goto <D.30999>;
  <D.30998>:
  if (1 != 0) goto <D.31000>; else goto <D.31001>;
  <D.31000>:
  code.273 = code;
  code = code.273 + 1;
  *code.273 = 4;
  code.274 = code;
  code = code.274 + 1;
  *code.274 = 36;
  goto <D.31004>;
  <D.31001>:
  if (1 != 0) goto <D.31005>; else goto <D.31006>;
  <D.31005>:
  code.275 = code;
  code = code.275 + 1;
  *code.275 = 68;
  code.276 = code;
  code = code.276 + 1;
  *code.276 = 36;
  *code = 0;
  code = code + 1;
  goto <D.31009>;
  <D.31006>:
  code.277 = code;
  code = code.277 + 1;
  *code.277 = 132;
  code.278 = code;
  code = code.278 + 1;
  *code.278 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.279 = code;
        code = code.279 + 1;
        D.31013 = imb.b[0];
        *code.279 = D.31013;
        code.280 = code;
        code = code.280 + 1;
        D.31015 = imb.b[1];
        *code.280 = D.31015;
        code.281 = code;
        code = code.281 + 1;
        D.31017 = imb.b[2];
        *code.281 = D.31017;
        code.282 = code;
        code = code.282 + 1;
        D.31019 = imb.b[3];
        *code.282 = D.31019;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31009>:
  <D.31004>:
  goto <D.24236>;
  <D.30999>:
  if (1 != 0) goto <D.31020>; else goto <D.31021>;
  <D.31020>:
  code.283 = code;
  code = code.283 + 1;
  *code.283 = 4;
  goto <D.24236>;
  <D.31021>:
  if (1 != 0) goto <D.31023>; else goto <D.31024>;
  <D.31023>:
  code.284 = code;
  code = code.284 + 1;
  *code.284 = 68;
  *code = 0;
  code = code + 1;
  goto <D.31026>;
  <D.31024>:
  code.285 = code;
  code = code.285 + 1;
  *code.285 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.286 = code;
        code = code.286 + 1;
        D.31029 = imb.b[0];
        *code.286 = D.31029;
        code.287 = code;
        code = code.287 + 1;
        D.31031 = imb.b[1];
        *code.287 = D.31031;
        code.288 = code;
        code = code.288 + 1;
        D.31033 = imb.b[2];
        *code.288 = D.31033;
        code.289 = code;
        code = code.289 + 1;
        D.31035 = imb.b[3];
        *code.289 = D.31035;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31026>:
  <D.24236>:
  if (0 != 0) goto <D.31036>; else goto <D.31037>;
  <D.31036>:
  code.290 = code;
  code = code.290 + 1;
  *code.290 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.291 = code;
        code = code.291 + 1;
        D.31040 = imb.b[0];
        *code.291 = D.31040;
        code.292 = code;
        code = code.292 + 1;
        D.31042 = imb.b[1];
        *code.292 = D.31042;
        code.293 = code;
        code = code.293 + 1;
        D.31044 = imb.b[2];
        *code.293 = D.31044;
        code.294 = code;
        code = code.294 + 1;
        D.31046 = imb.b[3];
        *code.294 = D.31046;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24239>;
  <D.31037>:
  if (1 != 0) goto <D.31047>; else goto <D.31048>;
  <D.31047>:
  code.295 = code;
  code = code.295 + 1;
  *code.295 = 131;
  code.296 = code;
  code = code.296 + 1;
  *code.296 = 196;
  *code = 8;
  code = code + 1;
  goto <D.31051>;
  <D.31048>:
  code.297 = code;
  code = code.297 + 1;
  *code.297 = 129;
  code.298 = code;
  code = code.298 + 1;
  *code.298 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.299 = code;
        code = code.299 + 1;
        D.31055 = imb.b[0];
        *code.299 = D.31055;
        code.300 = code;
        code = code.300 + 1;
        D.31057 = imb.b[1];
        *code.300 = D.31057;
        code.301 = code;
        code = code.301 + 1;
        D.31059 = imb.b[2];
        *code.301 = D.31059;
        code.302 = code;
        code = code.302 + 1;
        D.31061 = imb.b[3];
        *code.302 = D.31061;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31051>:
  <D.24239>:
  goto <D.24232>;
  <D.24241>:
  <D.24242>:
  goto <D.24232>;
  <D.24232>:
  if (0 != 0) goto <D.31062>; else goto <D.31063>;
  <D.31062>:
  code.303 = code;
  code = code.303 + 1;
  *code.303 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.31065 = 16 - stack_usage;
        imb.val = D.31065;
        code.304 = code;
        code = code.304 + 1;
        D.31067 = imb.b[0];
        *code.304 = D.31067;
        code.305 = code;
        code = code.305 + 1;
        D.31069 = imb.b[1];
        *code.305 = D.31069;
        code.306 = code;
        code = code.306 + 1;
        D.31071 = imb.b[2];
        *code.306 = D.31071;
        code.307 = code;
        code = code.307 + 1;
        D.31073 = imb.b[3];
        *code.307 = D.31073;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24244>;
  <D.31063>:
  stack_usage.131 = (unsigned int) stack_usage;
  D.31074 = 144 - stack_usage.131;
  if (D.31074 <= 255) goto <D.31075>; else goto <D.31076>;
  <D.31075>:
  code.308 = code;
  code = code.308 + 1;
  *code.308 = 131;
  code.309 = code;
  code = code.309 + 1;
  *code.309 = 196;
  D.30704 = (unsigned char) stack_usage;
  D.31079 = 16 - D.30704;
  *code = D.31079;
  code = code + 1;
  goto <D.31080>;
  <D.31076>:
  code.310 = code;
  code = code.310 + 1;
  *code.310 = 129;
  code.311 = code;
  code = code.311 + 1;
  *code.311 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.31065 = 16 - stack_usage;
        imb.val = D.31065;
        code.312 = code;
        code = code.312 + 1;
        D.31084 = imb.b[0];
        *code.312 = D.31084;
        code.313 = code;
        code = code.313 + 1;
        D.31086 = imb.b[1];
        *code.313 = D.31086;
        code.314 = code;
        code = code.314 + 1;
        D.31088 = imb.b[2];
        *code.314 = D.31088;
        code.315 = code;
        code = code.315 + 1;
        D.31090 = imb.b[3];
        *code.315 = D.31090;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31080>:
  <D.24244>:
  D.31091 = code;
  return D.31091;
}


mono_arch_peephole_pass_1 (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.316;
  short unsigned int D.31102;
  int D.31103;
  int D.31106;
  int D.31108;
  int D.31110;
  int D.31119;
  short unsigned int D.31128;
  int D.31131;
  int D.31134;
  int D.31135;
  int D.31138;
  short unsigned int D.31143;
  _Bool D.31144;
  _Bool D.31145;
  _Bool D.31146;
  struct MonoInst * iftmp.317;
  struct MonoInst * ins;
  struct MonoInst * n;

  ins = bb->code;
  if (ins != 0B) goto <D.31099>; else goto <D.31100>;
  <D.31099>:
  iftmp.316 = ins->next;
  goto <D.31101>;
  <D.31100>:
  iftmp.316 = 0B;
  <D.31101>:
  n = iftmp.316;
  goto <D.24284>;
  <D.24283>:
  {
    struct MonoInst * last_ins;

    last_ins = ins->prev;
    D.31102 = ins->opcode;
    D.31103 = (int) D.31102;
    switch (D.31103) <default: <D.31153>, case 323: <D.24279>, case 327: <D.24280>, case 433: <D.24275>, case 434: <D.24277>, case 629: <D.24274>, case 630: <D.24278>, case 1007: <D.24281>, case 1032: <D.24282>>
    <D.24274>:
    <D.24275>:
    D.31106 = ins->sreg1;
    if (D.31106 <= 7) goto <D.31107>; else goto <D.31104>;
    <D.31107>:
    D.31108 = ins->dreg;
    if (D.31108 > 7) goto <D.31109>; else goto <D.31104>;
    <D.31109>:
    ins->opcode = 1038;
    D.31106 = ins->sreg1;
    ins->sreg1 = D.31106;
    goto <D.31105>;
    <D.31104>:
    D.31110 = ins->data.op[1].const_val;
    if (D.31110 == 1) goto <D.31111>; else goto <D.31112>;
    <D.31111>:
    D.31108 = ins->dreg;
    D.31106 = ins->sreg1;
    if (D.31108 == D.31106) goto <D.31113>; else goto <D.31114>;
    <D.31113>:
    ins->opcode = 1011;
    <D.31114>:
    <D.31112>:
    <D.31105>:
    goto <D.24276>;
    <D.24277>:
    <D.24278>:
    D.31106 = ins->sreg1;
    if (D.31106 <= 7) goto <D.31117>; else goto <D.31115>;
    <D.31117>:
    D.31108 = ins->dreg;
    if (D.31108 > 7) goto <D.31118>; else goto <D.31115>;
    <D.31118>:
    ins->opcode = 1038;
    D.31106 = ins->sreg1;
    ins->sreg1 = D.31106;
    D.31110 = ins->data.op[1].const_val;
    D.31119 = -D.31110;
    ins->data.op[1].const_val = D.31119;
    goto <D.31116>;
    <D.31115>:
    D.31110 = ins->data.op[1].const_val;
    if (D.31110 == 1) goto <D.31120>; else goto <D.31121>;
    <D.31120>:
    D.31108 = ins->dreg;
    D.31106 = ins->sreg1;
    if (D.31108 == D.31106) goto <D.31122>; else goto <D.31123>;
    <D.31122>:
    ins->opcode = 1013;
    <D.31123>:
    <D.31121>:
    <D.31116>:
    goto <D.24276>;
    <D.24279>:
    <D.24280>:
    D.31110 = ins->data.op[1].const_val;
    if (D.31110 == 0) goto <D.31124>; else goto <D.31125>;
    <D.31124>:
    ins->opcode = 1005;
    <D.31125>:
    goto <D.24276>;
    <D.24281>:
    if (last_ins != 0B) goto <D.31126>; else goto <D.31127>;
    <D.31126>:
    D.31128 = last_ins->opcode;
    if (D.31128 == 377) goto <D.31129>; else goto <D.31130>;
    <D.31129>:
    D.31106 = ins->sreg1;
    D.31131 = last_ins->dreg;
    if (D.31106 == D.31131) goto <D.31132>; else goto <D.31133>;
    <D.31132>:
    D.31134 = ins->data.op[0].const_val;
    D.31135 = last_ins->data.op[0].const_val;
    if (D.31134 == D.31135) goto <D.31136>; else goto <D.31137>;
    <D.31136>:
    ins->opcode = 323;
    D.31138 = last_ins->sreg1;
    ins->sreg1 = D.31138;
    D.31110 = ins->data.op[1].const_val;
    if (D.31110 == 0) goto <D.31139>; else goto <D.31140>;
    <D.31139>:
    ins->opcode = 1005;
    <D.31140>:
    <D.31137>:
    <D.31133>:
    <D.31130>:
    <D.31127>:
    goto <D.24276>;
    <D.24282>:
    if (last_ins != 0B) goto <D.31141>; else goto <D.31142>;
    <D.31141>:
    D.31143 = last_ins->opcode;
    D.31144 = D.31143 == 377;
    D.31145 = D.31143 == 374;
    D.31146 = D.31144 | D.31145;
    if (D.31146 != 0) goto <D.31147>; else goto <D.31148>;
    <D.31147>:
    D.31106 = ins->sreg1;
    D.31131 = last_ins->dreg;
    if (D.31106 == D.31131) goto <D.31149>; else goto <D.31150>;
    <D.31149>:
    D.31134 = ins->data.op[0].const_val;
    D.31135 = last_ins->data.op[0].const_val;
    if (D.31134 == D.31135) goto <D.31151>; else goto <D.31152>;
    <D.31151>:
    ins->opcode = 1034;
    D.31138 = last_ins->sreg1;
    ins->sreg1 = D.31138;
    <D.31152>:
    <D.31150>:
    <D.31148>:
    <D.31142>:
    goto <D.24276>;
    <D.31153>:
    <D.24276>:
    mono_peephole_ins (bb, ins);
  }
  ins = n;
  if (ins != 0B) goto <D.31155>; else goto <D.31156>;
  <D.31155>:
  iftmp.317 = ins->next;
  goto <D.31157>;
  <D.31156>:
  iftmp.317 = 0B;
  <D.31157>:
  n = iftmp.317;
  <D.24284>:
  if (ins != 0B) goto <D.24283>; else goto <D.24285>;
  <D.24285>:
}


mono_arch_peephole_pass_2 (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.318;
  short unsigned int D.31162;
  int D.31163;
  int D.31166;
  struct MonoInst * D.31169;
  short unsigned int D.31172;
  _Bool D.31173;
  _Bool D.31174;
  _Bool D.31175;
  short unsigned int D.31177;
  int D.31183;
  short unsigned int D.31186;
  int D.31188;
  short unsigned int D.31194;
  int D.31196;
  int D.31199;
  struct MonoInst * iftmp.319;
  struct MonoInst * ins;
  struct MonoInst * n;

  ins = bb->code;
  if (ins != 0B) goto <D.31159>; else goto <D.31160>;
  <D.31159>:
  iftmp.318 = ins->next;
  goto <D.31161>;
  <D.31160>:
  iftmp.318 = 0B;
  <D.31161>:
  n = iftmp.318;
  goto <D.24303>;
  <D.24302>:
  D.31162 = ins->opcode;
  D.31163 = (int) D.31162;
  switch (D.31163) <default: <D.31206>, case 362: <D.24292>, case 433: <D.24299>, case 434: <D.24301>, case 629: <D.24298>, case 630: <D.24300>>
  <D.24292>:
  D.31166 = ins->data.op[0].const_val;
  if (D.31166 == 0) goto <D.31167>; else goto <D.31168>;
  <D.31167>:
  D.31169 = ins->next;
  if (D.31169 == 0B) goto <D.31164>; else goto <D.31170>;
  <D.31170>:
  D.31169 = ins->next;
  if (D.31169 != 0B) goto <D.31171>; else goto <D.31165>;
  <D.31171>:
  D.31169 = ins->next;
  D.31172 = D.31169->opcode;
  D.31173 = D.31172 != 755;
  D.31174 = D.31172 != 623;
  D.31175 = D.31173 & D.31174;
  if (D.31175 != 0) goto <D.31176>; else goto <D.31165>;
  <D.31176>:
  D.31169 = ins->next;
  D.31177 = D.31169->opcode;
  if (D.31177 != 756) goto <D.31178>; else goto <D.31165>;
  <D.31178>:
  D.31169 = ins->next;
  D.31177 = D.31169->opcode;
  if (D.31177 != 624) goto <D.31179>; else goto <D.31165>;
  <D.31179>:
  D.31169 = ins->next;
  D.31177 = D.31169->opcode;
  if (D.31177 != 757) goto <D.31180>; else goto <D.31165>;
  <D.31180>:
  D.31169 = ins->next;
  D.31177 = D.31169->opcode;
  if (D.31177 != 625) goto <D.31181>; else goto <D.31165>;
  <D.31181>:
  D.31169 = ins->next;
  D.31177 = D.31169->opcode;
  if (D.31177 != 758) goto <D.31182>; else goto <D.31165>;
  <D.31182>:
  D.31169 = ins->next;
  D.31177 = D.31169->opcode;
  if (D.31177 != 626) goto <D.31164>; else goto <D.31165>;
  <D.31164>:
  {
    struct MonoInst * ins2;

    ins->opcode = 578;
    D.31183 = ins->dreg;
    ins->sreg1 = D.31183;
    D.31183 = ins->dreg;
    ins->sreg2 = D.31183;
    ins2 = ins->next;
    goto <D.24296>;
    <D.24295>:
    D.31186 = ins2->opcode;
    if (D.31186 == 384) goto <D.31187>; else goto <D.31184>;
    <D.31187>:
    D.31188 = ins2->data.op[1].const_val;
    if (D.31188 == 0) goto <D.31189>; else goto <D.31184>;
    <D.31189>:
    ins2->opcode = 374;
    D.31183 = ins->dreg;
    ins2->sreg1 = D.31183;
    goto <D.31185>;
    <D.31184>:
    D.31186 = ins2->opcode;
    if (D.31186 == 387) goto <D.31192>; else goto <D.31190>;
    <D.31192>:
    D.31188 = ins2->data.op[1].const_val;
    if (D.31188 == 0) goto <D.31193>; else goto <D.31190>;
    <D.31193>:
    ins2->opcode = 377;
    D.31183 = ins->dreg;
    ins2->sreg1 = D.31183;
    goto <D.31191>;
    <D.31190>:
    D.31186 = ins2->opcode;
    D.31194 = D.31186 + 65151;
    if (D.31194 <= 1) goto <D.31195>; else goto <D.24294>;
    <D.31195>:
    <D.31191>:
    <D.31185>:
    ins2 = ins2->next;
    <D.24296>:
    if (ins2 != 0B) goto <D.24295>; else goto <D.24294>;
    <D.24294>:
  }
  <D.31165>:
  <D.31168>:
  goto <D.24297>;
  <D.24298>:
  <D.24299>:
  D.31196 = ins->data.op[1].const_val;
  if (D.31196 == 1) goto <D.31197>; else goto <D.31198>;
  <D.31197>:
  D.31183 = ins->dreg;
  D.31199 = ins->sreg1;
  if (D.31183 == D.31199) goto <D.31200>; else goto <D.31201>;
  <D.31200>:
  ins->opcode = 1011;
  <D.31201>:
  <D.31198>:
  goto <D.24297>;
  <D.24300>:
  <D.24301>:
  D.31196 = ins->data.op[1].const_val;
  if (D.31196 == 1) goto <D.31202>; else goto <D.31203>;
  <D.31202>:
  D.31183 = ins->dreg;
  D.31199 = ins->sreg1;
  if (D.31183 == D.31199) goto <D.31204>; else goto <D.31205>;
  <D.31204>:
  ins->opcode = 1013;
  <D.31205>:
  <D.31203>:
  goto <D.24297>;
  <D.31206>:
  <D.24297>:
  mono_peephole_ins (bb, ins);
  ins = n;
  if (ins != 0B) goto <D.31208>; else goto <D.31209>;
  <D.31208>:
  iftmp.319 = ins->next;
  goto <D.31210>;
  <D.31209>:
  iftmp.319 = 0B;
  <D.31210>:
  n = iftmp.319;
  <D.24303>:
  if (ins != 0B) goto <D.24302>; else goto <D.24304>;
  <D.24304>:
}


mono_arch_lowering_pass (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.320;
  short unsigned int D.31215;
  int D.31216;
  int D.31219;
  unsigned int D.31220;
  int D.31221;
  struct MonoInst * iftmp.321;
  unsigned int D.31227;
  struct MonoInst * ins;
  struct MonoInst * next;

  ins = bb->code;
  if (ins != 0B) goto <D.31212>; else goto <D.31213>;
  <D.31212>:
  iftmp.320 = ins->next;
  goto <D.31214>;
  <D.31213>:
  iftmp.320 = 0B;
  <D.31214>:
  next = iftmp.320;
  goto <D.24318>;
  <D.24317>:
  D.31215 = ins->opcode;
  D.31216 = (int) D.31215;
  switch (D.31216) <default: <D.24316>, case 632: <D.24312>, case 633: <D.24313>, case 634: <D.24311>, case 635: <D.24314>>
  <D.24311>:
  <D.24312>:
  <D.24313>:
  <D.24314>:
  D.31215 = ins->opcode;
  if (D.31215 == 634) goto <D.31217>; else goto <D.31218>;
  <D.31217>:
  D.31219 = ins->data.op[1].const_val;
  D.31220 = (unsigned int) D.31219;
  D.31221 = mono_is_power_of_two (D.31220);
  if (D.31221 >= 0) goto <D.24315>; else goto <D.31222>;
  <D.31222>:
  <D.31218>:
  mono_decompose_op_imm (cfg, bb, ins);
  goto <D.24315>;
  <D.24316>:
  goto <D.24315>;
  <D.24315>:
  ins = next;
  if (ins != 0B) goto <D.31224>; else goto <D.31225>;
  <D.31224>:
  iftmp.321 = ins->next;
  goto <D.31226>;
  <D.31225>:
  iftmp.321 = 0B;
  <D.31226>:
  next = iftmp.321;
  <D.24318>:
  if (ins != 0B) goto <D.24317>; else goto <D.24319>;
  <D.24319>:
  D.31227 = cfg->next_vreg;
  bb->max_vreg = D.31227;
}


mono_x86_have_tls_get ()
{
  gboolean D.31229;

  D.31229 = 1;
  return D.31229;
}


mono_x86_emit_tls_get (guint8 * code, int dreg, int tls_offset)
{
  int optimize_for_xen.322;
  guint8 * code.323;
  guint8 * code.324;
  guint8 * code.325;
  guint8 * code.326;
  guint8 * code.327;
  int D.31239;
  int D.31240;
  signed char D.31241;
  signed char D.31242;
  unsigned char D.31243;
  guint8 * code.328;
  unsigned char D.31245;
  guint8 * code.329;
  unsigned char D.31247;
  guint8 * code.330;
  unsigned char D.31249;
  guint8 * code.331;
  unsigned char D.31251;
  guint8 * code.332;
  guint8 * code.333;
  guint8 * code.334;
  guint8 * code.335;
  signed char D.31260;
  unsigned char D.31261;
  guint8 * code.336;
  unsigned int tls_offset.337;
  unsigned int D.31265;
  guint8 * code.338;
  signed char D.31269;
  unsigned char D.31270;
  guint8 * code.339;
  unsigned char D.31272;
  guint8 * code.340;
  signed char D.31275;
  unsigned char D.31276;
  guint8 * code.341;
  guint8 * code.342;
  unsigned char D.31279;
  guint8 * code.343;
  unsigned char D.31281;
  guint8 * code.344;
  unsigned char D.31283;
  guint8 * code.345;
  unsigned char D.31285;
  _Bool D.31286;
  _Bool D.31287;
  _Bool D.31288;
  guint8 * code.346;
  signed char D.31292;
  signed char D.31293;
  signed char D.31294;
  unsigned char D.31295;
  guint8 * code.347;
  signed char D.31299;
  signed char D.31300;
  unsigned char D.31301;
  guint8 * code.348;
  signed char D.31304;
  signed char D.31305;
  unsigned char D.31306;
  guint8 * code.349;
  unsigned char D.31308;
  guint8 * code.350;
  unsigned char D.31310;
  guint8 * code.351;
  unsigned char D.31312;
  guint8 * code.352;
  unsigned char D.31314;
  guint8 * code.353;
  guint8 * code.354;
  guint8 * code.355;
  guint8 * code.356;
  guint8 * code.357;
  guint8 * code.358;
  unsigned char D.31322;
  guint8 * code.359;
  unsigned char D.31324;
  guint8 * code.360;
  unsigned char D.31326;
  guint8 * code.361;
  unsigned char D.31328;
  guint8 * D.31329;
  static const char __PRETTY_FUNCTION__[22] = "mono_x86_emit_tls_get";

  optimize_for_xen.322 = optimize_for_xen;
  if (optimize_for_xen.322 != 0) goto <D.31232>; else goto <D.31233>;
  <D.31232>:
  code.323 = code;
  code = code.323 + 1;
  *code.323 = 101;
  switch (4) <default: <D.24586>, case 1: <D.24582>, case 2: <D.24584>, case 4: <D.24585>>
  <D.24582>:
  code.324 = code;
  code = code.324 + 1;
  *code.324 = 138;
  goto <D.24583>;
  <D.24584>:
  code.325 = code;
  code = code.325 + 1;
  *code.325 = 102;
  <D.24585>:
  code.326 = code;
  code = code.326 + 1;
  *code.326 = 139;
  goto <D.24583>;
  <D.24586>:
  __assert_fail ("0", "mini-x86.c", 2390, &__PRETTY_FUNCTION__);
  <D.24583>:
  code.327 = code;
  code = code.327 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31242 = D.31241 | 5;
  D.31243 = (unsigned char) D.31242;
  *code.327 = D.31243;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.328 = code;
        code = code.328 + 1;
        D.31245 = imb.b[0];
        *code.328 = D.31245;
        code.329 = code;
        code = code.329 + 1;
        D.31247 = imb.b[1];
        *code.329 = D.31247;
        code.330 = code;
        code = code.330 + 1;
        D.31249 = imb.b[2];
        *code.330 = D.31249;
        code.331 = code;
        code = code.331 + 1;
        D.31251 = imb.b[3];
        *code.331 = D.31251;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  switch (4) <default: <D.24593>, case 1: <D.24589>, case 2: <D.24591>, case 4: <D.24592>>
  <D.24589>:
  code.332 = code;
  code = code.332 + 1;
  *code.332 = 138;
  goto <D.24590>;
  <D.24591>:
  code.333 = code;
  code = code.333 + 1;
  *code.333 = 102;
  <D.24592>:
  code.334 = code;
  code = code.334 + 1;
  *code.334 = 139;
  goto <D.24590>;
  <D.24593>:
  __assert_fail ("0", "mini-x86.c", 2391, &__PRETTY_FUNCTION__);
  <D.24590>:
  if (dreg == 4) goto <D.31255>; else goto <D.31256>;
  <D.31255>:
  if (tls_offset == 0) goto <D.31257>; else goto <D.31258>;
  <D.31257>:
  code.335 = code;
  code = code.335 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31260 = D.31241 | 4;
  D.31261 = (unsigned char) D.31260;
  *code.335 = D.31261;
  code.336 = code;
  code = code.336 + 1;
  *code.336 = 36;
  goto <D.31263>;
  <D.31258>:
  tls_offset.337 = (unsigned int) tls_offset;
  D.31265 = tls_offset.337 + 128;
  if (D.31265 <= 255) goto <D.31266>; else goto <D.31267>;
  <D.31266>:
  code.338 = code;
  code = code.338 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31269 = D.31241 | 68;
  D.31270 = (unsigned char) D.31269;
  *code.338 = D.31270;
  code.339 = code;
  code = code.339 + 1;
  *code.339 = 36;
  D.31272 = (unsigned char) tls_offset;
  *code = D.31272;
  code = code + 1;
  goto <D.31273>;
  <D.31267>:
  code.340 = code;
  code = code.340 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31275 = D.31241 | -124;
  D.31276 = (unsigned char) D.31275;
  *code.340 = D.31276;
  code.341 = code;
  code = code.341 + 1;
  *code.341 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.342 = code;
        code = code.342 + 1;
        D.31279 = imb.b[0];
        *code.342 = D.31279;
        code.343 = code;
        code = code.343 + 1;
        D.31281 = imb.b[1];
        *code.343 = D.31281;
        code.344 = code;
        code = code.344 + 1;
        D.31283 = imb.b[2];
        *code.344 = D.31283;
        code.345 = code;
        code = code.345 + 1;
        D.31285 = imb.b[3];
        *code.345 = D.31285;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31273>:
  <D.31263>:
  goto <D.24595>;
  <D.31256>:
  D.31286 = tls_offset == 0;
  D.31287 = dreg != 5;
  D.31288 = D.31286 & D.31287;
  if (D.31288 != 0) goto <D.31289>; else goto <D.31290>;
  <D.31289>:
  code.346 = code;
  code = code.346 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31292 = (signed char) dreg;
  D.31293 = D.31292 & 7;
  D.31294 = D.31241 | D.31293;
  D.31295 = (unsigned char) D.31294;
  *code.346 = D.31295;
  goto <D.24595>;
  <D.31290>:
  tls_offset.337 = (unsigned int) tls_offset;
  D.31265 = tls_offset.337 + 128;
  if (D.31265 <= 255) goto <D.31296>; else goto <D.31297>;
  <D.31296>:
  code.347 = code;
  code = code.347 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31299 = D.31241 | 64;
  D.31292 = (signed char) dreg;
  D.31293 = D.31292 & 7;
  D.31300 = D.31299 | D.31293;
  D.31301 = (unsigned char) D.31300;
  *code.347 = D.31301;
  D.31272 = (unsigned char) tls_offset;
  *code = D.31272;
  code = code + 1;
  goto <D.31302>;
  <D.31297>:
  code.348 = code;
  code = code.348 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31304 = D.31241 | -128;
  D.31292 = (signed char) dreg;
  D.31293 = D.31292 & 7;
  D.31305 = D.31304 | D.31293;
  D.31306 = (unsigned char) D.31305;
  *code.348 = D.31306;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.349 = code;
        code = code.349 + 1;
        D.31308 = imb.b[0];
        *code.349 = D.31308;
        code.350 = code;
        code = code.350 + 1;
        D.31310 = imb.b[1];
        *code.350 = D.31310;
        code.351 = code;
        code = code.351 + 1;
        D.31312 = imb.b[2];
        *code.351 = D.31312;
        code.352 = code;
        code = code.352 + 1;
        D.31314 = imb.b[3];
        *code.352 = D.31314;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31302>:
  <D.24595>:
  goto <D.31315>;
  <D.31233>:
  code.353 = code;
  code = code.353 + 1;
  *code.353 = 101;
  switch (4) <default: <D.24601>, case 1: <D.24597>, case 2: <D.24599>, case 4: <D.24600>>
  <D.24597>:
  code.354 = code;
  code = code.354 + 1;
  *code.354 = 138;
  goto <D.24598>;
  <D.24599>:
  code.355 = code;
  code = code.355 + 1;
  *code.355 = 102;
  <D.24600>:
  code.356 = code;
  code = code.356 + 1;
  *code.356 = 139;
  goto <D.24598>;
  <D.24601>:
  __assert_fail ("0", "mini-x86.c", 2394, &__PRETTY_FUNCTION__);
  <D.24598>:
  code.357 = code;
  code = code.357 + 1;
  D.31239 = dreg & 7;
  D.31240 = D.31239 << 3;
  D.31241 = (signed char) D.31240;
  D.31242 = D.31241 | 5;
  D.31243 = (unsigned char) D.31242;
  *code.357 = D.31243;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.358 = code;
        code = code.358 + 1;
        D.31322 = imb.b[0];
        *code.358 = D.31322;
        code.359 = code;
        code = code.359 + 1;
        D.31324 = imb.b[1];
        *code.359 = D.31324;
        code.360 = code;
        code = code.360 + 1;
        D.31326 = imb.b[2];
        *code.360 = D.31326;
        code.361 = code;
        code = code.361 + 1;
        D.31328 = imb.b[3];
        *code.361 = D.31328;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31315>:
  D.31329 = code;
  return D.31329;
}


mono_x86_emit_tls_get_reg (guint8 * code, int dreg, int offset_reg)
{
  guint8 * D.31331;

  D.31331 = emit_tls_get_reg (code, dreg, offset_reg);
  return D.31331;
}


emit_tls_get_reg (guint8 * code, int dreg, int offset_reg)
{
  guint8 * code.362;
  guint8 * code.363;
  guint8 * code.364;
  guint8 * code.365;
  int D.31339;
  int D.31340;
  signed char D.31341;
  signed char D.31342;
  signed char D.31343;
  signed char D.31344;
  signed char D.31345;
  unsigned char D.31346;
  guint8 * code.366;
  guint8 * code.367;
  guint8 * code.368;
  guint8 * code.369;
  guint8 * code.370;
  signed char D.31356;
  unsigned char D.31357;
  guint8 * code.371;
  guint8 * code.372;
  signed char D.31363;
  unsigned char D.31364;
  guint8 * code.373;
  guint8 * code.374;
  signed char D.31368;
  unsigned char D.31369;
  guint8 * code.375;
  guint8 * code.376;
  unsigned char D.31372;
  guint8 * code.377;
  unsigned char D.31374;
  guint8 * code.378;
  unsigned char D.31376;
  guint8 * code.379;
  unsigned char D.31378;
  guint8 * code.380;
  signed char D.31382;
  signed char D.31383;
  signed char D.31384;
  unsigned char D.31385;
  guint8 * code.381;
  signed char D.31389;
  signed char D.31390;
  unsigned char D.31391;
  guint8 * code.382;
  signed char D.31394;
  signed char D.31395;
  unsigned char D.31396;
  guint8 * code.383;
  unsigned char D.31398;
  guint8 * code.384;
  unsigned char D.31400;
  guint8 * code.385;
  unsigned char D.31402;
  guint8 * code.386;
  unsigned char D.31404;
  guint8 * D.31405;
  static const char __PRETTY_FUNCTION__[17] = "emit_tls_get_reg";

  if (dreg != offset_reg) goto <D.31333>; else goto <D.31334>;
  <D.31333>:
  switch (4) <default: <D.24612>, case 1: <D.24608>, case 2: <D.24610>, case 4: <D.24611>>
  <D.24608>:
  code.362 = code;
  code = code.362 + 1;
  *code.362 = 138;
  goto <D.24609>;
  <D.24610>:
  code.363 = code;
  code = code.363 + 1;
  *code.363 = 102;
  <D.24611>:
  code.364 = code;
  code = code.364 + 1;
  *code.364 = 139;
  goto <D.24609>;
  <D.24612>:
  __assert_fail ("0", "mini-x86.c", 2406, &__PRETTY_FUNCTION__);
  <D.24609>:
  code.365 = code;
  code = code.365 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31342 = D.31341 | -64;
  D.31343 = (signed char) offset_reg;
  D.31344 = D.31343 & 7;
  D.31345 = D.31342 | D.31344;
  D.31346 = (unsigned char) D.31345;
  *code.365 = D.31346;
  <D.31334>:
  code.366 = code;
  code = code.366 + 1;
  *code.366 = 101;
  switch (4) <default: <D.24618>, case 1: <D.24614>, case 2: <D.24616>, case 4: <D.24617>>
  <D.24614>:
  code.367 = code;
  code = code.367 + 1;
  *code.367 = 138;
  goto <D.24615>;
  <D.24616>:
  code.368 = code;
  code = code.368 + 1;
  *code.368 = 102;
  <D.24617>:
  code.369 = code;
  code = code.369 + 1;
  *code.369 = 139;
  goto <D.24615>;
  <D.24618>:
  __assert_fail ("0", "mini-x86.c", 2408, &__PRETTY_FUNCTION__);
  <D.24615>:
  if (dreg == 4) goto <D.31351>; else goto <D.31352>;
  <D.31351>:
  if (1 != 0) goto <D.31353>; else goto <D.31354>;
  <D.31353>:
  code.370 = code;
  code = code.370 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31356 = D.31341 | 4;
  D.31357 = (unsigned char) D.31356;
  *code.370 = D.31357;
  code.371 = code;
  code = code.371 + 1;
  *code.371 = 36;
  goto <D.31359>;
  <D.31354>:
  if (1 != 0) goto <D.31360>; else goto <D.31361>;
  <D.31360>:
  code.372 = code;
  code = code.372 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31363 = D.31341 | 68;
  D.31364 = (unsigned char) D.31363;
  *code.372 = D.31364;
  code.373 = code;
  code = code.373 + 1;
  *code.373 = 36;
  *code = 0;
  code = code + 1;
  goto <D.31366>;
  <D.31361>:
  code.374 = code;
  code = code.374 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31368 = D.31341 | -124;
  D.31369 = (unsigned char) D.31368;
  *code.374 = D.31369;
  code.375 = code;
  code = code.375 + 1;
  *code.375 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.376 = code;
        code = code.376 + 1;
        D.31372 = imb.b[0];
        *code.376 = D.31372;
        code.377 = code;
        code = code.377 + 1;
        D.31374 = imb.b[1];
        *code.377 = D.31374;
        code.378 = code;
        code = code.378 + 1;
        D.31376 = imb.b[2];
        *code.378 = D.31376;
        code.379 = code;
        code = code.379 + 1;
        D.31378 = imb.b[3];
        *code.379 = D.31378;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31366>:
  <D.31359>:
  goto <D.24620>;
  <D.31352>:
  if (dreg != 5) goto <D.31379>; else goto <D.31380>;
  <D.31379>:
  code.380 = code;
  code = code.380 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31382 = (signed char) dreg;
  D.31383 = D.31382 & 7;
  D.31384 = D.31341 | D.31383;
  D.31385 = (unsigned char) D.31384;
  *code.380 = D.31385;
  goto <D.24620>;
  <D.31380>:
  if (1 != 0) goto <D.31386>; else goto <D.31387>;
  <D.31386>:
  code.381 = code;
  code = code.381 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31389 = D.31341 | 64;
  D.31382 = (signed char) dreg;
  D.31383 = D.31382 & 7;
  D.31390 = D.31389 | D.31383;
  D.31391 = (unsigned char) D.31390;
  *code.381 = D.31391;
  *code = 0;
  code = code + 1;
  goto <D.31392>;
  <D.31387>:
  code.382 = code;
  code = code.382 + 1;
  D.31339 = dreg & 7;
  D.31340 = D.31339 << 3;
  D.31341 = (signed char) D.31340;
  D.31394 = D.31341 | -128;
  D.31382 = (signed char) dreg;
  D.31383 = D.31382 & 7;
  D.31395 = D.31394 | D.31383;
  D.31396 = (unsigned char) D.31395;
  *code.382 = D.31396;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.383 = code;
        code = code.383 + 1;
        D.31398 = imb.b[0];
        *code.383 = D.31398;
        code.384 = code;
        code = code.384 + 1;
        D.31400 = imb.b[1];
        *code.384 = D.31400;
        code.385 = code;
        code = code.385 + 1;
        D.31402 = imb.b[2];
        *code.385 = D.31402;
        code.386 = code;
        code = code.386 + 1;
        D.31404 = imb.b[3];
        *code.386 = D.31404;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31392>:
  <D.24620>:
  D.31405 = code;
  return D.31405;
}


mono_arch_translate_tls_offset (int offset)
{
  int D.31407;

  D.31407 = offset;
  return D.31407;
}


mono_arch_output_basic_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  unsigned char * D.31409;
  unsigned int D.31410;
  unsigned int D.31411;
  unsigned int D.31412;
  signed char D.31415;
  signed char D.31418;
  int D.31421;
  unsigned int D.31422;
  unsigned int D.31423;
  guint8 * code.387;
  guint8 * code.388;
  guint8 * code.389;
  guint8 * code.390;
  guint8 * code.391;
  guint8 * code.392;
  guint8 * code.393;
  guint8 * code.394;
  guint8 * code.395;
  guint8 * code.396;
  guint8 * code.397;
  guint8 * code.398;
  guint8 * code.399;
  guint8 * code.400;
  guint8 * code.401;
  guint8 * code.402;
  guint8 * code.403;
  guint8 * code.404;
  guint8 * code.405;
  guint8 * code.406;
  guint8 * code.407;
  guint8 * code.408;
  guint8 * code.409;
  guint8 * code.410;
  guint8 * code.411;
  guint8 * code.412;
  guint8 * code.413;
  guint8 * code.414;
  unsigned int pad.415;
  unsigned int D.31455;
  int D.31456;
  unsigned int D.31457;
  int D.31460;
  int D.31461;
  unsigned int D.31462;
  unsigned int D.31463;
  unsigned char D.31466;
  unsigned char D.31467;
  _Bool D.31468;
  long int D.31469;
  long int D.31470;
  int D.31473;
  unsigned char * D.31474;
  guint8 * code.416;
  guint8 * code.417;
  int * D.31477;
  int D.31478;
  guint8 * code.418;
  unsigned char D.31480;
  guint8 * code.419;
  unsigned char D.31482;
  guint8 * code.420;
  unsigned char D.31484;
  guint8 * code.421;
  unsigned char D.31486;
  int code.422;
  int D.31488;
  int D.31489;
  struct MonoMethodDesc * mono_break_at_bb_method.423;
  struct MonoMethod * D.31493;
  int D.31494;
  int mono_break_at_bb_bb_num.424;
  guint8 * code.425;
  short unsigned int D.31501;
  int D.31502;
  int D.31503;
  short unsigned int D.31504;
  sizetype D.31505;
  sizetype D.31506;
  guint8 * D.31507;
  unsigned char D.31508;
  unsigned int D.31509;
  unsigned int max_len.426;
  unsigned int D.31511;
  unsigned int D.31512;
  _Bool D.31513;
  long int D.31514;
  long int D.31515;
  unsigned int D.31518;
  void * D.31519;
  int D.31520;
  int D.31521;
  void * D.31522;
  guint8 * code.427;
  guint8 * code.428;
  int D.31527;
  signed char D.31528;
  signed char D.31529;
  signed char D.31530;
  unsigned char D.31531;
  guint8 * code.429;
  guint8 * code.430;
  signed char D.31534;
  unsigned char D.31535;
  guint8 * code.431;
  guint8 * code.432;
  _Bool D.31540;
  int D.31541;
  unsigned char D.31542;
  unsigned char D.31543;
  guint8 * code.433;
  unsigned char D.31546;
  unsigned char D.31547;
  int D.31548;
  int D.31551;
  guint8 * code.434;
  guint8 * code.435;
  unsigned int D.31557;
  unsigned int D.31558;
  guint8 * code.436;
  guint8 * code.437;
  unsigned char D.31563;
  guint8 * code.438;
  guint8 * code.439;
  guint8 * code.440;
  unsigned char D.31568;
  guint8 * code.441;
  unsigned char D.31570;
  guint8 * code.442;
  unsigned char D.31572;
  guint8 * code.443;
  unsigned char D.31574;
  guint8 * code.444;
  unsigned char D.31580;
  unsigned char D.31581;
  guint8 * code.445;
  signed char D.31585;
  signed char D.31586;
  signed char D.31587;
  unsigned char D.31588;
  guint8 * code.446;
  signed char D.31591;
  unsigned char D.31592;
  guint8 * code.447;
  unsigned char D.31594;
  guint8 * code.448;
  unsigned char D.31596;
  guint8 * code.449;
  unsigned char D.31598;
  guint8 * code.450;
  unsigned char D.31600;
  guint8 * code.451;
  int D.31604;
  guint8 * code.452;
  guint8 * code.453;
  guint8 * code.454;
  guint8 * code.455;
  guint8 * code.456;
  guint8 * code.457;
  guint8 * code.458;
  unsigned char D.31620;
  guint8 * code.459;
  unsigned char D.31622;
  guint8 * code.460;
  unsigned char D.31624;
  guint8 * code.461;
  unsigned char D.31626;
  guint8 * code.462;
  unsigned char D.31632;
  unsigned char D.31633;
  guint8 * code.463;
  signed char D.31637;
  signed char D.31638;
  signed char D.31639;
  unsigned char D.31640;
  guint8 * code.464;
  signed char D.31643;
  unsigned char D.31644;
  guint8 * code.465;
  unsigned char D.31646;
  guint8 * code.466;
  unsigned char D.31648;
  guint8 * code.467;
  unsigned char D.31650;
  guint8 * code.468;
  unsigned char D.31652;
  int D.31653;
  unsigned char D.31654;
  guint8 * code.469;
  guint8 * code.470;
  guint8 * code.471;
  guint8 * code.472;
  guint8 * code.473;
  guint8 * code.474;
  guint8 * code.475;
  guint8 * code.476;
  guint8 * code.477;
  unsigned char D.31675;
  guint8 * code.478;
  unsigned char D.31677;
  guint8 * code.479;
  unsigned char D.31679;
  guint8 * code.480;
  unsigned char D.31681;
  guint8 * code.481;
  guint8 * code.482;
  guint8 * code.483;
  guint8 * code.484;
  unsigned char D.31693;
  guint8 * code.485;
  unsigned char D.31695;
  guint8 * code.486;
  unsigned char D.31697;
  guint8 * code.487;
  unsigned char D.31699;
  short int D.31700;
  guint8 * code.488;
  guint8 * code.489;
  guint8 * code.490;
  guint8 * code.491;
  guint8 * code.492;
  guint8 * code.493;
  guint8 * code.494;
  guint8 * code.495;
  unsigned char D.31718;
  guint8 * code.496;
  unsigned char D.31720;
  guint8 * code.497;
  unsigned char D.31722;
  guint8 * code.498;
  unsigned char D.31724;
  guint8 * code.499;
  guint8 * code.500;
  guint8 * code.501;
  guint8 * code.502;
  unsigned char D.31736;
  guint8 * code.503;
  unsigned char D.31738;
  guint8 * code.504;
  unsigned char D.31740;
  guint8 * code.505;
  unsigned char D.31742;
  guint8 * code.506;
  unsigned char D.31744;
  guint8 * code.507;
  unsigned char D.31746;
  guint8 * code.508;
  unsigned char D.31748;
  guint8 * code.509;
  unsigned char D.31750;
  guint8 * code.510;
  guint8 * code.511;
  guint8 * code.512;
  guint8 * code.513;
  guint8 * code.514;
  guint8 * code.515;
  guint8 * code.516;
  guint8 * code.517;
  unsigned char D.31769;
  guint8 * code.518;
  unsigned char D.31771;
  guint8 * code.519;
  unsigned char D.31773;
  guint8 * code.520;
  unsigned char D.31775;
  guint8 * code.521;
  guint8 * code.522;
  guint8 * code.523;
  guint8 * code.524;
  unsigned char D.31787;
  guint8 * code.525;
  unsigned char D.31789;
  guint8 * code.526;
  unsigned char D.31791;
  guint8 * code.527;
  unsigned char D.31793;
  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;
  unsigned char D.31814;
  guint8 * code.537;
  unsigned char D.31816;
  guint8 * code.538;
  unsigned char D.31818;
  guint8 * code.539;
  unsigned char D.31820;
  guint8 * code.540;
  guint8 * code.541;
  guint8 * code.542;
  guint8 * code.543;
  unsigned char D.31832;
  guint8 * code.544;
  unsigned char D.31834;
  guint8 * code.545;
  unsigned char D.31836;
  guint8 * code.546;
  unsigned char D.31838;
  guint8 * code.547;
  guint8 * code.548;
  guint8 * code.549;
  guint8 * code.550;
  guint8 * code.551;
  guint8 * code.552;
  guint8 * code.553;
  guint8 * code.554;
  unsigned char D.31856;
  guint8 * code.555;
  unsigned char D.31858;
  guint8 * code.556;
  unsigned char D.31860;
  guint8 * code.557;
  unsigned char D.31862;
  guint8 * code.558;
  guint8 * code.559;
  guint8 * code.560;
  guint8 * code.561;
  unsigned char D.31874;
  guint8 * code.562;
  unsigned char D.31876;
  guint8 * code.563;
  unsigned char D.31878;
  guint8 * code.564;
  unsigned char D.31880;
  guint8 * code.565;
  unsigned char D.31882;
  guint8 * code.566;
  unsigned char D.31884;
  guint8 * code.567;
  unsigned char D.31886;
  guint8 * code.568;
  unsigned char D.31888;
  guint8 * code.569;
  guint8 * code.570;
  guint8 * code.571;
  guint8 * code.572;
  guint8 * code.573;
  guint8 * code.574;
  guint8 * code.575;
  guint8 * code.576;
  unsigned char D.31907;
  guint8 * code.577;
  unsigned char D.31909;
  guint8 * code.578;
  unsigned char D.31911;
  guint8 * code.579;
  unsigned char D.31913;
  guint8 * code.580;
  guint8 * code.581;
  guint8 * code.582;
  guint8 * code.583;
  unsigned char D.31925;
  guint8 * code.584;
  unsigned char D.31927;
  guint8 * code.585;
  unsigned char D.31929;
  guint8 * code.586;
  unsigned char D.31931;
  guint8 * code.587;
  guint8 * code.588;
  guint8 * code.589;
  guint8 * code.590;
  guint8 * code.591;
  guint8 * code.592;
  guint8 * code.593;
  guint8 * code.594;
  guint8 * code.595;
  unsigned char D.31952;
  guint8 * code.596;
  unsigned char D.31954;
  guint8 * code.597;
  unsigned char D.31956;
  guint8 * code.598;
  unsigned char D.31958;
  guint8 * code.599;
  guint8 * code.600;
  guint8 * code.601;
  guint8 * code.602;
  unsigned char D.31970;
  guint8 * code.603;
  unsigned char D.31972;
  guint8 * code.604;
  unsigned char D.31974;
  guint8 * code.605;
  unsigned char D.31976;
  guint8 * code.606;
  guint8 * code.607;
  guint8 * code.608;
  guint8 * code.609;
  guint8 * code.610;
  guint8 * code.611;
  guint8 * code.612;
  guint8 * code.613;
  unsigned char D.31994;
  guint8 * code.614;
  unsigned char D.31996;
  guint8 * code.615;
  unsigned char D.31998;
  guint8 * code.616;
  unsigned char D.32000;
  guint8 * code.617;
  guint8 * code.618;
  guint8 * code.619;
  guint8 * code.620;
  unsigned char D.32012;
  guint8 * code.621;
  unsigned char D.32014;
  guint8 * code.622;
  unsigned char D.32016;
  guint8 * code.623;
  unsigned char D.32018;
  guint8 * code.624;
  unsigned char D.32020;
  guint8 * code.625;
  unsigned char D.32022;
  guint8 * code.626;
  unsigned char D.32024;
  guint8 * code.627;
  unsigned char D.32026;
  guint8 * code.628;
  guint8 * code.629;
  guint8 * code.630;
  guint8 * code.631;
  int D.32035;
  int D.32036;
  signed char D.32037;
  signed char D.32038;
  unsigned char D.32039;
  guint8 * code.632;
  guint8 * code.633;
  signed char D.32045;
  unsigned char D.32046;
  guint8 * code.634;
  guint8 * code.635;
  signed char D.32050;
  unsigned char D.32051;
  guint8 * code.636;
  guint8 * code.637;
  unsigned char D.32054;
  guint8 * code.638;
  unsigned char D.32056;
  guint8 * code.639;
  unsigned char D.32058;
  guint8 * code.640;
  unsigned char D.32060;
  guint8 * code.641;
  signed char D.32066;
  unsigned char D.32067;
  guint8 * code.642;
  signed char D.32071;
  signed char D.32072;
  unsigned char D.32073;
  guint8 * code.643;
  signed char D.32076;
  signed char D.32077;
  unsigned char D.32078;
  guint8 * code.644;
  unsigned char D.32080;
  guint8 * code.645;
  unsigned char D.32082;
  guint8 * code.646;
  unsigned char D.32084;
  guint8 * code.647;
  unsigned char D.32086;
  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;
  unsigned char D.32105;
  guint8 * code.658;
  unsigned char D.32107;
  guint8 * code.659;
  unsigned char D.32109;
  guint8 * code.660;
  unsigned char D.32111;
  guint8 * code.661;
  guint8 * code.662;
  guint8 * code.663;
  guint8 * code.664;
  unsigned char D.32123;
  guint8 * code.665;
  unsigned char D.32125;
  guint8 * code.666;
  unsigned char D.32127;
  guint8 * code.667;
  unsigned char D.32129;
  guint8 * code.668;
  guint8 * code.669;
  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.32148;
  guint8 * code.678;
  unsigned char D.32150;
  guint8 * code.679;
  unsigned char D.32152;
  guint8 * code.680;
  unsigned char D.32154;
  guint8 * code.681;
  guint8 * code.682;
  guint8 * code.683;
  guint8 * code.684;
  unsigned char D.32166;
  guint8 * code.685;
  unsigned char D.32168;
  guint8 * code.686;
  unsigned char D.32170;
  guint8 * code.687;
  unsigned char D.32172;
  guint8 * code.688;
  guint8 * code.689;
  void * D.32177;
  int D.32178;
  guint8 * code.690;
  unsigned char D.32180;
  guint8 * code.691;
  unsigned char D.32182;
  guint8 * code.692;
  unsigned char D.32184;
  guint8 * code.693;
  unsigned char D.32186;
  guint8 * code.694;
  guint8 * code.695;
  guint8 * code.696;
  guint8 * code.697;
  unsigned char D.32194;
  guint8 * code.698;
  unsigned char D.32196;
  guint8 * code.699;
  unsigned char D.32198;
  guint8 * code.700;
  unsigned char D.32200;
  short int D.32201;
  guint8 * code.701;
  guint8 * code.702;
  guint8 * code.703;
  unsigned char D.32206;
  guint8 * code.704;
  unsigned char D.32208;
  guint8 * code.705;
  unsigned char D.32210;
  guint8 * code.706;
  unsigned char D.32212;
  guint8 * code.707;
  unsigned char D.32214;
  guint8 * code.708;
  unsigned char D.32216;
  guint8 * code.709;
  unsigned char D.32218;
  guint8 * code.710;
  unsigned char D.32220;
  guint8 * code.711;
  guint8 * code.712;
  guint8 * code.713;
  guint8 * code.714;
  int D.32225;
  int D.32226;
  signed char D.32227;
  signed char D.32228;
  unsigned char D.32229;
  guint8 * code.715;
  unsigned char D.32231;
  guint8 * code.716;
  unsigned char D.32233;
  guint8 * code.717;
  unsigned char D.32235;
  guint8 * code.718;
  unsigned char D.32237;
  guint8 * code.719;
  guint8 * code.720;
  guint8 * code.721;
  guint8 * code.722;
  guint8 * code.723;
  unsigned char D.32243;
  guint8 * code.724;
  unsigned char D.32245;
  guint8 * code.725;
  unsigned char D.32247;
  guint8 * code.726;
  unsigned char D.32249;
  guint8 * code.727;
  guint8 * code.728;
  guint8 * code.729;
  guint8 * code.730;
  unsigned char D.32258;
  guint8 * code.731;
  unsigned char D.32260;
  guint8 * code.732;
  unsigned char D.32262;
  guint8 * code.733;
  unsigned char D.32264;
  guint8 * code.734;
  guint8 * code.735;
  guint8 * code.736;
  guint8 * code.737;
  unsigned char D.32273;
  guint8 * code.738;
  unsigned char D.32275;
  guint8 * code.739;
  unsigned char D.32277;
  guint8 * code.740;
  unsigned char D.32279;
  guint8 * code.741;
  guint8 * code.742;
  guint8 * code.743;
  guint8 * code.744;
  signed char D.32288;
  unsigned char D.32289;
  guint8 * code.745;
  guint8 * code.746;
  signed char D.32295;
  unsigned char D.32296;
  guint8 * code.747;
  guint8 * code.748;
  signed char D.32300;
  unsigned char D.32301;
  guint8 * code.749;
  guint8 * code.750;
  unsigned char D.32304;
  guint8 * code.751;
  unsigned char D.32306;
  guint8 * code.752;
  unsigned char D.32308;
  guint8 * code.753;
  unsigned char D.32310;
  guint8 * code.754;
  signed char D.32316;
  unsigned char D.32317;
  guint8 * code.755;
  signed char D.32321;
  signed char D.32322;
  unsigned char D.32323;
  guint8 * code.756;
  signed char D.32326;
  signed char D.32327;
  unsigned char D.32328;
  guint8 * code.757;
  unsigned char D.32330;
  guint8 * code.758;
  unsigned char D.32332;
  guint8 * code.759;
  unsigned char D.32334;
  guint8 * code.760;
  unsigned char D.32336;
  guint8 * code.761;
  guint8 * code.762;
  guint8 * code.763;
  guint8 * code.764;
  guint8 * code.765;
  guint8 * code.766;
  guint8 * code.767;
  guint8 * code.768;
  guint8 * code.769;
  unsigned char D.32358;
  guint8 * code.770;
  unsigned char D.32360;
  guint8 * code.771;
  unsigned char D.32362;
  guint8 * code.772;
  unsigned char D.32364;
  guint8 * code.773;
  guint8 * code.774;
  guint8 * code.775;
  guint8 * code.776;
  unsigned char D.32376;
  guint8 * code.777;
  unsigned char D.32378;
  guint8 * code.778;
  unsigned char D.32380;
  guint8 * code.779;
  unsigned char D.32382;
  guint8 * code.780;
  guint8 * code.781;
  guint8 * code.782;
  guint8 * code.783;
  guint8 * code.784;
  guint8 * code.785;
  guint8 * code.786;
  guint8 * code.787;
  guint8 * code.788;
  unsigned char D.32404;
  guint8 * code.789;
  unsigned char D.32406;
  guint8 * code.790;
  unsigned char D.32408;
  guint8 * code.791;
  unsigned char D.32410;
  guint8 * code.792;
  guint8 * code.793;
  guint8 * code.794;
  guint8 * code.795;
  unsigned char D.32422;
  guint8 * code.796;
  unsigned char D.32424;
  guint8 * code.797;
  unsigned char D.32426;
  guint8 * code.798;
  unsigned char D.32428;
  guint8 * code.799;
  guint8 * code.800;
  guint8 * code.801;
  guint8 * code.802;
  guint8 * code.803;
  guint8 * code.804;
  guint8 * code.805;
  guint8 * code.806;
  guint8 * code.807;
  unsigned char D.32450;
  guint8 * code.808;
  unsigned char D.32452;
  guint8 * code.809;
  unsigned char D.32454;
  guint8 * code.810;
  unsigned char D.32456;
  guint8 * code.811;
  guint8 * code.812;
  guint8 * code.813;
  guint8 * code.814;
  unsigned char D.32468;
  guint8 * code.815;
  unsigned char D.32470;
  guint8 * code.816;
  unsigned char D.32472;
  guint8 * code.817;
  unsigned char D.32474;
  guint8 * code.818;
  guint8 * code.819;
  guint8 * code.820;
  guint8 * code.821;
  guint8 * code.822;
  guint8 * code.823;
  guint8 * code.824;
  guint8 * code.825;
  guint8 * code.826;
  unsigned char D.32496;
  guint8 * code.827;
  unsigned char D.32498;
  guint8 * code.828;
  unsigned char D.32500;
  guint8 * code.829;
  unsigned char D.32502;
  guint8 * code.830;
  guint8 * code.831;
  guint8 * code.832;
  guint8 * code.833;
  unsigned char D.32514;
  guint8 * code.834;
  unsigned char D.32516;
  guint8 * code.835;
  unsigned char D.32518;
  guint8 * code.836;
  unsigned char D.32520;
  _Bool D.32521;
  long int D.32522;
  long int D.32523;
  guint8 * code.837;
  guint8 * code.838;
  guint8 * code.839;
  signed char D.32533;
  signed char D.32534;
  unsigned char D.32535;
  guint8 * code.840;
  guint8 * code.841;
  guint8 * code.842;
  guint8 * code.843;
  guint8 * code.844;
  guint8 * code.845;
  guint8 * code.846;
  guint8 * code.847;
  guint8 * code.848;
  guint8 * code.849;
  guint8 * code.850;
  signed char D.32565;
  signed char D.32566;
  unsigned char D.32567;
  guint8 * code.851;
  guint8 * code.852;
  unsigned char D.32572;
  guint8 * code.853;
  unsigned char D.32574;
  guint8 * code.854;
  unsigned char D.32576;
  guint8 * code.855;
  unsigned char D.32578;
  unsigned int D.32579;
  unsigned int D.32580;
  guint8 * code.856;
  guint8 * code.857;
  signed char D.32585;
  unsigned char D.32586;
  guint8 * code.858;
  guint8 * code.859;
  guint8 * code.860;
  unsigned char D.32591;
  guint8 * code.861;
  unsigned char D.32593;
  guint8 * code.862;
  unsigned char D.32595;
  guint8 * code.863;
  unsigned char D.32597;
  guint8 * code.864;
  guint8 * code.865;
  int D.32604;
  int D.32605;
  signed char D.32606;
  signed char D.32607;
  unsigned char D.32608;
  guint8 * code.866;
  guint8 * code.867;
  signed char D.32614;
  unsigned char D.32615;
  guint8 * code.868;
  guint8 * code.869;
  signed char D.32619;
  unsigned char D.32620;
  guint8 * code.870;
  guint8 * code.871;
  unsigned char D.32623;
  guint8 * code.872;
  unsigned char D.32625;
  guint8 * code.873;
  unsigned char D.32627;
  guint8 * code.874;
  unsigned char D.32629;
  guint8 * code.875;
  signed char D.32635;
  unsigned char D.32636;
  guint8 * code.876;
  signed char D.32640;
  signed char D.32641;
  unsigned char D.32642;
  guint8 * code.877;
  signed char D.32645;
  signed char D.32646;
  unsigned char D.32647;
  guint8 * code.878;
  unsigned char D.32649;
  guint8 * code.879;
  unsigned char D.32651;
  guint8 * code.880;
  unsigned char D.32653;
  guint8 * code.881;
  unsigned char D.32655;
  guint8 * code.882;
  guint8 * code.883;
  guint8 * code.884;
  guint8 * code.885;
  guint8 * code.886;
  guint8 * code.887;
  guint8 * code.888;
  guint8 * code.889;
  unsigned char D.32674;
  guint8 * code.890;
  unsigned char D.32676;
  guint8 * code.891;
  unsigned char D.32678;
  guint8 * code.892;
  unsigned char D.32680;
  guint8 * code.893;
  signed char D.32686;
  unsigned char D.32687;
  guint8 * code.894;
  signed char D.32691;
  unsigned char D.32692;
  guint8 * code.895;
  signed char D.32695;
  unsigned char D.32696;
  guint8 * code.896;
  unsigned char D.32698;
  guint8 * code.897;
  unsigned char D.32700;
  guint8 * code.898;
  unsigned char D.32702;
  guint8 * code.899;
  unsigned char D.32704;
  guint8 * code.900;
  guint8 * code.901;
  guint8 * code.902;
  guint8 * code.903;
  guint8 * code.904;
  guint8 * code.905;
  guint8 * code.906;
  guint8 * code.907;
  unsigned char D.32722;
  guint8 * code.908;
  unsigned char D.32724;
  guint8 * code.909;
  unsigned char D.32726;
  guint8 * code.910;
  unsigned char D.32728;
  guint8 * code.911;
  guint8 * code.912;
  guint8 * code.913;
  guint8 * code.914;
  unsigned char D.32740;
  guint8 * code.915;
  unsigned char D.32742;
  guint8 * code.916;
  unsigned char D.32744;
  guint8 * code.917;
  unsigned char D.32746;
  guint8 * code.918;
  unsigned char D.32748;
  guint8 * code.919;
  unsigned char D.32750;
  guint8 * code.920;
  unsigned char D.32752;
  guint8 * code.921;
  unsigned char D.32754;
  guint8 * code.922;
  guint8 * code.923;
  guint8 * code.924;
  guint8 * code.925;
  guint8 * code.926;
  guint8 * code.927;
  guint8 * code.928;
  guint8 * code.929;
  unsigned char D.32771;
  guint8 * code.930;
  unsigned char D.32773;
  guint8 * code.931;
  unsigned char D.32775;
  guint8 * code.932;
  unsigned char D.32777;
  guint8 * code.933;
  guint8 * code.934;
  guint8 * code.935;
  guint8 * code.936;
  unsigned char D.32789;
  guint8 * code.937;
  unsigned char D.32791;
  guint8 * code.938;
  unsigned char D.32793;
  guint8 * code.939;
  unsigned char D.32795;
  guint8 * code.940;
  guint8 * code.941;
  guint8 * code.942;
  guint8 * code.943;
  guint8 * code.944;
  guint8 * code.945;
  guint8 * code.946;
  guint8 * code.947;
  unsigned char D.32812;
  guint8 * code.948;
  unsigned char D.32814;
  guint8 * code.949;
  unsigned char D.32816;
  guint8 * code.950;
  unsigned char D.32818;
  guint8 * code.951;
  signed char D.32824;
  unsigned char D.32825;
  guint8 * code.952;
  signed char D.32829;
  unsigned char D.32830;
  guint8 * code.953;
  signed char D.32833;
  unsigned char D.32834;
  guint8 * code.954;
  unsigned char D.32836;
  guint8 * code.955;
  unsigned char D.32838;
  guint8 * code.956;
  unsigned char D.32840;
  guint8 * code.957;
  unsigned char D.32842;
  guint8 * code.958;
  guint8 * code.959;
  guint8 * code.960;
  unsigned char D.32848;
  guint8 * code.961;
  unsigned char D.32850;
  guint8 * code.962;
  unsigned char D.32852;
  guint8 * code.963;
  unsigned char D.32854;
  guint8 * code.964;
  guint8 * code.965;
  guint8 * code.966;
  unsigned char D.32859;
  guint8 * code.967;
  unsigned char D.32861;
  guint8 * code.968;
  unsigned char D.32863;
  guint8 * code.969;
  unsigned char D.32865;
  guint8 * code.970;
  unsigned char D.32867;
  guint8 * code.971;
  unsigned char D.32869;
  guint8 * code.972;
  unsigned char D.32871;
  guint8 * code.973;
  unsigned char D.32873;
  guint8 * code.974;
  guint8 * code.975;
  signed char D.32876;
  unsigned char D.32877;
  guint8 * code.976;
  guint8 * code.977;
  guint8 * code.978;
  guint8 * code.979;
  guint8 * code.980;
  guint8 * code.981;
  guint8 * code.982;
  guint8 * code.983;
  unsigned char D.32896;
  guint8 * code.984;
  unsigned char D.32898;
  guint8 * code.985;
  unsigned char D.32900;
  guint8 * code.986;
  unsigned char D.32902;
  guint8 * code.987;
  guint8 * code.988;
  guint8 * code.989;
  guint8 * code.990;
  unsigned char D.32914;
  guint8 * code.991;
  unsigned char D.32916;
  guint8 * code.992;
  unsigned char D.32918;
  guint8 * code.993;
  unsigned char D.32920;
  guint8 * code.994;
  guint8 * code.995;
  guint8 * code.996;
  guint8 * code.997;
  guint8 * code.998;
  guint8 * code.999;
  guint8 * code.1000;
  guint8 * code.1001;
  unsigned char D.32938;
  guint8 * code.1002;
  unsigned char D.32940;
  guint8 * code.1003;
  unsigned char D.32942;
  guint8 * code.1004;
  unsigned char D.32944;
  guint8 * code.1005;
  guint8 * code.1006;
  guint8 * code.1007;
  guint8 * code.1008;
  unsigned char D.32956;
  guint8 * code.1009;
  unsigned char D.32958;
  guint8 * code.1010;
  unsigned char D.32960;
  guint8 * code.1011;
  unsigned char D.32962;
  guint8 * code.1012;
  unsigned char D.32964;
  guint8 * code.1013;
  unsigned char D.32966;
  guint8 * code.1014;
  unsigned char D.32968;
  guint8 * code.1015;
  unsigned char D.32970;
  guint8 * code.1016;
  guint8 * code.1017;
  guint8 * code.1018;
  guint8 * code.1019;
  guint8 * code.1020;
  guint8 * code.1021;
  guint8 * code.1022;
  guint8 * code.1023;
  unsigned char D.32987;
  guint8 * code.1024;
  unsigned char D.32989;
  guint8 * code.1025;
  unsigned char D.32991;
  guint8 * code.1026;
  unsigned char D.32993;
  guint8 * code.1027;
  guint8 * code.1028;
  guint8 * code.1029;
  guint8 * code.1030;
  unsigned char D.33005;
  guint8 * code.1031;
  unsigned char D.33007;
  guint8 * code.1032;
  unsigned char D.33009;
  guint8 * code.1033;
  unsigned char D.33011;
  guint8 * code.1034;
  guint8 * code.1035;
  guint8 * code.1036;
  guint8 * code.1037;
  guint8 * code.1038;
  guint8 * code.1039;
  guint8 * code.1040;
  guint8 * code.1041;
  unsigned char D.33030;
  guint8 * code.1042;
  unsigned char D.33032;
  guint8 * code.1043;
  unsigned char D.33034;
  guint8 * code.1044;
  unsigned char D.33036;
  guint8 * code.1045;
  signed char D.33042;
  unsigned char D.33043;
  guint8 * code.1046;
  signed char D.33047;
  unsigned char D.33048;
  guint8 * code.1047;
  signed char D.33051;
  unsigned char D.33052;
  guint8 * code.1048;
  unsigned char D.33054;
  guint8 * code.1049;
  unsigned char D.33056;
  guint8 * code.1050;
  unsigned char D.33058;
  guint8 * code.1051;
  unsigned char D.33060;
  guint8 * code.1052;
  guint8 * code.1053;
  guint8 * code.1054;
  guint8 * code.1055;
  guint8 * code.1056;
  guint8 * code.1057;
  guint8 * code.1058;
  guint8 * code.1059;
  unsigned char D.33078;
  guint8 * code.1060;
  unsigned char D.33080;
  guint8 * code.1061;
  unsigned char D.33082;
  guint8 * code.1062;
  unsigned char D.33084;
  guint8 * code.1063;
  guint8 * code.1064;
  guint8 * code.1065;
  guint8 * code.1066;
  unsigned char D.33096;
  guint8 * code.1067;
  unsigned char D.33098;
  guint8 * code.1068;
  unsigned char D.33100;
  guint8 * code.1069;
  unsigned char D.33102;
  guint8 * code.1070;
  unsigned char D.33104;
  guint8 * code.1071;
  unsigned char D.33106;
  guint8 * code.1072;
  unsigned char D.33108;
  guint8 * code.1073;
  unsigned char D.33110;
  guint8 * code.1074;
  guint8 * code.1075;
  guint8 * code.1076;
  guint8 * code.1077;
  guint8 * code.1078;
  guint8 * code.1079;
  guint8 * code.1080;
  guint8 * code.1081;
  unsigned char D.33127;
  guint8 * code.1082;
  unsigned char D.33129;
  guint8 * code.1083;
  unsigned char D.33131;
  guint8 * code.1084;
  unsigned char D.33133;
  guint8 * code.1085;
  guint8 * code.1086;
  guint8 * code.1087;
  guint8 * code.1088;
  unsigned char D.33145;
  guint8 * code.1089;
  unsigned char D.33147;
  guint8 * code.1090;
  unsigned char D.33149;
  guint8 * code.1091;
  unsigned char D.33151;
  guint8 * code.1092;
  guint8 * code.1093;
  guint8 * code.1094;
  guint8 * code.1095;
  guint8 * code.1096;
  guint8 * code.1097;
  guint8 * code.1098;
  guint8 * code.1099;
  unsigned char D.33170;
  guint8 * code.1100;
  unsigned char D.33172;
  guint8 * code.1101;
  unsigned char D.33174;
  guint8 * code.1102;
  unsigned char D.33176;
  guint8 * code.1103;
  signed char D.33182;
  unsigned char D.33183;
  guint8 * code.1104;
  signed char D.33187;
  unsigned char D.33188;
  guint8 * code.1105;
  signed char D.33191;
  unsigned char D.33192;
  guint8 * code.1106;
  unsigned char D.33194;
  guint8 * code.1107;
  unsigned char D.33196;
  guint8 * code.1108;
  unsigned char D.33198;
  guint8 * code.1109;
  unsigned char D.33200;
  guint8 * code.1110;
  guint8 * code.1111;
  guint8 * code.1112;
  guint8 * code.1113;
  guint8 * code.1114;
  guint8 * code.1115;
  guint8 * code.1116;
  guint8 * code.1117;
  unsigned char D.33218;
  guint8 * code.1118;
  unsigned char D.33220;
  guint8 * code.1119;
  unsigned char D.33222;
  guint8 * code.1120;
  unsigned char D.33224;
  guint8 * code.1121;
  guint8 * code.1122;
  guint8 * code.1123;
  guint8 * code.1124;
  unsigned char D.33236;
  guint8 * code.1125;
  unsigned char D.33238;
  guint8 * code.1126;
  unsigned char D.33240;
  guint8 * code.1127;
  unsigned char D.33242;
  guint8 * code.1128;
  unsigned char D.33244;
  guint8 * code.1129;
  unsigned char D.33246;
  guint8 * code.1130;
  unsigned char D.33248;
  guint8 * code.1131;
  unsigned char D.33250;
  guint8 * code.1132;
  guint8 * code.1133;
  guint8 * code.1134;
  guint8 * code.1135;
  guint8 * code.1136;
  guint8 * code.1137;
  guint8 * code.1138;
  guint8 * code.1139;
  unsigned char D.33269;
  guint8 * code.1140;
  unsigned char D.33271;
  guint8 * code.1141;
  unsigned char D.33273;
  guint8 * code.1142;
  unsigned char D.33275;
  guint8 * code.1143;
  signed char D.33281;
  unsigned char D.33282;
  guint8 * code.1144;
  signed char D.33286;
  unsigned char D.33287;
  guint8 * code.1145;
  signed char D.33290;
  unsigned char D.33291;
  guint8 * code.1146;
  unsigned char D.33293;
  guint8 * code.1147;
  unsigned char D.33295;
  guint8 * code.1148;
  unsigned char D.33297;
  guint8 * code.1149;
  unsigned char D.33299;
  guint8 * code.1150;
  guint8 * code.1151;
  guint8 * code.1152;
  guint8 * code.1153;
  guint8 * code.1154;
  guint8 * code.1155;
  guint8 * code.1156;
  guint8 * code.1157;
  unsigned char D.33317;
  guint8 * code.1158;
  unsigned char D.33319;
  guint8 * code.1159;
  unsigned char D.33321;
  guint8 * code.1160;
  unsigned char D.33323;
  guint8 * code.1161;
  guint8 * code.1162;
  guint8 * code.1163;
  guint8 * code.1164;
  unsigned char D.33335;
  guint8 * code.1165;
  unsigned char D.33337;
  guint8 * code.1166;
  unsigned char D.33339;
  guint8 * code.1167;
  unsigned char D.33341;
  guint8 * code.1168;
  unsigned char D.33343;
  guint8 * code.1169;
  unsigned char D.33345;
  guint8 * code.1170;
  unsigned char D.33347;
  guint8 * code.1171;
  unsigned char D.33349;
  guint8 * code.1172;
  guint8 * code.1173;
  guint8 * code.1174;
  guint8 * code.1175;
  guint8 * code.1176;
  guint8 * code.1177;
  guint8 * code.1178;
  guint8 * code.1179;
  unsigned char D.33368;
  guint8 * code.1180;
  unsigned char D.33370;
  guint8 * code.1181;
  unsigned char D.33372;
  guint8 * code.1182;
  unsigned char D.33374;
  guint8 * code.1183;
  signed char D.33380;
  unsigned char D.33381;
  guint8 * code.1184;
  signed char D.33385;
  unsigned char D.33386;
  guint8 * code.1185;
  signed char D.33389;
  unsigned char D.33390;
  guint8 * code.1186;
  unsigned char D.33392;
  guint8 * code.1187;
  unsigned char D.33394;
  guint8 * code.1188;
  unsigned char D.33396;
  guint8 * code.1189;
  unsigned char D.33398;
  guint8 * code.1190;
  guint8 * code.1191;
  guint8 * code.1192;
  guint8 * code.1193;
  guint8 * code.1194;
  guint8 * code.1195;
  guint8 * code.1196;
  guint8 * code.1197;
  unsigned char D.33416;
  guint8 * code.1198;
  unsigned char D.33418;
  guint8 * code.1199;
  unsigned char D.33420;
  guint8 * code.1200;
  unsigned char D.33422;
  guint8 * code.1201;
  guint8 * code.1202;
  guint8 * code.1203;
  guint8 * code.1204;
  unsigned char D.33434;
  guint8 * code.1205;
  unsigned char D.33436;
  guint8 * code.1206;
  unsigned char D.33438;
  guint8 * code.1207;
  unsigned char D.33440;
  guint8 * code.1208;
  unsigned char D.33442;
  guint8 * code.1209;
  unsigned char D.33444;
  guint8 * code.1210;
  unsigned char D.33446;
  guint8 * code.1211;
  unsigned char D.33448;
  guint8 * code.1212;
  guint8 * code.1213;
  guint8 * code.1214;
  guint8 * code.1215;
  guint8 * code.1216;
  guint8 * code.1217;
  guint8 * code.1218;
  guint8 * code.1219;
  unsigned char D.33465;
  guint8 * code.1220;
  unsigned char D.33467;
  guint8 * code.1221;
  unsigned char D.33469;
  guint8 * code.1222;
  unsigned char D.33471;
  guint8 * code.1223;
  guint8 * code.1224;
  guint8 * code.1225;
  guint8 * code.1226;
  unsigned char D.33483;
  guint8 * code.1227;
  unsigned char D.33485;
  guint8 * code.1228;
  unsigned char D.33487;
  guint8 * code.1229;
  unsigned char D.33489;
  guint8 * code.1230;
  guint8 * code.1231;
  guint8 * code.1232;
  guint8 * code.1233;
  guint8 * code.1234;
  guint8 * code.1235;
  guint8 * code.1236;
  guint8 * code.1237;
  unsigned char D.33506;
  guint8 * code.1238;
  unsigned char D.33508;
  guint8 * code.1239;
  unsigned char D.33510;
  guint8 * code.1240;
  unsigned char D.33512;
  guint8 * code.1241;
  guint8 * code.1242;
  guint8 * code.1243;
  guint8 * code.1244;
  unsigned char D.33524;
  guint8 * code.1245;
  unsigned char D.33526;
  guint8 * code.1246;
  unsigned char D.33528;
  guint8 * code.1247;
  unsigned char D.33530;
  guint8 * code.1248;
  guint8 * code.1249;
  guint8 * code.1250;
  guint8 * code.1251;
  guint8 * code.1252;
  guint8 * code.1253;
  guint8 * code.1254;
  guint8 * code.1255;
  unsigned char D.33547;
  guint8 * code.1256;
  unsigned char D.33549;
  guint8 * code.1257;
  unsigned char D.33551;
  guint8 * code.1258;
  unsigned char D.33553;
  guint8 * code.1259;
  guint8 * code.1260;
  guint8 * code.1261;
  guint8 * code.1262;
  unsigned char D.33565;
  guint8 * code.1263;
  unsigned char D.33567;
  guint8 * code.1264;
  unsigned char D.33569;
  guint8 * code.1265;
  unsigned char D.33571;
  guint8 * code.1266;
  guint8 * code.1267;
  guint8 * code.1268;
  guint8 * code.1269;
  guint8 * code.1270;
  guint8 * code.1271;
  guint8 * code.1272;
  guint8 * code.1273;
  unsigned char D.33588;
  guint8 * code.1274;
  unsigned char D.33590;
  guint8 * code.1275;
  unsigned char D.33592;
  guint8 * code.1276;
  unsigned char D.33594;
  guint8 * code.1277;
  guint8 * code.1278;
  guint8 * code.1279;
  guint8 * code.1280;
  unsigned char D.33606;
  guint8 * code.1281;
  unsigned char D.33608;
  guint8 * code.1282;
  unsigned char D.33610;
  guint8 * code.1283;
  unsigned char D.33612;
  guint8 * code.1284;
  guint8 * code.1285;
  guint8 * code.1286;
  guint8 * code.1287;
  guint8 * code.1288;
  guint8 * code.1289;
  guint8 * code.1290;
  guint8 * code.1291;
  unsigned char D.33629;
  guint8 * code.1292;
  unsigned char D.33631;
  guint8 * code.1293;
  unsigned char D.33633;
  guint8 * code.1294;
  unsigned char D.33635;
  guint8 * code.1295;
  guint8 * code.1296;
  guint8 * code.1297;
  guint8 * code.1298;
  unsigned char D.33647;
  guint8 * code.1299;
  unsigned char D.33649;
  guint8 * code.1300;
  unsigned char D.33651;
  guint8 * code.1301;
  unsigned char D.33653;
  guint8 * code.1302;
  guint8 * code.1303;
  guint8 * code.1304;
  guint8 * code.1305;
  guint8 * code.1306;
  guint8 * code.1307;
  guint8 * code.1308;
  guint8 * code.1309;
  unsigned char D.33670;
  guint8 * code.1310;
  unsigned char D.33672;
  guint8 * code.1311;
  unsigned char D.33674;
  guint8 * code.1312;
  unsigned char D.33676;
  guint8 * code.1313;
  guint8 * code.1314;
  guint8 * code.1315;
  guint8 * code.1316;
  unsigned char D.33688;
  guint8 * code.1317;
  unsigned char D.33690;
  guint8 * code.1318;
  unsigned char D.33692;
  guint8 * code.1319;
  unsigned char D.33694;
  guint8 * code.1320;
  unsigned char D.33696;
  unsigned char D.33697;
  guint8 * code.1321;
  guint8 * code.1322;
  guint8 * code.1323;
  guint8 * code.1324;
  guint8 * code.1325;
  guint8 * code.1326;
  guint8 * code.1327;
  guint8 * code.1328;
  unsigned char D.33714;
  guint8 * code.1329;
  unsigned char D.33716;
  guint8 * code.1330;
  unsigned char D.33718;
  guint8 * code.1331;
  unsigned char D.33720;
  guint8 * code.1332;
  guint8 * code.1333;
  guint8 * code.1334;
  guint8 * code.1335;
  unsigned char D.33732;
  guint8 * code.1336;
  unsigned char D.33734;
  guint8 * code.1337;
  unsigned char D.33736;
  guint8 * code.1338;
  unsigned char D.33738;
  guint8 * code.1339;
  unsigned char D.33740;
  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;
  unsigned char D.33758;
  guint8 * code.1349;
  unsigned char D.33760;
  guint8 * code.1350;
  unsigned char D.33762;
  guint8 * code.1351;
  unsigned char D.33764;
  guint8 * code.1352;
  guint8 * code.1353;
  guint8 * code.1354;
  guint8 * code.1355;
  unsigned char D.33776;
  guint8 * code.1356;
  unsigned char D.33778;
  guint8 * code.1357;
  unsigned char D.33780;
  guint8 * code.1358;
  unsigned char D.33782;
  guint8 * code.1359;
  guint8 * code.1360;
  guint8 * code.1361;
  guint8 * code.1362;
  guint8 * code.1363;
  guint8 * code.1364;
  guint8 * code.1365;
  guint8 * code.1366;
  unsigned char D.33799;
  guint8 * code.1367;
  unsigned char D.33801;
  guint8 * code.1368;
  unsigned char D.33803;
  guint8 * code.1369;
  unsigned char D.33805;
  guint8 * code.1370;
  guint8 * code.1371;
  guint8 * code.1372;
  guint8 * code.1373;
  unsigned char D.33817;
  guint8 * code.1374;
  unsigned char D.33819;
  guint8 * code.1375;
  unsigned char D.33821;
  guint8 * code.1376;
  unsigned char D.33823;
  guint8 * code.1377;
  guint8 * code.1378;
  guint8 * code.1379;
  guint8 * code.1380;
  guint8 * code.1381;
  guint8 * code.1382;
  guint8 * code.1383;
  guint8 * code.1384;
  unsigned char D.33840;
  guint8 * code.1385;
  unsigned char D.33842;
  guint8 * code.1386;
  unsigned char D.33844;
  guint8 * code.1387;
  unsigned char D.33846;
  guint8 * code.1388;
  guint8 * code.1389;
  guint8 * code.1390;
  guint8 * code.1391;
  unsigned char D.33858;
  guint8 * code.1392;
  unsigned char D.33860;
  guint8 * code.1393;
  unsigned char D.33862;
  guint8 * code.1394;
  unsigned char D.33864;
  guint8 * code.1395;
  guint8 * code.1396;
  guint8 * code.1397;
  guint8 * code.1398;
  guint8 * code.1399;
  guint8 * code.1400;
  guint8 * code.1401;
  guint8 * code.1402;
  unsigned char D.33881;
  guint8 * code.1403;
  unsigned char D.33883;
  guint8 * code.1404;
  unsigned char D.33885;
  guint8 * code.1405;
  unsigned char D.33887;
  guint8 * code.1406;
  guint8 * code.1407;
  guint8 * code.1408;
  guint8 * code.1409;
  unsigned char D.33899;
  guint8 * code.1410;
  unsigned char D.33901;
  guint8 * code.1411;
  unsigned char D.33903;
  guint8 * code.1412;
  unsigned char D.33905;
  guint8 * code.1413;
  guint8 * code.1414;
  guint8 * code.1415;
  guint8 * code.1416;
  unsigned char D.33912;
  int D.33913;
  int D.33914;
  guint8 * code.1417;
  guint8 * code.1418;
  void * ss_trigger_page.1419;
  int ss_trigger_page.1420;
  guint8 * code.1421;
  unsigned char D.33922;
  guint8 * code.1422;
  unsigned char D.33924;
  guint8 * code.1423;
  unsigned char D.33926;
  guint8 * code.1424;
  unsigned char D.33928;
  guint8 * code.1425;
  guint8 * code.1426;
  guint8 * code.1427;
  guint8 * code.1428;
  guint8 * code.1429;
  guint8 * code.1430;
  guint8 * code.1431;
  guint8 * code.1432;
  unsigned char D.33939;
  guint8 * code.1433;
  unsigned char D.33941;
  guint8 * code.1434;
  unsigned char D.33943;
  guint8 * code.1435;
  unsigned char D.33945;
  guint8 * code.1436;
  guint8 * code.1437;
  signed char D.33950;
  unsigned char D.33951;
  guint8 * code.1438;
  guint8 * code.1439;
  guint8 * code.1440;
  unsigned char D.33956;
  guint8 * code.1441;
  unsigned char D.33958;
  guint8 * code.1442;
  unsigned char D.33960;
  guint8 * code.1443;
  unsigned char D.33962;
  guint8 * code.1444;
  guint8 * code.1445;
  unsigned char D.33967;
  guint8 * code.1446;
  unsigned char D.33969;
  guint8 * code.1447;
  unsigned char D.33971;
  guint8 * code.1448;
  unsigned char D.33973;
  guint8 * code.1449;
  guint8 * code.1450;
  signed char D.33978;
  unsigned char D.33979;
  guint8 * code.1451;
  guint8 * code.1452;
  guint8 * code.1453;
  unsigned char D.33984;
  guint8 * code.1454;
  unsigned char D.33986;
  guint8 * code.1455;
  unsigned char D.33988;
  guint8 * code.1456;
  unsigned char D.33990;
  guint8 * code.1457;
  guint8 * code.1458;
  guint8 * code.1459;
  guint8 * code.1460;
  guint8 * code.1461;
  guint8 * code.1462;
  unsigned char D.33999;
  guint8 * code.1463;
  unsigned char D.34001;
  guint8 * code.1464;
  unsigned char D.34003;
  guint8 * code.1465;
  unsigned char D.34005;
  guint8 * code.1466;
  guint8 * code.1467;
  signed char D.34010;
  unsigned char D.34011;
  guint8 * code.1468;
  guint8 * code.1469;
  guint8 * code.1470;
  unsigned char D.34016;
  guint8 * code.1471;
  unsigned char D.34018;
  guint8 * code.1472;
  unsigned char D.34020;
  guint8 * code.1473;
  unsigned char D.34022;
  guint8 * code.1474;
  guint8 * code.1475;
  unsigned char D.34027;
  guint8 * code.1476;
  unsigned char D.34029;
  guint8 * code.1477;
  unsigned char D.34031;
  guint8 * code.1478;
  unsigned char D.34033;
  guint8 * code.1479;
  guint8 * code.1480;
  signed char D.34038;
  unsigned char D.34039;
  guint8 * code.1481;
  guint8 * code.1482;
  guint8 * code.1483;
  unsigned char D.34044;
  guint8 * code.1484;
  unsigned char D.34046;
  guint8 * code.1485;
  unsigned char D.34048;
  guint8 * code.1486;
  unsigned char D.34050;
  guint8 * code.1487;
  guint8 * code.1488;
  guint8 * code.1489;
  guint8 * code.1490;
  unsigned char D.34057;
  guint8 * code.1491;
  unsigned char D.34059;
  guint8 * code.1492;
  unsigned char D.34061;
  guint8 * code.1493;
  unsigned char D.34063;
  guint8 * code.1494;
  guint8 * code.1495;
  signed char D.34068;
  unsigned char D.34069;
  guint8 * code.1496;
  guint8 * code.1497;
  guint8 * code.1498;
  unsigned char D.34074;
  guint8 * code.1499;
  unsigned char D.34076;
  guint8 * code.1500;
  unsigned char D.34078;
  guint8 * code.1501;
  unsigned char D.34080;
  guint8 * code.1502;
  unsigned char D.34084;
  unsigned char D.34085;
  guint8 * code.1503;
  guint8 * code.1504;
  guint8 * code.1505;
  guint8 * code.1506;
  guint8 * code.1507;
  guint8 * code.1508;
  guint8 * code.1509;
  guint8 * code.1510;
  guint8 * code.1511;
  unsigned char D.34103;
  guint8 * code.1512;
  unsigned char D.34105;
  guint8 * code.1513;
  unsigned char D.34107;
  guint8 * code.1514;
  unsigned char D.34109;
  guint8 * code.1515;
  guint8 * code.1516;
  guint8 * code.1517;
  guint8 * code.1518;
  unsigned char D.34119;
  guint8 * code.1519;
  unsigned char D.34121;
  guint8 * code.1520;
  unsigned char D.34123;
  guint8 * code.1521;
  unsigned char D.34125;
  guint8 * code.1522;
  guint8 * code.1523;
  unsigned char D.34130;
  guint8 * code.1524;
  unsigned char D.34132;
  guint8 * code.1525;
  unsigned char D.34134;
  guint8 * code.1526;
  unsigned char D.34136;
  guint8 * code.1527;
  guint8 * code.1528;
  guint8 * code.1529;
  guint8 * code.1530;
  guint8 * code.1531;
  unsigned char D.34145;
  guint8 * code.1532;
  unsigned char D.34147;
  guint8 * code.1533;
  unsigned char D.34149;
  guint8 * code.1534;
  unsigned char D.34151;
  guint8 * code.1535;
  guint8 * code.1536;
  guint8 * code.1537;
  signed char D.34156;
  unsigned char D.34157;
  guint8 * code.1538;
  guint8 * code.1539;
  guint8 * code.1540;
  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.34179;
  guint8 * code.1549;
  unsigned char D.34181;
  guint8 * code.1550;
  unsigned char D.34183;
  guint8 * code.1551;
  unsigned char D.34185;
  guint8 * code.1552;
  guint8 * code.1553;
  guint8 * code.1554;
  guint8 * code.1555;
  unsigned char D.34195;
  guint8 * code.1556;
  unsigned char D.34197;
  guint8 * code.1557;
  unsigned char D.34199;
  guint8 * code.1558;
  unsigned char D.34201;
  guint8 * code.1559;
  guint8 * code.1560;
  unsigned char D.34206;
  guint8 * code.1561;
  unsigned char D.34208;
  guint8 * code.1562;
  unsigned char D.34210;
  guint8 * code.1563;
  unsigned char D.34212;
  guint8 * code.1564;
  guint8 * code.1565;
  guint8 * code.1566;
  guint8 * code.1567;
  guint8 * code.1568;
  unsigned char D.34221;
  guint8 * code.1569;
  unsigned char D.34223;
  guint8 * code.1570;
  unsigned char D.34225;
  guint8 * code.1571;
  unsigned char D.34227;
  guint8 * code.1572;
  guint8 * code.1573;
  guint8 * code.1574;
  guint8 * code.1575;
  signed char D.34233;
  unsigned char D.34234;
  guint8 * code.1576;
  unsigned char D.34236;
  guint8 * code.1577;
  unsigned char D.34238;
  guint8 * code.1578;
  unsigned char D.34240;
  guint8 * code.1579;
  unsigned char D.34242;
  guint8 * code.1580;
  unsigned char D.34244;
  guint8 * code.1581;
  guint8 * code.1582;
  guint8 * code.1583;
  unsigned int D.34248;
  _Bool D.34249;
  long int D.34250;
  long int D.34251;
  _Bool D.34254;
  long int D.34255;
  long int D.34256;
  _Bool D.34259;
  long int D.34260;
  long int D.34261;
  guint8 * code.1584;
  guint8 * code.1585;
  guint8 * code.1586;
  unsigned char D.34271;
  guint8 * code.1587;
  unsigned char D.34273;
  guint8 * code.1588;
  unsigned char D.34275;
  guint8 * code.1589;
  unsigned char D.34277;
  guint8 * code.1590;
  guint8 * code.1591;
  guint8 * code.1592;
  guint8 * code.1593;
  guint8 * code.1594;
  unsigned char D.34286;
  guint8 * code.1595;
  unsigned char D.34288;
  guint8 * code.1596;
  unsigned char D.34290;
  guint8 * code.1597;
  unsigned char D.34292;
  guint8 * code.1598;
  guint8 * code.1599;
  guint8 * code.1600;
  guint8 * code.1601;
  guint8 * code.1602;
  guint8 * code.1603;
  signed char D.34302;
  unsigned char D.34303;
  guint8 * code.1604;
  int D.34306;
  guint8 * code.1605;
  guint8 * code.1606;
  guint8 * code.1607;
  guint8 * code.1608;
  unsigned char D.34314;
  unsigned char D.34315;
  guint8 * code.1609;
  guint8 * code.1610;
  guint8 * code.1611;
  int D.34321;
  int D.34322;
  guint8 * code.1612;
  unsigned char D.34324;
  guint8 * code.1613;
  unsigned char D.34326;
  guint8 * code.1614;
  unsigned char D.34328;
  guint8 * code.1615;
  unsigned char D.34330;
  unsigned int D.34331;
  unsigned int D.34332;
  guint8 * code.1616;
  guint8 * code.1617;
  unsigned char D.34337;
  unsigned char D.34338;
  guint8 * code.1618;
  guint8 * code.1619;
  guint8 * code.1620;
  unsigned char D.34343;
  guint8 * code.1621;
  unsigned char D.34345;
  guint8 * code.1622;
  unsigned char D.34347;
  guint8 * code.1623;
  unsigned char D.34349;
  guint8 * code.1624;
  guint8 * code.1625;
  guint8 * code.1626;
  guint8 * code.1627;
  guint8 * code.1628;
  guint8 * code.1629;
  unsigned char D.34358;
  guint8 * code.1630;
  unsigned char D.34360;
  guint8 * code.1631;
  unsigned char D.34362;
  guint8 * code.1632;
  unsigned char D.34364;
  guint8 * code.1633;
  guint8 * code.1634;
  signed char D.34369;
  unsigned char D.34370;
  guint8 * code.1635;
  guint8 * code.1636;
  guint8 * code.1637;
  unsigned char D.34375;
  guint8 * code.1638;
  unsigned char D.34377;
  guint8 * code.1639;
  unsigned char D.34379;
  guint8 * code.1640;
  unsigned char D.34381;
  guint8 * code.1641;
  guint8 * code.1642;
  guint8 * code.1643;
  guint8 * code.1644;
  unsigned char D.34388;
  guint8 * code.1645;
  unsigned char D.34390;
  guint8 * code.1646;
  unsigned char D.34392;
  guint8 * code.1647;
  unsigned char D.34394;
  guint8 * code.1648;
  guint8 * code.1649;
  signed char D.34399;
  unsigned char D.34400;
  guint8 * code.1650;
  guint8 * code.1651;
  guint8 * code.1652;
  unsigned char D.34405;
  guint8 * code.1653;
  unsigned char D.34407;
  guint8 * code.1654;
  unsigned char D.34409;
  guint8 * code.1655;
  unsigned char D.34411;
  _Bool D.34412;
  long int D.34413;
  long int D.34414;
  guint8 * code.1656;
  guint8 * code.1657;
  signed char D.34419;
  unsigned char D.34420;
  guint8 * code.1658;
  guint8 * code.1659;
  signed char D.34425;
  unsigned char D.34426;
  guint8 * code.1660;
  guint8 * code.1661;
  guint8 * code.1662;
  guint8 * code.1663;
  guint8 * code.1664;
  guint8 * code.1665;
  guint8 * code.1666;
  guint8 * code.1667;
  guint8 * code.1668;
  guint8 * code.1669;
  guint8 * code.1670;
  guint8 * code.1671;
  guint8 * code.1672;
  guint8 * code.1673;
  guint8 * code.1674;
  guint8 * code.1675;
  guint8 * code.1676;
  int D.34455;
  signed char D.34456;
  signed char D.34457;
  signed char D.34458;
  unsigned char D.34459;
  guint8 * code.1677;
  guint8 * code.1678;
  guint8 * code.1679;
  guint8 * code.1680;
  guint8 * code.1681;
  guint8 * code.1682;
  unsigned char D.34469;
  guint8 * code.1683;
  unsigned char D.34471;
  guint8 * code.1684;
  unsigned char D.34473;
  guint8 * code.1685;
  unsigned char D.34475;
  guint8 * code.1686;
  unsigned char D.34479;
  guint8 * code.1687;
  unsigned char D.34482;
  guint8 * code.1688;
  guint8 * code.1689;
  guint8 * code.1690;
  guint8 * code.1691;
  int D.34487;
  int D.34488;
  signed char D.34489;
  signed char D.34490;
  signed char D.34491;
  unsigned char D.34492;
  guint8 * code.1692;
  guint8 * code.1693;
  unsigned char D.34495;
  int D.34496;
  unsigned char D.34497;
  unsigned char D.34498;
  int pos.1694;
  int D.34504;
  unsigned char * pos.1695;
  unsigned char D.34506;
  unsigned char * pos.1696;
  unsigned char D.34508;
  unsigned char * pos.1697;
  unsigned char D.34510;
  unsigned char * pos.1698;
  unsigned char D.34512;
  unsigned int disp.1699;
  unsigned int D.34515;
  unsigned char D.34518;
  unsigned char D.34519;
  guint8 * code.1700;
  guint8 * code.1701;
  guint8 * code.1702;
  guint8 * code.1703;
  guint8 * code.1704;
  signed char D.34526;
  unsigned char D.34527;
  guint8 * code.1705;
  guint8 * code.1706;
  guint8 * code.1707;
  guint8 * code.1708;
  unsigned char D.34535;
  guint8 * code.1709;
  unsigned char D.34537;
  guint8 * code.1710;
  unsigned char D.34539;
  guint8 * code.1711;
  unsigned char D.34541;
  guint8 * code.1712;
  guint8 * code.1713;
  guint8 * code.1714;
  guint8 * code.1715;
  guint8 * code.1716;
  guint8 * code.1717;
  guint8 * code.1718;
  guint8 * code.1719;
  guint8 * code.1720;
  guint8 * code.1721;
  unsigned char D.34558;
  int D.34559;
  unsigned char D.34560;
  unsigned char D.34561;
  int pos.1722;
  int D.34567;
  unsigned char * pos.1723;
  unsigned char D.34569;
  unsigned char * pos.1724;
  unsigned char D.34571;
  unsigned char * pos.1725;
  unsigned char D.34573;
  unsigned char * pos.1726;
  unsigned char D.34575;
  unsigned int disp.1727;
  unsigned int D.34578;
  unsigned char D.34581;
  unsigned char D.34582;
  guint8 * code.1728;
  guint8 * code.1729;
  guint8 * code.1730;
  guint8 * code.1731;
  guint8 * code.1732;
  signed char D.34589;
  unsigned char D.34590;
  guint8 * code.1733;
  guint8 * code.1734;
  guint8 * code.1735;
  guint8 * code.1736;
  unsigned char D.34598;
  guint8 * code.1737;
  unsigned char D.34600;
  guint8 * code.1738;
  unsigned char D.34602;
  guint8 * code.1739;
  unsigned char D.34604;
  guint8 * code.1740;
  guint8 * code.1741;
  guint8 * code.1742;
  guint8 * code.1743;
  guint8 * code.1744;
  guint8 * code.1745;
  guint8 * code.1746;
  guint8 * code.1747;
  signed char D.34616;
  unsigned char D.34617;
  unsigned char D.34618;
  int D.34619;
  unsigned char D.34620;
  unsigned char D.34621;
  int pos.1748;
  int D.34627;
  unsigned char * pos.1749;
  unsigned char D.34629;
  unsigned char * pos.1750;
  unsigned char D.34631;
  unsigned char * pos.1751;
  unsigned char D.34633;
  unsigned char * pos.1752;
  unsigned char D.34635;
  unsigned int disp.1753;
  unsigned int D.34638;
  unsigned char D.34641;
  unsigned char D.34642;
  guint8 * code.1754;
  guint8 * code.1755;
  guint8 * code.1756;
  guint8 * code.1757;
  guint8 * code.1758;
  guint8 * code.1759;
  guint8 * code.1760;
  guint8 * code.1761;
  signed char D.34656;
  unsigned char D.34657;
  guint8 * code.1762;
  guint8 * code.1763;
  unsigned char D.34661;
  unsigned char D.34662;
  guint8 * code.1764;
  guint8 * code.1765;
  guint8 * code.1766;
  guint8 * code.1767;
  guint8 * code.1768;
  guint8 * code.1769;
  guint8 * code.1770;
  guint8 * code.1771;
  guint8 * code.1772;
  guint8 * code.1773;
  guint8 * code.1774;
  guint8 * code.1775;
  guint8 * code.1776;
  guint8 * code.1777;
  guint8 * code.1778;
  guint8 * code.1779;
  guint8 * code.1780;
  guint8 * code.1781;
  guint8 * code.1782;
  guint8 * code.1783;
  guint8 * code.1784;
  guint8 * code.1785;
  guint8 * code.1786;
  guint8 * code.1787;
  guint8 * code.1788;
  guint8 * code.1789;
  guint8 * code.1790;
  guint8 * code.1791;
  guint8 * code.1792;
  guint8 * code.1793;
  guint8 * code.1794;
  guint8 * code.1795;
  guint8 * code.1796;
  guint8 * code.1797;
  signed char D.34717;
  unsigned char D.34718;
  guint8 * code.1798;
  guint8 * code.1799;
  guint8 * code.1800;
  guint8 * code.1801;
  guint8 * code.1802;
  guint8 * code.1803;
  guint8 * code.1804;
  guint8 * code.1805;
  guint8 * code.1806;
  guint8 * code.1807;
  guint8 * code.1808;
  signed char D.34735;
  unsigned char D.34736;
  guint8 * code.1809;
  guint8 * code.1810;
  signed char D.34739;
  unsigned char D.34740;
  guint8 * code.1811;
  guint8 * code.1812;
  guint8 * code.1813;
  guint8 * code.1814;
  guint8 * code.1815;
  guint8 * code.1816;
  guint8 * code.1817;
  guint8 * code.1818;
  guint8 * code.1819;
  guint8 * code.1820;
  guint8 * code.1821;
  guint8 * code.1822;
  signed char D.34757;
  unsigned char D.34758;
  guint8 * code.1823;
  unsigned char D.34760;
  guint8 * code.1824;
  unsigned char D.34762;
  guint8 * code.1825;
  unsigned char D.34764;
  guint8 * code.1826;
  unsigned char D.34766;
  guint8 * code.1827;
  guint8 * code.1828;
  signed char D.34772;
  unsigned char D.34773;
  guint8 * code.1829;
  guint8 * code.1830;
  guint8 * code.1831;
  guint8 * code.1832;
  guint8 * code.1833;
  unsigned char D.34783;
  guint8 * code.1834;
  unsigned char D.34785;
  guint8 * code.1835;
  unsigned char D.34787;
  guint8 * code.1836;
  unsigned char D.34789;
  guint8 * code.1837;
  guint8 * code.1838;
  guint8 * code.1839;
  signed char D.34795;
  unsigned char D.34796;
  guint8 * code.1840;
  unsigned char D.34798;
  guint8 * code.1841;
  unsigned char D.34800;
  guint8 * code.1842;
  unsigned char D.34802;
  guint8 * code.1843;
  unsigned char D.34804;
  guint8 * code.1844;
  guint8 * code.1845;
  signed char D.34810;
  unsigned char D.34811;
  guint8 * code.1846;
  guint8 * code.1847;
  guint8 * code.1848;
  guint8 * code.1849;
  guint8 * code.1850;
  unsigned char D.34821;
  guint8 * code.1851;
  unsigned char D.34823;
  guint8 * code.1852;
  unsigned char D.34825;
  guint8 * code.1853;
  unsigned char D.34827;
  guint8 * code.1854;
  guint8 * code.1855;
  guint8 * code.1856;
  guint8 * code.1857;
  unsigned char D.34834;
  guint8 * code.1858;
  unsigned char D.34836;
  guint8 * code.1859;
  unsigned char D.34838;
  guint8 * code.1860;
  unsigned char D.34840;
  guint8 * code.1861;
  guint8 * code.1862;
  guint8 * code.1863;
  guint8 * code.1864;
  guint8 * code.1865;
  guint8 * code.1866;
  guint8 * code.1867;
  unsigned char D.34855;
  guint8 * code.1868;
  unsigned char D.34857;
  guint8 * code.1869;
  unsigned char D.34859;
  guint8 * code.1870;
  unsigned char D.34861;
  guint8 * code.1871;
  guint8 * code.1872;
  guint8 * code.1873;
  guint8 * code.1874;
  guint8 * code.1875;
  signed char D.34869;
  unsigned char D.34870;
  guint8 * code.1876;
  unsigned char D.34872;
  guint8 * code.1877;
  unsigned char D.34874;
  guint8 * code.1878;
  unsigned char D.34876;
  guint8 * code.1879;
  unsigned char D.34878;
  guint8 * code.1880;
  guint8 * code.1881;
  guint8 * code.1882;
  guint8 * code.1883;
  guint8 * code.1884;
  guint8 * code.1885;
  guint8 * code.1886;
  unsigned char D.34893;
  guint8 * code.1887;
  unsigned char D.34895;
  guint8 * code.1888;
  unsigned char D.34897;
  guint8 * code.1889;
  unsigned char D.34899;
  guint8 * code.1890;
  guint8 * code.1891;
  guint8 * code.1892;
  guint8 * code.1893;
  unsigned char D.34906;
  guint8 * code.1894;
  unsigned char D.34908;
  guint8 * code.1895;
  unsigned char D.34910;
  guint8 * code.1896;
  unsigned char D.34912;
  guint8 * code.1897;
  guint8 * code.1898;
  guint8 * code.1899;
  guint8 * code.1900;
  guint8 * code.1901;
  guint8 * code.1902;
  guint8 * code.1903;
  unsigned char D.34927;
  guint8 * code.1904;
  unsigned char D.34929;
  guint8 * code.1905;
  unsigned char D.34931;
  guint8 * code.1906;
  unsigned char D.34933;
  guint8 * code.1907;
  guint8 * code.1908;
  guint8 * code.1909;
  guint8 * code.1910;
  guint8 * code.1911;
  guint8 * code.1912;
  unsigned char D.34942;
  guint8 * code.1913;
  unsigned char D.34944;
  guint8 * code.1914;
  unsigned char D.34946;
  guint8 * code.1915;
  unsigned char D.34948;
  guint8 * code.1916;
  guint8 * code.1917;
  guint8 * code.1918;
  guint8 * code.1919;
  guint8 * code.1920;
  guint8 * code.1921;
  guint8 * code.1922;
  unsigned char D.34963;
  guint8 * code.1923;
  unsigned char D.34965;
  guint8 * code.1924;
  unsigned char D.34967;
  guint8 * code.1925;
  unsigned char D.34969;
  guint8 * code.1926;
  guint8 * code.1927;
  guint8 * code.1928;
  guint8 * code.1929;
  guint8 * code.1930;
  guint8 * code.1931;
  guint8 * code.1932;
  guint8 * code.1933;
  unsigned char D.34983;
  guint8 * code.1934;
  unsigned char D.34985;
  guint8 * code.1935;
  unsigned char D.34987;
  guint8 * code.1936;
  unsigned char D.34989;
  guint8 * code.1937;
  guint8 * code.1938;
  guint8 * code.1939;
  guint8 * code.1940;
  guint8 * code.1941;
  guint8 * code.1942;
  guint8 * code.1943;
  unsigned char D.35004;
  guint8 * code.1944;
  unsigned char D.35006;
  guint8 * code.1945;
  unsigned char D.35008;
  guint8 * code.1946;
  unsigned char D.35010;
  guint8 * code.1947;
  guint8 * code.1948;
  guint8 * code.1949;
  signed char D.35016;
  unsigned char D.35017;
  guint8 * code.1950;
  unsigned char D.35019;
  guint8 * code.1951;
  unsigned char D.35021;
  guint8 * code.1952;
  unsigned char D.35023;
  guint8 * code.1953;
  unsigned char D.35025;
  guint8 * code.1954;
  guint8 * code.1955;
  signed char D.35031;
  unsigned char D.35032;
  guint8 * code.1956;
  guint8 * code.1957;
  guint8 * code.1958;
  guint8 * code.1959;
  guint8 * code.1960;
  unsigned char D.35042;
  guint8 * code.1961;
  unsigned char D.35044;
  guint8 * code.1962;
  unsigned char D.35046;
  guint8 * code.1963;
  unsigned char D.35048;
  guint8 * code.1964;
  guint8 * code.1965;
  guint8 * code.1966;
  guint8 * code.1967;
  unsigned char D.35055;
  guint8 * code.1968;
  unsigned char D.35057;
  guint8 * code.1969;
  unsigned char D.35059;
  guint8 * code.1970;
  unsigned char D.35061;
  guint8 * code.1971;
  guint8 * code.1972;
  guint8 * code.1973;
  guint8 * code.1974;
  guint8 * code.1975;
  guint8 * code.1976;
  guint8 * code.1977;
  unsigned char D.35076;
  guint8 * code.1978;
  unsigned char D.35078;
  guint8 * code.1979;
  unsigned char D.35080;
  guint8 * code.1980;
  unsigned char D.35082;
  guint8 * code.1981;
  guint8 * code.1982;
  guint8 * code.1983;
  guint8 * code.1984;
  guint8 * code.1985;
  guint8 * code.1986;
  guint8 * code.1987;
  guint8 * code.1988;
  unsigned char D.35096;
  guint8 * code.1989;
  unsigned char D.35098;
  guint8 * code.1990;
  unsigned char D.35100;
  guint8 * code.1991;
  unsigned char D.35102;
  guint8 * code.1992;
  guint8 * code.1993;
  guint8 * code.1994;
  guint8 * code.1995;
  guint8 * code.1996;
  guint8 * code.1997;
  guint8 * code.1998;
  unsigned char D.35117;
  guint8 * code.1999;
  unsigned char D.35119;
  guint8 * code.2000;
  unsigned char D.35121;
  guint8 * code.2001;
  unsigned char D.35123;
  guint8 * code.2002;
  guint8 * code.2003;
  guint8 * code.2004;
  guint8 * code.2005;
  guint8 * code.2006;
  unsigned char D.35132;
  guint8 * code.2007;
  unsigned char D.35134;
  guint8 * code.2008;
  unsigned char D.35136;
  guint8 * code.2009;
  unsigned char D.35138;
  guint8 * code.2010;
  guint8 * code.2011;
  guint8 * code.2012;
  guint8 * code.2013;
  guint8 * code.2014;
  unsigned char D.35148;
  unsigned char D.35149;
  guint8 * code.2015;
  unsigned char D.35152;
  unsigned char D.35153;
  guint8 * code.2016;
  unsigned char D.35155;
  guint8 * code.2017;
  unsigned char D.35157;
  guint8 * code.2018;
  unsigned char D.35159;
  guint8 * code.2019;
  unsigned char D.35161;
  struct MonoBasicBlock * * D.35163;
  struct MonoBasicBlock * D.35164;
  int D.35165;
  sizetype D.35168;
  unsigned char * D.35169;
  int D.35170;
  int D.35171;
  unsigned int offset.2020;
  unsigned int D.35173;
  guint8 * code.2021;
  guint8 * code.2022;
  unsigned char D.35181;
  guint8 * code.2023;
  guint8 * code.2024;
  guint8 * code.2025;
  guint8 * code.2026;
  unsigned char D.35190;
  guint8 * code.2027;
  unsigned char D.35192;
  guint8 * code.2028;
  unsigned char D.35194;
  guint8 * code.2029;
  unsigned char D.35196;
  unsigned char D.35197;
  int D.35198;
  unsigned char D.35199;
  unsigned char D.35200;
  int pos.2030;
  int D.35206;
  unsigned char * pos.2031;
  unsigned char D.35208;
  unsigned char * pos.2032;
  unsigned char D.35210;
  unsigned char * pos.2033;
  unsigned char D.35212;
  unsigned char * pos.2034;
  unsigned char D.35214;
  unsigned int disp.2035;
  unsigned int D.35217;
  unsigned char D.35220;
  unsigned char D.35221;
  unsigned int D.35226;
  int D.35228;
  int D.35229;
  unsigned int D.35230;
  unsigned int D.35231;
  guint8 * code.2036;
  guint8 * code.2037;
  guint8 * code.2038;
  guint8 * code.2039;
  guint8 * code.2040;
  guint8 * code.2041;
  unsigned char D.35245;
  guint8 * code.2042;
  unsigned char D.35247;
  guint8 * code.2043;
  unsigned char D.35249;
  guint8 * code.2044;
  unsigned char D.35251;
  guint8 * code.2045;
  guint8 * code.2046;
  guint8 * code.2047;
  guint8 * code.2048;
  guint8 * code.2049;
  signed char D.35265;
  unsigned char D.35266;
  guint8 * code.2050;
  guint8 * code.2051;
  guint8 * code.2052;
  guint8 * code.2053;
  signed char D.35278;
  signed char D.35279;
  signed char D.35280;
  unsigned char D.35281;
  guint8 * code.2054;
  guint8 * code.2055;
  guint8 * code.2056;
  guint8 * code.2057;
  unsigned char D.35288;
  guint8 * code.2058;
  guint8 * code.2059;
  guint8 * code.2060;
  guint8 * code.2061;
  guint8 * code.2062;
  guint8 * code.2063;
  unsigned char D.35304;
  guint8 * code.2064;
  unsigned char D.35306;
  guint8 * code.2065;
  unsigned char D.35308;
  guint8 * code.2066;
  unsigned char D.35310;
  struct MonoBasicBlock * * D.35312;
  struct MonoBasicBlock * D.35313;
  int D.35314;
  sizetype D.35317;
  unsigned char * D.35318;
  int D.35319;
  int D.35320;
  unsigned int offset.2067;
  unsigned int D.35322;
  guint8 * code.2068;
  guint8 * code.2069;
  unsigned char D.35330;
  guint8 * code.2070;
  guint8 * code.2071;
  guint8 * code.2072;
  guint8 * code.2073;
  unsigned char D.35339;
  guint8 * code.2074;
  unsigned char D.35341;
  guint8 * code.2075;
  unsigned char D.35343;
  guint8 * code.2076;
  unsigned char D.35345;
  unsigned char D.35346;
  int D.35347;
  unsigned char D.35348;
  unsigned char D.35349;
  int pos.2077;
  int D.35355;
  unsigned char * pos.2078;
  unsigned char D.35357;
  unsigned char * pos.2079;
  unsigned char D.35359;
  unsigned char * pos.2080;
  unsigned char D.35361;
  unsigned char * pos.2081;
  unsigned char D.35363;
  unsigned int disp.2082;
  unsigned int D.35366;
  unsigned char D.35369;
  unsigned char D.35370;
  int D.35376;
  int D.35377;
  unsigned int D.35378;
  unsigned int D.35379;
  guint8 * code.2083;
  guint8 * code.2084;
  guint8 * code.2085;
  guint8 * code.2086;
  guint8 * code.2087;
  guint8 * code.2088;
  unsigned char D.35393;
  guint8 * code.2089;
  unsigned char D.35395;
  guint8 * code.2090;
  unsigned char D.35397;
  guint8 * code.2091;
  unsigned char D.35399;
  guint8 * code.2092;
  unsigned char D.35401;
  guint8 * code.2093;
  unsigned char D.35403;
  guint8 * code.2094;
  unsigned char D.35405;
  guint8 * code.2095;
  unsigned char D.35407;
  guint8 * code.2096;
  unsigned char D.35409;
  struct MonoInst * D.35410;
  <unnamed type> D.35411;
  int offset.2097;
  guint8 * code.2098;
  guint8 * code.2099;
  unsigned char D.35415;
  guint8 * code.2100;
  unsigned char D.35417;
  guint8 * code.2101;
  unsigned char D.35419;
  guint8 * code.2102;
  unsigned char D.35421;
  guint8 * code.2103;
  guint8 * code.2104;
  unsigned char D.35424;
  guint8 * code.2105;
  unsigned char D.35426;
  guint8 * code.2106;
  unsigned char D.35428;
  guint8 * code.2107;
  unsigned char D.35430;
  _Bool D.35431;
  long int D.35432;
  long int D.35433;
  void * D.35436;
  struct MonoInst * D.35437;
  <unnamed type> D.35438;
  guint8 * code.2108;
  guint8 * code.2109;
  guint8 * code.2110;
  guint8 * code.2111;
  guint8 * code.2112;
  guint8 * code.2113;
  guint8 * code.2114;
  guint8 * code.2115;
  guint8 * code.2116;
  guint8 * code.2117;
  unsigned char D.35457;
  guint8 * code.2118;
  unsigned char D.35459;
  guint8 * code.2119;
  unsigned char D.35461;
  guint8 * code.2120;
  unsigned char D.35463;
  guint8 * code.2121;
  guint8 * code.2122;
  guint8 * code.2123;
  guint8 * code.2124;
  unsigned char D.35473;
  guint8 * code.2125;
  unsigned char D.35475;
  guint8 * code.2126;
  unsigned char D.35477;
  guint8 * code.2127;
  unsigned char D.35479;
  guint8 * code.2128;
  guint8 * code.2129;
  guint8 * code.2130;
  guint8 * code.2131;
  guint8 * code.2132;
  guint8 * code.2133;
  guint8 * code.2134;
  guint8 * code.2135;
  unsigned char D.35496;
  guint8 * code.2136;
  unsigned char D.35498;
  guint8 * code.2137;
  unsigned char D.35500;
  guint8 * code.2138;
  unsigned char D.35502;
  guint8 * code.2139;
  guint8 * code.2140;
  guint8 * code.2141;
  guint8 * code.2142;
  unsigned char D.35512;
  guint8 * code.2143;
  unsigned char D.35514;
  guint8 * code.2144;
  unsigned char D.35516;
  guint8 * code.2145;
  unsigned char D.35518;
  guint8 * code.2146;
  guint8 * code.2147;
  guint8 * code.2148;
  guint8 * code.2149;
  unsigned char D.35523;
  unsigned int D.35524;
  unsigned char D.35527;
  unsigned char D.35528;
  _Bool D.35529;
  long int D.35530;
  long int D.35531;
  _Bool D.35536;
  _Bool D.35537;
  _Bool D.35538;
  unsigned int D.35540;
  int D.35541;
  unsigned int D.35542;
  unsigned int D.35543;
  unsigned int D.35546;
  guint8 * code.2150;
  guint8 * code.2151;
  guint8 * code.2152;
  guint8 * code.2153;
  guint8 * code.2154;
  unsigned int pos.2155;
  unsigned int D.35560;
  guint8 * code.2156;
  guint8 * code.2157;
  unsigned char D.35565;
  guint8 * code.2158;
  guint8 * code.2159;
  guint8 * code.2160;
  unsigned char D.35570;
  guint8 * code.2161;
  unsigned char D.35572;
  guint8 * code.2162;
  unsigned char D.35574;
  guint8 * code.2163;
  unsigned char D.35576;
  guint8 * code.2164;
  guint8 * code.2165;
  guint8 * code.2166;
  guint8 * code.2167;
  unsigned char D.35586;
  guint8 * code.2168;
  unsigned char D.35588;
  guint8 * code.2169;
  unsigned char D.35590;
  guint8 * code.2170;
  unsigned char D.35592;
  unsigned int D.35593;
  guint8 * code.2171;
  guint8 * code.2172;
  guint8 * code.2173;
  guint8 * code.2174;
  guint8 * code.2175;
  guint8 * code.2176;
  guint8 * code.2177;
  guint8 * code.2178;
  guint8 * code.2179;
  guint8 * code.2180;
  unsigned char D.35614;
  guint8 * code.2181;
  unsigned char D.35616;
  guint8 * code.2182;
  unsigned char D.35618;
  guint8 * code.2183;
  unsigned char D.35620;
  guint8 * code.2184;
  guint8 * code.2185;
  guint8 * code.2186;
  guint8 * code.2187;
  unsigned char D.35630;
  guint8 * code.2188;
  unsigned char D.35632;
  guint8 * code.2189;
  unsigned char D.35634;
  guint8 * code.2190;
  unsigned char D.35636;
  unsigned int D.35637;
  guint8 * code.2191;
  guint8 * code.2192;
  guint8 * code.2193;
  guint8 * code.2194;
  guint8 * code.2195;
  guint8 * code.2196;
  guint8 * code.2197;
  guint8 * code.2198;
  guint8 * code.2199;
  guint8 * code.2200;
  unsigned char D.35658;
  guint8 * code.2201;
  unsigned char D.35660;
  guint8 * code.2202;
  unsigned char D.35662;
  guint8 * code.2203;
  unsigned char D.35664;
  guint8 * code.2204;
  guint8 * code.2205;
  guint8 * code.2206;
  guint8 * code.2207;
  unsigned char D.35674;
  guint8 * code.2208;
  unsigned char D.35676;
  guint8 * code.2209;
  unsigned char D.35678;
  guint8 * code.2210;
  unsigned char D.35680;
  guint8 * code.2211;
  guint8 * code.2212;
  guint8 * code.2213;
  guint8 * code.2214;
  guint8 * code.2215;
  unsigned int i.2216;
  unsigned int D.35692;
  guint8 * code.2217;
  guint8 * code.2218;
  unsigned char D.35697;
  guint8 * code.2219;
  guint8 * code.2220;
  guint8 * code.2221;
  unsigned char D.35702;
  guint8 * code.2222;
  unsigned char D.35704;
  guint8 * code.2223;
  unsigned char D.35706;
  guint8 * code.2224;
  unsigned char D.35708;
  guint8 * code.2225;
  guint8 * code.2226;
  guint8 * code.2227;
  guint8 * code.2228;
  unsigned char D.35718;
  guint8 * code.2229;
  unsigned char D.35720;
  guint8 * code.2230;
  unsigned char D.35722;
  guint8 * code.2231;
  unsigned char D.35724;
  guint8 * code.2232;
  guint8 * code.2233;
  guint8 * code.2234;
  guint8 * code.2235;
  guint8 * code.2236;
  unsigned int D.35735;
  guint8 * code.2237;
  guint8 * code.2238;
  unsigned char D.35740;
  unsigned char D.35741;
  guint8 * code.2239;
  guint8 * code.2240;
  int D.35745;
  guint8 * code.2241;
  unsigned char D.35747;
  guint8 * code.2242;
  unsigned char D.35749;
  guint8 * code.2243;
  unsigned char D.35751;
  guint8 * code.2244;
  unsigned char D.35753;
  guint8 * code.2245;
  guint8 * code.2246;
  guint8 * code.2247;
  guint8 * code.2248;
  unsigned char D.35763;
  guint8 * code.2249;
  unsigned char D.35765;
  guint8 * code.2250;
  unsigned char D.35767;
  guint8 * code.2251;
  unsigned char D.35769;
  unsigned int i.2252;
  unsigned int D.35771;
  unsigned int D.35772;
  unsigned int D.35773;
  guint8 * code.2253;
  struct MonoMethod * D.35775;
  guint8 * code.2254;
  guint8 * code.2255;
  unsigned char D.35778;
  guint8 * code.2256;
  unsigned char D.35780;
  guint8 * code.2257;
  unsigned char D.35782;
  guint8 * code.2258;
  unsigned char D.35784;
  guint8 * code.2259;
  guint8 * code.2260;
  guint8 * code.2261;
  guint8 * code.2262;
  guint8 * code.2263;
  guint8 * code.2264;
  guint8 * code.2265;
  guint8 * code.2266;
  unsigned char D.35801;
  guint8 * code.2267;
  unsigned char D.35803;
  guint8 * code.2268;
  unsigned char D.35805;
  guint8 * code.2269;
  unsigned char D.35807;
  guint8 * code.2270;
  signed char D.35811;
  unsigned char D.35812;
  guint8 * code.2271;
  guint8 * code.2272;
  guint8 * code.2273;
  unsigned char D.35819;
  guint8 * code.2274;
  unsigned char D.35821;
  guint8 * code.2275;
  unsigned char D.35823;
  guint8 * code.2276;
  unsigned char D.35825;
  _Bool D.35826;
  guint8 * code.2277;
  unsigned char D.35828;
  unsigned char D.35829;
  guint8 * code.2278;
  int D.35833;
  guint8 * code.2279;
  int D.35837;
  int D.35838;
  signed char D.35839;
  signed char D.35840;
  unsigned char D.35841;
  guint8 * code.2280;
  unsigned int D.35844;
  unsigned int D.35845;
  guint8 * code.2281;
  signed char D.35849;
  unsigned char D.35850;
  guint8 * code.2282;
  unsigned char D.35852;
  guint8 * code.2283;
  signed char D.35855;
  unsigned char D.35856;
  guint8 * code.2284;
  guint8 * code.2285;
  unsigned char D.35859;
  guint8 * code.2286;
  unsigned char D.35861;
  guint8 * code.2287;
  unsigned char D.35863;
  guint8 * code.2288;
  unsigned char D.35865;
  guint8 * code.2289;
  signed char D.35869;
  unsigned char D.35870;
  guint8 * code.2290;
  signed char D.35874;
  unsigned char D.35875;
  guint8 * code.2291;
  signed char D.35878;
  unsigned char D.35879;
  guint8 * code.2292;
  unsigned char D.35881;
  guint8 * code.2293;
  unsigned char D.35883;
  guint8 * code.2294;
  unsigned char D.35885;
  guint8 * code.2295;
  unsigned char D.35887;
  guint8 * code.2296;
  guint8 * code.2297;
  guint8 * code.2298;
  guint8 * code.2299;
  guint8 * code.2300;
  guint8 * code.2301;
  guint8 * code.2302;
  guint8 * code.2303;
  guint8 * code.2304;
  guint8 * code.2305;
  unsigned char D.35906;
  guint8 * code.2306;
  unsigned char D.35908;
  guint8 * code.2307;
  unsigned char D.35910;
  guint8 * code.2308;
  unsigned char D.35912;
  guint8 * code.2309;
  signed char D.35916;
  unsigned char D.35917;
  guint8 * code.2310;
  signed char D.35921;
  signed char D.35922;
  unsigned char D.35923;
  guint8 * code.2311;
  signed char D.35926;
  signed char D.35927;
  unsigned char D.35928;
  guint8 * code.2312;
  unsigned char D.35930;
  guint8 * code.2313;
  unsigned char D.35932;
  guint8 * code.2314;
  unsigned char D.35934;
  guint8 * code.2315;
  unsigned char D.35936;
  guint8 * code.2316;
  unsigned char D.35938;
  struct MonoMethod * D.35941;
  const void * D.35943;
  unsigned int D.35944;
  struct MonoMethodSignature * D.35947;
  unsigned char D.35948;
  unsigned char D.35949;
  short unsigned int D.35952;
  short unsigned int D.35953;
  guint8 * code.2317;
  guint8 * code.2318;
  int D.35963;
  guint8 * code.2319;
  unsigned char D.35965;
  guint8 * code.2320;
  unsigned char D.35967;
  guint8 * code.2321;
  unsigned char D.35969;
  guint8 * code.2322;
  unsigned char D.35971;
  guint8 * code.2323;
  guint8 * code.2324;
  unsigned char D.35978;
  guint8 * code.2325;
  guint8 * code.2326;
  guint8 * code.2327;
  unsigned char D.35982;
  guint8 * code.2328;
  unsigned char D.35984;
  guint8 * code.2329;
  unsigned char D.35986;
  guint8 * code.2330;
  unsigned char D.35988;
  guint8 * code.2331;
  guint8 * code.2332;
  guint8 * code.2333;
  guint8 * code.2334;
  guint8 * code.2335;
  unsigned char D.36005;
  guint8 * code.2336;
  unsigned char D.36007;
  guint8 * code.2337;
  unsigned char D.36009;
  guint8 * code.2338;
  unsigned char D.36011;
  guint8 * code.2339;
  guint8 * code.2340;
  guint8 * code.2341;
  guint8 * code.2342;
  guint8 * code.2343;
  unsigned char D.36021;
  guint8 * code.2344;
  unsigned char D.36023;
  guint8 * code.2345;
  unsigned char D.36025;
  guint8 * code.2346;
  unsigned char D.36027;
  guint8 * code.2347;
  guint8 * code.2348;
  guint8 * code.2349;
  guint8 * code.2350;
  guint8 * code.2351;
  guint8 * code.2352;
  guint8 * code.2353;
  guint8 * code.2354;
  unsigned char D.36044;
  guint8 * code.2355;
  unsigned char D.36046;
  guint8 * code.2356;
  unsigned char D.36048;
  guint8 * code.2357;
  unsigned char D.36050;
  guint8 * code.2358;
  signed char D.36056;
  unsigned char D.36057;
  guint8 * code.2359;
  signed char D.36061;
  unsigned char D.36062;
  guint8 * code.2360;
  signed char D.36065;
  unsigned char D.36066;
  guint8 * code.2361;
  unsigned char D.36068;
  guint8 * code.2362;
  unsigned char D.36070;
  guint8 * code.2363;
  unsigned char D.36072;
  guint8 * code.2364;
  unsigned char D.36074;
  guint8 * code.2365;
  guint8 * code.2366;
  guint8 * code.2367;
  unsigned char D.36089;
  guint8 * code.2368;
  unsigned char D.36091;
  guint8 * code.2369;
  unsigned char D.36093;
  guint8 * code.2370;
  unsigned char D.36095;
  guint8 * code.2371;
  guint8 * code.2372;
  guint8 * code.2373;
  guint8 * code.2374;
  guint8 * code.2375;
  unsigned char D.36105;
  guint8 * code.2376;
  unsigned char D.36107;
  guint8 * code.2377;
  unsigned char D.36109;
  guint8 * code.2378;
  unsigned char D.36111;
  guint8 * code.2379;
  unsigned char D.36113;
  unsigned char D.36114;
  unsigned int _imm.2380;
  unsigned int D.36116;
  guint8 * code.2381;
  unsigned char D.36120;
  guint8 * code.2382;
  guint8 * code.2383;
  unsigned char D.36124;
  guint8 * code.2384;
  unsigned char D.36126;
  guint8 * code.2385;
  unsigned char D.36128;
  guint8 * code.2386;
  unsigned char D.36130;
  guint8 * code.2387;
  guint8 * code.2388;
  guint8 * code.2389;
  guint8 * code.2390;
  guint8 * code.2391;
  guint8 * code.2392;
  guint8 * code.2393;
  guint8 * code.2394;
  unsigned char D.36147;
  guint8 * code.2395;
  unsigned char D.36149;
  guint8 * code.2396;
  unsigned char D.36151;
  guint8 * code.2397;
  unsigned char D.36153;
  guint8 * code.2398;
  guint8 * code.2399;
  guint8 * code.2400;
  guint8 * code.2401;
  unsigned char D.36165;
  guint8 * code.2402;
  unsigned char D.36167;
  guint8 * code.2403;
  unsigned char D.36169;
  guint8 * code.2404;
  unsigned char D.36171;
  guint8 * code.2405;
  guint8 * code.2406;
  unsigned char D.36176;
  guint8 * code.2407;
  unsigned char D.36178;
  guint8 * code.2408;
  unsigned char D.36180;
  guint8 * code.2409;
  unsigned char D.36182;
  guint8 * code.2410;
  guint8 * code.2411;
  guint8 * code.2412;
  guint8 * code.2413;
  guint8 * code.2414;
  unsigned char D.36191;
  guint8 * code.2415;
  unsigned char D.36193;
  guint8 * code.2416;
  unsigned char D.36195;
  guint8 * code.2417;
  unsigned char D.36197;
  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;
  guint8 * code.2428;
  unsigned char D.36219;
  guint8 * code.2429;
  unsigned char D.36221;
  guint8 * code.2430;
  unsigned char D.36223;
  guint8 * code.2431;
  unsigned char D.36225;
  guint8 * code.2432;
  guint8 * code.2433;
  guint8 * code.2434;
  guint8 * code.2435;
  unsigned char D.36237;
  guint8 * code.2436;
  unsigned char D.36239;
  guint8 * code.2437;
  unsigned char D.36241;
  guint8 * code.2438;
  unsigned char D.36243;
  guint8 * code.2439;
  guint8 * code.2440;
  guint8 * code.2441;
  guint8 * code.2442;
  guint8 * code.2443;
  guint8 * code.2444;
  guint8 * code.2445;
  guint8 * code.2446;
  guint8 * code.2447;
  guint8 * code.2448;
  guint8 * code.2449;
  guint8 * code.2450;
  unsigned char D.36265;
  guint8 * code.2451;
  unsigned char D.36267;
  guint8 * code.2452;
  unsigned char D.36269;
  guint8 * code.2453;
  unsigned char D.36271;
  guint8 * code.2454;
  guint8 * code.2455;
  guint8 * code.2456;
  guint8 * code.2457;
  unsigned char D.36281;
  guint8 * code.2458;
  unsigned char D.36283;
  guint8 * code.2459;
  unsigned char D.36285;
  guint8 * code.2460;
  unsigned char D.36287;
  guint8 * code.2461;
  int D.36289;
  guint8 * code.2462;
  unsigned char D.36291;
  guint8 * code.2463;
  unsigned char D.36293;
  guint8 * code.2464;
  unsigned char D.36295;
  guint8 * code.2465;
  unsigned char D.36297;
  guint8 * code.2466;
  guint8 * code.2467;
  guint8 * code.2468;
  guint8 * code.2469;
  guint8 * code.2470;
  guint8 * code.2471;
  guint8 * code.2472;
  guint8 * code.2473;
  guint8 * code.2474;
  int D.36309;
  int D.36310;
  signed char D.36311;
  signed char D.36312;
  signed char D.36313;
  unsigned char D.36314;
  guint8 * code.2475;
  unsigned char D.36316;
  guint8 * code.2476;
  unsigned char D.36318;
  guint8 * code.2477;
  unsigned char D.36320;
  guint8 * code.2478;
  unsigned char D.36322;
  guint8 * code.2479;
  guint8 * code.2480;
  signed char D.36330;
  unsigned char D.36331;
  guint8 * code.2481;
  guint8 * code.2482;
  guint8 * code.2483;
  guint8 * code.2484;
  guint8 * code.2485;
  unsigned char D.36340;
  guint8 * code.2486;
  unsigned char D.36342;
  guint8 * code.2487;
  unsigned char D.36344;
  guint8 * code.2488;
  unsigned char D.36346;
  guint8 * code.2489;
  guint8 * code.2490;
  guint8 * code.2491;
  guint8 * code.2492;
  guint8 * code.2493;
  guint8 * code.2494;
  guint8 * code.2495;
  guint8 * code.2496;
  unsigned char D.36363;
  guint8 * code.2497;
  unsigned char D.36365;
  guint8 * code.2498;
  unsigned char D.36367;
  guint8 * code.2499;
  unsigned char D.36369;
  guint8 * code.2500;
  guint8 * code.2501;
  guint8 * code.2502;
  guint8 * code.2503;
  unsigned char D.36381;
  guint8 * code.2504;
  unsigned char D.36383;
  guint8 * code.2505;
  unsigned char D.36385;
  guint8 * code.2506;
  unsigned char D.36387;
  guint8 * code.2507;
  guint8 * code.2508;
  guint8 * code.2509;
  signed char D.36394;
  signed char D.36395;
  unsigned char D.36396;
  guint8 * code.2510;
  guint8 * code.2511;
  unsigned char D.36401;
  guint8 * code.2512;
  unsigned char D.36403;
  guint8 * code.2513;
  unsigned char D.36405;
  guint8 * code.2514;
  unsigned char D.36407;
  guint8 * code.2515;
  guint8 * code.2516;
  guint8 * code.2517;
  guint8 * code.2518;
  guint8 * code.2519;
  unsigned char D.36416;
  guint8 * code.2520;
  unsigned char D.36418;
  guint8 * code.2521;
  unsigned char D.36420;
  guint8 * code.2522;
  unsigned char D.36422;
  guint8 * code.2523;
  guint8 * code.2524;
  unsigned char D.36427;
  guint8 * code.2525;
  unsigned char D.36429;
  guint8 * code.2526;
  unsigned char D.36431;
  guint8 * code.2527;
  unsigned char D.36433;
  guint8 * code.2528;
  guint8 * code.2529;
  guint8 * code.2530;
  guint8 * code.2531;
  guint8 * code.2532;
  unsigned char D.36442;
  guint8 * code.2533;
  unsigned char D.36444;
  guint8 * code.2534;
  unsigned char D.36446;
  guint8 * code.2535;
  unsigned char D.36448;
  guint8 * code.2536;
  guint8 * code.2537;
  guint8 * code.2538;
  guint8 * code.2539;
  signed char D.36453;
  unsigned char D.36454;
  unsigned int D.36455;
  guint8 * code.2540;
  int size.2541;
  guint8 * code.2542;
  unsigned char D.36461;
  guint8 * code.2543;
  unsigned char D.36463;
  guint8 * code.2544;
  unsigned char D.36465;
  guint8 * code.2545;
  unsigned char D.36467;
  guint8 * code.2546;
  guint8 * code.2547;
  guint8 * code.2548;
  guint8 * code.2549;
  guint8 * code.2550;
  guint8 * code.2551;
  unsigned char D.36477;
  guint8 * code.2552;
  unsigned char D.36479;
  guint8 * code.2553;
  unsigned char D.36481;
  guint8 * code.2554;
  unsigned char D.36483;
  _Bool D.36484;
  _Bool D.36485;
  _Bool D.36486;
  guint8 * code.2555;
  guint8 * code.2556;
  unsigned char D.36491;
  guint8 * code.2557;
  guint8 * code.2558;
  guint8 * code.2559;
  unsigned char D.36496;
  guint8 * code.2560;
  unsigned char D.36498;
  guint8 * code.2561;
  unsigned char D.36500;
  guint8 * code.2562;
  unsigned char D.36502;
  guint8 * code.2563;
  guint8 * code.2564;
  guint8 * code.2565;
  guint8 * code.2566;
  guint8 * code.2567;
  guint8 * code.2568;
  unsigned char D.36511;
  guint8 * code.2569;
  unsigned char D.36513;
  guint8 * code.2570;
  unsigned char D.36515;
  guint8 * code.2571;
  unsigned char D.36517;
  guint8 * code.2572;
  guint8 * code.2573;
  guint8 * code.2574;
  guint8 * code.2575;
  guint8 * code.2576;
  unsigned char D.36526;
  guint8 * code.2577;
  unsigned char D.36528;
  guint8 * code.2578;
  unsigned char D.36530;
  guint8 * code.2579;
  unsigned char D.36532;
  guint8 * code.2580;
  guint8 * code.2581;
  guint8 * code.2582;
  unsigned char D.36538;
  guint8 * code.2583;
  unsigned char D.36540;
  guint8 * code.2584;
  unsigned char D.36542;
  guint8 * code.2585;
  unsigned char D.36544;
  guint8 * code.2586;
  guint8 * code.2587;
  guint8 * code.2588;
  guint8 * code.2589;
  guint8 * code.2590;
  unsigned char D.36553;
  guint8 * code.2591;
  unsigned char D.36555;
  guint8 * code.2592;
  unsigned char D.36557;
  guint8 * code.2593;
  unsigned char D.36559;
  guint8 * code.2594;
  guint8 * code.2595;
  guint8 * code.2596;
  unsigned char D.36565;
  guint8 * code.2597;
  unsigned char D.36567;
  guint8 * code.2598;
  unsigned char D.36569;
  guint8 * code.2599;
  unsigned char D.36571;
  guint8 * code.2600;
  guint8 * code.2601;
  guint8 * code.2602;
  guint8 * code.2603;
  guint8 * code.2604;
  unsigned char D.36580;
  guint8 * code.2605;
  unsigned char D.36582;
  guint8 * code.2606;
  unsigned char D.36584;
  guint8 * code.2607;
  unsigned char D.36586;
  struct MonoBasicBlock * D.36587;
  guint8 * code.2608;
  guint8 * code.2609;
  unsigned char D.36590;
  guint8 * code.2610;
  unsigned char D.36592;
  guint8 * code.2611;
  unsigned char D.36594;
  guint8 * code.2612;
  unsigned char D.36596;
  struct MonoExceptionClause * D.36597;
  guint8 * code.2613;
  guint8 * code.2614;
  unsigned char D.36602;
  guint8 * code.2615;
  unsigned char D.36604;
  guint8 * code.2616;
  unsigned char D.36606;
  guint8 * code.2617;
  unsigned char D.36608;
  guint8 * code.2618;
  guint8 * code.2619;
  guint8 * code.2620;
  guint8 * code.2621;
  guint8 * code.2622;
  unsigned char D.36617;
  guint8 * code.2623;
  unsigned char D.36619;
  guint8 * code.2624;
  unsigned char D.36621;
  guint8 * code.2625;
  unsigned char D.36623;
  unsigned int D.36624;
  int D.36625;
  guint8 * code.2626;
  guint8 * code.2627;
  guint8 * code.2628;
  int D.36629;
  int D.36632;
  guint8 * code.2629;
  guint8 * code.2630;
  unsigned int D.36638;
  unsigned int D.36639;
  guint8 * code.2631;
  guint8 * code.2632;
  unsigned char D.36644;
  guint8 * code.2633;
  guint8 * code.2634;
  guint8 * code.2635;
  unsigned char D.36649;
  guint8 * code.2636;
  unsigned char D.36651;
  guint8 * code.2637;
  unsigned char D.36653;
  guint8 * code.2638;
  unsigned char D.36655;
  guint8 * code.2639;
  signed char D.36661;
  signed char D.36662;
  signed char D.36663;
  unsigned char D.36664;
  guint8 * code.2640;
  signed char D.36668;
  unsigned char D.36669;
  guint8 * code.2641;
  signed char D.36672;
  unsigned char D.36673;
  guint8 * code.2642;
  unsigned char D.36675;
  guint8 * code.2643;
  unsigned char D.36677;
  guint8 * code.2644;
  unsigned char D.36679;
  guint8 * code.2645;
  unsigned char D.36681;
  guint8 * code.2646;
  guint8 * code.2647;
  guint8 * code.2648;
  int D.36685;
  int D.36688;
  guint8 * code.2649;
  guint8 * code.2650;
  unsigned int D.36694;
  unsigned int D.36695;
  guint8 * code.2651;
  guint8 * code.2652;
  unsigned char D.36700;
  guint8 * code.2653;
  guint8 * code.2654;
  guint8 * code.2655;
  unsigned char D.36705;
  guint8 * code.2656;
  unsigned char D.36707;
  guint8 * code.2657;
  unsigned char D.36709;
  guint8 * code.2658;
  unsigned char D.36711;
  guint8 * code.2659;
  signed char D.36717;
  signed char D.36718;
  signed char D.36719;
  unsigned char D.36720;
  guint8 * code.2660;
  signed char D.36724;
  unsigned char D.36725;
  guint8 * code.2661;
  signed char D.36728;
  unsigned char D.36729;
  guint8 * code.2662;
  unsigned char D.36731;
  guint8 * code.2663;
  unsigned char D.36733;
  guint8 * code.2664;
  unsigned char D.36735;
  guint8 * code.2665;
  unsigned char D.36737;
  guint8 * code.2666;
  guint8 * code.2667;
  guint8 * code.2668;
  guint8 * code.2669;
  int D.36742;
  int D.36745;
  guint8 * code.2670;
  guint8 * code.2671;
  unsigned int D.36751;
  unsigned int D.36752;
  guint8 * code.2672;
  guint8 * code.2673;
  unsigned char D.36757;
  guint8 * code.2674;
  guint8 * code.2675;
  guint8 * code.2676;
  unsigned char D.36762;
  guint8 * code.2677;
  unsigned char D.36764;
  guint8 * code.2678;
  unsigned char D.36766;
  guint8 * code.2679;
  unsigned char D.36768;
  guint8 * code.2680;
  signed char D.36774;
  signed char D.36775;
  signed char D.36776;
  unsigned char D.36777;
  guint8 * code.2681;
  signed char D.36781;
  unsigned char D.36782;
  guint8 * code.2682;
  signed char D.36785;
  unsigned char D.36786;
  guint8 * code.2683;
  unsigned char D.36788;
  guint8 * code.2684;
  unsigned char D.36790;
  guint8 * code.2685;
  unsigned char D.36792;
  guint8 * code.2686;
  unsigned char D.36794;
  guint8 * code.2687;
  int D.36796;
  sizetype D.36799;
  unsigned char * D.36800;
  int D.36801;
  int D.36802;
  unsigned int t.2688;
  unsigned int D.36804;
  guint8 * code.2689;
  unsigned char D.36808;
  guint8 * code.2690;
  guint8 * code.2691;
  unsigned char D.36812;
  guint8 * code.2692;
  unsigned char D.36814;
  guint8 * code.2693;
  unsigned char D.36816;
  guint8 * code.2694;
  unsigned char D.36818;
  int D.36823;
  int D.36824;
  unsigned int D.36825;
  unsigned int D.36826;
  guint8 * code.2695;
  guint8 * code.2696;
  guint8 * code.2697;
  unsigned char D.36831;
  guint8 * code.2698;
  unsigned char D.36833;
  guint8 * code.2699;
  unsigned char D.36835;
  guint8 * code.2700;
  unsigned char D.36837;
  guint8 * code.2701;
  guint8 * code.2702;
  _Bool D.36840;
  long int D.36841;
  long int D.36842;
  guint8 * code.2703;
  <unnamed type> D.36846;
  int D.36847;
  guint8 * code.2704;
  <unnamed type> D.36851;
  int D.36852;
  unsigned char D.36853;
  unsigned char D.36854;
  guint8 * code.2705;
  <unnamed type> D.36857;
  int D.36858;
  unsigned char D.36859;
  unsigned char D.36860;
  guint8 * code.2706;
  guint8 * code.2707;
  guint8 * code.2708;
  guint8 * code.2709;
  void * D.36871;
  guint8 * code.2710;
  <unnamed type> D.36875;
  int D.36876;
  guint8 * code.2711;
  <unnamed type> D.36880;
  int D.36881;
  unsigned char D.36882;
  unsigned char D.36883;
  guint8 * code.2712;
  <unnamed type> D.36886;
  int D.36887;
  unsigned char D.36888;
  unsigned char D.36889;
  guint8 * code.2713;
  unsigned char D.36891;
  guint8 * code.2714;
  unsigned char D.36893;
  guint8 * code.2715;
  unsigned char D.36895;
  guint8 * code.2716;
  unsigned char D.36897;
  struct MonoBasicBlock * * D.36899;
  struct MonoBasicBlock * D.36900;
  int D.36901;
  sizetype D.36904;
  unsigned char * D.36905;
  int D.36906;
  int D.36907;
  unsigned int offset.2717;
  unsigned int D.36909;
  <unnamed type> D.36912;
  int D.36913;
  guint8 * code.2718;
  <unnamed type> D.36917;
  int D.36918;
  unsigned char D.36919;
  guint8 * code.2719;
  <unnamed type> D.36922;
  int D.36923;
  unsigned char D.36924;
  unsigned char D.36925;
  guint8 * code.2720;
  <unnamed type> D.36928;
  int D.36929;
  guint8 * code.2721;
  <unnamed type> D.36933;
  int D.36934;
  unsigned char D.36935;
  unsigned char D.36936;
  guint8 * code.2722;
  <unnamed type> D.36939;
  int D.36940;
  unsigned char D.36941;
  unsigned char D.36942;
  guint8 * code.2723;
  unsigned char D.36944;
  guint8 * code.2724;
  unsigned char D.36946;
  guint8 * code.2725;
  unsigned char D.36948;
  guint8 * code.2726;
  unsigned char D.36950;
  unsigned char D.36951;
  int D.36952;
  unsigned char D.36953;
  unsigned char D.36954;
  int pos.2727;
  int D.36960;
  unsigned char * pos.2728;
  unsigned char D.36962;
  unsigned char * pos.2729;
  unsigned char D.36964;
  unsigned char * pos.2730;
  unsigned char D.36966;
  unsigned char * pos.2731;
  unsigned char D.36968;
  unsigned int disp.2732;
  unsigned int D.36971;
  unsigned char D.36974;
  unsigned char D.36975;
  int D.36981;
  int D.36982;
  unsigned int D.36983;
  unsigned int D.36984;
  <unnamed type> D.36986;
  int D.36987;
  guint8 * code.2733;
  <unnamed type> D.36991;
  int D.36992;
  unsigned char D.36993;
  guint8 * code.2734;
  <unnamed type> D.36996;
  int D.36997;
  unsigned char D.36998;
  guint8 * code.2735;
  <unnamed type> D.37000;
  int D.37001;
  guint8 * code.2736;
  <unnamed type> D.37005;
  int D.37006;
  unsigned char D.37007;
  unsigned char D.37008;
  guint8 * code.2737;
  <unnamed type> D.37011;
  int D.37012;
  unsigned char D.37013;
  unsigned char D.37014;
  guint8 * code.2738;
  unsigned char D.37016;
  guint8 * code.2739;
  unsigned char D.37018;
  guint8 * code.2740;
  unsigned char D.37020;
  guint8 * code.2741;
  unsigned char D.37022;
  guint8 * code.2742;
  guint8 * code.2743;
  int D.37029;
  int D.37030;
  unsigned char D.37031;
  unsigned char D.37032;
  guint8 * code.2744;
  unsigned char D.37035;
  unsigned char D.37036;
  guint8 * code.2745;
  unsigned char D.37038;
  guint8 * code.2746;
  unsigned char D.37040;
  guint8 * code.2747;
  unsigned char D.37042;
  guint8 * code.2748;
  unsigned char D.37044;
  struct MonoBasicBlock * * D.37046;
  struct MonoBasicBlock * D.37047;
  int D.37048;
  sizetype D.37051;
  unsigned char * D.37052;
  int D.37053;
  int D.37054;
  unsigned int offset.2749;
  unsigned int D.37056;
  guint8 * code.2750;
  guint8 * code.2751;
  unsigned char D.37064;
  guint8 * code.2752;
  guint8 * code.2753;
  guint8 * code.2754;
  guint8 * code.2755;
  unsigned char D.37073;
  guint8 * code.2756;
  unsigned char D.37075;
  guint8 * code.2757;
  unsigned char D.37077;
  guint8 * code.2758;
  unsigned char D.37079;
  unsigned char D.37080;
  int D.37081;
  unsigned char D.37082;
  unsigned char D.37083;
  int pos.2759;
  int D.37089;
  unsigned char * pos.2760;
  unsigned char D.37091;
  unsigned char * pos.2761;
  unsigned char D.37093;
  unsigned char * pos.2762;
  unsigned char D.37095;
  unsigned char * pos.2763;
  unsigned char D.37097;
  unsigned int disp.2764;
  unsigned int D.37100;
  unsigned char D.37103;
  unsigned char D.37104;
  int D.37110;
  int D.37111;
  unsigned int D.37112;
  unsigned int D.37113;
  guint8 * code.2765;
  guint8 * code.2766;
  guint8 * code.2767;
  guint8 * code.2768;
  guint8 * code.2769;
  guint8 * code.2770;
  unsigned char D.37127;
  guint8 * code.2771;
  unsigned char D.37129;
  guint8 * code.2772;
  unsigned char D.37131;
  guint8 * code.2773;
  unsigned char D.37133;
  guint8 * code.2774;
  guint8 * code.2775;
  int D.37140;
  int D.37141;
  unsigned char D.37142;
  unsigned char D.37143;
  guint8 * code.2776;
  unsigned char D.37146;
  unsigned char D.37147;
  guint8 * code.2777;
  unsigned char D.37149;
  guint8 * code.2778;
  unsigned char D.37151;
  guint8 * code.2779;
  unsigned char D.37153;
  guint8 * code.2780;
  unsigned char D.37155;
  struct MonoBasicBlock * * D.37157;
  struct MonoBasicBlock * D.37158;
  int D.37159;
  sizetype D.37162;
  unsigned char * D.37163;
  int D.37164;
  int D.37165;
  unsigned int offset.2781;
  unsigned int D.37167;
  guint8 * code.2782;
  guint8 * code.2783;
  unsigned char D.37175;
  guint8 * code.2784;
  guint8 * code.2785;
  guint8 * code.2786;
  guint8 * code.2787;
  unsigned char D.37184;
  guint8 * code.2788;
  unsigned char D.37186;
  guint8 * code.2789;
  unsigned char D.37188;
  guint8 * code.2790;
  unsigned char D.37190;
  unsigned char D.37191;
  int D.37192;
  unsigned char D.37193;
  unsigned char D.37194;
  int pos.2791;
  int D.37200;
  unsigned char * pos.2792;
  unsigned char D.37202;
  unsigned char * pos.2793;
  unsigned char D.37204;
  unsigned char * pos.2794;
  unsigned char D.37206;
  unsigned char * pos.2795;
  unsigned char D.37208;
  unsigned int disp.2796;
  unsigned int D.37211;
  unsigned char D.37214;
  unsigned char D.37215;
  int D.37221;
  int D.37222;
  unsigned int D.37223;
  unsigned int D.37224;
  guint8 * code.2797;
  guint8 * code.2798;
  guint8 * code.2799;
  guint8 * code.2800;
  guint8 * code.2801;
  guint8 * code.2802;
  unsigned char D.37238;
  guint8 * code.2803;
  unsigned char D.37240;
  guint8 * code.2804;
  unsigned char D.37242;
  guint8 * code.2805;
  unsigned char D.37244;
  struct MonoBasicBlock * * D.37245;
  struct MonoBasicBlock * D.37246;
  int D.37247;
  sizetype D.37250;
  unsigned char * D.37251;
  int D.37252;
  int D.37253;
  unsigned int offset.2806;
  unsigned int D.37255;
  <unnamed type> D.37258;
  int D.37259;
  guint8 * code.2807;
  <unnamed type> D.37263;
  int D.37264;
  unsigned char D.37265;
  guint8 * code.2808;
  <unnamed type> D.37268;
  int D.37269;
  unsigned char D.37270;
  unsigned char D.37271;
  guint8 * code.2809;
  <unnamed type> D.37274;
  int D.37275;
  guint8 * code.2810;
  <unnamed type> D.37279;
  int D.37280;
  unsigned char D.37281;
  unsigned char D.37282;
  guint8 * code.2811;
  <unnamed type> D.37285;
  int D.37286;
  unsigned char D.37287;
  unsigned char D.37288;
  guint8 * code.2812;
  unsigned char D.37290;
  guint8 * code.2813;
  unsigned char D.37292;
  guint8 * code.2814;
  unsigned char D.37294;
  guint8 * code.2815;
  unsigned char D.37296;
  unsigned char D.37297;
  int D.37298;
  unsigned char D.37299;
  unsigned char D.37300;
  int pos.2816;
  int D.37306;
  unsigned char * pos.2817;
  unsigned char D.37308;
  unsigned char * pos.2818;
  unsigned char D.37310;
  unsigned char * pos.2819;
  unsigned char D.37312;
  unsigned char * pos.2820;
  unsigned char D.37314;
  unsigned int disp.2821;
  unsigned int D.37317;
  unsigned char D.37320;
  unsigned char D.37321;
  int D.37327;
  int D.37328;
  unsigned int D.37329;
  unsigned int D.37330;
  <unnamed type> D.37332;
  int D.37333;
  guint8 * code.2822;
  <unnamed type> D.37337;
  int D.37338;
  unsigned char D.37339;
  guint8 * code.2823;
  <unnamed type> D.37342;
  int D.37343;
  unsigned char D.37344;
  guint8 * code.2824;
  <unnamed type> D.37346;
  int D.37347;
  guint8 * code.2825;
  <unnamed type> D.37351;
  int D.37352;
  unsigned char D.37353;
  unsigned char D.37354;
  guint8 * code.2826;
  <unnamed type> D.37357;
  int D.37358;
  unsigned char D.37359;
  unsigned char D.37360;
  guint8 * code.2827;
  unsigned char D.37362;
  guint8 * code.2828;
  unsigned char D.37364;
  guint8 * code.2829;
  unsigned char D.37366;
  guint8 * code.2830;
  unsigned char D.37368;
  _Bool D.37369;
  long int D.37370;
  long int D.37371;
  guint8 * code.2831;
  <unnamed type> D.37375;
  int D.37376;
  guint8 * code.2832;
  <unnamed type> D.37380;
  int D.37381;
  unsigned char D.37382;
  unsigned char D.37383;
  guint8 * code.2833;
  <unnamed type> D.37386;
  int D.37387;
  unsigned char D.37388;
  unsigned char D.37389;
  guint8 * code.2834;
  signed char D.37391;
  unsigned char D.37392;
  double d.2835;
  double d.2836;
  int D.37398;
  guint8 * code.2837;
  guint8 * code.2838;
  guint8 * code.2839;
  guint8 * code.2840;
  guint32 * D.37409;
  unsigned int D.37410;
  unsigned int _imm.2841;
  unsigned int D.37412;
  guint8 * code.2842;
  unsigned char D.37416;
  guint8 * code.2843;
  guint8 * code.2844;
  unsigned char D.37420;
  guint8 * code.2845;
  unsigned char D.37422;
  guint8 * code.2846;
  unsigned char D.37424;
  guint8 * code.2847;
  unsigned char D.37426;
  unsigned int D.37427;
  unsigned int _imm.2848;
  unsigned int D.37429;
  guint8 * code.2849;
  unsigned char D.37433;
  guint8 * code.2850;
  guint8 * code.2851;
  unsigned char D.37437;
  guint8 * code.2852;
  unsigned char D.37439;
  guint8 * code.2853;
  unsigned char D.37441;
  guint8 * code.2854;
  unsigned char D.37443;
  guint8 * code.2855;
  guint8 * code.2856;
  guint8 * code.2857;
  guint8 * code.2858;
  guint8 * code.2859;
  guint8 * code.2860;
  guint8 * code.2861;
  guint8 * code.2862;
  unsigned char D.37460;
  guint8 * code.2863;
  unsigned char D.37462;
  guint8 * code.2864;
  unsigned char D.37464;
  guint8 * code.2865;
  unsigned char D.37466;
  guint8 * code.2866;
  guint8 * code.2867;
  guint8 * code.2868;
  guint8 * code.2869;
  unsigned char D.37476;
  guint8 * code.2870;
  unsigned char D.37478;
  guint8 * code.2871;
  unsigned char D.37480;
  guint8 * code.2872;
  unsigned char D.37482;
  guint8 * code.2873;
  guint8 * code.2874;
  unsigned char D.37487;
  guint8 * code.2875;
  unsigned char D.37489;
  guint8 * code.2876;
  unsigned char D.37491;
  guint8 * code.2877;
  unsigned char D.37493;
  guint8 * code.2878;
  guint8 * code.2879;
  guint8 * code.2880;
  guint8 * code.2881;
  guint8 * code.2882;
  unsigned char D.37502;
  guint8 * code.2883;
  unsigned char D.37504;
  guint8 * code.2884;
  unsigned char D.37506;
  guint8 * code.2885;
  unsigned char D.37508;
  guint8 * code.2886;
  guint8 * code.2887;
  guint8 * code.2888;
  unsigned char D.37513;
  guint8 * code.2889;
  unsigned char D.37515;
  guint8 * code.2890;
  unsigned char D.37517;
  guint8 * code.2891;
  unsigned char D.37519;
  float f.2892;
  float f.2893;
  int D.37525;
  guint8 * code.2894;
  guint8 * code.2895;
  guint8 * code.2896;
  guint8 * code.2897;
  float * f.2898;
  unsigned int _imm.2899;
  unsigned int D.37538;
  guint8 * code.2900;
  unsigned char D.37542;
  guint8 * code.2901;
  guint8 * code.2902;
  unsigned char D.37546;
  guint8 * code.2903;
  unsigned char D.37548;
  guint8 * code.2904;
  unsigned char D.37550;
  guint8 * code.2905;
  unsigned char D.37552;
  guint8 * code.2906;
  guint8 * code.2907;
  guint8 * code.2908;
  guint8 * code.2909;
  guint8 * code.2910;
  guint8 * code.2911;
  guint8 * code.2912;
  guint8 * code.2913;
  unsigned char D.37569;
  guint8 * code.2914;
  unsigned char D.37571;
  guint8 * code.2915;
  unsigned char D.37573;
  guint8 * code.2916;
  unsigned char D.37575;
  guint8 * code.2917;
  guint8 * code.2918;
  guint8 * code.2919;
  guint8 * code.2920;
  unsigned char D.37585;
  guint8 * code.2921;
  unsigned char D.37587;
  guint8 * code.2922;
  unsigned char D.37589;
  guint8 * code.2923;
  unsigned char D.37591;
  guint8 * code.2924;
  guint8 * code.2925;
  unsigned char D.37596;
  guint8 * code.2926;
  unsigned char D.37598;
  guint8 * code.2927;
  unsigned char D.37600;
  guint8 * code.2928;
  unsigned char D.37602;
  guint8 * code.2929;
  guint8 * code.2930;
  guint8 * code.2931;
  guint8 * code.2932;
  guint8 * code.2933;
  unsigned char D.37611;
  guint8 * code.2934;
  unsigned char D.37613;
  guint8 * code.2935;
  unsigned char D.37615;
  guint8 * code.2936;
  unsigned char D.37617;
  guint8 * code.2937;
  guint8 * code.2938;
  guint8 * code.2939;
  unsigned char D.37622;
  guint8 * code.2940;
  unsigned char D.37624;
  guint8 * code.2941;
  unsigned char D.37626;
  guint8 * code.2942;
  unsigned char D.37628;
  guint8 * code.2943;
  guint8 * code.2944;
  guint8 * code.2945;
  guint8 * code.2946;
  guint8 * code.2947;
  guint8 * code.2948;
  guint8 * code.2949;
  guint8 * code.2950;
  unsigned char D.37645;
  guint8 * code.2951;
  unsigned char D.37647;
  guint8 * code.2952;
  unsigned char D.37649;
  guint8 * code.2953;
  unsigned char D.37651;
  guint8 * code.2954;
  signed char D.37657;
  unsigned char D.37658;
  guint8 * code.2955;
  signed char D.37662;
  unsigned char D.37663;
  guint8 * code.2956;
  signed char D.37666;
  unsigned char D.37667;
  guint8 * code.2957;
  unsigned char D.37669;
  guint8 * code.2958;
  unsigned char D.37671;
  guint8 * code.2959;
  unsigned char D.37673;
  guint8 * code.2960;
  unsigned char D.37675;
  guint8 * code.2961;
  guint8 * code.2962;
  guint8 * code.2963;
  guint8 * code.2964;
  guint8 * code.2965;
  guint8 * code.2966;
  guint8 * code.2967;
  guint8 * code.2968;
  unsigned char D.37692;
  guint8 * code.2969;
  unsigned char D.37694;
  guint8 * code.2970;
  unsigned char D.37696;
  guint8 * code.2971;
  unsigned char D.37698;
  guint8 * code.2972;
  guint8 * code.2973;
  guint8 * code.2974;
  guint8 * code.2975;
  unsigned char D.37710;
  guint8 * code.2976;
  unsigned char D.37712;
  guint8 * code.2977;
  unsigned char D.37714;
  guint8 * code.2978;
  unsigned char D.37716;
  guint8 * code.2979;
  guint8 * code.2980;
  guint8 * code.2981;
  guint8 * code.2982;
  guint8 * code.2983;
  guint8 * code.2984;
  guint8 * code.2985;
  guint8 * code.2986;
  unsigned char D.37733;
  guint8 * code.2987;
  unsigned char D.37735;
  guint8 * code.2988;
  unsigned char D.37737;
  guint8 * code.2989;
  unsigned char D.37739;
  guint8 * code.2990;
  guint8 * code.2991;
  guint8 * code.2992;
  guint8 * code.2993;
  unsigned char D.37751;
  guint8 * code.2994;
  unsigned char D.37753;
  guint8 * code.2995;
  unsigned char D.37755;
  guint8 * code.2996;
  unsigned char D.37757;
  guint8 * code.2997;
  guint8 * code.2998;
  guint8 * code.2999;
  guint8 * code.3000;
  guint8 * code.3001;
  guint8 * code.3002;
  guint8 * code.3003;
  guint8 * code.3004;
  unsigned char D.37774;
  guint8 * code.3005;
  unsigned char D.37776;
  guint8 * code.3006;
  unsigned char D.37778;
  guint8 * code.3007;
  unsigned char D.37780;
  guint8 * code.3008;
  guint8 * code.3009;
  guint8 * code.3010;
  guint8 * code.3011;
  unsigned char D.37792;
  guint8 * code.3012;
  unsigned char D.37794;
  guint8 * code.3013;
  unsigned char D.37796;
  guint8 * code.3014;
  unsigned char D.37798;
  guint8 * code.3015;
  guint8 * code.3016;
  guint8 * code.3017;
  guint8 * code.3018;
  guint8 * code.3019;
  guint8 * code.3020;
  guint8 * code.3021;
  guint8 * code.3022;
  guint8 * code.3023;
  unsigned char D.37818;
  guint8 * code.3024;
  unsigned char D.37820;
  guint8 * code.3025;
  unsigned char D.37822;
  guint8 * code.3026;
  unsigned char D.37824;
  guint8 * code.3027;
  guint8 * code.3028;
  guint8 * code.3029;
  guint8 * code.3030;
  unsigned char D.37834;
  guint8 * code.3031;
  unsigned char D.37836;
  guint8 * code.3032;
  unsigned char D.37838;
  guint8 * code.3033;
  unsigned char D.37840;
  guint8 * code.3034;
  guint8 * code.3035;
  guint8 * code.3036;
  guint8 * code.3037;
  guint8 * code.3038;
  guint8 * code.3039;
  guint8 * code.3040;
  guint8 * code.3041;
  unsigned char D.37858;
  guint8 * code.3042;
  unsigned char D.37860;
  guint8 * code.3043;
  unsigned char D.37862;
  guint8 * code.3044;
  unsigned char D.37864;
  guint8 * code.3045;
  guint8 * code.3046;
  guint8 * code.3047;
  guint8 * code.3048;
  unsigned char D.37874;
  guint8 * code.3049;
  unsigned char D.37876;
  guint8 * code.3050;
  unsigned char D.37878;
  guint8 * code.3051;
  unsigned char D.37880;
  guint8 * code.3052;
  guint8 * code.3053;
  guint8 * code.3054;
  guint8 * code.3055;
  guint8 * code.3056;
  guint8 * code.3057;
  guint8 * code.3058;
  guint8 * code.3059;
  unsigned char D.37897;
  guint8 * code.3060;
  unsigned char D.37899;
  guint8 * code.3061;
  unsigned char D.37901;
  guint8 * code.3062;
  unsigned char D.37903;
  guint8 * code.3063;
  guint8 * code.3064;
  guint8 * code.3065;
  guint8 * code.3066;
  unsigned char D.37913;
  guint8 * code.3067;
  unsigned char D.37915;
  guint8 * code.3068;
  unsigned char D.37917;
  guint8 * code.3069;
  unsigned char D.37919;
  guint8 * code.3070;
  guint8 * code.3071;
  guint8 * code.3072;
  guint8 * code.3073;
  guint8 * code.3074;
  guint8 * code.3075;
  guint8 * code.3076;
  guint8 * code.3077;
  unsigned char D.37936;
  guint8 * code.3078;
  unsigned char D.37938;
  guint8 * code.3079;
  unsigned char D.37940;
  guint8 * code.3080;
  unsigned char D.37942;
  guint8 * code.3081;
  guint8 * code.3082;
  guint8 * code.3083;
  guint8 * code.3084;
  unsigned char D.37952;
  guint8 * code.3085;
  unsigned char D.37954;
  guint8 * code.3086;
  unsigned char D.37956;
  guint8 * code.3087;
  unsigned char D.37958;
  guint8 * code.3088;
  guint8 * code.3089;
  unsigned char D.37963;
  guint8 * code.3090;
  unsigned char D.37965;
  guint8 * code.3091;
  unsigned char D.37967;
  guint8 * code.3092;
  unsigned char D.37969;
  guint8 * code.3093;
  guint8 * code.3094;
  guint8 * code.3095;
  guint8 * code.3096;
  guint8 * code.3097;
  unsigned char D.37978;
  guint8 * code.3098;
  unsigned char D.37980;
  guint8 * code.3099;
  unsigned char D.37982;
  guint8 * code.3100;
  unsigned char D.37984;
  guint8 * code.3101;
  guint8 * code.3102;
  guint8 * code.3103;
  guint8 * code.3104;
  guint8 * code.3105;
  guint8 * code.3106;
  guint8 * code.3107;
  guint8 * code.3108;
  guint8 * code.3109;
  unsigned char D.38004;
  guint8 * code.3110;
  unsigned char D.38006;
  guint8 * code.3111;
  unsigned char D.38008;
  guint8 * code.3112;
  unsigned char D.38010;
  guint8 * code.3113;
  guint8 * code.3114;
  guint8 * code.3115;
  guint8 * code.3116;
  unsigned char D.38020;
  guint8 * code.3117;
  unsigned char D.38022;
  guint8 * code.3118;
  unsigned char D.38024;
  guint8 * code.3119;
  unsigned char D.38026;
  guint8 * code.3120;
  guint8 * code.3121;
  guint8 * code.3122;
  guint8 * code.3123;
  guint8 * code.3124;
  guint8 * code.3125;
  guint8 * code.3126;
  guint8 * code.3127;
  unsigned char D.38044;
  guint8 * code.3128;
  unsigned char D.38046;
  guint8 * code.3129;
  unsigned char D.38048;
  guint8 * code.3130;
  unsigned char D.38050;
  guint8 * code.3131;
  guint8 * code.3132;
  guint8 * code.3133;
  guint8 * code.3134;
  unsigned char D.38060;
  guint8 * code.3135;
  unsigned char D.38062;
  guint8 * code.3136;
  unsigned char D.38064;
  guint8 * code.3137;
  unsigned char D.38066;
  guint8 * code.3138;
  guint8 * code.3139;
  unsigned char D.38071;
  guint8 * code.3140;
  unsigned char D.38073;
  guint8 * code.3141;
  unsigned char D.38075;
  guint8 * code.3142;
  unsigned char D.38077;
  guint8 * code.3143;
  guint8 * code.3144;
  guint8 * code.3145;
  guint8 * code.3146;
  guint8 * code.3147;
  unsigned char D.38086;
  guint8 * code.3148;
  unsigned char D.38088;
  guint8 * code.3149;
  unsigned char D.38090;
  guint8 * code.3150;
  unsigned char D.38092;
  unsigned int _imm.3151;
  unsigned int D.38094;
  guint8 * code.3152;
  unsigned char D.38098;
  guint8 * code.3153;
  guint8 * code.3154;
  unsigned char D.38102;
  guint8 * code.3155;
  unsigned char D.38104;
  guint8 * code.3156;
  unsigned char D.38106;
  guint8 * code.3157;
  unsigned char D.38108;
  guint8 * code.3158;
  guint8 * code.3159;
  guint8 * code.3160;
  guint8 * code.3161;
  guint8 * code.3162;
  guint8 * code.3163;
  guint8 * code.3164;
  guint8 * code.3165;
  guint8 * code.3166;
  unsigned char D.38128;
  guint8 * code.3167;
  unsigned char D.38130;
  guint8 * code.3168;
  unsigned char D.38132;
  guint8 * code.3169;
  unsigned char D.38134;
  guint8 * code.3170;
  guint8 * code.3171;
  guint8 * code.3172;
  guint8 * code.3173;
  unsigned char D.38144;
  guint8 * code.3174;
  unsigned char D.38146;
  guint8 * code.3175;
  unsigned char D.38148;
  guint8 * code.3176;
  unsigned char D.38150;
  guint8 * code.3177;
  guint8 * code.3178;
  guint8 * code.3179;
  guint8 * code.3180;
  guint8 * code.3181;
  guint8 * code.3182;
  guint8 * code.3183;
  guint8 * code.3184;
  unsigned char D.38168;
  guint8 * code.3185;
  unsigned char D.38170;
  guint8 * code.3186;
  unsigned char D.38172;
  guint8 * code.3187;
  unsigned char D.38174;
  guint8 * code.3188;
  guint8 * code.3189;
  guint8 * code.3190;
  guint8 * code.3191;
  unsigned char D.38184;
  guint8 * code.3192;
  unsigned char D.38186;
  guint8 * code.3193;
  unsigned char D.38188;
  guint8 * code.3194;
  unsigned char D.38190;
  guint8 * code.3195;
  guint8 * code.3196;
  unsigned char D.38195;
  guint8 * code.3197;
  unsigned char D.38197;
  guint8 * code.3198;
  unsigned char D.38199;
  guint8 * code.3199;
  unsigned char D.38201;
  guint8 * code.3200;
  guint8 * code.3201;
  guint8 * code.3202;
  guint8 * code.3203;
  guint8 * code.3204;
  unsigned char D.38210;
  guint8 * code.3205;
  unsigned char D.38212;
  guint8 * code.3206;
  unsigned char D.38214;
  guint8 * code.3207;
  unsigned char D.38216;
  guint8 * code.3208;
  guint8 * code.3209;
  guint8 * code.3210;
  guint8 * code.3211;
  guint8 * code.3212;
  guint8 * code.3213;
  guint8 * code.3214;
  guint8 * code.3215;
  unsigned char D.38235;
  guint8 * code.3216;
  unsigned char D.38237;
  guint8 * code.3217;
  unsigned char D.38239;
  guint8 * code.3218;
  unsigned char D.38241;
  guint8 * code.3219;
  guint8 * code.3220;
  guint8 * code.3221;
  guint8 * code.3222;
  unsigned char D.38253;
  guint8 * code.3223;
  unsigned char D.38255;
  guint8 * code.3224;
  unsigned char D.38257;
  guint8 * code.3225;
  unsigned char D.38259;
  guint8 * code.3226;
  guint8 * code.3227;
  guint8 * code.3228;
  guint8 * code.3229;
  guint8 * code.3230;
  guint8 * code.3231;
  guint8 * code.3232;
  guint8 * code.3233;
  unsigned char D.38277;
  guint8 * code.3234;
  unsigned char D.38279;
  guint8 * code.3235;
  unsigned char D.38281;
  guint8 * code.3236;
  unsigned char D.38283;
  guint8 * code.3237;
  guint8 * code.3238;
  guint8 * code.3239;
  guint8 * code.3240;
  unsigned char D.38295;
  guint8 * code.3241;
  unsigned char D.38297;
  guint8 * code.3242;
  unsigned char D.38299;
  guint8 * code.3243;
  unsigned char D.38301;
  guint8 * code.3244;
  guint8 * code.3245;
  guint8 * code.3246;
  guint8 * code.3247;
  guint8 * code.3248;
  guint8 * code.3249;
  guint8 * code.3250;
  guint8 * code.3251;
  unsigned char D.38320;
  guint8 * code.3252;
  unsigned char D.38322;
  guint8 * code.3253;
  unsigned char D.38324;
  guint8 * code.3254;
  unsigned char D.38326;
  guint8 * code.3255;
  guint8 * code.3256;
  guint8 * code.3257;
  guint8 * code.3258;
  unsigned char D.38338;
  guint8 * code.3259;
  unsigned char D.38340;
  guint8 * code.3260;
  unsigned char D.38342;
  guint8 * code.3261;
  unsigned char D.38344;
  guint8 * code.3262;
  guint8 * code.3263;
  guint8 * code.3264;
  guint8 * code.3265;
  guint8 * code.3266;
  guint8 * code.3267;
  guint8 * code.3268;
  guint8 * code.3269;
  unsigned char D.38362;
  guint8 * code.3270;
  unsigned char D.38364;
  guint8 * code.3271;
  unsigned char D.38366;
  guint8 * code.3272;
  unsigned char D.38368;
  guint8 * code.3273;
  guint8 * code.3274;
  guint8 * code.3275;
  guint8 * code.3276;
  unsigned char D.38380;
  guint8 * code.3277;
  unsigned char D.38382;
  guint8 * code.3278;
  unsigned char D.38384;
  guint8 * code.3279;
  unsigned char D.38386;
  guint8 * code.3280;
  guint8 * code.3281;
  unsigned char D.38391;
  guint8 * code.3282;
  unsigned char D.38393;
  guint8 * code.3283;
  unsigned char D.38395;
  guint8 * code.3284;
  unsigned char D.38397;
  guint8 * code.3285;
  guint8 * code.3286;
  guint8 * code.3287;
  guint8 * code.3288;
  guint8 * code.3289;
  unsigned char D.38406;
  guint8 * code.3290;
  unsigned char D.38408;
  guint8 * code.3291;
  unsigned char D.38410;
  guint8 * code.3292;
  unsigned char D.38412;
  guint8 * code.3293;
  guint8 * code.3294;
  guint8 * code.3295;
  guint8 * code.3296;
  guint8 * code.3297;
  guint8 * code.3298;
  guint8 * code.3299;
  guint8 * code.3300;
  unsigned char D.38429;
  guint8 * code.3301;
  unsigned char D.38431;
  guint8 * code.3302;
  unsigned char D.38433;
  guint8 * code.3303;
  unsigned char D.38435;
  guint8 * code.3304;
  guint8 * code.3305;
  guint8 * code.3306;
  guint8 * code.3307;
  unsigned char D.38445;
  guint8 * code.3308;
  unsigned char D.38447;
  guint8 * code.3309;
  unsigned char D.38449;
  guint8 * code.3310;
  unsigned char D.38451;
  guint8 * code.3311;
  guint8 * code.3312;
  guint8 * code.3313;
  guint8 * code.3314;
  guint8 * code.3315;
  guint8 * code.3316;
  guint8 * code.3317;
  guint8 * code.3318;
  unsigned char D.38468;
  guint8 * code.3319;
  unsigned char D.38470;
  guint8 * code.3320;
  unsigned char D.38472;
  guint8 * code.3321;
  unsigned char D.38474;
  guint8 * code.3322;
  guint8 * code.3323;
  guint8 * code.3324;
  guint8 * code.3325;
  unsigned char D.38484;
  guint8 * code.3326;
  unsigned char D.38486;
  guint8 * code.3327;
  unsigned char D.38488;
  guint8 * code.3328;
  unsigned char D.38490;
  guint8 * code.3329;
  guint8 * code.3330;
  unsigned char D.38495;
  guint8 * code.3331;
  unsigned char D.38497;
  guint8 * code.3332;
  unsigned char D.38499;
  guint8 * code.3333;
  unsigned char D.38501;
  guint8 * code.3334;
  guint8 * code.3335;
  guint8 * code.3336;
  guint8 * code.3337;
  guint8 * code.3338;
  unsigned char D.38510;
  guint8 * code.3339;
  unsigned char D.38512;
  guint8 * code.3340;
  unsigned char D.38514;
  guint8 * code.3341;
  unsigned char D.38516;
  guint8 * code.3342;
  guint8 * code.3343;
  unsigned char D.38521;
  guint8 * code.3344;
  unsigned char D.38523;
  guint8 * code.3345;
  unsigned char D.38525;
  guint8 * code.3346;
  unsigned char D.38527;
  guint8 * code.3347;
  guint8 * code.3348;
  guint8 * code.3349;
  guint8 * code.3350;
  guint8 * code.3351;
  unsigned char D.38536;
  guint8 * code.3352;
  unsigned char D.38538;
  guint8 * code.3353;
  unsigned char D.38540;
  guint8 * code.3354;
  unsigned char D.38542;
  guint8 * code.3355;
  guint8 * code.3356;
  guint8 * code.3357;
  guint8 * code.3358;
  guint8 * code.3359;
  guint8 * code.3360;
  guint8 * code.3361;
  guint8 * code.3362;
  unsigned char D.38559;
  guint8 * code.3363;
  unsigned char D.38561;
  guint8 * code.3364;
  unsigned char D.38563;
  guint8 * code.3365;
  unsigned char D.38565;
  guint8 * code.3366;
  guint8 * code.3367;
  guint8 * code.3368;
  guint8 * code.3369;
  unsigned char D.38575;
  guint8 * code.3370;
  unsigned char D.38577;
  guint8 * code.3371;
  unsigned char D.38579;
  guint8 * code.3372;
  unsigned char D.38581;
  guint8 * code.3373;
  guint8 * code.3374;
  guint8 * code.3375;
  guint8 * code.3376;
  guint8 * code.3377;
  guint8 * code.3378;
  guint8 * code.3379;
  guint8 * code.3380;
  guint8 * code.3381;
  guint8 * code.3382;
  unsigned char D.38600;
  guint8 * code.3383;
  unsigned char D.38602;
  guint8 * code.3384;
  unsigned char D.38604;
  guint8 * code.3385;
  unsigned char D.38606;
  guint8 * code.3386;
  guint8 * code.3387;
  guint8 * code.3388;
  guint8 * code.3389;
  unsigned char D.38616;
  guint8 * code.3390;
  unsigned char D.38618;
  guint8 * code.3391;
  unsigned char D.38620;
  guint8 * code.3392;
  unsigned char D.38622;
  guint8 * code.3393;
  guint8 * code.3394;
  unsigned char D.38627;
  guint8 * code.3395;
  unsigned char D.38629;
  guint8 * code.3396;
  unsigned char D.38631;
  guint8 * code.3397;
  unsigned char D.38633;
  guint8 * code.3398;
  guint8 * code.3399;
  signed char D.38638;
  unsigned char D.38639;
  guint8 * code.3400;
  guint8 * code.3401;
  guint8 * code.3402;
  unsigned char D.38644;
  guint8 * code.3403;
  unsigned char D.38646;
  guint8 * code.3404;
  unsigned char D.38648;
  guint8 * code.3405;
  unsigned char D.38650;
  guint8 * code.3406;
  guint8 * code.3407;
  guint8 * code.3408;
  guint8 * code.3409;
  guint8 * code.3410;
  guint8 * code.3411;
  guint8 * code.3412;
  guint8 * code.3413;
  guint8 * code.3414;
  guint8 * code.3415;
  unsigned char D.38669;
  guint8 * code.3416;
  unsigned char D.38671;
  guint8 * code.3417;
  unsigned char D.38673;
  guint8 * code.3418;
  unsigned char D.38675;
  guint8 * code.3419;
  guint8 * code.3420;
  guint8 * code.3421;
  guint8 * code.3422;
  unsigned char D.38685;
  guint8 * code.3423;
  unsigned char D.38687;
  guint8 * code.3424;
  unsigned char D.38689;
  guint8 * code.3425;
  unsigned char D.38691;
  guint8 * code.3426;
  guint8 * code.3427;
  guint8 * code.3428;
  guint8 * code.3429;
  guint8 * code.3430;
  guint8 * code.3431;
  guint8 * code.3432;
  guint8 * code.3433;
  unsigned char D.38708;
  guint8 * code.3434;
  unsigned char D.38710;
  guint8 * code.3435;
  unsigned char D.38712;
  guint8 * code.3436;
  unsigned char D.38714;
  guint8 * code.3437;
  guint8 * code.3438;
  guint8 * code.3439;
  guint8 * code.3440;
  unsigned char D.38724;
  guint8 * code.3441;
  unsigned char D.38726;
  guint8 * code.3442;
  unsigned char D.38728;
  guint8 * code.3443;
  unsigned char D.38730;
  guint8 * code.3444;
  guint8 * code.3445;
  unsigned char D.38735;
  guint8 * code.3446;
  unsigned char D.38737;
  guint8 * code.3447;
  unsigned char D.38739;
  guint8 * code.3448;
  unsigned char D.38741;
  guint8 * code.3449;
  guint8 * code.3450;
  guint8 * code.3451;
  guint8 * code.3452;
  guint8 * code.3453;
  unsigned char D.38750;
  guint8 * code.3454;
  unsigned char D.38752;
  guint8 * code.3455;
  unsigned char D.38754;
  guint8 * code.3456;
  unsigned char D.38756;
  guint8 * code.3457;
  guint8 * code.3458;
  guint8 * code.3459;
  guint8 * code.3460;
  guint8 * code.3461;
  guint8 * code.3462;
  guint8 * code.3463;
  guint8 * code.3464;
  unsigned char D.38775;
  guint8 * code.3465;
  unsigned char D.38777;
  guint8 * code.3466;
  unsigned char D.38779;
  guint8 * code.3467;
  unsigned char D.38781;
  guint8 * code.3468;
  guint8 * code.3469;
  guint8 * code.3470;
  guint8 * code.3471;
  unsigned char D.38791;
  guint8 * code.3472;
  unsigned char D.38793;
  guint8 * code.3473;
  unsigned char D.38795;
  guint8 * code.3474;
  unsigned char D.38797;
  guint8 * code.3475;
  guint8 * code.3476;
  guint8 * code.3477;
  guint8 * code.3478;
  guint8 * code.3479;
  guint8 * code.3480;
  guint8 * code.3481;
  guint8 * code.3482;
  unsigned char D.38815;
  guint8 * code.3483;
  unsigned char D.38817;
  guint8 * code.3484;
  unsigned char D.38819;
  guint8 * code.3485;
  unsigned char D.38821;
  guint8 * code.3486;
  guint8 * code.3487;
  guint8 * code.3488;
  guint8 * code.3489;
  unsigned char D.38831;
  guint8 * code.3490;
  unsigned char D.38833;
  guint8 * code.3491;
  unsigned char D.38835;
  guint8 * code.3492;
  unsigned char D.38837;
  guint8 * code.3493;
  unsigned char D.38839;
  guint8 * code.3494;
  unsigned char D.38841;
  unsigned char D.38842;
  guint8 * code.3495;
  guint8 * code.3496;
  guint8 * code.3497;
  guint8 * code.3498;
  guint8 * code.3499;
  guint8 * code.3500;
  guint8 * code.3501;
  guint8 * code.3502;
  unsigned char D.38859;
  guint8 * code.3503;
  unsigned char D.38861;
  guint8 * code.3504;
  unsigned char D.38863;
  guint8 * code.3505;
  unsigned char D.38865;
  guint8 * code.3506;
  guint8 * code.3507;
  guint8 * code.3508;
  guint8 * code.3509;
  unsigned char D.38875;
  guint8 * code.3510;
  unsigned char D.38877;
  guint8 * code.3511;
  unsigned char D.38879;
  guint8 * code.3512;
  unsigned char D.38881;
  guint8 * code.3513;
  guint8 * code.3514;
  unsigned char D.38886;
  guint8 * code.3515;
  unsigned char D.38888;
  guint8 * code.3516;
  unsigned char D.38890;
  guint8 * code.3517;
  unsigned char D.38892;
  guint8 * code.3518;
  guint8 * code.3519;
  guint8 * code.3520;
  guint8 * code.3521;
  guint8 * code.3522;
  unsigned char D.38901;
  guint8 * code.3523;
  unsigned char D.38903;
  guint8 * code.3524;
  unsigned char D.38905;
  guint8 * code.3525;
  unsigned char D.38907;
  guint8 * code.3526;
  guint8 * code.3527;
  guint8 * code.3528;
  guint8 * code.3529;
  guint8 * code.3530;
  guint8 * code.3531;
  guint8 * code.3532;
  guint8 * code.3533;
  guint8 * code.3534;
  guint8 * code.3535;
  unsigned char D.38928;
  guint8 * code.3536;
  unsigned char D.38930;
  guint8 * code.3537;
  unsigned char D.38932;
  guint8 * code.3538;
  unsigned char D.38934;
  guint8 * code.3539;
  guint8 * code.3540;
  guint8 * code.3541;
  guint8 * code.3542;
  unsigned char D.38944;
  guint8 * code.3543;
  unsigned char D.38946;
  guint8 * code.3544;
  unsigned char D.38948;
  guint8 * code.3545;
  unsigned char D.38950;
  guint8 * code.3546;
  guint8 * code.3547;
  guint8 * code.3548;
  guint8 * code.3549;
  guint8 * code.3550;
  guint8 * code.3551;
  guint8 * code.3552;
  guint8 * code.3553;
  unsigned char D.38968;
  guint8 * code.3554;
  unsigned char D.38970;
  guint8 * code.3555;
  unsigned char D.38972;
  guint8 * code.3556;
  unsigned char D.38974;
  guint8 * code.3557;
  guint8 * code.3558;
  guint8 * code.3559;
  guint8 * code.3560;
  unsigned char D.38984;
  guint8 * code.3561;
  unsigned char D.38986;
  guint8 * code.3562;
  unsigned char D.38988;
  guint8 * code.3563;
  unsigned char D.38990;
  guint8 * code.3564;
  guint8 * code.3565;
  guint8 * code.3566;
  guint8 * code.3567;
  guint8 * code.3568;
  guint8 * code.3569;
  guint8 * code.3570;
  guint8 * code.3571;
  unsigned char D.39007;
  guint8 * code.3572;
  unsigned char D.39009;
  guint8 * code.3573;
  unsigned char D.39011;
  guint8 * code.3574;
  unsigned char D.39013;
  guint8 * code.3575;
  guint8 * code.3576;
  guint8 * code.3577;
  guint8 * code.3578;
  unsigned char D.39023;
  guint8 * code.3579;
  unsigned char D.39025;
  guint8 * code.3580;
  unsigned char D.39027;
  guint8 * code.3581;
  unsigned char D.39029;
  guint8 * code.3582;
  guint8 * code.3583;
  guint8 * code.3584;
  guint8 * code.3585;
  guint8 * code.3586;
  guint8 * code.3587;
  guint8 * code.3588;
  guint8 * code.3589;
  unsigned char D.39046;
  guint8 * code.3590;
  unsigned char D.39048;
  guint8 * code.3591;
  unsigned char D.39050;
  guint8 * code.3592;
  unsigned char D.39052;
  guint8 * code.3593;
  guint8 * code.3594;
  guint8 * code.3595;
  guint8 * code.3596;
  unsigned char D.39062;
  guint8 * code.3597;
  unsigned char D.39064;
  guint8 * code.3598;
  unsigned char D.39066;
  guint8 * code.3599;
  unsigned char D.39068;
  guint8 * code.3600;
  guint8 * code.3601;
  unsigned char D.39073;
  guint8 * code.3602;
  unsigned char D.39075;
  guint8 * code.3603;
  unsigned char D.39077;
  guint8 * code.3604;
  unsigned char D.39079;
  guint8 * code.3605;
  guint8 * code.3606;
  guint8 * code.3607;
  guint8 * code.3608;
  guint8 * code.3609;
  unsigned char D.39088;
  guint8 * code.3610;
  unsigned char D.39090;
  guint8 * code.3611;
  unsigned char D.39092;
  guint8 * code.3612;
  unsigned char D.39094;
  guint8 * code.3613;
  guint8 * code.3614;
  guint8 * code.3615;
  guint8 * code.3616;
  guint8 * code.3617;
  guint8 * code.3618;
  guint8 * code.3619;
  guint8 * code.3620;
  guint8 * code.3621;
  guint8 * code.3622;
  unsigned char D.39115;
  guint8 * code.3623;
  unsigned char D.39117;
  guint8 * code.3624;
  unsigned char D.39119;
  guint8 * code.3625;
  unsigned char D.39121;
  guint8 * code.3626;
  guint8 * code.3627;
  guint8 * code.3628;
  guint8 * code.3629;
  unsigned char D.39131;
  guint8 * code.3630;
  unsigned char D.39133;
  guint8 * code.3631;
  unsigned char D.39135;
  guint8 * code.3632;
  unsigned char D.39137;
  guint8 * code.3633;
  guint8 * code.3634;
  guint8 * code.3635;
  guint8 * code.3636;
  guint8 * code.3637;
  guint8 * code.3638;
  guint8 * code.3639;
  guint8 * code.3640;
  unsigned char D.39155;
  guint8 * code.3641;
  unsigned char D.39157;
  guint8 * code.3642;
  unsigned char D.39159;
  guint8 * code.3643;
  unsigned char D.39161;
  guint8 * code.3644;
  guint8 * code.3645;
  guint8 * code.3646;
  guint8 * code.3647;
  unsigned char D.39171;
  guint8 * code.3648;
  unsigned char D.39173;
  guint8 * code.3649;
  unsigned char D.39175;
  guint8 * code.3650;
  unsigned char D.39177;
  guint8 * code.3651;
  guint8 * code.3652;
  guint8 * code.3653;
  guint8 * code.3654;
  guint8 * code.3655;
  guint8 * code.3656;
  guint8 * code.3657;
  guint8 * code.3658;
  unsigned char D.39194;
  guint8 * code.3659;
  unsigned char D.39196;
  guint8 * code.3660;
  unsigned char D.39198;
  guint8 * code.3661;
  unsigned char D.39200;
  guint8 * code.3662;
  guint8 * code.3663;
  guint8 * code.3664;
  guint8 * code.3665;
  unsigned char D.39210;
  guint8 * code.3666;
  unsigned char D.39212;
  guint8 * code.3667;
  unsigned char D.39214;
  guint8 * code.3668;
  unsigned char D.39216;
  guint8 * code.3669;
  guint8 * code.3670;
  guint8 * code.3671;
  guint8 * code.3672;
  guint8 * code.3673;
  guint8 * code.3674;
  guint8 * code.3675;
  guint8 * code.3676;
  unsigned char D.39233;
  guint8 * code.3677;
  unsigned char D.39235;
  guint8 * code.3678;
  unsigned char D.39237;
  guint8 * code.3679;
  unsigned char D.39239;
  guint8 * code.3680;
  guint8 * code.3681;
  guint8 * code.3682;
  guint8 * code.3683;
  unsigned char D.39249;
  guint8 * code.3684;
  unsigned char D.39251;
  guint8 * code.3685;
  unsigned char D.39253;
  guint8 * code.3686;
  unsigned char D.39255;
  guint8 * code.3687;
  guint8 * code.3688;
  unsigned char D.39260;
  guint8 * code.3689;
  unsigned char D.39262;
  guint8 * code.3690;
  unsigned char D.39264;
  guint8 * code.3691;
  unsigned char D.39266;
  guint8 * code.3692;
  guint8 * code.3693;
  guint8 * code.3694;
  guint8 * code.3695;
  guint8 * code.3696;
  unsigned char D.39275;
  guint8 * code.3697;
  unsigned char D.39277;
  guint8 * code.3698;
  unsigned char D.39279;
  guint8 * code.3699;
  unsigned char D.39281;
  guint8 * code.3700;
  guint8 * code.3701;
  guint8 * code.3702;
  guint8 * code.3703;
  guint8 * code.3704;
  guint8 * code.3705;
  guint8 * code.3706;
  guint8 * code.3707;
  guint8 * code.3708;
  guint8 * code.3709;
  unsigned char D.39302;
  guint8 * code.3710;
  unsigned char D.39304;
  guint8 * code.3711;
  unsigned char D.39306;
  guint8 * code.3712;
  unsigned char D.39308;
  guint8 * code.3713;
  guint8 * code.3714;
  guint8 * code.3715;
  guint8 * code.3716;
  unsigned char D.39318;
  guint8 * code.3717;
  unsigned char D.39320;
  guint8 * code.3718;
  unsigned char D.39322;
  guint8 * code.3719;
  unsigned char D.39324;
  guint8 * code.3720;
  guint8 * code.3721;
  guint8 * code.3722;
  guint8 * code.3723;
  guint8 * code.3724;
  guint8 * code.3725;
  guint8 * code.3726;
  guint8 * code.3727;
  unsigned char D.39342;
  guint8 * code.3728;
  unsigned char D.39344;
  guint8 * code.3729;
  unsigned char D.39346;
  guint8 * code.3730;
  unsigned char D.39348;
  guint8 * code.3731;
  guint8 * code.3732;
  guint8 * code.3733;
  guint8 * code.3734;
  unsigned char D.39358;
  guint8 * code.3735;
  unsigned char D.39360;
  guint8 * code.3736;
  unsigned char D.39362;
  guint8 * code.3737;
  unsigned char D.39364;
  guint8 * code.3738;
  guint8 * code.3739;
  signed char D.39367;
  unsigned char D.39368;
  guint8 * code.3740;
  unsigned char D.39372;
  guint8 * code.3741;
  unsigned char D.39375;
  unsigned char D.39378;
  unsigned int D.39379;
  unsigned int D.39380;
  unsigned char D.39381;
  unsigned int D.39382;
  unsigned int D.39383;
  unsigned int D.39384;
  unsigned char D.39385;
  unsigned int D.39386;
  unsigned int D.39387;
  unsigned int D.39388;
  unsigned char D.39389;
  unsigned int D.39390;
  unsigned int D.39391;
  unsigned int _imm.3742;
  unsigned int D.39393;
  guint8 * code.3743;
  unsigned char D.39397;
  guint8 * code.3744;
  guint8 * code.3745;
  unsigned char D.39401;
  guint8 * code.3746;
  unsigned char D.39403;
  guint8 * code.3747;
  unsigned char D.39405;
  guint8 * code.3748;
  unsigned char D.39407;
  unsigned char D.39408;
  unsigned int D.39409;
  unsigned int D.39410;
  unsigned char D.39411;
  unsigned int D.39412;
  unsigned int D.39413;
  unsigned int D.39414;
  unsigned char D.39415;
  unsigned int D.39416;
  unsigned int D.39417;
  unsigned int D.39418;
  unsigned char D.39419;
  unsigned int D.39420;
  unsigned int D.39421;
  unsigned int _imm.3749;
  unsigned int D.39423;
  guint8 * code.3750;
  unsigned char D.39427;
  guint8 * code.3751;
  guint8 * code.3752;
  unsigned char D.39431;
  guint8 * code.3753;
  unsigned char D.39433;
  guint8 * code.3754;
  unsigned char D.39435;
  guint8 * code.3755;
  unsigned char D.39437;
  unsigned char D.39438;
  unsigned int D.39439;
  unsigned int D.39440;
  unsigned char D.39441;
  unsigned int D.39442;
  unsigned int D.39443;
  unsigned int D.39444;
  unsigned int _imm.3756;
  unsigned int D.39446;
  guint8 * code.3757;
  unsigned char D.39450;
  guint8 * code.3758;
  guint8 * code.3759;
  unsigned char D.39454;
  guint8 * code.3760;
  unsigned char D.39456;
  guint8 * code.3761;
  unsigned char D.39458;
  guint8 * code.3762;
  unsigned char D.39460;
  guint8 * code.3763;
  guint8 * code.3764;
  guint8 * code.3765;
  guint8 * code.3766;
  guint8 * code.3767;
  guint8 * code.3768;
  guint8 * code.3769;
  guint8 * code.3770;
  unsigned char D.39477;
  guint8 * code.3771;
  unsigned char D.39479;
  guint8 * code.3772;
  unsigned char D.39481;
  guint8 * code.3773;
  unsigned char D.39483;
  guint8 * code.3774;
  guint8 * code.3775;
  guint8 * code.3776;
  guint8 * code.3777;
  unsigned char D.39493;
  guint8 * code.3778;
  unsigned char D.39495;
  guint8 * code.3779;
  unsigned char D.39497;
  guint8 * code.3780;
  unsigned char D.39499;
  guint8 * code.3781;
  guint8 * code.3782;
  unsigned char D.39504;
  guint8 * code.3783;
  unsigned char D.39506;
  guint8 * code.3784;
  unsigned char D.39508;
  guint8 * code.3785;
  unsigned char D.39510;
  guint8 * code.3786;
  guint8 * code.3787;
  guint8 * code.3788;
  guint8 * code.3789;
  guint8 * code.3790;
  unsigned char D.39519;
  guint8 * code.3791;
  unsigned char D.39521;
  guint8 * code.3792;
  unsigned char D.39523;
  guint8 * code.3793;
  unsigned char D.39525;
  guint8 * code.3794;
  guint8 * code.3795;
  int mn.3796;
  guint8 * code.3797;
  unsigned char D.39531;
  guint8 * code.3798;
  unsigned char D.39533;
  guint8 * code.3799;
  unsigned char D.39535;
  guint8 * code.3800;
  unsigned char D.39537;
  guint8 * code.3801;
  guint8 * code.3802;
  unsigned char D.39540;
  unsigned char D.39541;
  unsigned char D.39542;
  unsigned char D.39543;
  int D.39544;
  unsigned char D.39545;
  unsigned char D.39546;
  int pos.3803;
  int D.39552;
  unsigned char * pos.3804;
  unsigned char D.39554;
  unsigned char * pos.3805;
  unsigned char D.39556;
  unsigned char * pos.3806;
  unsigned char D.39558;
  unsigned char * pos.3807;
  unsigned char D.39560;
  unsigned int disp.3808;
  unsigned int D.39563;
  unsigned char D.39566;
  unsigned char D.39567;
  guint8 * code.3809;
  guint8 * code.3810;
  guint8 * code.3811;
  guint8 * code.3812;
  guint8 * code.3813;
  guint8 * code.3814;
  guint8 * code.3815;
  guint8 * code.3816;
  unsigned char D.39585;
  guint8 * code.3817;
  unsigned char D.39587;
  guint8 * code.3818;
  unsigned char D.39589;
  guint8 * code.3819;
  unsigned char D.39591;
  guint8 * code.3820;
  guint8 * code.3821;
  guint8 * code.3822;
  guint8 * code.3823;
  unsigned char D.39601;
  guint8 * code.3824;
  unsigned char D.39603;
  guint8 * code.3825;
  unsigned char D.39605;
  guint8 * code.3826;
  unsigned char D.39607;
  guint8 * code.3827;
  guint8 * code.3828;
  guint8 * code.3829;
  guint8 * code.3830;
  guint8 * code.3831;
  guint8 * code.3832;
  guint8 * code.3833;
  guint8 * code.3834;
  unsigned char D.39624;
  guint8 * code.3835;
  unsigned char D.39626;
  guint8 * code.3836;
  unsigned char D.39628;
  guint8 * code.3837;
  unsigned char D.39630;
  guint8 * code.3838;
  guint8 * code.3839;
  guint8 * code.3840;
  guint8 * code.3841;
  unsigned char D.39640;
  guint8 * code.3842;
  unsigned char D.39642;
  guint8 * code.3843;
  unsigned char D.39644;
  guint8 * code.3844;
  unsigned char D.39646;
  guint8 * code.3845;
  guint8 * code.3846;
  unsigned char D.39651;
  guint8 * code.3847;
  unsigned char D.39653;
  guint8 * code.3848;
  unsigned char D.39655;
  guint8 * code.3849;
  unsigned char D.39657;
  guint8 * code.3850;
  guint8 * code.3851;
  guint8 * code.3852;
  guint8 * code.3853;
  guint8 * code.3854;
  unsigned char D.39666;
  guint8 * code.3855;
  unsigned char D.39668;
  guint8 * code.3856;
  unsigned char D.39670;
  guint8 * code.3857;
  unsigned char D.39672;
  guint8 * code.3858;
  guint8 * code.3859;
  guint8 * code.3860;
  unsigned char D.39678;
  guint8 * code.3861;
  unsigned char D.39681;
  guint8 * code.3862;
  guint8 * code.3863;
  guint8 * code.3864;
  guint8 * code.3865;
  struct MonoBasicBlock * * D.39691;
  struct MonoBasicBlock * D.39692;
  int D.39696;
  int D.39697;
  unsigned int D.39698;
  unsigned int D.39699;
  guint8 * code.3866;
  guint8 * code.3867;
  guint8 * code.3868;
  unsigned char D.39704;
  guint8 * code.3869;
  unsigned char D.39706;
  guint8 * code.3870;
  unsigned char D.39708;
  guint8 * code.3871;
  unsigned char D.39710;
  guint8 * code.3872;
  guint8 * code.3873;
  unsigned char D.39714;
  guint8 * code.3874;
  unsigned char D.39716;
  guint8 * code.3875;
  unsigned char D.39718;
  guint8 * code.3876;
  unsigned char D.39720;
  guint8 * D.39721;
  unsigned char D.39722;
  int D.39723;
  unsigned char D.39724;
  unsigned char D.39725;
  int pos.3877;
  int D.39731;
  unsigned char * pos.3878;
  unsigned char D.39733;
  unsigned char * pos.3879;
  unsigned char D.39735;
  unsigned char * pos.3880;
  unsigned char D.39737;
  unsigned char * pos.3881;
  unsigned char D.39739;
  unsigned int disp.3882;
  unsigned int D.39742;
  unsigned char D.39745;
  unsigned char D.39746;
  guint8 * code.3883;
  guint8 * code.3884;
  unsigned char D.39752;
  guint8 * code.3885;
  unsigned char D.39754;
  guint8 * code.3886;
  unsigned char D.39756;
  guint8 * code.3887;
  unsigned char D.39758;
  guint8 * code.3888;
  guint8 * code.3889;
  guint8 * code.3890;
  guint8 * code.3891;
  guint8 * code.3892;
  unsigned char D.39767;
  guint8 * code.3893;
  unsigned char D.39769;
  guint8 * code.3894;
  unsigned char D.39771;
  guint8 * code.3895;
  unsigned char D.39773;
  guint8 * D.39774;
  unsigned char D.39775;
  int D.39776;
  unsigned char D.39777;
  unsigned char D.39778;
  int pos.3896;
  int D.39784;
  unsigned char * pos.3897;
  unsigned char D.39786;
  unsigned char * pos.3898;
  unsigned char D.39788;
  unsigned char * pos.3899;
  unsigned char D.39790;
  unsigned char * pos.3900;
  unsigned char D.39792;
  unsigned int disp.3901;
  unsigned int D.39795;
  unsigned char D.39798;
  unsigned char D.39799;
  guint8 * code.3902;
  unsigned char D.39804;
  guint8 * code.3903;
  unsigned char D.39807;
  guint8 * D.39808;
  unsigned char D.39809;
  int D.39810;
  unsigned char D.39811;
  unsigned char D.39812;
  guint8 * D.39815;
  int D.39816;
  int pos.3904;
  int D.39820;
  unsigned char * pos.3905;
  unsigned char D.39822;
  unsigned char * pos.3906;
  unsigned char D.39824;
  unsigned char * pos.3907;
  unsigned char D.39826;
  unsigned char * pos.3908;
  unsigned char D.39828;
  unsigned int disp.3909;
  unsigned int D.39831;
  unsigned char D.39834;
  unsigned char D.39835;
  guint8 * code.3910;
  guint8 * code.3911;
  guint8 * code.3912;
  guint8 * code.3913;
  guint8 * code.3914;
  guint8 * code.3915;
  unsigned char D.39845;
  unsigned char D.39846;
  unsigned char D.39847;
  guint8 * code.3916;
  guint8 * code.3917;
  unsigned char D.39850;
  unsigned char D.39851;
  unsigned char D.39852;
  guint8 * code.3918;
  guint8 * code.3919;
  unsigned char D.39855;
  unsigned char D.39856;
  unsigned char D.39857;
  guint8 * code.3920;
  guint8 * code.3921;
  unsigned char D.39860;
  unsigned char D.39861;
  unsigned char D.39862;
  guint8 * code.3922;
  guint8 * code.3923;
  guint8 * code.3924;
  guint8 * code.3925;
  guint8 * code.3926;
  guint8 * code.3927;
  guint8 * code.3928;
  guint8 * code.3929;
  unsigned char D.39871;
  unsigned char D.39872;
  unsigned char D.39873;
  guint8 * code.3930;
  guint8 * code.3931;
  guint8 * code.3932;
  guint8 * code.3933;
  guint8 * code.3934;
  guint8 * code.3935;
  unsigned char D.39880;
  unsigned char D.39881;
  unsigned char D.39882;
  guint8 * code.3936;
  guint8 * code.3937;
  guint8 * code.3938;
  guint8 * code.3939;
  guint8 * code.3940;
  guint8 * code.3941;
  guint8 * code.3942;
  guint8 * code.3943;
  guint8 * code.3944;
  guint8 * code.3945;
  guint8 * code.3946;
  unsigned char D.39897;
  guint8 * code.3947;
  unsigned char D.39899;
  guint8 * code.3948;
  unsigned char D.39901;
  guint8 * code.3949;
  unsigned char D.39903;
  guint8 * code.3950;
  guint8 * code.3951;
  guint8 * code.3952;
  guint8 * code.3953;
  guint8 * code.3954;
  guint8 * code.3955;
  guint8 * code.3956;
  guint8 * code.3957;
  guint8 * code.3958;
  guint8 * code.3959;
  guint8 * code.3960;
  guint8 * code.3961;
  guint8 * code.3962;
  guint8 * code.3963;
  guint8 * code.3964;
  guint8 * code.3965;
  guint8 * code.3966;
  guint8 * code.3967;
  guint8 * code.3968;
  guint8 * code.3969;
  unsigned char D.39930;
  guint8 * code.3970;
  unsigned char D.39932;
  guint8 * code.3971;
  unsigned char D.39934;
  guint8 * code.3972;
  unsigned char D.39936;
  guint8 * code.3973;
  guint8 * code.3974;
  guint8 * code.3975;
  guint8 * code.3976;
  guint8 * code.3977;
  guint8 * code.3978;
  unsigned char D.39946;
  int D.39947;
  unsigned char D.39948;
  unsigned char D.39949;
  int pos.3979;
  int D.39955;
  unsigned char * pos.3980;
  unsigned char D.39957;
  unsigned char * pos.3981;
  unsigned char D.39959;
  unsigned char * pos.3982;
  unsigned char D.39961;
  unsigned char * pos.3983;
  unsigned char D.39963;
  unsigned int disp.3984;
  unsigned int D.39966;
  unsigned char D.39969;
  unsigned char D.39970;
  guint8 * code.3985;
  guint8 * code.3986;
  unsigned char D.39974;
  int D.39975;
  unsigned char D.39976;
  unsigned char D.39977;
  int pos.3987;
  int D.39983;
  unsigned char * pos.3988;
  unsigned char D.39985;
  unsigned char * pos.3989;
  unsigned char D.39987;
  unsigned char * pos.3990;
  unsigned char D.39989;
  unsigned char * pos.3991;
  unsigned char D.39991;
  unsigned int disp.3992;
  unsigned int D.39994;
  unsigned char D.39997;
  unsigned char D.39998;
  unsigned char D.40000;
  int D.40001;
  unsigned char D.40002;
  unsigned char D.40003;
  int pos.3993;
  int D.40009;
  unsigned char * pos.3994;
  unsigned char D.40011;
  unsigned char * pos.3995;
  unsigned char D.40013;
  unsigned char * pos.3996;
  unsigned char D.40015;
  unsigned char * pos.3997;
  unsigned char D.40017;
  unsigned int disp.3998;
  unsigned int D.40020;
  unsigned char D.40023;
  unsigned char D.40024;
  guint8 * code.3999;
  guint8 * code.4000;
  guint8 * code.4001;
  guint8 * code.4002;
  unsigned char D.40030;
  unsigned char D.40031;
  unsigned char D.40032;
  guint8 * code.4003;
  guint8 * code.4004;
  guint8 * code.4005;
  guint8 * code.4006;
  guint8 * code.4007;
  guint8 * code.4008;
  guint8 * code.4009;
  guint8 * code.4010;
  guint8 * code.4011;
  unsigned char D.40042;
  unsigned char D.40043;
  unsigned char D.40044;
  guint8 * code.4012;
  guint8 * code.4013;
  guint8 * code.4014;
  guint8 * code.4015;
  unsigned int D.40049;
  _Bool D.40050;
  long int D.40051;
  long int D.40052;
  guint8 * code.4016;
  guint8 * code.4017;
  guint8 * code.4018;
  guint8 * code.4019;
  unsigned char D.40063;
  unsigned char D.40064;
  guint8 * code.4020;
  unsigned char D.40067;
  unsigned char D.40068;
  guint8 * code.4021;
  guint8 * code.4022;
  guint8 * code.4023;
  guint8 * code.4024;
  guint8 * code.4025;
  guint8 * code.4026;
  guint8 * code.4027;
  guint8 * code.4028;
  guint8 * code.4029;
  guint8 * code.4030;
  guint8 * code.4031;
  unsigned char D.40093;
  guint8 * code.4032;
  unsigned char D.40096;
  guint8 * code.4033;
  guint8 * code.4034;
  guint8 * code.4035;
  guint8 * code.4036;
  guint8 * code.4037;
  guint8 * code.4038;
  guint8 * code.4039;
  guint8 * code.4040;
  guint8 * code.4041;
  guint8 * code.4042;
  guint8 * code.4043;
  unsigned char D.40115;
  unsigned char D.40116;
  unsigned char D.40117;
  guint8 * code.4044;
  guint8 * code.4045;
  guint8 * code.4046;
  guint8 * code.4047;
  guint8 * code.4048;
  guint8 * code.4049;
  guint8 * code.4050;
  guint8 * code.4051;
  guint8 * code.4052;
  unsigned char D.40129;
  guint8 * code.4053;
  unsigned char D.40131;
  guint8 * code.4054;
  unsigned char D.40133;
  guint8 * code.4055;
  unsigned char D.40135;
  guint8 * code.4056;
  guint8 * code.4057;
  guint8 * code.4058;
  guint8 * code.4059;
  guint8 * code.4060;
  unsigned char D.40144;
  guint8 * code.4061;
  unsigned char D.40146;
  guint8 * code.4062;
  unsigned char D.40148;
  guint8 * code.4063;
  unsigned char D.40150;
  guint8 * code.4064;
  guint8 * code.4065;
  unsigned char D.40156;
  int D.40157;
  unsigned char D.40158;
  unsigned char D.40159;
  int l1.4066;
  int pos.4067;
  int D.40166;
  unsigned char * pos.4068;
  unsigned char D.40168;
  unsigned char * pos.4069;
  unsigned char D.40170;
  unsigned char * pos.4070;
  unsigned char D.40172;
  unsigned char * pos.4071;
  unsigned char D.40174;
  unsigned int disp.4072;
  unsigned int D.40177;
  unsigned char D.40180;
  unsigned char D.40181;
  guint8 * code.4073;
  guint8 * code.4074;
  guint8 * code.4075;
  unsigned int D.40186;
  guint8 * code.4076;
  guint8 * code.4077;
  guint8 * code.4078;
  guint8 * code.4079;
  guint8 * code.4080;
  guint8 * code.4081;
  guint8 * code.4082;
  guint8 * code.4083;
  guint8 * code.4084;
  guint8 * code.4085;
  unsigned char D.40201;
  guint8 * code.4086;
  unsigned char D.40203;
  guint8 * code.4087;
  unsigned char D.40205;
  guint8 * code.4088;
  unsigned char D.40207;
  guint8 * code.4089;
  guint8 * code.4090;
  guint8 * code.4091;
  guint8 * code.4092;
  guint8 * code.4093;
  unsigned char D.40216;
  guint8 * code.4094;
  unsigned char D.40218;
  guint8 * code.4095;
  unsigned char D.40220;
  guint8 * code.4096;
  unsigned char D.40222;
  guint8 * code.4097;
  guint8 * code.4098;
  guint8 * code.4099;
  guint8 * code.4100;
  guint8 * code.4101;
  guint8 * code.4102;
  guint8 * code.4103;
  unsigned char D.40234;
  guint8 * code.4104;
  unsigned char D.40237;
  guint8 * code.4105;
  guint8 * code.4106;
  unsigned char D.40246;
  guint8 * code.4107;
  unsigned char D.40249;
  guint8 * code.4108;
  unsigned char D.40251;
  int D.40252;
  unsigned char D.40253;
  unsigned char D.40254;
  int pos.4109;
  int D.40260;
  unsigned char * pos.4110;
  unsigned char D.40262;
  unsigned char * pos.4111;
  unsigned char D.40264;
  unsigned char * pos.4112;
  unsigned char D.40266;
  unsigned char * pos.4113;
  unsigned char D.40268;
  unsigned int disp.4114;
  unsigned int D.40271;
  unsigned char D.40274;
  unsigned char D.40275;
  guint8 * code.4115;
  guint8 * code.4116;
  unsigned char D.40284;
  guint8 * code.4117;
  unsigned char D.40287;
  guint8 * code.4118;
  guint8 * code.4119;
  unsigned char D.40290;
  unsigned char D.40291;
  int pos.4120;
  int D.40297;
  unsigned char * pos.4121;
  unsigned char D.40299;
  unsigned char * pos.4122;
  unsigned char D.40301;
  unsigned char * pos.4123;
  unsigned char D.40303;
  unsigned char * pos.4124;
  unsigned char D.40305;
  unsigned int disp.4125;
  unsigned int D.40308;
  unsigned char D.40311;
  unsigned char D.40312;
  guint8 * code.4126;
  unsigned char D.40315;
  int D.40316;
  unsigned char D.40317;
  unsigned char D.40318;
  int pos.4127;
  int D.40324;
  unsigned char * pos.4128;
  unsigned char D.40326;
  unsigned char * pos.4129;
  unsigned char D.40328;
  unsigned char * pos.4130;
  unsigned char D.40330;
  unsigned char * pos.4131;
  unsigned char D.40332;
  unsigned int disp.4132;
  unsigned int D.40335;
  unsigned char D.40338;
  unsigned char D.40339;
  guint8 * code.4133;
  guint8 * code.4134;
  guint8 * code.4135;
  guint8 * code.4136;
  guint8 * code.4137;
  guint8 * code.4138;
  guint8 * code.4139;
  unsigned char D.40352;
  guint8 * code.4140;
  unsigned char D.40354;
  guint8 * code.4141;
  unsigned char D.40356;
  guint8 * code.4142;
  unsigned char D.40358;
  guint8 * code.4143;
  guint8 * code.4144;
  guint8 * code.4145;
  guint8 * code.4146;
  guint8 * code.4147;
  unsigned char D.40367;
  guint8 * code.4148;
  unsigned char D.40369;
  guint8 * code.4149;
  unsigned char D.40371;
  guint8 * code.4150;
  unsigned char D.40373;
  guint8 * code.4151;
  guint8 * code.4152;
  unsigned char D.40378;
  guint8 * code.4153;
  unsigned char D.40380;
  guint8 * code.4154;
  unsigned char D.40382;
  guint8 * code.4155;
  unsigned char D.40384;
  guint8 * code.4156;
  guint8 * code.4157;
  guint8 * code.4158;
  guint8 * code.4159;
  guint8 * code.4160;
  unsigned char D.40393;
  guint8 * code.4161;
  unsigned char D.40395;
  guint8 * code.4162;
  unsigned char D.40397;
  guint8 * code.4163;
  unsigned char D.40399;
  guint8 * code.4164;
  guint8 * code.4165;
  _Bool D.40406;
  int D.40407;
  unsigned char D.40408;
  unsigned char D.40409;
  guint8 * code.4166;
  unsigned char D.40412;
  unsigned char D.40413;
  guint8 * code.4167;
  guint8 * code.4168;
  guint8 * code.4169;
  guint8 * code.4170;
  guint8 * code.4171;
  guint8 * code.4172;
  guint8 * code.4173;
  guint8 * code.4174;
  guint8 * code.4175;
  guint8 * code.4176;
  guint8 * code.4177;
  guint8 * code.4178;
  guint8 * code.4179;
  guint8 * code.4180;
  guint8 * code.4181;
  unsigned char D.40448;
  guint8 * code.4182;
  unsigned char D.40451;
  guint8 * code.4183;
  guint8 * code.4184;
  unsigned char D.40454;
  int D.40455;
  unsigned char D.40456;
  unsigned char D.40457;
  int pos.4185;
  int D.40463;
  unsigned char * pos.4186;
  unsigned char D.40465;
  unsigned char * pos.4187;
  unsigned char D.40467;
  unsigned char * pos.4188;
  unsigned char D.40469;
  unsigned char * pos.4189;
  unsigned char D.40471;
  unsigned int disp.4190;
  unsigned int D.40474;
  unsigned char D.40477;
  unsigned char D.40478;
  guint8 * code.4191;
  unsigned char D.40481;
  int D.40482;
  unsigned char D.40483;
  unsigned char D.40484;
  int pos.4192;
  int D.40490;
  unsigned char * pos.4193;
  unsigned char D.40492;
  unsigned char * pos.4194;
  unsigned char D.40494;
  unsigned char * pos.4195;
  unsigned char D.40496;
  unsigned char * pos.4196;
  unsigned char D.40498;
  unsigned int disp.4197;
  unsigned int D.40501;
  unsigned char D.40504;
  unsigned char D.40505;
  guint8 * code.4198;
  guint8 * code.4199;
  guint8 * code.4200;
  guint8 * code.4201;
  guint8 * code.4202;
  guint8 * code.4203;
  guint8 * code.4204;
  guint8 * code.4205;
  guint8 * code.4206;
  guint8 * code.4207;
  guint8 * code.4208;
  unsigned char D.40528;
  guint8 * code.4209;
  unsigned char D.40530;
  guint8 * code.4210;
  unsigned char D.40532;
  guint8 * code.4211;
  unsigned char D.40534;
  guint8 * code.4212;
  guint8 * code.4213;
  guint8 * code.4214;
  guint8 * code.4215;
  guint8 * code.4216;
  unsigned char D.40543;
  guint8 * code.4217;
  unsigned char D.40545;
  guint8 * code.4218;
  unsigned char D.40547;
  guint8 * code.4219;
  unsigned char D.40549;
  guint8 * code.4220;
  guint8 * code.4221;
  guint8 * code.4222;
  unsigned char D.40558;
  int D.40559;
  unsigned char D.40560;
  unsigned char D.40561;
  int pos.4223;
  int D.40567;
  unsigned char * pos.4224;
  unsigned char D.40569;
  unsigned char * pos.4225;
  unsigned char D.40571;
  unsigned char * pos.4226;
  unsigned char D.40573;
  unsigned char * pos.4227;
  unsigned char D.40575;
  unsigned int disp.4228;
  unsigned int D.40578;
  unsigned char D.40581;
  unsigned char D.40582;
  guint8 * code.4229;
  guint8 * code.4230;
  unsigned char D.40588;
  guint8 * code.4231;
  unsigned char D.40590;
  guint8 * code.4232;
  unsigned char D.40592;
  guint8 * code.4233;
  unsigned char D.40594;
  guint8 * code.4234;
  guint8 * code.4235;
  guint8 * code.4236;
  guint8 * code.4237;
  guint8 * code.4238;
  unsigned char D.40603;
  guint8 * code.4239;
  unsigned char D.40605;
  guint8 * code.4240;
  unsigned char D.40607;
  guint8 * code.4241;
  unsigned char D.40609;
  unsigned char D.40610;
  int D.40611;
  unsigned char D.40612;
  unsigned char D.40613;
  int pos.4242;
  int D.40619;
  unsigned char * pos.4243;
  unsigned char D.40621;
  unsigned char * pos.4244;
  unsigned char D.40623;
  unsigned char * pos.4245;
  unsigned char D.40625;
  unsigned char * pos.4246;
  unsigned char D.40627;
  unsigned int disp.4247;
  unsigned int D.40630;
  unsigned char D.40633;
  unsigned char D.40634;
  guint8 * code.4248;
  guint8 * code.4249;
  guint8 * code.4250;
  guint8 * code.4251;
  guint8 * code.4252;
  guint8 * code.4253;
  guint8 * code.4254;
  guint8 * code.4255;
  guint8 * code.4256;
  guint8 * code.4257;
  guint8 * code.4258;
  guint8 * code.4259;
  guint8 * code.4260;
  guint8 * code.4261;
  guint8 * code.4262;
  guint8 * code.4263;
  guint8 * code.4264;
  guint8 * code.4265;
  unsigned char D.40676;
  unsigned char D.40677;
  guint8 * code.4266;
  unsigned char D.40680;
  unsigned char D.40681;
  guint8 * code.4267;
  unsigned char D.40683;
  int D.40684;
  unsigned char D.40685;
  unsigned char D.40686;
  int pos.4268;
  int D.40692;
  unsigned char * pos.4269;
  unsigned char D.40694;
  unsigned char * pos.4270;
  unsigned char D.40696;
  unsigned char * pos.4271;
  unsigned char D.40698;
  unsigned char * pos.4272;
  unsigned char D.40700;
  unsigned int disp.4273;
  unsigned int D.40703;
  unsigned char D.40706;
  unsigned char D.40707;
  guint8 * code.4274;
  guint8 * code.4275;
  guint8 * code.4276;
  guint8 * code.4277;
  guint8 * code.4278;
  guint8 * code.4279;
  guint8 * code.4280;
  unsigned char D.40720;
  guint8 * code.4281;
  unsigned char D.40722;
  guint8 * code.4282;
  unsigned char D.40724;
  guint8 * code.4283;
  unsigned char D.40726;
  guint8 * code.4284;
  guint8 * code.4285;
  guint8 * code.4286;
  guint8 * code.4287;
  guint8 * code.4288;
  unsigned char D.40735;
  guint8 * code.4289;
  unsigned char D.40737;
  guint8 * code.4290;
  unsigned char D.40739;
  guint8 * code.4291;
  unsigned char D.40741;
  guint8 * code.4292;
  guint8 * code.4293;
  unsigned char D.40746;
  guint8 * code.4294;
  unsigned char D.40748;
  guint8 * code.4295;
  unsigned char D.40750;
  guint8 * code.4296;
  unsigned char D.40752;
  guint8 * code.4297;
  guint8 * code.4298;
  guint8 * code.4299;
  guint8 * code.4300;
  guint8 * code.4301;
  unsigned char D.40761;
  guint8 * code.4302;
  unsigned char D.40763;
  guint8 * code.4303;
  unsigned char D.40765;
  guint8 * code.4304;
  unsigned char D.40767;
  guint8 * code.4305;
  guint8 * code.4306;
  guint8 * code.4307;
  guint8 * code.4308;
  unsigned char D.40777;
  guint8 * code.4309;
  unsigned char D.40779;
  guint8 * code.4310;
  unsigned char D.40781;
  guint8 * code.4311;
  unsigned char D.40783;
  guint8 * code.4312;
  guint8 * code.4313;
  guint8 * code.4314;
  guint8 * code.4315;
  guint8 * code.4316;
  unsigned char D.40792;
  guint8 * code.4317;
  unsigned char D.40794;
  guint8 * code.4318;
  unsigned char D.40796;
  guint8 * code.4319;
  unsigned char D.40798;
  guint8 * code.4320;
  guint8 * code.4321;
  guint8 * code.4322;
  guint8 * code.4323;
  guint8 * code.4324;
  guint8 * code.4325;
  guint8 * code.4326;
  guint8 * code.4327;
  unsigned char D.40818;
  unsigned char D.40819;
  int pos.4328;
  int D.40825;
  unsigned char * pos.4329;
  unsigned char D.40827;
  unsigned char * pos.4330;
  unsigned char D.40829;
  unsigned char * pos.4331;
  unsigned char D.40831;
  unsigned char * pos.4332;
  unsigned char D.40833;
  unsigned int disp.4333;
  unsigned int D.40836;
  unsigned char D.40839;
  unsigned char D.40840;
  guint8 * code.4334;
  guint8 * code.4335;
  unsigned char D.40844;
  int D.40845;
  unsigned char D.40846;
  unsigned char D.40847;
  int pos.4336;
  int D.40853;
  unsigned char * pos.4337;
  unsigned char D.40855;
  unsigned char * pos.4338;
  unsigned char D.40857;
  unsigned char * pos.4339;
  unsigned char D.40859;
  unsigned char * pos.4340;
  unsigned char D.40861;
  unsigned int disp.4341;
  unsigned int D.40864;
  unsigned char D.40867;
  unsigned char D.40868;
  guint8 * code.4342;
  guint8 * code.4343;
  guint8 * code.4344;
  guint8 * code.4345;
  guint8 * code.4346;
  guint8 * code.4347;
  guint8 * code.4348;
  guint8 * code.4349;
  guint8 * code.4350;
  guint8 * code.4351;
  guint8 * code.4352;
  unsigned char D.40894;
  guint8 * code.4353;
  unsigned char D.40897;
  guint8 * code.4354;
  unsigned char D.40899;
  int D.40900;
  unsigned char D.40901;
  unsigned char D.40902;
  int pos.4355;
  int D.40908;
  unsigned char * pos.4356;
  unsigned char D.40910;
  unsigned char * pos.4357;
  unsigned char D.40912;
  unsigned char * pos.4358;
  unsigned char D.40914;
  unsigned char * pos.4359;
  unsigned char D.40916;
  unsigned int disp.4360;
  unsigned int D.40919;
  unsigned char D.40922;
  unsigned char D.40923;
  guint8 * code.4361;
  guint8 * code.4362;
  guint8 * code.4363;
  guint8 * code.4364;
  guint8 * code.4365;
  guint8 * code.4366;
  guint8 * code.4367;
  guint8 * code.4368;
  guint8 * code.4369;
  guint8 * code.4370;
  guint8 * code.4371;
  unsigned char D.40946;
  guint8 * code.4372;
  unsigned char D.40948;
  guint8 * code.4373;
  unsigned char D.40950;
  guint8 * code.4374;
  unsigned char D.40952;
  guint8 * code.4375;
  guint8 * code.4376;
  guint8 * code.4377;
  guint8 * code.4378;
  guint8 * code.4379;
  unsigned char D.40961;
  guint8 * code.4380;
  unsigned char D.40963;
  guint8 * code.4381;
  unsigned char D.40965;
  guint8 * code.4382;
  unsigned char D.40967;
  guint8 * code.4383;
  guint8 * code.4384;
  unsigned char D.40972;
  guint8 * code.4385;
  unsigned char D.40974;
  guint8 * code.4386;
  unsigned char D.40976;
  guint8 * code.4387;
  unsigned char D.40978;
  guint8 * code.4388;
  guint8 * code.4389;
  guint8 * code.4390;
  guint8 * code.4391;
  guint8 * code.4392;
  unsigned char D.40987;
  guint8 * code.4393;
  unsigned char D.40989;
  guint8 * code.4394;
  unsigned char D.40991;
  guint8 * code.4395;
  unsigned char D.40993;
  guint8 * code.4396;
  guint8 * code.4397;
  guint8 * code.4398;
  unsigned char D.41002;
  int D.41003;
  unsigned char D.41004;
  unsigned char D.41005;
  int pos.4399;
  int D.41011;
  unsigned char * pos.4400;
  unsigned char D.41013;
  unsigned char * pos.4401;
  unsigned char D.41015;
  unsigned char * pos.4402;
  unsigned char D.41017;
  unsigned char * pos.4403;
  unsigned char D.41019;
  unsigned int disp.4404;
  unsigned int D.41022;
  unsigned char D.41025;
  unsigned char D.41026;
  guint8 * code.4405;
  guint8 * code.4406;
  unsigned char D.41032;
  guint8 * code.4407;
  unsigned char D.41034;
  guint8 * code.4408;
  unsigned char D.41036;
  guint8 * code.4409;
  unsigned char D.41038;
  guint8 * code.4410;
  guint8 * code.4411;
  guint8 * code.4412;
  guint8 * code.4413;
  guint8 * code.4414;
  unsigned char D.41047;
  guint8 * code.4415;
  unsigned char D.41049;
  guint8 * code.4416;
  unsigned char D.41051;
  guint8 * code.4417;
  unsigned char D.41053;
  unsigned char D.41054;
  int D.41055;
  unsigned char D.41056;
  unsigned char D.41057;
  int pos.4418;
  int D.41063;
  unsigned char * pos.4419;
  unsigned char D.41065;
  unsigned char * pos.4420;
  unsigned char D.41067;
  unsigned char * pos.4421;
  unsigned char D.41069;
  unsigned char * pos.4422;
  unsigned char D.41071;
  unsigned int disp.4423;
  unsigned int D.41074;
  unsigned char D.41077;
  unsigned char D.41078;
  guint8 * code.4424;
  guint8 * code.4425;
  guint8 * code.4426;
  guint8 * code.4427;
  guint8 * code.4428;
  guint8 * code.4429;
  guint8 * code.4430;
  guint8 * code.4431;
  guint8 * code.4432;
  guint8 * code.4433;
  guint8 * code.4434;
  guint8 * code.4435;
  guint8 * code.4436;
  guint8 * code.4437;
  guint8 * code.4438;
  guint8 * code.4439;
  guint8 * code.4440;
  guint8 * code.4441;
  unsigned char D.41120;
  unsigned char D.41121;
  guint8 * code.4442;
  unsigned char D.41124;
  unsigned char D.41125;
  guint8 * code.4443;
  unsigned char D.41127;
  int D.41128;
  unsigned char D.41129;
  unsigned char D.41130;
  int pos.4444;
  int D.41136;
  unsigned char * pos.4445;
  unsigned char D.41138;
  unsigned char * pos.4446;
  unsigned char D.41140;
  unsigned char * pos.4447;
  unsigned char D.41142;
  unsigned char * pos.4448;
  unsigned char D.41144;
  unsigned int disp.4449;
  unsigned int D.41147;
  unsigned char D.41150;
  unsigned char D.41151;
  guint8 * code.4450;
  guint8 * code.4451;
  guint8 * code.4452;
  guint8 * code.4453;
  guint8 * code.4454;
  guint8 * code.4455;
  guint8 * code.4456;
  unsigned char D.41164;
  guint8 * code.4457;
  unsigned char D.41166;
  guint8 * code.4458;
  unsigned char D.41168;
  guint8 * code.4459;
  unsigned char D.41170;
  guint8 * code.4460;
  guint8 * code.4461;
  guint8 * code.4462;
  guint8 * code.4463;
  guint8 * code.4464;
  unsigned char D.41179;
  guint8 * code.4465;
  unsigned char D.41181;
  guint8 * code.4466;
  unsigned char D.41183;
  guint8 * code.4467;
  unsigned char D.41185;
  guint8 * code.4468;
  guint8 * code.4469;
  unsigned char D.41190;
  guint8 * code.4470;
  unsigned char D.41192;
  guint8 * code.4471;
  unsigned char D.41194;
  guint8 * code.4472;
  unsigned char D.41196;
  guint8 * code.4473;
  guint8 * code.4474;
  guint8 * code.4475;
  guint8 * code.4476;
  guint8 * code.4477;
  unsigned char D.41205;
  guint8 * code.4478;
  unsigned char D.41207;
  guint8 * code.4479;
  unsigned char D.41209;
  guint8 * code.4480;
  unsigned char D.41211;
  guint8 * code.4481;
  guint8 * code.4482;
  guint8 * code.4483;
  guint8 * code.4484;
  unsigned char D.41221;
  guint8 * code.4485;
  unsigned char D.41223;
  guint8 * code.4486;
  unsigned char D.41225;
  guint8 * code.4487;
  unsigned char D.41227;
  guint8 * code.4488;
  guint8 * code.4489;
  guint8 * code.4490;
  guint8 * code.4491;
  guint8 * code.4492;
  unsigned char D.41236;
  guint8 * code.4493;
  unsigned char D.41238;
  guint8 * code.4494;
  unsigned char D.41240;
  guint8 * code.4495;
  unsigned char D.41242;
  guint8 * code.4496;
  guint8 * code.4497;
  guint8 * code.4498;
  guint8 * code.4499;
  guint8 * code.4500;
  guint8 * code.4501;
  guint8 * code.4502;
  guint8 * code.4503;
  unsigned char D.41262;
  unsigned char D.41263;
  int pos.4504;
  int D.41269;
  unsigned char * pos.4505;
  unsigned char D.41271;
  unsigned char * pos.4506;
  unsigned char D.41273;
  unsigned char * pos.4507;
  unsigned char D.41275;
  unsigned char * pos.4508;
  unsigned char D.41277;
  unsigned int disp.4509;
  unsigned int D.41280;
  unsigned char D.41283;
  unsigned char D.41284;
  guint8 * code.4510;
  guint8 * code.4511;
  unsigned char D.41288;
  int D.41289;
  unsigned char D.41290;
  unsigned char D.41291;
  int pos.4512;
  int D.41297;
  unsigned char * pos.4513;
  unsigned char D.41299;
  unsigned char * pos.4514;
  unsigned char D.41301;
  unsigned char * pos.4515;
  unsigned char D.41303;
  unsigned char * pos.4516;
  unsigned char D.41305;
  unsigned int disp.4517;
  unsigned int D.41308;
  unsigned char D.41311;
  unsigned char D.41312;
  guint8 * code.4518;
  guint8 * code.4519;
  guint8 * code.4520;
  unsigned int offset.4521;
  unsigned int D.41327;
  guint8 * code.4522;
  guint8 * code.4523;
  unsigned char D.41335;
  guint8 * code.4524;
  guint8 * code.4525;
  unsigned char D.41341;
  guint8 * code.4526;
  unsigned char D.41344;
  guint8 * code.4527;
  unsigned char D.41346;
  guint8 * code.4528;
  unsigned char D.41348;
  guint8 * code.4529;
  unsigned char D.41350;
  guint8 * code.4530;
  unsigned char D.41352;
  unsigned char D.41353;
  int D.41354;
  unsigned char D.41355;
  unsigned char D.41356;
  int pos.4531;
  int D.41362;
  unsigned char * pos.4532;
  unsigned char D.41364;
  unsigned char * pos.4533;
  unsigned char D.41366;
  unsigned char * pos.4534;
  unsigned char D.41368;
  unsigned char * pos.4535;
  unsigned char D.41370;
  unsigned int disp.4536;
  unsigned int D.41373;
  unsigned char D.41376;
  unsigned char D.41377;
  guint8 * code.4537;
  guint8 * code.4538;
  guint8 * code.4539;
  guint8 * code.4540;
  guint8 * code.4541;
  guint8 * code.4542;
  unsigned char D.41396;
  guint8 * code.4543;
  unsigned char D.41398;
  guint8 * code.4544;
  unsigned char D.41400;
  guint8 * code.4545;
  unsigned char D.41402;
  unsigned char D.41403;
  int D.41404;
  unsigned char D.41405;
  unsigned char D.41406;
  int pos.4546;
  int D.41412;
  unsigned char * pos.4547;
  unsigned char D.41414;
  unsigned char * pos.4548;
  unsigned char D.41416;
  unsigned char * pos.4549;
  unsigned char D.41418;
  unsigned char * pos.4550;
  unsigned char D.41420;
  unsigned int disp.4551;
  unsigned int D.41423;
  unsigned char D.41426;
  unsigned char D.41427;
  guint8 * code.4552;
  guint8 * code.4553;
  unsigned char D.41433;
  guint8 * code.4554;
  unsigned char D.41435;
  guint8 * code.4555;
  unsigned char D.41437;
  guint8 * code.4556;
  unsigned char D.41439;
  guint8 * code.4557;
  guint8 * code.4558;
  guint8 * code.4559;
  guint8 * code.4560;
  guint8 * code.4561;
  unsigned char D.41448;
  guint8 * code.4562;
  unsigned char D.41450;
  guint8 * code.4563;
  unsigned char D.41452;
  guint8 * code.4564;
  unsigned char D.41454;
  unsigned int offset.4565;
  unsigned int D.41458;
  guint8 * code.4566;
  guint8 * code.4567;
  unsigned char D.41466;
  guint8 * code.4568;
  guint8 * code.4569;
  guint8 * code.4570;
  guint8 * code.4571;
  unsigned char D.41475;
  guint8 * code.4572;
  unsigned char D.41477;
  guint8 * code.4573;
  unsigned char D.41479;
  guint8 * code.4574;
  unsigned char D.41481;
  unsigned char D.41482;
  int D.41483;
  unsigned char D.41484;
  unsigned char D.41485;
  int pos.4575;
  int D.41491;
  unsigned char * pos.4576;
  unsigned char D.41493;
  unsigned char * pos.4577;
  unsigned char D.41495;
  unsigned char * pos.4578;
  unsigned char D.41497;
  unsigned char * pos.4579;
  unsigned char D.41499;
  unsigned int disp.4580;
  unsigned int D.41502;
  unsigned char D.41505;
  unsigned char D.41506;
  guint8 * code.4581;
  guint8 * code.4582;
  guint8 * code.4583;
  guint8 * code.4584;
  guint8 * code.4585;
  guint8 * code.4586;
  unsigned char D.41525;
  guint8 * code.4587;
  unsigned char D.41527;
  guint8 * code.4588;
  unsigned char D.41529;
  guint8 * code.4589;
  unsigned char D.41531;
  unsigned int offset.4590;
  unsigned int D.41537;
  guint8 * code.4591;
  guint8 * code.4592;
  unsigned char D.41545;
  guint8 * code.4593;
  guint8 * code.4594;
  unsigned char D.41551;
  guint8 * code.4595;
  unsigned char D.41554;
  guint8 * code.4596;
  unsigned char D.41556;
  guint8 * code.4597;
  unsigned char D.41558;
  guint8 * code.4598;
  unsigned char D.41560;
  guint8 * code.4599;
  unsigned char D.41562;
  unsigned char D.41563;
  int D.41564;
  unsigned char D.41565;
  unsigned char D.41566;
  int pos.4600;
  int D.41572;
  unsigned char * pos.4601;
  unsigned char D.41574;
  unsigned char * pos.4602;
  unsigned char D.41576;
  unsigned char * pos.4603;
  unsigned char D.41578;
  unsigned char * pos.4604;
  unsigned char D.41580;
  unsigned int disp.4605;
  unsigned int D.41583;
  unsigned char D.41586;
  unsigned char D.41587;
  guint8 * code.4606;
  guint8 * code.4607;
  guint8 * code.4608;
  guint8 * code.4609;
  guint8 * code.4610;
  guint8 * code.4611;
  unsigned char D.41606;
  guint8 * code.4612;
  unsigned char D.41608;
  guint8 * code.4613;
  unsigned char D.41610;
  guint8 * code.4614;
  unsigned char D.41612;
  unsigned int offset.4615;
  unsigned int D.41616;
  guint8 * code.4616;
  guint8 * code.4617;
  unsigned char D.41624;
  guint8 * code.4618;
  guint8 * code.4619;
  unsigned char D.41630;
  guint8 * code.4620;
  unsigned char D.41633;
  guint8 * code.4621;
  unsigned char D.41635;
  guint8 * code.4622;
  unsigned char D.41637;
  guint8 * code.4623;
  unsigned char D.41639;
  guint8 * code.4624;
  unsigned char D.41641;
  unsigned char D.41642;
  int D.41643;
  unsigned char D.41644;
  unsigned char D.41645;
  int pos.4625;
  int D.41651;
  unsigned char * pos.4626;
  unsigned char D.41653;
  unsigned char * pos.4627;
  unsigned char D.41655;
  unsigned char * pos.4628;
  unsigned char D.41657;
  unsigned char * pos.4629;
  unsigned char D.41659;
  unsigned int disp.4630;
  unsigned int D.41662;
  unsigned char D.41665;
  unsigned char D.41666;
  guint8 * code.4631;
  guint8 * code.4632;
  guint8 * code.4633;
  guint8 * code.4634;
  guint8 * code.4635;
  guint8 * code.4636;
  unsigned char D.41685;
  guint8 * code.4637;
  unsigned char D.41687;
  guint8 * code.4638;
  unsigned char D.41689;
  guint8 * code.4639;
  unsigned char D.41691;
  unsigned int offset.4640;
  unsigned int D.41695;
  guint8 * code.4641;
  guint8 * code.4642;
  unsigned char D.41703;
  guint8 * code.4643;
  guint8 * code.4644;
  unsigned char D.41709;
  guint8 * code.4645;
  unsigned char D.41712;
  guint8 * code.4646;
  unsigned char D.41714;
  guint8 * code.4647;
  unsigned char D.41716;
  guint8 * code.4648;
  unsigned char D.41718;
  guint8 * code.4649;
  unsigned char D.41720;
  unsigned char D.41721;
  int D.41722;
  unsigned char D.41723;
  unsigned char D.41724;
  int pos.4650;
  int D.41730;
  unsigned char * pos.4651;
  unsigned char D.41732;
  unsigned char * pos.4652;
  unsigned char D.41734;
  unsigned char * pos.4653;
  unsigned char D.41736;
  unsigned char * pos.4654;
  unsigned char D.41738;
  unsigned int disp.4655;
  unsigned int D.41741;
  unsigned char D.41744;
  unsigned char D.41745;
  guint8 * code.4656;
  guint8 * code.4657;
  guint8 * code.4658;
  guint8 * code.4659;
  guint8 * code.4660;
  guint8 * code.4661;
  unsigned char D.41764;
  guint8 * code.4662;
  unsigned char D.41766;
  guint8 * code.4663;
  unsigned char D.41768;
  guint8 * code.4664;
  unsigned char D.41770;
  guint8 * code.4665;
  guint8 * code.4666;
  unsigned char D.41775;
  guint8 * code.4667;
  unsigned char D.41777;
  guint8 * code.4668;
  unsigned char D.41779;
  guint8 * code.4669;
  unsigned char D.41781;
  guint8 * code.4670;
  guint8 * code.4671;
  guint8 * code.4672;
  guint8 * code.4673;
  guint8 * code.4674;
  unsigned char D.41790;
  guint8 * code.4675;
  unsigned char D.41792;
  guint8 * code.4676;
  unsigned char D.41794;
  guint8 * code.4677;
  unsigned char D.41796;
  unsigned int offset.4678;
  unsigned int D.41800;
  guint8 * code.4679;
  guint8 * code.4680;
  unsigned char D.41808;
  guint8 * code.4681;
  guint8 * code.4682;
  guint8 * code.4683;
  guint8 * code.4684;
  unsigned char D.41817;
  guint8 * code.4685;
  unsigned char D.41819;
  guint8 * code.4686;
  unsigned char D.41821;
  guint8 * code.4687;
  unsigned char D.41823;
  unsigned char D.41824;
  int D.41825;
  unsigned char D.41826;
  unsigned char D.41827;
  int pos.4688;
  int D.41833;
  unsigned char * pos.4689;
  unsigned char D.41835;
  unsigned char * pos.4690;
  unsigned char D.41837;
  unsigned char * pos.4691;
  unsigned char D.41839;
  unsigned char * pos.4692;
  unsigned char D.41841;
  unsigned int disp.4693;
  unsigned int D.41844;
  unsigned char D.41847;
  unsigned char D.41848;
  guint8 * code.4694;
  guint8 * code.4695;
  guint8 * code.4696;
  guint8 * code.4697;
  guint8 * code.4698;
  guint8 * code.4699;
  unsigned char D.41867;
  guint8 * code.4700;
  unsigned char D.41869;
  guint8 * code.4701;
  unsigned char D.41871;
  guint8 * code.4702;
  unsigned char D.41873;
  unsigned int offset.4703;
  unsigned int D.41879;
  guint8 * code.4704;
  guint8 * code.4705;
  unsigned char D.41887;
  guint8 * code.4706;
  guint8 * code.4707;
  unsigned char D.41893;
  guint8 * code.4708;
  unsigned char D.41896;
  guint8 * code.4709;
  unsigned char D.41898;
  guint8 * code.4710;
  unsigned char D.41900;
  guint8 * code.4711;
  unsigned char D.41902;
  guint8 * code.4712;
  unsigned char D.41904;
  unsigned char D.41905;
  int D.41906;
  unsigned char D.41907;
  unsigned char D.41908;
  int pos.4713;
  int D.41914;
  unsigned char * pos.4714;
  unsigned char D.41916;
  unsigned char * pos.4715;
  unsigned char D.41918;
  unsigned char * pos.4716;
  unsigned char D.41920;
  unsigned char * pos.4717;
  unsigned char D.41922;
  unsigned int disp.4718;
  unsigned int D.41925;
  unsigned char D.41928;
  unsigned char D.41929;
  guint8 * code.4719;
  guint8 * code.4720;
  guint8 * code.4721;
  guint8 * code.4722;
  guint8 * code.4723;
  guint8 * code.4724;
  unsigned char D.41948;
  guint8 * code.4725;
  unsigned char D.41950;
  guint8 * code.4726;
  unsigned char D.41952;
  guint8 * code.4727;
  unsigned char D.41954;
  unsigned int offset.4728;
  unsigned int D.41958;
  guint8 * code.4729;
  guint8 * code.4730;
  unsigned char D.41966;
  guint8 * code.4731;
  guint8 * code.4732;
  guint8 * code.4733;
  guint8 * code.4734;
  unsigned char D.41975;
  guint8 * code.4735;
  unsigned char D.41977;
  guint8 * code.4736;
  unsigned char D.41979;
  guint8 * code.4737;
  unsigned char D.41981;
  unsigned char D.41982;
  int D.41983;
  unsigned char D.41984;
  unsigned char D.41985;
  int pos.4738;
  int D.41991;
  unsigned char * pos.4739;
  unsigned char D.41993;
  unsigned char * pos.4740;
  unsigned char D.41995;
  unsigned char * pos.4741;
  unsigned char D.41997;
  unsigned char * pos.4742;
  unsigned char D.41999;
  unsigned int disp.4743;
  unsigned int D.42002;
  unsigned char D.42005;
  unsigned char D.42006;
  guint8 * code.4744;
  guint8 * code.4745;
  guint8 * code.4746;
  guint8 * code.4747;
  guint8 * code.4748;
  guint8 * code.4749;
  unsigned char D.42025;
  guint8 * code.4750;
  unsigned char D.42027;
  guint8 * code.4751;
  unsigned char D.42029;
  guint8 * code.4752;
  unsigned char D.42031;
  unsigned int offset.4753;
  unsigned int D.42037;
  guint8 * code.4754;
  guint8 * code.4755;
  unsigned char D.42045;
  guint8 * code.4756;
  guint8 * code.4757;
  guint8 * code.4758;
  guint8 * code.4759;
  unsigned char D.42054;
  guint8 * code.4760;
  unsigned char D.42056;
  guint8 * code.4761;
  unsigned char D.42058;
  guint8 * code.4762;
  unsigned char D.42060;
  unsigned char D.42061;
  int D.42062;
  unsigned char D.42063;
  unsigned char D.42064;
  int pos.4763;
  int D.42070;
  unsigned char * pos.4764;
  unsigned char D.42072;
  unsigned char * pos.4765;
  unsigned char D.42074;
  unsigned char * pos.4766;
  unsigned char D.42076;
  unsigned char * pos.4767;
  unsigned char D.42078;
  unsigned int disp.4768;
  unsigned int D.42081;
  unsigned char D.42084;
  unsigned char D.42085;
  guint8 * code.4769;
  guint8 * code.4770;
  guint8 * code.4771;
  guint8 * code.4772;
  guint8 * code.4773;
  guint8 * code.4774;
  unsigned char D.42104;
  guint8 * code.4775;
  unsigned char D.42106;
  guint8 * code.4776;
  unsigned char D.42108;
  guint8 * code.4777;
  unsigned char D.42110;
  unsigned int offset.4778;
  unsigned int D.42114;
  guint8 * code.4779;
  guint8 * code.4780;
  unsigned char D.42122;
  guint8 * code.4781;
  guint8 * code.4782;
  guint8 * code.4783;
  guint8 * code.4784;
  unsigned char D.42131;
  guint8 * code.4785;
  unsigned char D.42133;
  guint8 * code.4786;
  unsigned char D.42135;
  guint8 * code.4787;
  unsigned char D.42137;
  unsigned char D.42138;
  int D.42139;
  unsigned char D.42140;
  unsigned char D.42141;
  int pos.4788;
  int D.42147;
  unsigned char * pos.4789;
  unsigned char D.42149;
  unsigned char * pos.4790;
  unsigned char D.42151;
  unsigned char * pos.4791;
  unsigned char D.42153;
  unsigned char * pos.4792;
  unsigned char D.42155;
  unsigned int disp.4793;
  unsigned int D.42158;
  unsigned char D.42161;
  unsigned char D.42162;
  guint8 * code.4794;
  guint8 * code.4795;
  guint8 * code.4796;
  guint8 * code.4797;
  guint8 * code.4798;
  guint8 * code.4799;
  unsigned char D.42181;
  guint8 * code.4800;
  unsigned char D.42183;
  guint8 * code.4801;
  unsigned char D.42185;
  guint8 * code.4802;
  unsigned char D.42187;
  guint8 * code.4803;
  guint8 * code.4804;
  guint8 * code.4805;
  unsigned char D.42196;
  int D.42197;
  unsigned char D.42198;
  unsigned char D.42199;
  int pos.4806;
  int D.42205;
  unsigned char * pos.4807;
  unsigned char D.42207;
  unsigned char * pos.4808;
  unsigned char D.42209;
  unsigned char * pos.4809;
  unsigned char D.42211;
  unsigned char * pos.4810;
  unsigned char D.42213;
  unsigned int disp.4811;
  unsigned int D.42216;
  unsigned char D.42219;
  unsigned char D.42220;
  guint8 * code.4812;
  guint8 * code.4813;
  unsigned char D.42226;
  guint8 * code.4814;
  unsigned char D.42228;
  guint8 * code.4815;
  unsigned char D.42230;
  guint8 * code.4816;
  unsigned char D.42232;
  guint8 * code.4817;
  guint8 * code.4818;
  guint8 * code.4819;
  guint8 * code.4820;
  guint8 * code.4821;
  unsigned char D.42241;
  guint8 * code.4822;
  unsigned char D.42243;
  guint8 * code.4823;
  unsigned char D.42245;
  guint8 * code.4824;
  unsigned char D.42247;
  unsigned char D.42248;
  int D.42249;
  unsigned char D.42250;
  unsigned char D.42251;
  int pos.4825;
  int D.42257;
  unsigned char * pos.4826;
  unsigned char D.42259;
  unsigned char * pos.4827;
  unsigned char D.42261;
  unsigned char * pos.4828;
  unsigned char D.42263;
  unsigned char * pos.4829;
  unsigned char D.42265;
  unsigned int disp.4830;
  unsigned int D.42268;
  unsigned char D.42271;
  unsigned char D.42272;
  unsigned int offset.4831;
  unsigned int D.42277;
  guint8 * code.4832;
  guint8 * code.4833;
  unsigned char D.42285;
  guint8 * code.4834;
  guint8 * code.4835;
  guint8 * code.4836;
  guint8 * code.4837;
  unsigned char D.42294;
  guint8 * code.4838;
  unsigned char D.42296;
  guint8 * code.4839;
  unsigned char D.42298;
  guint8 * code.4840;
  unsigned char D.42300;
  unsigned char D.42301;
  int D.42302;
  unsigned char D.42303;
  unsigned char D.42304;
  int pos.4841;
  int D.42310;
  unsigned char * pos.4842;
  unsigned char D.42312;
  unsigned char * pos.4843;
  unsigned char D.42314;
  unsigned char * pos.4844;
  unsigned char D.42316;
  unsigned char * pos.4845;
  unsigned char D.42318;
  unsigned int disp.4846;
  unsigned int D.42321;
  unsigned char D.42324;
  unsigned char D.42325;
  guint8 * code.4847;
  guint8 * code.4848;
  guint8 * code.4849;
  guint8 * code.4850;
  guint8 * code.4851;
  guint8 * code.4852;
  unsigned char D.42344;
  guint8 * code.4853;
  unsigned char D.42346;
  guint8 * code.4854;
  unsigned char D.42348;
  guint8 * code.4855;
  unsigned char D.42350;
  guint8 * code.4856;
  guint8 * code.4857;
  unsigned int offset.4858;
  unsigned int D.42363;
  guint8 * code.4859;
  guint8 * code.4860;
  unsigned char D.42371;
  guint8 * code.4861;
  guint8 * code.4862;
  guint8 * code.4863;
  guint8 * code.4864;
  unsigned char D.42380;
  guint8 * code.4865;
  unsigned char D.42382;
  guint8 * code.4866;
  unsigned char D.42384;
  guint8 * code.4867;
  unsigned char D.42386;
  unsigned char D.42387;
  int D.42388;
  unsigned char D.42389;
  unsigned char D.42390;
  int pos.4868;
  int D.42396;
  unsigned char * pos.4869;
  unsigned char D.42398;
  unsigned char * pos.4870;
  unsigned char D.42400;
  unsigned char * pos.4871;
  unsigned char D.42402;
  unsigned char * pos.4872;
  unsigned char D.42404;
  unsigned int disp.4873;
  unsigned int D.42407;
  unsigned char D.42410;
  unsigned char D.42411;
  guint8 * code.4874;
  guint8 * code.4875;
  guint8 * code.4876;
  guint8 * code.4877;
  guint8 * code.4878;
  guint8 * code.4879;
  unsigned char D.42430;
  guint8 * code.4880;
  unsigned char D.42432;
  guint8 * code.4881;
  unsigned char D.42434;
  guint8 * code.4882;
  unsigned char D.42436;
  unsigned char D.42437;
  int D.42438;
  unsigned char D.42439;
  unsigned char D.42440;
  int pos.4883;
  int D.42446;
  unsigned char * pos.4884;
  unsigned char D.42448;
  unsigned char * pos.4885;
  unsigned char D.42450;
  unsigned char * pos.4886;
  unsigned char D.42452;
  unsigned char * pos.4887;
  unsigned char D.42454;
  unsigned int disp.4888;
  unsigned int D.42457;
  unsigned char D.42460;
  unsigned char D.42461;
  unsigned int offset.4889;
  unsigned int D.42467;
  guint8 * code.4890;
  guint8 * code.4891;
  unsigned char D.42475;
  guint8 * code.4892;
  guint8 * code.4893;
  guint8 * code.4894;
  guint8 * code.4895;
  unsigned char D.42484;
  guint8 * code.4896;
  unsigned char D.42486;
  guint8 * code.4897;
  unsigned char D.42488;
  guint8 * code.4898;
  unsigned char D.42490;
  unsigned char D.42491;
  int D.42492;
  unsigned char D.42493;
  unsigned char D.42494;
  int pos.4899;
  int D.42500;
  unsigned char * pos.4900;
  unsigned char D.42502;
  unsigned char * pos.4901;
  unsigned char D.42504;
  unsigned char * pos.4902;
  unsigned char D.42506;
  unsigned char * pos.4903;
  unsigned char D.42508;
  unsigned int disp.4904;
  unsigned int D.42511;
  unsigned char D.42514;
  unsigned char D.42515;
  guint8 * code.4905;
  guint8 * code.4906;
  guint8 * code.4907;
  guint8 * code.4908;
  guint8 * code.4909;
  guint8 * code.4910;
  unsigned char D.42534;
  guint8 * code.4911;
  unsigned char D.42536;
  guint8 * code.4912;
  unsigned char D.42538;
  guint8 * code.4913;
  unsigned char D.42540;
  guint8 * code.4914;
  guint8 * code.4915;
  unsigned char D.42545;
  guint8 * code.4916;
  unsigned char D.42547;
  guint8 * code.4917;
  unsigned char D.42549;
  guint8 * code.4918;
  unsigned char D.42551;
  guint8 * code.4919;
  guint8 * code.4920;
  guint8 * code.4921;
  guint8 * code.4922;
  guint8 * code.4923;
  unsigned char D.42560;
  guint8 * code.4924;
  unsigned char D.42562;
  guint8 * code.4925;
  unsigned char D.42564;
  guint8 * code.4926;
  unsigned char D.42566;
  guint8 * code.4927;
  guint8 * code.4928;
  guint8 * code.4929;
  unsigned char D.42575;
  int D.42576;
  unsigned char D.42577;
  unsigned char D.42578;
  int pos.4930;
  int D.42584;
  unsigned char * pos.4931;
  unsigned char D.42586;
  unsigned char * pos.4932;
  unsigned char D.42588;
  unsigned char * pos.4933;
  unsigned char D.42590;
  unsigned char * pos.4934;
  unsigned char D.42592;
  unsigned int disp.4935;
  unsigned int D.42595;
  unsigned char D.42598;
  unsigned char D.42599;
  guint8 * code.4936;
  guint8 * code.4937;
  unsigned char D.42605;
  guint8 * code.4938;
  unsigned char D.42607;
  guint8 * code.4939;
  unsigned char D.42609;
  guint8 * code.4940;
  unsigned char D.42611;
  guint8 * code.4941;
  guint8 * code.4942;
  guint8 * code.4943;
  guint8 * code.4944;
  guint8 * code.4945;
  unsigned char D.42620;
  guint8 * code.4946;
  unsigned char D.42622;
  guint8 * code.4947;
  unsigned char D.42624;
  guint8 * code.4948;
  unsigned char D.42626;
  unsigned char D.42627;
  int D.42628;
  unsigned char D.42629;
  unsigned char D.42630;
  int pos.4949;
  int D.42636;
  unsigned char * pos.4950;
  unsigned char D.42638;
  unsigned char * pos.4951;
  unsigned char D.42640;
  unsigned char * pos.4952;
  unsigned char D.42642;
  unsigned char * pos.4953;
  unsigned char D.42644;
  unsigned int disp.4954;
  unsigned int D.42647;
  unsigned char D.42650;
  unsigned char D.42651;
  unsigned int offset.4955;
  unsigned int D.42656;
  guint8 * code.4956;
  guint8 * code.4957;
  unsigned char D.42664;
  guint8 * code.4958;
  guint8 * code.4959;
  guint8 * code.4960;
  guint8 * code.4961;
  unsigned char D.42673;
  guint8 * code.4962;
  unsigned char D.42675;
  guint8 * code.4963;
  unsigned char D.42677;
  guint8 * code.4964;
  unsigned char D.42679;
  unsigned char D.42680;
  int D.42681;
  unsigned char D.42682;
  unsigned char D.42683;
  int pos.4965;
  int D.42689;
  unsigned char * pos.4966;
  unsigned char D.42691;
  unsigned char * pos.4967;
  unsigned char D.42693;
  unsigned char * pos.4968;
  unsigned char D.42695;
  unsigned char * pos.4969;
  unsigned char D.42697;
  unsigned int disp.4970;
  unsigned int D.42700;
  unsigned char D.42703;
  unsigned char D.42704;
  guint8 * code.4971;
  guint8 * code.4972;
  guint8 * code.4973;
  guint8 * code.4974;
  guint8 * code.4975;
  guint8 * code.4976;
  unsigned char D.42723;
  guint8 * code.4977;
  unsigned char D.42725;
  guint8 * code.4978;
  unsigned char D.42727;
  guint8 * code.4979;
  unsigned char D.42729;
  guint8 * code.4980;
  guint8 * code.4981;
  unsigned int offset.4982;
  unsigned int D.42740;
  guint8 * code.4983;
  guint8 * code.4984;
  unsigned char D.42748;
  guint8 * code.4985;
  guint8 * code.4986;
  unsigned char D.42754;
  guint8 * code.4987;
  unsigned char D.42757;
  guint8 * code.4988;
  unsigned char D.42759;
  guint8 * code.4989;
  unsigned char D.42761;
  guint8 * code.4990;
  unsigned char D.42763;
  guint8 * code.4991;
  unsigned char D.42765;
  unsigned char D.42766;
  int D.42767;
  unsigned char D.42768;
  unsigned char D.42769;
  int pos.4992;
  int D.42775;
  unsigned char * pos.4993;
  unsigned char D.42777;
  unsigned char * pos.4994;
  unsigned char D.42779;
  unsigned char * pos.4995;
  unsigned char D.42781;
  unsigned char * pos.4996;
  unsigned char D.42783;
  unsigned int disp.4997;
  unsigned int D.42786;
  unsigned char D.42789;
  unsigned char D.42790;
  guint8 * code.4998;
  guint8 * code.4999;
  guint8 * code.5000;
  guint8 * code.5001;
  guint8 * code.5002;
  guint8 * code.5003;
  unsigned char D.42809;
  guint8 * code.5004;
  unsigned char D.42811;
  guint8 * code.5005;
  unsigned char D.42813;
  guint8 * code.5006;
  unsigned char D.42815;
  unsigned char D.42816;
  int D.42817;
  unsigned char D.42818;
  unsigned char D.42819;
  int pos.5007;
  int D.42825;
  unsigned char * pos.5008;
  unsigned char D.42827;
  unsigned char * pos.5009;
  unsigned char D.42829;
  unsigned char * pos.5010;
  unsigned char D.42831;
  unsigned char * pos.5011;
  unsigned char D.42833;
  unsigned int disp.5012;
  unsigned int D.42836;
  unsigned char D.42839;
  unsigned char D.42840;
  guint8 * code.5013;
  guint8 * code.5014;
  unsigned char D.42846;
  guint8 * code.5015;
  unsigned char D.42848;
  guint8 * code.5016;
  unsigned char D.42850;
  guint8 * code.5017;
  unsigned char D.42852;
  guint8 * code.5018;
  guint8 * code.5019;
  guint8 * code.5020;
  guint8 * code.5021;
  guint8 * code.5022;
  unsigned char D.42861;
  guint8 * code.5023;
  unsigned char D.42863;
  guint8 * code.5024;
  unsigned char D.42865;
  guint8 * code.5025;
  unsigned char D.42867;
  unsigned int offset.5026;
  unsigned int D.42871;
  guint8 * code.5027;
  guint8 * code.5028;
  unsigned char D.42879;
  guint8 * code.5029;
  guint8 * code.5030;
  guint8 * code.5031;
  guint8 * code.5032;
  unsigned char D.42888;
  guint8 * code.5033;
  unsigned char D.42890;
  guint8 * code.5034;
  unsigned char D.42892;
  guint8 * code.5035;
  unsigned char D.42894;
  unsigned char D.42895;
  int D.42896;
  unsigned char D.42897;
  unsigned char D.42898;
  int pos.5036;
  int D.42904;
  unsigned char * pos.5037;
  unsigned char D.42906;
  unsigned char * pos.5038;
  unsigned char D.42908;
  unsigned char * pos.5039;
  unsigned char D.42910;
  unsigned char * pos.5040;
  unsigned char D.42912;
  unsigned int disp.5041;
  unsigned int D.42915;
  unsigned char D.42918;
  unsigned char D.42919;
  guint8 * code.5042;
  guint8 * code.5043;
  guint8 * code.5044;
  guint8 * code.5045;
  guint8 * code.5046;
  guint8 * code.5047;
  unsigned char D.42938;
  guint8 * code.5048;
  unsigned char D.42940;
  guint8 * code.5049;
  unsigned char D.42942;
  guint8 * code.5050;
  unsigned char D.42944;
  guint8 * code.5051;
  guint8 * code.5052;
  unsigned char D.42949;
  guint8 * code.5053;
  unsigned char D.42951;
  guint8 * code.5054;
  unsigned char D.42953;
  guint8 * code.5055;
  unsigned char D.42955;
  guint8 * code.5056;
  guint8 * code.5057;
  guint8 * code.5058;
  guint8 * code.5059;
  guint8 * code.5060;
  unsigned char D.42964;
  guint8 * code.5061;
  unsigned char D.42966;
  guint8 * code.5062;
  unsigned char D.42968;
  guint8 * code.5063;
  unsigned char D.42970;
  unsigned int offset.5064;
  unsigned int D.42974;
  guint8 * code.5065;
  guint8 * code.5066;
  unsigned char D.42982;
  guint8 * code.5067;
  guint8 * code.5068;
  guint8 * code.5069;
  guint8 * code.5070;
  unsigned char D.42991;
  guint8 * code.5071;
  unsigned char D.42993;
  guint8 * code.5072;
  unsigned char D.42995;
  guint8 * code.5073;
  unsigned char D.42997;
  unsigned char D.42998;
  int D.42999;
  unsigned char D.43000;
  unsigned char D.43001;
  int pos.5074;
  int D.43007;
  unsigned char * pos.5075;
  unsigned char D.43009;
  unsigned char * pos.5076;
  unsigned char D.43011;
  unsigned char * pos.5077;
  unsigned char D.43013;
  unsigned char * pos.5078;
  unsigned char D.43015;
  unsigned int disp.5079;
  unsigned int D.43018;
  unsigned char D.43021;
  unsigned char D.43022;
  guint8 * code.5080;
  guint8 * code.5081;
  guint8 * code.5082;
  guint8 * code.5083;
  guint8 * code.5084;
  guint8 * code.5085;
  unsigned char D.43041;
  guint8 * code.5086;
  unsigned char D.43043;
  guint8 * code.5087;
  unsigned char D.43045;
  guint8 * code.5088;
  unsigned char D.43047;
  unsigned int offset.5089;
  unsigned int D.43053;
  guint8 * code.5090;
  guint8 * code.5091;
  unsigned char D.43061;
  guint8 * code.5092;
  guint8 * code.5093;
  guint8 * code.5094;
  guint8 * code.5095;
  unsigned char D.43070;
  guint8 * code.5096;
  unsigned char D.43072;
  guint8 * code.5097;
  unsigned char D.43074;
  guint8 * code.5098;
  unsigned char D.43076;
  unsigned char D.43077;
  int D.43078;
  unsigned char D.43079;
  unsigned char D.43080;
  int pos.5099;
  int D.43086;
  unsigned char * pos.5100;
  unsigned char D.43088;
  unsigned char * pos.5101;
  unsigned char D.43090;
  unsigned char * pos.5102;
  unsigned char D.43092;
  unsigned char * pos.5103;
  unsigned char D.43094;
  unsigned int disp.5104;
  unsigned int D.43097;
  unsigned char D.43100;
  unsigned char D.43101;
  guint8 * code.5105;
  guint8 * code.5106;
  guint8 * code.5107;
  guint8 * code.5108;
  guint8 * code.5109;
  guint8 * code.5110;
  unsigned char D.43120;
  guint8 * code.5111;
  unsigned char D.43122;
  guint8 * code.5112;
  unsigned char D.43124;
  guint8 * code.5113;
  unsigned char D.43126;
  unsigned int offset.5114;
  unsigned int D.43130;
  guint8 * code.5115;
  guint8 * code.5116;
  unsigned char D.43138;
  guint8 * code.5117;
  guint8 * code.5118;
  guint8 * code.5119;
  guint8 * code.5120;
  unsigned char D.43147;
  guint8 * code.5121;
  unsigned char D.43149;
  guint8 * code.5122;
  unsigned char D.43151;
  guint8 * code.5123;
  unsigned char D.43153;
  unsigned char D.43154;
  int D.43155;
  unsigned char D.43156;
  unsigned char D.43157;
  int pos.5124;
  int D.43163;
  unsigned char * pos.5125;
  unsigned char D.43165;
  unsigned char * pos.5126;
  unsigned char D.43167;
  unsigned char * pos.5127;
  unsigned char D.43169;
  unsigned char * pos.5128;
  unsigned char D.43171;
  unsigned int disp.5129;
  unsigned int D.43174;
  unsigned char D.43177;
  unsigned char D.43178;
  guint8 * code.5130;
  guint8 * code.5131;
  guint8 * code.5132;
  guint8 * code.5133;
  guint8 * code.5134;
  guint8 * code.5135;
  unsigned char D.43197;
  guint8 * code.5136;
  unsigned char D.43199;
  guint8 * code.5137;
  unsigned char D.43201;
  guint8 * code.5138;
  unsigned char D.43203;
  guint8 * code.5139;
  guint8 * code.5140;
  unsigned int offset.5141;
  unsigned int D.43214;
  guint8 * code.5142;
  guint8 * code.5143;
  unsigned char D.43222;
  guint8 * code.5144;
  guint8 * code.5145;
  unsigned char D.43228;
  guint8 * code.5146;
  unsigned char D.43231;
  guint8 * code.5147;
  unsigned char D.43233;
  guint8 * code.5148;
  unsigned char D.43235;
  guint8 * code.5149;
  unsigned char D.43237;
  guint8 * code.5150;
  unsigned char D.43239;
  unsigned char D.43240;
  int D.43241;
  unsigned char D.43242;
  unsigned char D.43243;
  int pos.5151;
  int D.43249;
  unsigned char * pos.5152;
  unsigned char D.43251;
  unsigned char * pos.5153;
  unsigned char D.43253;
  unsigned char * pos.5154;
  unsigned char D.43255;
  unsigned char * pos.5155;
  unsigned char D.43257;
  unsigned int disp.5156;
  unsigned int D.43260;
  unsigned char D.43263;
  unsigned char D.43264;
  guint8 * code.5157;
  guint8 * code.5158;
  guint8 * code.5159;
  guint8 * code.5160;
  guint8 * code.5161;
  guint8 * code.5162;
  unsigned char D.43283;
  guint8 * code.5163;
  unsigned char D.43285;
  guint8 * code.5164;
  unsigned char D.43287;
  guint8 * code.5165;
  unsigned char D.43289;
  unsigned char D.43290;
  int D.43291;
  unsigned char D.43292;
  unsigned char D.43293;
  int pos.5166;
  int D.43299;
  unsigned char * pos.5167;
  unsigned char D.43301;
  unsigned char * pos.5168;
  unsigned char D.43303;
  unsigned char * pos.5169;
  unsigned char D.43305;
  unsigned char * pos.5170;
  unsigned char D.43307;
  unsigned int disp.5171;
  unsigned int D.43310;
  unsigned char D.43313;
  unsigned char D.43314;
  guint8 * code.5172;
  guint8 * code.5173;
  unsigned char D.43320;
  guint8 * code.5174;
  unsigned char D.43322;
  guint8 * code.5175;
  unsigned char D.43324;
  guint8 * code.5176;
  unsigned char D.43326;
  guint8 * code.5177;
  guint8 * code.5178;
  guint8 * code.5179;
  guint8 * code.5180;
  guint8 * code.5181;
  unsigned char D.43335;
  guint8 * code.5182;
  unsigned char D.43337;
  guint8 * code.5183;
  unsigned char D.43339;
  guint8 * code.5184;
  unsigned char D.43341;
  guint8 * code.5185;
  guint8 * code.5186;
  unsigned char D.43346;
  guint8 * code.5187;
  unsigned char D.43348;
  guint8 * code.5188;
  unsigned char D.43350;
  guint8 * code.5189;
  unsigned char D.43352;
  guint8 * code.5190;
  guint8 * code.5191;
  guint8 * code.5192;
  guint8 * code.5193;
  guint8 * code.5194;
  unsigned char D.43361;
  guint8 * code.5195;
  unsigned char D.43363;
  guint8 * code.5196;
  unsigned char D.43365;
  guint8 * code.5197;
  unsigned char D.43367;
  unsigned int offset.5198;
  unsigned int D.43371;
  guint8 * code.5199;
  guint8 * code.5200;
  unsigned char D.43379;
  guint8 * code.5201;
  guint8 * code.5202;
  guint8 * code.5203;
  guint8 * code.5204;
  unsigned char D.43388;
  guint8 * code.5205;
  unsigned char D.43390;
  guint8 * code.5206;
  unsigned char D.43392;
  guint8 * code.5207;
  unsigned char D.43394;
  unsigned char D.43395;
  int D.43396;
  unsigned char D.43397;
  unsigned char D.43398;
  int pos.5208;
  int D.43404;
  unsigned char * pos.5209;
  unsigned char D.43406;
  unsigned char * pos.5210;
  unsigned char D.43408;
  unsigned char * pos.5211;
  unsigned char D.43410;
  unsigned char * pos.5212;
  unsigned char D.43412;
  unsigned int disp.5213;
  unsigned int D.43415;
  unsigned char D.43418;
  unsigned char D.43419;
  guint8 * code.5214;
  guint8 * code.5215;
  guint8 * code.5216;
  guint8 * code.5217;
  guint8 * code.5218;
  guint8 * code.5219;
  unsigned char D.43438;
  guint8 * code.5220;
  unsigned char D.43440;
  guint8 * code.5221;
  unsigned char D.43442;
  guint8 * code.5222;
  unsigned char D.43444;
  unsigned int offset.5223;
  unsigned int D.43450;
  guint8 * code.5224;
  guint8 * code.5225;
  unsigned char D.43458;
  guint8 * code.5226;
  guint8 * code.5227;
  guint8 * code.5228;
  guint8 * code.5229;
  unsigned char D.43467;
  guint8 * code.5230;
  unsigned char D.43469;
  guint8 * code.5231;
  unsigned char D.43471;
  guint8 * code.5232;
  unsigned char D.43473;
  unsigned char D.43474;
  int D.43475;
  unsigned char D.43476;
  unsigned char D.43477;
  int pos.5233;
  int D.43483;
  unsigned char * pos.5234;
  unsigned char D.43485;
  unsigned char * pos.5235;
  unsigned char D.43487;
  unsigned char * pos.5236;
  unsigned char D.43489;
  unsigned char * pos.5237;
  unsigned char D.43491;
  unsigned int disp.5238;
  unsigned int D.43494;
  unsigned char D.43497;
  unsigned char D.43498;
  guint8 * code.5239;
  guint8 * code.5240;
  guint8 * code.5241;
  guint8 * code.5242;
  guint8 * code.5243;
  guint8 * code.5244;
  unsigned char D.43517;
  guint8 * code.5245;
  unsigned char D.43519;
  guint8 * code.5246;
  unsigned char D.43521;
  guint8 * code.5247;
  unsigned char D.43523;
  unsigned int offset.5248;
  unsigned int D.43527;
  guint8 * code.5249;
  guint8 * code.5250;
  unsigned char D.43535;
  guint8 * code.5251;
  guint8 * code.5252;
  guint8 * code.5253;
  guint8 * code.5254;
  unsigned char D.43544;
  guint8 * code.5255;
  unsigned char D.43546;
  guint8 * code.5256;
  unsigned char D.43548;
  guint8 * code.5257;
  unsigned char D.43550;
  unsigned char D.43551;
  int D.43552;
  unsigned char D.43553;
  unsigned char D.43554;
  int pos.5258;
  int D.43560;
  unsigned char * pos.5259;
  unsigned char D.43562;
  unsigned char * pos.5260;
  unsigned char D.43564;
  unsigned char * pos.5261;
  unsigned char D.43566;
  unsigned char * pos.5262;
  unsigned char D.43568;
  unsigned int disp.5263;
  unsigned int D.43571;
  unsigned char D.43574;
  unsigned char D.43575;
  guint8 * code.5264;
  guint8 * code.5265;
  guint8 * code.5266;
  guint8 * code.5267;
  guint8 * code.5268;
  guint8 * code.5269;
  unsigned char D.43594;
  guint8 * code.5270;
  unsigned char D.43596;
  guint8 * code.5271;
  unsigned char D.43598;
  guint8 * code.5272;
  unsigned char D.43600;
  guint8 * code.5273;
  guint8 * code.5274;
  unsigned char D.43605;
  guint8 * code.5275;
  unsigned char D.43607;
  guint8 * code.5276;
  unsigned char D.43609;
  guint8 * code.5277;
  unsigned char D.43611;
  guint8 * code.5278;
  guint8 * code.5279;
  guint8 * code.5280;
  guint8 * code.5281;
  guint8 * code.5282;
  unsigned char D.43620;
  guint8 * code.5283;
  unsigned char D.43622;
  guint8 * code.5284;
  unsigned char D.43624;
  guint8 * code.5285;
  unsigned char D.43626;
  unsigned int offset.5286;
  unsigned int D.43630;
  guint8 * code.5287;
  guint8 * code.5288;
  unsigned char D.43638;
  guint8 * code.5289;
  guint8 * code.5290;
  guint8 * code.5291;
  guint8 * code.5292;
  unsigned char D.43647;
  guint8 * code.5293;
  unsigned char D.43649;
  guint8 * code.5294;
  unsigned char D.43651;
  guint8 * code.5295;
  unsigned char D.43653;
  unsigned char D.43654;
  int D.43655;
  unsigned char D.43656;
  unsigned char D.43657;
  int pos.5296;
  int D.43663;
  unsigned char * pos.5297;
  unsigned char D.43665;
  unsigned char * pos.5298;
  unsigned char D.43667;
  unsigned char * pos.5299;
  unsigned char D.43669;
  unsigned char * pos.5300;
  unsigned char D.43671;
  unsigned int disp.5301;
  unsigned int D.43674;
  unsigned char D.43677;
  unsigned char D.43678;
  guint8 * code.5302;
  guint8 * code.5303;
  guint8 * code.5304;
  guint8 * code.5305;
  guint8 * code.5306;
  guint8 * code.5307;
  unsigned char D.43697;
  guint8 * code.5308;
  unsigned char D.43699;
  guint8 * code.5309;
  unsigned char D.43701;
  guint8 * code.5310;
  unsigned char D.43703;
  guint8 * code.5311;
  guint8 * code.5312;
  guint8 * code.5313;
  guint8 * code.5314;
  guint8 * code.5315;
  guint8 * code.5316;
  guint8 * code.5317;
  unsigned char D.43713;
  guint8 * code.5318;
  unsigned char D.43715;
  guint8 * code.5319;
  unsigned char D.43717;
  guint8 * code.5320;
  unsigned char D.43719;
  guint8 * code.5321;
  guint8 * code.5322;
  guint8 * code.5323;
  guint8 * code.5324;
  guint8 * code.5325;
  unsigned char D.43728;
  guint8 * code.5326;
  unsigned char D.43730;
  guint8 * code.5327;
  unsigned char D.43732;
  guint8 * code.5328;
  unsigned char D.43734;
  guint8 * code.5329;
  guint8 * code.5330;
  unsigned char D.43739;
  guint8 * code.5331;
  unsigned char D.43741;
  guint8 * code.5332;
  unsigned char D.43743;
  guint8 * code.5333;
  unsigned char D.43745;
  guint8 * code.5334;
  guint8 * code.5335;
  guint8 * code.5336;
  guint8 * code.5337;
  guint8 * code.5338;
  unsigned char D.43754;
  guint8 * code.5339;
  unsigned char D.43756;
  guint8 * code.5340;
  unsigned char D.43758;
  guint8 * code.5341;
  unsigned char D.43760;
  guint8 * code.5342;
  guint8 * code.5343;
  guint8 * code.5344;
  guint8 * code.5345;
  guint8 * code.5346;
  guint8 * code.5347;
  guint8 * code.5348;
  guint8 * code.5349;
  guint8 * code.5350;
  unsigned char D.43778;
  guint8 * code.5351;
  unsigned char D.43780;
  guint8 * code.5352;
  unsigned char D.43782;
  guint8 * code.5353;
  unsigned char D.43784;
  struct MonoBasicBlock * * D.43786;
  struct MonoBasicBlock * D.43787;
  int D.43788;
  sizetype D.43791;
  unsigned char * D.43792;
  int D.43793;
  int D.43794;
  unsigned int offset.5354;
  unsigned int D.43796;
  guint8 * code.5355;
  guint8 * code.5356;
  unsigned char D.43804;
  guint8 * code.5357;
  guint8 * code.5358;
  guint8 * code.5359;
  guint8 * code.5360;
  unsigned char D.43813;
  guint8 * code.5361;
  unsigned char D.43815;
  guint8 * code.5362;
  unsigned char D.43817;
  guint8 * code.5363;
  unsigned char D.43819;
  unsigned char D.43820;
  int D.43821;
  unsigned char D.43822;
  unsigned char D.43823;
  int pos.5364;
  int D.43829;
  unsigned char * pos.5365;
  unsigned char D.43831;
  unsigned char * pos.5366;
  unsigned char D.43833;
  unsigned char * pos.5367;
  unsigned char D.43835;
  unsigned char * pos.5368;
  unsigned char D.43837;
  unsigned int disp.5369;
  unsigned int D.43840;
  unsigned char D.43843;
  unsigned char D.43844;
  int D.43850;
  int D.43851;
  unsigned int D.43852;
  unsigned int D.43853;
  guint8 * code.5370;
  guint8 * code.5371;
  guint8 * code.5372;
  guint8 * code.5373;
  guint8 * code.5374;
  guint8 * code.5375;
  unsigned char D.43867;
  guint8 * code.5376;
  unsigned char D.43869;
  guint8 * code.5377;
  unsigned char D.43871;
  guint8 * code.5378;
  unsigned char D.43873;
  unsigned char D.43874;
  int D.43875;
  unsigned char D.43876;
  unsigned char D.43877;
  int pos.5379;
  int D.43883;
  unsigned char * pos.5380;
  unsigned char D.43885;
  unsigned char * pos.5381;
  unsigned char D.43887;
  unsigned char * pos.5382;
  unsigned char D.43889;
  unsigned char * pos.5383;
  unsigned char D.43891;
  unsigned int disp.5384;
  unsigned int D.43894;
  unsigned char D.43897;
  unsigned char D.43898;
  int D.43900;
  guint8 * code.5385;
  guint8 * code.5386;
  guint8 * code.5387;
  guint8 * code.5388;
  guint8 * code.5389;
  guint8 * code.5390;
  guint8 * code.5391;
  guint8 * code.5392;
  guint8 * code.5393;
  unsigned char D.43920;
  guint8 * code.5394;
  unsigned char D.43922;
  guint8 * code.5395;
  unsigned char D.43924;
  guint8 * code.5396;
  unsigned char D.43926;
  guint8 * code.5397;
  guint8 * code.5398;
  guint8 * code.5399;
  guint8 * code.5400;
  unsigned char D.43936;
  guint8 * code.5401;
  unsigned char D.43938;
  guint8 * code.5402;
  unsigned char D.43940;
  guint8 * code.5403;
  unsigned char D.43942;
  guint8 * code.5404;
  guint8 * code.5405;
  guint8 * code.5406;
  guint8 * code.5407;
  guint8 * code.5408;
  guint8 * code.5409;
  guint8 * code.5410;
  guint8 * code.5411;
  unsigned char D.43960;
  guint8 * code.5412;
  unsigned char D.43962;
  guint8 * code.5413;
  unsigned char D.43964;
  guint8 * code.5414;
  unsigned char D.43966;
  guint8 * code.5415;
  guint8 * code.5416;
  guint8 * code.5417;
  guint8 * code.5418;
  unsigned char D.43976;
  guint8 * code.5419;
  unsigned char D.43978;
  guint8 * code.5420;
  unsigned char D.43980;
  guint8 * code.5421;
  unsigned char D.43982;
  guint8 * code.5422;
  unsigned char D.43984;
  guint8 * code.5423;
  unsigned char D.43986;
  guint8 * code.5424;
  unsigned char D.43988;
  guint8 * code.5425;
  unsigned char D.43990;
  guint8 * code.5426;
  guint8 * code.5427;
  guint8 * code.5428;
  guint8 * code.5429;
  guint8 * code.5430;
  guint8 * code.5431;
  guint8 * code.5432;
  guint8 * code.5433;
  guint8 * code.5434;
  guint8 * code.5435;
  int D.44013;
  int D.44014;
  signed char D.44015;
  signed char D.44016;
  unsigned char D.44017;
  guint8 * code.5436;
  guint8 * code.5437;
  signed char D.44023;
  unsigned char D.44024;
  guint8 * code.5438;
  guint8 * code.5439;
  signed char D.44028;
  unsigned char D.44029;
  guint8 * code.5440;
  guint8 * code.5441;
  unsigned char D.44032;
  guint8 * code.5442;
  unsigned char D.44034;
  guint8 * code.5443;
  unsigned char D.44036;
  guint8 * code.5444;
  unsigned char D.44038;
  guint8 * code.5445;
  signed char D.44044;
  unsigned char D.44045;
  guint8 * code.5446;
  signed char D.44049;
  signed char D.44050;
  unsigned char D.44051;
  guint8 * code.5447;
  signed char D.44054;
  signed char D.44055;
  unsigned char D.44056;
  guint8 * code.5448;
  unsigned char D.44058;
  guint8 * code.5449;
  unsigned char D.44060;
  guint8 * code.5450;
  unsigned char D.44062;
  guint8 * code.5451;
  unsigned char D.44064;
  guint8 * code.5452;
  guint8 * code.5453;
  guint8 * code.5454;
  guint8 * code.5455;
  signed char D.44071;
  signed char D.44072;
  signed char D.44073;
  unsigned char D.44074;
  guint8 * code.5456;
  unsigned char D.44076;
  unsigned char D.44077;
  unsigned char D.44078;
  unsigned char D.44079;
  _Bool D.44080;
  long int D.44081;
  long int D.44082;
  guint8 * code.5457;
  unsigned char D.44107;
  unsigned char D.44108;
  guint8 * code.5458;
  guint8 * code.5459;
  guint8 * code.5460;
  guint8 * code.5461;
  int D.44113;
  int D.44114;
  signed char D.44115;
  signed char D.44116;
  signed char D.44117;
  unsigned char D.44118;
  guint8 * code.5462;
  guint8 * code.5463;
  guint8 * code.5464;
  guint8 * code.5465;
  guint8 * code.5466;
  signed char D.44131;
  unsigned char D.44132;
  guint8 * code.5467;
  guint8 * code.5468;
  signed char D.44138;
  unsigned char D.44139;
  guint8 * code.5469;
  guint8 * code.5470;
  signed char D.44143;
  unsigned char D.44144;
  guint8 * code.5471;
  guint8 * code.5472;
  unsigned char D.44147;
  guint8 * code.5473;
  unsigned char D.44149;
  guint8 * code.5474;
  unsigned char D.44151;
  guint8 * code.5475;
  unsigned char D.44153;
  guint8 * code.5476;
  signed char D.44159;
  unsigned char D.44160;
  guint8 * code.5477;
  signed char D.44164;
  signed char D.44165;
  unsigned char D.44166;
  guint8 * code.5478;
  signed char D.44169;
  signed char D.44170;
  unsigned char D.44171;
  guint8 * code.5479;
  unsigned char D.44173;
  guint8 * code.5480;
  unsigned char D.44175;
  guint8 * code.5481;
  unsigned char D.44177;
  guint8 * code.5482;
  unsigned char D.44179;
  guint8 * code.5483;
  guint8 * code.5484;
  guint8 * code.5485;
  guint8 * code.5486;
  guint8 * code.5487;
  guint8 * code.5488;
  signed char D.44188;
  signed char D.44189;
  signed char D.44190;
  unsigned char D.44191;
  guint8 * code.5489;
  unsigned char D.44193;
  unsigned char D.44194;
  _Bool D.44195;
  long int D.44196;
  long int D.44197;
  int iftmp.5490;
  guint8 * code.5491;
  unsigned char D.44209;
  unsigned char D.44210;
  guint8 * code.5492;
  guint8 * code.5493;
  guint8 * code.5494;
  guint8 * code.5495;
  int D.44215;
  int D.44216;
  signed char D.44217;
  signed char D.44218;
  unsigned char D.44219;
  int iftmp.5496;
  guint8 * code.5497;
  unsigned char D.44227;
  unsigned char D.44228;
  guint8 * code.5498;
  guint8 * code.5499;
  guint8 * code.5500;
  guint8 * code.5501;
  int D.44233;
  int D.44234;
  signed char D.44235;
  signed char D.44236;
  unsigned char D.44237;
  guint8 * code.5502;
  guint8 * code.5503;
  guint8 * code.5504;
  guint8 * code.5505;
  guint8 * code.5506;
  guint8 * code.5507;
  guint8 * code.5508;
  guint8 * code.5509;
  guint8 * code.5510;
  guint8 * code.5511;
  unsigned char D.44256;
  guint8 * code.5512;
  unsigned char D.44258;
  guint8 * code.5513;
  unsigned char D.44260;
  guint8 * code.5514;
  unsigned char D.44262;
  guint8 * code.5515;
  unsigned char D.44268;
  unsigned char D.44269;
  guint8 * code.5516;
  signed char D.44273;
  signed char D.44274;
  signed char D.44275;
  unsigned char D.44276;
  guint8 * code.5517;
  signed char D.44279;
  unsigned char D.44280;
  guint8 * code.5518;
  unsigned char D.44282;
  guint8 * code.5519;
  unsigned char D.44284;
  guint8 * code.5520;
  unsigned char D.44286;
  guint8 * code.5521;
  unsigned char D.44288;
  guint8 * code.5522;
  guint8 * code.5523;
  guint8 * code.5524;
  guint8 * code.5525;
  signed char D.44297;
  unsigned char D.44298;
  guint8 * code.5526;
  guint8 * code.5527;
  signed char D.44304;
  unsigned char D.44305;
  guint8 * code.5528;
  guint8 * code.5529;
  signed char D.44309;
  unsigned char D.44310;
  guint8 * code.5530;
  guint8 * code.5531;
  unsigned char D.44313;
  guint8 * code.5532;
  unsigned char D.44315;
  guint8 * code.5533;
  unsigned char D.44317;
  guint8 * code.5534;
  unsigned char D.44319;
  guint8 * code.5535;
  signed char D.44325;
  unsigned char D.44326;
  guint8 * code.5536;
  signed char D.44330;
  signed char D.44331;
  unsigned char D.44332;
  guint8 * code.5537;
  signed char D.44335;
  signed char D.44336;
  unsigned char D.44337;
  guint8 * code.5538;
  unsigned char D.44339;
  guint8 * code.5539;
  unsigned char D.44341;
  guint8 * code.5540;
  unsigned char D.44343;
  guint8 * code.5541;
  unsigned char D.44345;
  guint8 * code.5542;
  guint8 * code.5543;
  guchar * D.44351;
  unsigned char D.44352;
  int D.44353;
  unsigned char D.44354;
  unsigned char D.44355;
  guchar * D.44358;
  int D.44359;
  int pos.5544;
  int D.44363;
  unsigned char * pos.5545;
  unsigned char D.44365;
  unsigned char * pos.5546;
  unsigned char D.44367;
  unsigned char * pos.5547;
  unsigned char D.44369;
  unsigned char * pos.5548;
  unsigned char D.44371;
  unsigned int disp.5549;
  unsigned int D.44374;
  unsigned char D.44377;
  unsigned char D.44378;
  guint8 * code.5550;
  unsigned char D.44383;
  guint8 * code.5551;
  unsigned char D.44387;
  int D.44390;
  _Bool D.44391;
  long int D.44392;
  long int D.44393;
  long int D.44396;
  long int D.44397;
  _Bool D.44400;
  long int D.44401;
  long int D.44402;
  guint8 * code.5552;
  guint8 * code.5553;
  guint8 * code.5554;
  guint8 * code.5555;
  guint8 * code.5556;
  guint8 * code.5557;
  guint8 * code.5558;
  guint8 * code.5559;
  guint8 * code.5560;
  guint8 * code.5561;
  unsigned char D.44423;
  guint8 * code.5562;
  unsigned char D.44425;
  guint8 * code.5563;
  unsigned char D.44427;
  guint8 * code.5564;
  unsigned char D.44429;
  guint8 * code.5565;
  guint8 * code.5566;
  guint8 * code.5567;
  guint8 * code.5568;
  unsigned char D.44441;
  guint8 * code.5569;
  unsigned char D.44443;
  guint8 * code.5570;
  unsigned char D.44445;
  guint8 * code.5571;
  unsigned char D.44447;
  guint8 * D.44448;
  void * D.44449;
  guint8 * code.5572;
  guint8 * code.5573;
  guint8 * code.5574;
  guint8 * code.5575;
  signed char D.44460;
  signed char D.44461;
  signed char D.44462;
  unsigned char D.44463;
  int nursery_shift.5576;
  guint8 * code.5577;
  guint8 * code.5578;
  guint8 * code.5579;
  guint8 * code.5580;
  unsigned char D.44472;
  guint8 * code.5581;
  long unsigned int D.44476;
  int D.44477;
  guint8 * code.5582;
  unsigned char D.44479;
  guint8 * code.5583;
  unsigned char D.44481;
  guint8 * code.5584;
  unsigned char D.44483;
  guint8 * code.5585;
  unsigned char D.44485;
  guint8 * code.5586;
  guint8 * code.5587;
  unsigned char D.44492;
  guint8 * code.5588;
  guint8 * code.5589;
  guint8 * code.5590;
  unsigned char D.44496;
  guint8 * code.5591;
  unsigned char D.44498;
  guint8 * code.5592;
  unsigned char D.44500;
  guint8 * code.5593;
  unsigned char D.44502;
  guint8 * code.5594;
  guint8 * code.5595;
  guint8 * code.5596;
  guint8 * code.5597;
  guint8 * code.5598;
  guint8 * code.5599;
  signed char D.44512;
  signed char D.44513;
  signed char D.44514;
  unsigned char D.44515;
  int card_table_shift.5600;
  guint8 * code.5601;
  guint8 * code.5602;
  guint8 * code.5603;
  guint8 * code.5604;
  unsigned char D.44524;
  void * card_table_mask.5605;
  guint8 * code.5606;
  int card_table_mask.5607;
  guint8 * code.5608;
  unsigned char D.44533;
  guint8 * code.5609;
  unsigned char D.44535;
  guint8 * code.5610;
  unsigned char D.44537;
  guint8 * code.5611;
  unsigned char D.44539;
  unsigned int card_table_mask.5612;
  unsigned int D.44541;
  guint8 * code.5613;
  guint8 * code.5614;
  unsigned char D.44546;
  guint8 * code.5615;
  guint8 * code.5616;
  guint8 * code.5617;
  unsigned char D.44551;
  guint8 * code.5618;
  unsigned char D.44553;
  guint8 * code.5619;
  unsigned char D.44555;
  guint8 * code.5620;
  unsigned char D.44557;
  guint8 * code.5621;
  guint8 * code.5622;
  guint8 * code.5623;
  int card_table.5624;
  _Bool D.44569;
  _Bool D.44570;
  _Bool D.44571;
  guint8 * code.5625;
  guint8 * code.5626;
  unsigned char D.44576;
  guint8 * code.5627;
  guint8 * code.5628;
  guint8 * code.5629;
  unsigned char D.44581;
  guint8 * code.5630;
  unsigned char D.44583;
  guint8 * code.5631;
  unsigned char D.44585;
  guint8 * code.5632;
  unsigned char D.44587;
  guint8 * code.5633;
  guint8 * code.5634;
  guint8 * code.5635;
  guint8 * code.5636;
  unsigned char D.44597;
  guint8 * code.5637;
  unsigned char D.44599;
  guint8 * code.5638;
  unsigned char D.44601;
  guint8 * code.5639;
  unsigned char D.44603;
  guint8 * code.5640;
  guint8 * code.5641;
  guint8 * code.5642;
  guint8 * code.5643;
  guint8 * code.5644;
  guint8 * code.5645;
  guint8 * code.5646;
  guint8 * code.5647;
  guint8 * code.5648;
  unsigned char D.44624;
  guint8 * code.5649;
  unsigned char D.44626;
  guint8 * code.5650;
  unsigned char D.44628;
  guint8 * code.5651;
  unsigned char D.44630;
  guint8 * code.5652;
  guint8 * code.5653;
  guint8 * code.5654;
  guint8 * code.5655;
  unsigned char D.44640;
  guint8 * code.5656;
  unsigned char D.44642;
  guint8 * code.5657;
  unsigned char D.44644;
  guint8 * code.5658;
  unsigned char D.44646;
  guint8 * code.5659;
  guint8 * code.5660;
  guint8 * code.5661;
  guint8 * code.5662;
  guint8 * code.5663;
  guint8 * code.5664;
  guint8 * code.5665;
  guint8 * code.5666;
  unsigned char D.44664;
  guint8 * code.5667;
  unsigned char D.44666;
  guint8 * code.5668;
  unsigned char D.44668;
  guint8 * code.5669;
  unsigned char D.44670;
  guint8 * code.5670;
  guint8 * code.5671;
  guint8 * code.5672;
  guint8 * code.5673;
  unsigned char D.44680;
  guint8 * code.5674;
  unsigned char D.44682;
  guint8 * code.5675;
  unsigned char D.44684;
  guint8 * code.5676;
  unsigned char D.44686;
  guint8 * code.5677;
  unsigned char D.44688;
  guint8 * code.5678;
  unsigned char D.44690;
  guint8 * code.5679;
  unsigned char D.44692;
  guint8 * code.5680;
  unsigned char D.44694;
  unsigned char D.44697;
  int D.44698;
  unsigned char D.44699;
  unsigned char D.44700;
  int pos.5681;
  int D.44706;
  unsigned char * pos.5682;
  unsigned char D.44708;
  unsigned char * pos.5683;
  unsigned char D.44710;
  unsigned char * pos.5684;
  unsigned char D.44712;
  unsigned char * pos.5685;
  unsigned char D.44714;
  unsigned int disp.5686;
  unsigned int D.44717;
  unsigned char D.44720;
  unsigned char D.44721;
  guint8 * code.5687;
  guint8 * code.5688;
  guint8 * code.5689;
  guint8 * code.5690;
  guint8 * code.5691;
  guint8 * code.5692;
  guint8 * code.5693;
  guint8 * code.5694;
  guint8 * code.5695;
  guint8 * code.5696;
  guint8 * code.5697;
  guint8 * code.5698;
  guint8 * code.5699;
  guint8 * code.5700;
  guint8 * code.5701;
  guint8 * code.5702;
  guint8 * code.5703;
  guint8 * code.5704;
  _Bool D.44741;
  long int D.44742;
  long int D.44743;
  guint8 * code.5705;
  guint8 * code.5706;
  guint8 * code.5707;
  guint8 * code.5708;
  unsigned char D.44750;
  guint8 * code.5709;
  guint8 * code.5710;
  guint8 * code.5711;
  guint8 * code.5712;
  guint8 * code.5713;
  guint8 * code.5714;
  guint8 * code.5715;
  guint8 * code.5716;
  guint8 * code.5717;
  guint8 * code.5718;
  guint8 * code.5719;
  guint8 * code.5720;
  guint8 * code.5721;
  guint8 * code.5722;
  guint8 * code.5723;
  guint8 * code.5724;
  guint8 * code.5725;
  guint8 * code.5726;
  guint8 * code.5727;
  guint8 * code.5728;
  guint8 * code.5729;
  guint8 * code.5730;
  guint8 * code.5731;
  guint8 * code.5732;
  guint8 * code.5733;
  guint8 * code.5734;
  guint8 * code.5735;
  guint8 * code.5736;
  guint8 * code.5737;
  guint8 * code.5738;
  guint8 * code.5739;
  guint8 * code.5740;
  guint8 * code.5741;
  guint8 * code.5742;
  guint8 * code.5743;
  guint8 * code.5744;
  guint8 * code.5745;
  guint8 * code.5746;
  guint8 * code.5747;
  guint8 * code.5748;
  guint8 * code.5749;
  _Bool D.44792;
  long int D.44793;
  long int D.44794;
  guint8 * code.5750;
  guint8 * code.5751;
  guint8 * code.5752;
  guint8 * code.5753;
  guint8 * code.5754;
  guint8 * code.5755;
  guint8 * code.5756;
  guint8 * code.5757;
  guint8 * code.5758;
  guint8 * code.5759;
  guint8 * code.5760;
  guint8 * code.5761;
  guint8 * code.5762;
  guint8 * code.5763;
  guint8 * code.5764;
  guint8 * code.5765;
  guint8 * code.5766;
  guint8 * code.5767;
  _Bool D.44821;
  long int D.44822;
  long int D.44823;
  guint8 * code.5768;
  guint8 * code.5769;
  guint8 * code.5770;
  guint8 * code.5771;
  guint8 * code.5772;
  guint8 * code.5773;
  guint8 * code.5774;
  guint8 * code.5775;
  guint8 * code.5776;
  guint8 * code.5777;
  guint8 * code.5778;
  guint8 * code.5779;
  guint8 * code.5780;
  guint8 * code.5781;
  guint8 * code.5782;
  guint8 * code.5783;
  guint8 * code.5784;
  guint8 * code.5785;
  guint8 * code.5786;
  guint8 * code.5787;
  guint8 * code.5788;
  guint8 * code.5789;
  guint8 * code.5790;
  guint8 * code.5791;
  guint8 * code.5792;
  guint8 * code.5793;
  guint8 * code.5794;
  guint8 * code.5795;
  guint8 * code.5796;
  guint8 * code.5797;
  guint8 * code.5798;
  guint8 * code.5799;
  guint8 * code.5800;
  guint8 * code.5801;
  guint8 * code.5802;
  guint8 * code.5803;
  guint8 * code.5804;
  guint8 * code.5805;
  guint8 * code.5806;
  guint8 * code.5807;
  guint8 * code.5808;
  guint8 * code.5809;
  guint8 * code.5810;
  guint8 * code.5811;
  guint8 * code.5812;
  guint8 * code.5813;
  guint8 * code.5814;
  guint8 * code.5815;
  guint8 * code.5816;
  guint8 * code.5817;
  guint8 * code.5818;
  guint8 * code.5819;
  guint8 * code.5820;
  guint8 * code.5821;
  guint8 * code.5822;
  guint8 * code.5823;
  guint8 * code.5824;
  guint8 * code.5825;
  guint8 * code.5826;
  guint8 * code.5827;
  guint8 * code.5828;
  guint8 * code.5829;
  guint8 * code.5830;
  guint8 * code.5831;
  guint8 * code.5832;
  guint8 * code.5833;
  guint8 * code.5834;
  guint8 * code.5835;
  guint8 * code.5836;
  guint8 * code.5837;
  guint8 * code.5838;
  guint8 * code.5839;
  guint8 * code.5840;
  guint8 * code.5841;
  guint8 * code.5842;
  guint8 * code.5843;
  guint8 * code.5844;
  guint8 * code.5845;
  guint8 * code.5846;
  guint8 * code.5847;
  guint8 * code.5848;
  guint8 * code.5849;
  guint8 * code.5850;
  guint8 * code.5851;
  guint8 * code.5852;
  guint8 * code.5853;
  guint8 * code.5854;
  guint8 * code.5855;
  guint8 * code.5856;
  guint8 * code.5857;
  guint8 * code.5858;
  guint8 * code.5859;
  guint8 * code.5860;
  guint8 * code.5861;
  guint8 * code.5862;
  guint8 * code.5863;
  guint8 * code.5864;
  guint8 * code.5865;
  guint8 * code.5866;
  guint8 * code.5867;
  guint8 * code.5868;
  guint8 * code.5869;
  guint8 * code.5870;
  guint8 * code.5871;
  guint8 * code.5872;
  guint8 * code.5873;
  guint8 * code.5874;
  guint8 * code.5875;
  guint8 * code.5876;
  guint8 * code.5877;
  guint8 * code.5878;
  guint8 * code.5879;
  guint8 * code.5880;
  guint8 * code.5881;
  guint8 * code.5882;
  guint8 * code.5883;
  guint8 * code.5884;
  guint8 * code.5885;
  guint8 * code.5886;
  guint8 * code.5887;
  guint8 * code.5888;
  guint8 * code.5889;
  guint8 * code.5890;
  guint8 * code.5891;
  guint8 * code.5892;
  guint8 * code.5893;
  guint8 * code.5894;
  guint8 * code.5895;
  guint8 * code.5896;
  guint8 * code.5897;
  guint8 * code.5898;
  guint8 * code.5899;
  guint8 * code.5900;
  guint8 * code.5901;
  guint8 * code.5902;
  guint8 * code.5903;
  guint8 * code.5904;
  guint8 * code.5905;
  guint8 * code.5906;
  guint8 * code.5907;
  guint8 * code.5908;
  guint8 * code.5909;
  guint8 * code.5910;
  guint8 * code.5911;
  guint8 * code.5912;
  guint8 * code.5913;
  guint8 * code.5914;
  guint8 * code.5915;
  guint8 * code.5916;
  guint8 * code.5917;
  guint8 * code.5918;
  guint8 * code.5919;
  guint8 * code.5920;
  guint8 * code.5921;
  guint8 * code.5922;
  guint8 * code.5923;
  guint8 * code.5924;
  guint8 * code.5925;
  guint8 * code.5926;
  guint8 * code.5927;
  guint8 * code.5928;
  guint8 * code.5929;
  guint8 * code.5930;
  guint8 * code.5931;
  guint8 * code.5932;
  guint8 * code.5933;
  guint8 * code.5934;
  guint8 * code.5935;
  guint8 * code.5936;
  guint8 * code.5937;
  guint8 * code.5938;
  guint8 * code.5939;
  guint8 * code.5940;
  guint8 * code.5941;
  guint8 * code.5942;
  guint8 * code.5943;
  guint8 * code.5944;
  guint8 * code.5945;
  guint8 * code.5946;
  guint8 * code.5947;
  guint8 * code.5948;
  guint8 * code.5949;
  guint8 * code.5950;
  guint8 * code.5951;
  guint8 * code.5952;
  guint8 * code.5953;
  guint8 * code.5954;
  guint8 * code.5955;
  guint8 * code.5956;
  guint8 * code.5957;
  guint8 * code.5958;
  guint8 * code.5959;
  guint8 * code.5960;
  guint8 * code.5961;
  guint8 * code.5962;
  guint8 * code.5963;
  guint8 * code.5964;
  guint8 * code.5965;
  guint8 * code.5966;
  guint8 * code.5967;
  guint8 * code.5968;
  guint8 * code.5969;
  guint8 * code.5970;
  guint8 * code.5971;
  guint8 * code.5972;
  guint8 * code.5973;
  guint8 * code.5974;
  guint8 * code.5975;
  guint8 * code.5976;
  guint8 * code.5977;
  guint8 * code.5978;
  guint8 * code.5979;
  guint8 * code.5980;
  guint8 * code.5981;
  guint8 * code.5982;
  guint8 * code.5983;
  guint8 * code.5984;
  guint8 * code.5985;
  guint8 * code.5986;
  guint8 * code.5987;
  guint8 * code.5988;
  guint8 * code.5989;
  guint8 * code.5990;
  guint8 * code.5991;
  guint8 * code.5992;
  guint8 * code.5993;
  guint8 * code.5994;
  guint8 * code.5995;
  guint8 * code.5996;
  guint8 * code.5997;
  guint8 * code.5998;
  guint8 * code.5999;
  guint8 * code.6000;
  guint8 * code.6001;
  guint8 * code.6002;
  guint8 * code.6003;
  guint8 * code.6004;
  guint8 * code.6005;
  guint8 * code.6006;
  guint8 * code.6007;
  guint8 * code.6008;
  guint8 * code.6009;
  guint8 * code.6010;
  guint8 * code.6011;
  guint8 * code.6012;
  guint8 * code.6013;
  guint8 * code.6014;
  guint8 * code.6015;
  guint8 * code.6016;
  guint8 * code.6017;
  guint8 * code.6018;
  guint8 * code.6019;
  guint8 * code.6020;
  guint8 * code.6021;
  guint8 * code.6022;
  guint8 * code.6023;
  guint8 * code.6024;
  guint8 * code.6025;
  guint8 * code.6026;
  guint8 * code.6027;
  guint8 * code.6028;
  guint8 * code.6029;
  guint8 * code.6030;
  guint8 * code.6031;
  guint8 * code.6032;
  guint8 * code.6033;
  guint8 * code.6034;
  guint8 * code.6035;
  guint8 * code.6036;
  guint8 * code.6037;
  guint8 * code.6038;
  guint8 * code.6039;
  guint8 * code.6040;
  guint8 * code.6041;
  guint8 * code.6042;
  guint8 * code.6043;
  guint8 * code.6044;
  guint8 * code.6045;
  guint8 * code.6046;
  guint8 * code.6047;
  guint8 * code.6048;
  guint8 * code.6049;
  guint8 * code.6050;
  guint8 * code.6051;
  guint8 * code.6052;
  guint8 * code.6053;
  guint8 * code.6054;
  guint8 * code.6055;
  guint8 * code.6056;
  guint8 * code.6057;
  guint8 * code.6058;
  guint8 * code.6059;
  guint8 * code.6060;
  guint8 * code.6061;
  guint8 * code.6062;
  guint8 * code.6063;
  guint8 * code.6064;
  guint8 * code.6065;
  guint8 * code.6066;
  guint8 * code.6067;
  guint8 * code.6068;
  guint8 * code.6069;
  guint8 * code.6070;
  guint8 * code.6071;
  guint8 * code.6072;
  guint8 * code.6073;
  guint8 * code.6074;
  guint8 * code.6075;
  guint8 * code.6076;
  guint8 * code.6077;
  guint8 * code.6078;
  guint8 * code.6079;
  guint8 * code.6080;
  guint8 * code.6081;
  guint8 * code.6082;
  guint8 * code.6083;
  guint8 * code.6084;
  guint8 * code.6085;
  guint8 * code.6086;
  guint8 * code.6087;
  guint8 * code.6088;
  guint8 * code.6089;
  guint8 * code.6090;
  guint8 * code.6091;
  guint8 * code.6092;
  guint8 * code.6093;
  guint8 * code.6094;
  guint8 * code.6095;
  guint8 * code.6096;
  guint8 * code.6097;
  guint8 * code.6098;
  guint8 * code.6099;
  guint8 * code.6100;
  guint8 * code.6101;
  guint8 * code.6102;
  guint8 * code.6103;
  guint8 * code.6104;
  guint8 * code.6105;
  guint8 * code.6106;
  guint8 * code.6107;
  guint8 * code.6108;
  guint8 * code.6109;
  guint8 * code.6110;
  guint8 * code.6111;
  guint8 * code.6112;
  guint8 * code.6113;
  guint8 * code.6114;
  guint8 * code.6115;
  guint8 * code.6116;
  guint8 * code.6117;
  guint8 * code.6118;
  guint8 * code.6119;
  guint8 * code.6120;
  guint8 * code.6121;
  guint8 * code.6122;
  guint8 * code.6123;
  signed char D.45184;
  unsigned char D.45185;
  guint8 * code.6124;
  guint8 * code.6125;
  guint8 * code.6126;
  guint8 * code.6127;
  guint8 * code.6128;
  guint8 * code.6129;
  guint8 * code.6130;
  guint8 * code.6131;
  guint8 * code.6132;
  guint8 * code.6133;
  guint8 * code.6134;
  guint8 * code.6135;
  guint8 * code.6136;
  guint8 * code.6137;
  guint8 * code.6138;
  guint8 * code.6139;
  guint8 * code.6140;
  guint8 * code.6141;
  guint8 * code.6142;
  guint8 * code.6143;
  guint8 * code.6144;
  guint8 * code.6145;
  guint8 * code.6146;
  guint8 * code.6147;
  guint8 * code.6148;
  guint8 * code.6149;
  guint8 * code.6150;
  guint8 * code.6151;
  guint8 * code.6152;
  guint8 * code.6153;
  guint8 * code.6154;
  guint8 * code.6155;
  guint8 * code.6156;
  guint8 * code.6157;
  guint8 * code.6158;
  guint8 * code.6159;
  guint8 * code.6160;
  guint8 * code.6161;
  guint8 * code.6162;
  guint8 * code.6163;
  guint8 * code.6164;
  guint8 * code.6165;
  guint8 * code.6166;
  guint8 * code.6167;
  guint8 * code.6168;
  guint8 * code.6169;
  guint8 * code.6170;
  guint8 * code.6171;
  guint8 * code.6172;
  guint8 * code.6173;
  guint8 * code.6174;
  guint8 * code.6175;
  signed char D.45238;
  unsigned char D.45239;
  guint8 * code.6176;
  guint8 * code.6177;
  guint8 * code.6178;
  guint8 * code.6179;
  int D.45246;
  guint8 * code.6180;
  guint8 * code.6181;
  guint8 * code.6182;
  guint8 * code.6183;
  unsigned char D.45254;
  unsigned char D.45255;
  guint8 * code.6184;
  guint8 * code.6185;
  guint8 * code.6186;
  guint8 * code.6187;
  guint8 * code.6188;
  guint8 * code.6189;
  guint8 * code.6190;
  guint8 * code.6191;
  guint8 * code.6192;
  guint8 * code.6193;
  guint8 * code.6194;
  guint8 * code.6195;
  guint8 * code.6196;
  guint8 * code.6197;
  guint8 * code.6198;
  guint8 * code.6199;
  guint8 * code.6200;
  struct MonoInst * D.45292;
  int D.45293;
  int D.45296;
  guint8 * code.6201;
  guint8 * code.6202;
  unsigned int D.45302;
  unsigned int D.45303;
  guint8 * code.6203;
  guint8 * code.6204;
  unsigned char D.45308;
  guint8 * code.6205;
  guint8 * code.6206;
  guint8 * code.6207;
  unsigned char D.45313;
  guint8 * code.6208;
  unsigned char D.45315;
  guint8 * code.6209;
  unsigned char D.45317;
  guint8 * code.6210;
  unsigned char D.45319;
  guint8 * code.6211;
  signed char D.45325;
  signed char D.45326;
  signed char D.45327;
  unsigned char D.45328;
  guint8 * code.6212;
  signed char D.45332;
  unsigned char D.45333;
  guint8 * code.6213;
  signed char D.45336;
  unsigned char D.45337;
  guint8 * code.6214;
  unsigned char D.45339;
  guint8 * code.6215;
  unsigned char D.45341;
  guint8 * code.6216;
  unsigned char D.45343;
  guint8 * code.6217;
  unsigned char D.45345;
  guint8 * code.6218;
  guint8 * code.6219;
  guint8 * code.6220;
  guint8 * code.6221;
  guint8 * code.6222;
  guint8 * code.6223;
  guint8 * code.6224;
  guint8 * code.6225;
  guint8 * code.6226;
  guint8 * code.6227;
  unsigned char D.45365;
  guint8 * code.6228;
  unsigned char D.45367;
  guint8 * code.6229;
  unsigned char D.45369;
  guint8 * code.6230;
  unsigned char D.45371;
  guint8 * code.6231;
  guint8 * code.6232;
  guint8 * code.6233;
  guint8 * code.6234;
  unsigned char D.45383;
  guint8 * code.6235;
  unsigned char D.45385;
  guint8 * code.6236;
  unsigned char D.45387;
  guint8 * code.6237;
  unsigned char D.45389;
  guint8 * code.6238;
  guint8 * code.6239;
  guint8 * code.6240;
  guint8 * code.6241;
  guint8 * code.6242;
  guint8 * code.6243;
  guint8 * code.6244;
  guint8 * code.6245;
  unsigned char D.45406;
  guint8 * code.6246;
  unsigned char D.45408;
  guint8 * code.6247;
  unsigned char D.45410;
  guint8 * code.6248;
  unsigned char D.45412;
  guint8 * code.6249;
  unsigned char D.45418;
  unsigned char D.45419;
  guint8 * code.6250;
  signed char D.45423;
  unsigned char D.45424;
  guint8 * code.6251;
  signed char D.45427;
  unsigned char D.45428;
  guint8 * code.6252;
  unsigned char D.45430;
  guint8 * code.6253;
  unsigned char D.45432;
  guint8 * code.6254;
  unsigned char D.45434;
  guint8 * code.6255;
  unsigned char D.45436;
  guint8 * code.6256;
  guint8 * code.6257;
  guint8 * code.6258;
  guint8 * code.6259;
  guint8 * code.6260;
  guint8 * code.6261;
  guint8 * code.6262;
  guint8 * code.6263;
  guint8 * code.6264;
  guint8 * code.6265;
  guint8 * code.6266;
  int iftmp.6267;
  int D.45451;
  guint8 * code.6268;
  unsigned char D.45456;
  guint8 * code.6269;
  unsigned char D.45458;
  guint8 * code.6270;
  unsigned char D.45460;
  guint8 * code.6271;
  unsigned char D.45462;
  guint8 * code.6272;
  guint8 * code.6273;
  unsigned char iftmp.6274;
  guint8 * code.6275;
  guint8 * code.6276;
  int iftmp.6277;
  guint8 * code.6278;
  unsigned char D.45479;
  guint8 * code.6279;
  unsigned char D.45481;
  guint8 * code.6280;
  unsigned char D.45483;
  guint8 * code.6281;
  unsigned char D.45485;
  guint8 * code.6282;
  guint8 * code.6283;
  guint8 * code.6284;
  guint8 * code.6285;
  guint8 * code.6286;
  guint8 * code.6287;
  guint8 * code.6288;
  guint8 * code.6289;
  guint8 * code.6290;
  guint8 * code.6291;
  guint8 * code.6292;
  int D.45502;
  unsigned char D.45503;
  guint8 * code.6293;
  guint8 * code.6294;
  guint8 * code.6295;
  guint8 * code.6296;
  guint8 * code.6297;
  unsigned char D.45509;
  guint8 * code.6298;
  guint8 * code.6299;
  guint8 * code.6300;
  guint8 * code.6301;
  guint8 * code.6302;
  guint8 * code.6303;
  guint8 * code.6304;
  guint8 * code.6305;
  guint8 * code.6306;
  unsigned char D.45522;
  guint8 * code.6307;
  guint8 * code.6308;
  guint8 * code.6309;
  guint8 * code.6310;
  guint8 * code.6311;
  guint8 * code.6312;
  guint8 * code.6313;
  guint8 * code.6314;
  unsigned char D.45539;
  guint8 * code.6315;
  unsigned char D.45541;
  guint8 * code.6316;
  unsigned char D.45543;
  guint8 * code.6317;
  unsigned char D.45545;
  guint8 * code.6318;
  signed char D.45551;
  unsigned char D.45552;
  guint8 * code.6319;
  signed char D.45556;
  unsigned char D.45557;
  guint8 * code.6320;
  signed char D.45560;
  unsigned char D.45561;
  guint8 * code.6321;
  unsigned char D.45563;
  guint8 * code.6322;
  unsigned char D.45565;
  guint8 * code.6323;
  unsigned char D.45567;
  guint8 * code.6324;
  unsigned char D.45569;
  guint8 * code.6325;
  guint8 * code.6326;
  guint8 * code.6327;
  guint8 * code.6328;
  guint8 * code.6329;
  guint8 * code.6330;
  guint8 * code.6331;
  guint8 * code.6332;
  guint8 * code.6333;
  guint8 * code.6334;
  unsigned char D.45588;
  guint8 * code.6335;
  unsigned char D.45590;
  guint8 * code.6336;
  unsigned char D.45592;
  guint8 * code.6337;
  unsigned char D.45594;
  guint8 * code.6338;
  signed char D.45600;
  unsigned char D.45601;
  guint8 * code.6339;
  signed char D.45605;
  unsigned char D.45606;
  guint8 * code.6340;
  signed char D.45609;
  unsigned char D.45610;
  guint8 * code.6341;
  unsigned char D.45612;
  guint8 * code.6342;
  unsigned char D.45614;
  guint8 * code.6343;
  unsigned char D.45616;
  guint8 * code.6344;
  unsigned char D.45618;
  guint8 * code.6345;
  guint8 * code.6346;
  guint8 * code.6347;
  guint8 * code.6348;
  guint8 * code.6349;
  guint8 * code.6350;
  unsigned int D.45630;
  guint8 * code.6351;
  guint8 * code.6352;
  unsigned char D.45635;
  unsigned char D.45636;
  guint8 * code.6353;
  guint8 * code.6354;
  int D.45640;
  guint8 * code.6355;
  unsigned char D.45642;
  guint8 * code.6356;
  unsigned char D.45644;
  guint8 * code.6357;
  unsigned char D.45646;
  guint8 * code.6358;
  unsigned char D.45648;
  guint8 * code.6359;
  guint8 * code.6360;
  guint8 * code.6361;
  guint8 * code.6362;
  unsigned char D.45660;
  guint8 * code.6363;
  unsigned char D.45662;
  guint8 * code.6364;
  unsigned char D.45664;
  guint8 * code.6365;
  unsigned char D.45666;
  guint8 * code.6366;
  guint8 * code.6367;
  guint8 * code.6368;
  guint8 * code.6369;
  guint8 * code.6370;
  guint8 * code.6371;
  guint8 * code.6372;
  guint8 * code.6373;
  guint8 * code.6374;
  unsigned char D.45684;
  guint8 * code.6375;
  unsigned char D.45686;
  guint8 * code.6376;
  unsigned char D.45688;
  guint8 * code.6377;
  unsigned char D.45690;
  guint8 * code.6378;
  guint8 * code.6379;
  guint8 * code.6380;
  guint8 * code.6381;
  unsigned char D.45702;
  guint8 * code.6382;
  unsigned char D.45704;
  guint8 * code.6383;
  unsigned char D.45706;
  guint8 * code.6384;
  unsigned char D.45708;
  guint8 * code.6385;
  guint8 * code.6386;
  guint8 * code.6387;
  guint8 * code.6388;
  guint8 * code.6389;
  guint8 * code.6390;
  guint8 * code.6391;
  guint8 * code.6392;
  guint8 * code.6393;
  guint8 * code.6394;
  unsigned char D.45731;
  guint8 * code.6395;
  unsigned char D.45733;
  guint8 * code.6396;
  unsigned char D.45735;
  guint8 * code.6397;
  unsigned char D.45737;
  guint8 * code.6398;
  guint8 * code.6399;
  guint8 * code.6400;
  guint8 * code.6401;
  unsigned char D.45749;
  guint8 * code.6402;
  unsigned char D.45751;
  guint8 * code.6403;
  unsigned char D.45753;
  guint8 * code.6404;
  unsigned char D.45755;
  guint8 * code.6405;
  guint8 * code.6406;
  guint8 * code.6407;
  guint8 * code.6408;
  guint8 * code.6409;
  guint8 * code.6410;
  guint8 * code.6411;
  guint8 * code.6412;
  guint8 * code.6413;
  guint8 * code.6414;
  unsigned char D.45775;
  guint8 * code.6415;
  unsigned char D.45777;
  guint8 * code.6416;
  unsigned char D.45779;
  guint8 * code.6417;
  unsigned char D.45781;
  guint8 * code.6418;
  guint8 * code.6419;
  guint8 * code.6420;
  guint8 * code.6421;
  unsigned char D.45793;
  guint8 * code.6422;
  unsigned char D.45795;
  guint8 * code.6423;
  unsigned char D.45797;
  guint8 * code.6424;
  unsigned char D.45799;
  guint8 * code.6425;
  guint8 * code.6426;
  guint8 * code.6427;
  guint8 * code.6428;
  guint8 * code.6429;
  guint8 * code.6430;
  guint8 * code.6431;
  guint8 * code.6432;
  guint8 * code.6433;
  unsigned char D.45817;
  guint8 * code.6434;
  unsigned char D.45819;
  guint8 * code.6435;
  unsigned char D.45821;
  guint8 * code.6436;
  unsigned char D.45823;
  guint8 * code.6437;
  guint8 * code.6438;
  guint8 * code.6439;
  guint8 * code.6440;
  unsigned char D.45835;
  guint8 * code.6441;
  unsigned char D.45837;
  guint8 * code.6442;
  unsigned char D.45839;
  guint8 * code.6443;
  unsigned char D.45841;
  guint8 * code.6444;
  guint8 * code.6445;
  guint8 * code.6446;
  guint8 * code.6447;
  guint8 * code.6448;
  guint8 * code.6449;
  guint8 * code.6450;
  guint8 * code.6451;
  guint8 * code.6452;
  unsigned char D.45859;
  guint8 * code.6453;
  unsigned char D.45861;
  guint8 * code.6454;
  unsigned char D.45863;
  guint8 * code.6455;
  unsigned char D.45865;
  guint8 * code.6456;
  guint8 * code.6457;
  guint8 * code.6458;
  guint8 * code.6459;
  unsigned char D.45877;
  guint8 * code.6460;
  unsigned char D.45879;
  guint8 * code.6461;
  unsigned char D.45881;
  guint8 * code.6462;
  unsigned char D.45883;
  guint8 * code.6463;
  guint8 * code.6464;
  guint8 * code.6465;
  guint8 * code.6466;
  guint8 * code.6467;
  guint8 * code.6468;
  guint8 * code.6469;
  guint8 * code.6470;
  guint8 * code.6471;
  unsigned char D.45901;
  guint8 * code.6472;
  unsigned char D.45903;
  guint8 * code.6473;
  unsigned char D.45905;
  guint8 * code.6474;
  unsigned char D.45907;
  guint8 * code.6475;
  guint8 * code.6476;
  guint8 * code.6477;
  guint8 * code.6478;
  unsigned char D.45919;
  guint8 * code.6479;
  unsigned char D.45921;
  guint8 * code.6480;
  unsigned char D.45923;
  guint8 * code.6481;
  unsigned char D.45925;
  guint8 * code.6482;
  guint8 * code.6483;
  guint8 * code.6484;
  guint8 * code.6485;
  guint8 * code.6486;
  guint8 * code.6487;
  guint8 * code.6488;
  guint8 * code.6489;
  guint8 * code.6490;
  unsigned char D.45943;
  guint8 * code.6491;
  unsigned char D.45945;
  guint8 * code.6492;
  unsigned char D.45947;
  guint8 * code.6493;
  unsigned char D.45949;
  guint8 * code.6494;
  guint8 * code.6495;
  guint8 * code.6496;
  guint8 * code.6497;
  unsigned char D.45961;
  guint8 * code.6498;
  unsigned char D.45963;
  guint8 * code.6499;
  unsigned char D.45965;
  guint8 * code.6500;
  unsigned char D.45967;
  guint8 * code.6501;
  guint8 * code.6502;
  guint8 * code.6503;
  guint8 * code.6504;
  guint8 * code.6505;
  guint8 * code.6506;
  guint8 * code.6507;
  guint8 * code.6508;
  guint8 * code.6509;
  unsigned char D.45985;
  guint8 * code.6510;
  unsigned char D.45987;
  guint8 * code.6511;
  unsigned char D.45989;
  guint8 * code.6512;
  unsigned char D.45991;
  guint8 * code.6513;
  guint8 * code.6514;
  guint8 * code.6515;
  guint8 * code.6516;
  unsigned char D.46003;
  guint8 * code.6517;
  unsigned char D.46005;
  guint8 * code.6518;
  unsigned char D.46007;
  guint8 * code.6519;
  unsigned char D.46009;
  guint8 * code.6520;
  guint8 * code.6521;
  guint8 * code.6522;
  int D.46017;
  int D.46018;
  int D.46019;
  signed char D.46020;
  signed char D.46021;
  unsigned char D.46022;
  guint8 * code.6523;
  guint8 * code.6524;
  signed char D.46028;
  unsigned char D.46029;
  guint8 * code.6525;
  guint8 * code.6526;
  signed char D.46033;
  unsigned char D.46034;
  guint8 * code.6527;
  guint8 * code.6528;
  unsigned char D.46037;
  guint8 * code.6529;
  unsigned char D.46039;
  guint8 * code.6530;
  unsigned char D.46041;
  guint8 * code.6531;
  unsigned char D.46043;
  guint8 * code.6532;
  signed char D.46049;
  unsigned char D.46050;
  guint8 * code.6533;
  signed char D.46054;
  signed char D.46055;
  unsigned char D.46056;
  guint8 * code.6534;
  signed char D.46059;
  signed char D.46060;
  unsigned char D.46061;
  guint8 * code.6535;
  unsigned char D.46063;
  guint8 * code.6536;
  unsigned char D.46065;
  guint8 * code.6537;
  unsigned char D.46067;
  guint8 * code.6538;
  unsigned char D.46069;
  guint8 * code.6539;
  guint8 * code.6540;
  guint8 * code.6541;
  guint8 * code.6542;
  guint8 * code.6543;
  guint8 * code.6544;
  guint8 * code.6545;
  guint8 * code.6546;
  guint8 * code.6547;
  guint8 * code.6548;
  guint8 * code.6549;
  guint8 * code.6550;
  guint8 * code.6551;
  guint8 * code.6552;
  guint8 * code.6553;
  guint8 * code.6554;
  guint8 * code.6555;
  unsigned char D.46097;
  guint8 * code.6556;
  unsigned char D.46099;
  guint8 * code.6557;
  unsigned char D.46101;
  guint8 * code.6558;
  unsigned char D.46103;
  guint8 * code.6559;
  guint8 * code.6560;
  guint8 * code.6561;
  guint8 * code.6562;
  unsigned char D.46115;
  guint8 * code.6563;
  unsigned char D.46117;
  guint8 * code.6564;
  unsigned char D.46119;
  guint8 * code.6565;
  unsigned char D.46121;
  guint8 * code.6566;
  guint8 * code.6567;
  guint8 * code.6568;
  guint8 * code.6569;
  guint8 * code.6570;
  guint8 * code.6571;
  guint8 * code.6572;
  guint8 * code.6573;
  unsigned char D.46138;
  guint8 * code.6574;
  unsigned char D.46140;
  guint8 * code.6575;
  unsigned char D.46142;
  guint8 * code.6576;
  unsigned char D.46144;
  guint8 * code.6577;
  guint8 * code.6578;
  guint8 * code.6579;
  guint8 * code.6580;
  unsigned char D.46156;
  guint8 * code.6581;
  unsigned char D.46158;
  guint8 * code.6582;
  unsigned char D.46160;
  guint8 * code.6583;
  unsigned char D.46162;
  guint8 * code.6584;
  guint8 * code.6585;
  guint8 * code.6586;
  guint8 * code.6587;
  guint8 * code.6588;
  guint8 * code.6589;
  guint8 * code.6590;
  guint8 * code.6591;
  unsigned char D.46179;
  guint8 * code.6592;
  unsigned char D.46181;
  guint8 * code.6593;
  unsigned char D.46183;
  guint8 * code.6594;
  unsigned char D.46185;
  guint8 * code.6595;
  guint8 * code.6596;
  guint8 * code.6597;
  guint8 * code.6598;
  unsigned char D.46197;
  guint8 * code.6599;
  unsigned char D.46199;
  guint8 * code.6600;
  unsigned char D.46201;
  guint8 * code.6601;
  unsigned char D.46203;
  guint8 * code.6602;
  guint8 * code.6603;
  guint8 * code.6604;
  guint8 * code.6605;
  guint8 * code.6606;
  guint8 * code.6607;
  guint8 * code.6608;
  guint8 * code.6609;
  guint8 * code.6610;
  guint8 * code.6611;
  unsigned char D.46222;
  guint8 * code.6612;
  unsigned char D.46224;
  guint8 * code.6613;
  unsigned char D.46226;
  guint8 * code.6614;
  unsigned char D.46228;
  guint8 * code.6615;
  guint8 * code.6616;
  guint8 * code.6617;
  guint8 * code.6618;
  unsigned char D.46240;
  guint8 * code.6619;
  unsigned char D.46242;
  guint8 * code.6620;
  unsigned char D.46244;
  guint8 * code.6621;
  unsigned char D.46246;
  guint8 * code.6622;
  guint8 * code.6623;
  guint8 * code.6624;
  guint8 * code.6625;
  short unsigned int D.46251;
  int D.46252;
  guint8 * code.6626;
  guint8 * code.6627;
  guint8 * code.6628;
  guint8 * code.6629;
  guint8 * code.6630;
  guint8 * code.6631;
  guint8 * code.6632;
  guint8 * code.6633;
  guint8 * code.6634;
  guint8 * code.6635;
  guint8 * code.6636;
  guint8 * code.6637;
  guint8 * code.6638;
  guint8 * code.6639;
  guint8 * code.6640;
  guint8 * code.6641;
  int D.46294;
  int D.46295;
  int D.46296;
  signed char D.46297;
  signed char D.46298;
  signed char D.46299;
  unsigned char D.46300;
  guint8 * code.6642;
  guint8 * code.6643;
  guint8 * code.6644;
  guint8 * code.6645;
  guint8 * code.6646;
  guint8 * code.6647;
  guint8 * code.6648;
  guint8 * code.6649;
  guint8 * code.6650;
  guint8 * code.6651;
  guint8 * code.6652;
  guint8 * code.6653;
  guint8 * code.6654;
  guint8 * code.6655;
  guint8 * code.6656;
  guint8 * code.6657;
  guint8 * code.6658;
  guint8 * code.6659;
  guint8 * code.6660;
  guint8 * code.6661;
  guint8 * code.6662;
  guint8 * code.6663;
  guint8 * code.6664;
  guint8 * code.6665;
  guint8 * code.6666;
  guint8 * code.6667;
  guint8 * code.6668;
  guint8 * code.6669;
  guint8 * code.6670;
  guint8 * code.6671;
  guint8 * code.6672;
  guint8 * code.6673;
  guint8 * code.6674;
  guint8 * code.6675;
  guint8 * code.6676;
  guint8 * code.6677;
  guint8 * code.6678;
  guint8 * code.6679;
  guint8 * code.6680;
  guint8 * code.6681;
  guint8 * code.6682;
  guint8 * code.6683;
  guint8 * code.6684;
  guint8 * code.6685;
  unsigned char D.46353;
  guint8 * code.6686;
  unsigned char D.46355;
  guint8 * code.6687;
  unsigned char D.46357;
  guint8 * code.6688;
  unsigned char D.46359;
  guint8 * code.6689;
  guint8 * code.6690;
  guint8 * code.6691;
  guint8 * code.6692;
  unsigned char D.46371;
  guint8 * code.6693;
  unsigned char D.46373;
  guint8 * code.6694;
  unsigned char D.46375;
  guint8 * code.6695;
  unsigned char D.46377;
  guint8 * code.6696;
  guint8 * code.6697;
  guint8 * code.6698;
  guint8 * code.6699;
  guint8 * code.6700;
  guint8 * code.6701;
  guint8 * code.6702;
  guint8 * code.6703;
  guint8 * code.6704;
  guint8 * code.6705;
  unsigned char D.46396;
  guint8 * code.6706;
  unsigned char D.46398;
  guint8 * code.6707;
  unsigned char D.46400;
  guint8 * code.6708;
  unsigned char D.46402;
  guint8 * code.6709;
  guint8 * code.6710;
  guint8 * code.6711;
  guint8 * code.6712;
  unsigned char D.46414;
  guint8 * code.6713;
  unsigned char D.46416;
  guint8 * code.6714;
  unsigned char D.46418;
  guint8 * code.6715;
  unsigned char D.46420;
  guint8 * code.6716;
  guint8 * code.6717;
  guint8 * code.6718;
  guint8 * code.6719;
  guint8 * code.6720;
  guint8 * code.6721;
  guint8 * code.6722;
  guint8 * code.6723;
  guint8 * code.6724;
  guint8 * code.6725;
  guint8 * code.6726;
  guint8 * code.6727;
  unsigned char D.46441;
  guint8 * code.6728;
  unsigned char D.46443;
  guint8 * code.6729;
  unsigned char D.46445;
  guint8 * code.6730;
  unsigned char D.46447;
  guint8 * code.6731;
  guint8 * code.6732;
  guint8 * code.6733;
  guint8 * code.6734;
  unsigned char D.46459;
  guint8 * code.6735;
  unsigned char D.46461;
  guint8 * code.6736;
  unsigned char D.46463;
  guint8 * code.6737;
  unsigned char D.46465;
  guint8 * code.6738;
  guint8 * code.6739;
  guint8 * code.6740;
  guint8 * code.6741;
  guint8 * code.6742;
  guint8 * code.6743;
  guint8 * code.6744;
  guint8 * code.6745;
  guint8 * code.6746;
  guint8 * code.6747;
  unsigned char D.46484;
  guint8 * code.6748;
  unsigned char D.46486;
  guint8 * code.6749;
  unsigned char D.46488;
  guint8 * code.6750;
  unsigned char D.46490;
  guint8 * code.6751;
  guint8 * code.6752;
  guint8 * code.6753;
  guint8 * code.6754;
  unsigned char D.46502;
  guint8 * code.6755;
  unsigned char D.46504;
  guint8 * code.6756;
  unsigned char D.46506;
  guint8 * code.6757;
  unsigned char D.46508;
  guint8 * code.6758;
  guint8 * code.6759;
  guint8 * code.6760;
  guint8 * code.6761;
  guint8 * code.6762;
  guint8 * code.6763;
  guint8 * code.6764;
  guint8 * code.6765;
  guint8 * code.6766;
  guint8 * code.6767;
  guint8 * code.6768;
  guint8 * code.6769;
  guint8 * code.6770;
  guint8 * code.6771;
  guint8 * code.6772;
  guint8 * code.6773;
  guint8 * code.6774;
  guint8 * code.6775;
  guint8 * code.6776;
  guint8 * code.6777;
  guint8 * code.6778;
  guint8 * code.6779;
  guint8 * code.6780;
  guint8 * code.6781;
  guint8 * code.6782;
  guint8 * code.6783;
  guint8 * code.6784;
  guint8 * code.6785;
  guint8 * code.6786;
  guint8 * code.6787;
  guint8 * code.6788;
  guint8 * code.6789;
  guint8 * code.6790;
  guint8 * code.6791;
  struct MonoMethodVar * D.46545;
  unsigned int D.46546;
  unsigned int D.46547;
  struct MonoMethodVar * D.46548;
  int D.46549;
  struct GSList * D.46552;
  struct MonoMemPool * D.46553;
  struct GSList * D.46554;
  const char * D.46555;
  unsigned int D.46556;
  unsigned int D.46557;
  _Bool D.46558;
  long int D.46559;
  long int D.46560;
  const char * D.46563;
  struct MonoInst * ins;
  struct MonoCallInst * call;
  guint offset;
  guint8 * code;
  int max_len;
  int cpos;
  static const char __PRETTY_FUNCTION__[29] = "mono_arch_output_basic_block";

  D.31409 = cfg->native_code;
  D.31410 = cfg->code_len;
  code = D.31409 + D.31410;
  D.31411 = cfg->opt;
  D.31412 = D.31411 & 8192;
  if (D.31412 != 0) goto <D.31413>; else goto <D.31414>;
  <D.31413>:
  {
    int pad;
    int align;

    align = 8;
    D.31415 = bb->loop_body_start;
    if (D.31415 != 0) goto <D.31416>; else goto <D.31417>;
    <D.31416>:
    D.31418 = bb->nesting;
    if (D.31418 != 0) goto <D.31419>; else goto <D.31420>;
    <D.31419>:
    D.31410 = cfg->code_len;
    D.31421 = align + -1;
    D.31422 = (unsigned int) D.31421;
    D.31423 = D.31410 & D.31422;
    pad = (int) D.31423;
    if (pad != 0) goto <D.31424>; else goto <D.31425>;
    <D.31424>:
    pad = align - pad;
    switch (pad) <default: <D.24791>, case 1: <D.24783>, case 2: <D.24785>, case 3: <D.24786>, case 4: <D.24787>, case 5: <D.24788>, case 6: <D.24789>, case 7: <D.24790>>
    <D.24783>:
    code.387 = code;
    code = code.387 + 1;
    *code.387 = 144;
    goto <D.24784>;
    <D.24785>:
    code.388 = code;
    code = code.388 + 1;
    *code.388 = 139;
    code.389 = code;
    code = code.389 + 1;
    *code.389 = 192;
    goto <D.24784>;
    <D.24786>:
    code.390 = code;
    code = code.390 + 1;
    *code.390 = 141;
    code.391 = code;
    code = code.391 + 1;
    *code.391 = 109;
    code.392 = code;
    code = code.392 + 1;
    *code.392 = 0;
    goto <D.24784>;
    <D.24787>:
    code.393 = code;
    code = code.393 + 1;
    *code.393 = 141;
    code.394 = code;
    code = code.394 + 1;
    *code.394 = 100;
    code.395 = code;
    code = code.395 + 1;
    *code.395 = 36;
    code.396 = code;
    code = code.396 + 1;
    *code.396 = 0;
    goto <D.24784>;
    <D.24788>:
    code.397 = code;
    code = code.397 + 1;
    *code.397 = 141;
    code.398 = code;
    code = code.398 + 1;
    *code.398 = 100;
    code.399 = code;
    code = code.399 + 1;
    *code.399 = 36;
    code.400 = code;
    code = code.400 + 1;
    *code.400 = 0;
    code.401 = code;
    code = code.401 + 1;
    *code.401 = 144;
    goto <D.24784>;
    <D.24789>:
    code.402 = code;
    code = code.402 + 1;
    *code.402 = 141;
    code.403 = code;
    code = code.403 + 1;
    *code.403 = 173;
    code.404 = code;
    code = code.404 + 1;
    *code.404 = 0;
    code.405 = code;
    code = code.405 + 1;
    *code.405 = 0;
    code.406 = code;
    code = code.406 + 1;
    *code.406 = 0;
    code.407 = code;
    code = code.407 + 1;
    *code.407 = 0;
    goto <D.24784>;
    <D.24790>:
    code.408 = code;
    code = code.408 + 1;
    *code.408 = 141;
    code.409 = code;
    code = code.409 + 1;
    *code.409 = 164;
    code.410 = code;
    code = code.410 + 1;
    *code.410 = 36;
    code.411 = code;
    code = code.411 + 1;
    *code.411 = 0;
    code.412 = code;
    code = code.412 + 1;
    *code.412 = 0;
    code.413 = code;
    code = code.413 + 1;
    *code.413 = 0;
    code.414 = code;
    code = code.414 + 1;
    *code.414 = 0;
    goto <D.24784>;
    <D.24791>:
    __assert_fail ("0", "mini-x86.c", 2613, &__PRETTY_FUNCTION__);
    <D.24784>:
    D.31410 = cfg->code_len;
    pad.415 = (unsigned int) pad;
    D.31455 = D.31410 + pad.415;
    cfg->code_len = D.31455;
    D.31410 = cfg->code_len;
    D.31456 = (int) D.31410;
    bb->native_offset = D.31456;
    <D.31425>:
    <D.31420>:
    <D.31417>:
  }
  <D.31414>:
  D.31457 = cfg->verbose_level;
  if (D.31457 > 2) goto <D.31458>; else goto <D.31459>;
  <D.31458>:
  D.31460 = bb->native_offset;
  D.31461 = bb->block_num;
  monoeg_g_print ("Basic block %d starting at offset 0x%x\n", D.31461, D.31460);
  <D.31459>:
  cpos = bb->max_offset;
  D.31462 = cfg->prof_options;
  D.31463 = D.31462 & 8192;
  if (D.31463 != 0) goto <D.31464>; else goto <D.31465>;
  <D.31464>:
  {
    struct MonoProfileCoverageInfo * cov;

    cov = cfg->coverage_info;
    D.31466 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.31467 = D.31466 & 64;
    D.31468 = D.31467 != 0;
    D.31469 = (long int) D.31468;
    D.31470 = __builtin_expect (D.31469, 0);
    if (D.31470 != 0) goto <D.31471>; else goto <D.31472>;
    <D.31471>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2642, "!cfg->compile_aot");
    <D.31472>:
    cpos = cpos + 6;
    D.31473 = bb->dfn;
    D.31474 = bb->cil_code;
    cov->data[D.31473].cil_code = D.31474;
    code.416 = code;
    code = code.416 + 1;
    *code.416 = 255;
    code.417 = code;
    code = code.417 + 1;
    *code.417 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          D.31473 = bb->dfn;
          D.31477 = &cov->data[D.31473].count;
          D.31478 = (int) D.31477;
          imb.val = D.31478;
          code.418 = code;
          code = code.418 + 1;
          D.31480 = imb.b[0];
          *code.418 = D.31480;
          code.419 = code;
          code = code.419 + 1;
          D.31482 = imb.b[1];
          *code.419 = D.31482;
          code.420 = code;
          code = code.420 + 1;
          D.31484 = imb.b[2];
          *code.420 = D.31484;
          code.421 = code;
          code = code.421 + 1;
          D.31486 = imb.b[3];
          *code.421 = D.31486;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
  <D.31465>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  offset = (guint) D.31489;
  mono_debug_open_block (cfg, bb, offset);
  mono_break_at_bb_method.423 = mono_break_at_bb_method;
  if (mono_break_at_bb_method.423 != 0B) goto <D.31491>; else goto <D.31492>;
  <D.31491>:
  D.31493 = cfg->method;
  mono_break_at_bb_method.423 = mono_break_at_bb_method;
  D.31494 = mono_method_desc_full_match (mono_break_at_bb_method.423, D.31493);
  if (D.31494 != 0) goto <D.31495>; else goto <D.31496>;
  <D.31495>:
  D.31461 = bb->block_num;
  mono_break_at_bb_bb_num.424 = mono_break_at_bb_bb_num;
  if (D.31461 == mono_break_at_bb_bb_num.424) goto <D.31498>; else goto <D.31499>;
  <D.31498>:
  code.425 = code;
  code = code.425 + 1;
  *code.425 = 204;
  <D.31499>:
  <D.31496>:
  <D.31492>:
  ins = bb->code;
  goto <D.28464>;
  <D.28463>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  offset = (guint) D.31489;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.31503 = D.31502 + -313;
  D.31504 = x86_desc_idx[D.31503];
  D.31505 = (sizetype) D.31504;
  D.31506 = D.31505 + 4;
  D.31507 = &x86_desc + D.31506;
  D.31508 = *D.31507;
  max_len = (int) D.31508;
  D.31509 = cfg->code_size;
  max_len.426 = (unsigned int) max_len;
  D.31511 = D.31509 - max_len.426;
  D.31512 = D.31511 + 4294967280;
  D.31513 = D.31512 < offset;
  D.31514 = (long int) D.31513;
  D.31515 = __builtin_expect (D.31514, 0);
  if (D.31515 != 0) goto <D.31516>; else goto <D.31517>;
  <D.31516>:
  D.31509 = cfg->code_size;
  D.31518 = D.31509 * 2;
  cfg->code_size = D.31518;
  D.31519 = mono_realloc_native_code (cfg);
  cfg->native_code = D.31519;
  D.31409 = cfg->native_code;
  code = D.31409 + offset;
  D.31520 = cfg->stat_code_reallocs;
  D.31521 = D.31520 + 1;
  cfg->stat_code_reallocs = D.31521;
  <D.31517>:
  D.31522 = cfg->debug_info;
  if (D.31522 != 0B) goto <D.31523>; else goto <D.31524>;
  <D.31523>:
  mono_debug_record_line_number (cfg, ins, offset);
  <D.31524>:
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  switch (D.31502) <default: <D.28462>, case 316: <D.25061>, case 317: <D.25060>, case 318: <D.25059>, case 322: <D.24932>, case 323: <D.24934>, case 324: <D.26358>, case 326: <D.24933>, case 327: <D.24935>, case 338: <D.25569>, case 339: <D.25581>, case 340: <D.25490>, case 341: <D.25066>, case 343: <D.25511>, case 344: <D.25520>, case 345: <D.25529>, case 346: <D.25512>, case 347: <D.25521>, case 348: <D.25530>, case 349: <D.25507>, case 350: <D.25516>, case 351: <D.25525>, case 352: <D.25508>, case 353: <D.25517>, case 354: <D.25526>, case 355: <D.25509>, case 356: <D.25518>, case 357: <D.25527>, case 358: <D.25510>, case 359: <D.25519>, case 360: <D.25528>, case 362: <D.25413>, case 364: <D.25866>, case 365: <D.25852>, case 369: <D.25643>, case 371: <D.25597>, case 372: <D.25601>, case 373: <D.25494>, case 374: <D.24855>, case 375: <D.24837>, case 376: <D.24846>, case 377: <D.24856>, case 379: <D.25886>, case 380: <D.25878>, case 381: <D.28369>, case 382: <D.28382>, case 383: <D.28386>, case 384: <D.24825>, case 385: <D.24803>, case 386: <D.24814>, case 387: <D.24826>, case 389: <D.28370>, case 391: <D.24891>, case 392: <D.24907>, case 393: <D.24902>, case 394: <D.24917>, case 395: <D.24912>, case 396: <D.24892>, case 397: <D.24893>, case 399: <D.25890>, case 400: <D.25882>, case 401: <D.28374>, case 402: <D.28378>, case 421: <D.24877>, case 422: <D.24885>, case 423: <D.24888>, case 424: <D.24878>, case 425: <D.24870>, case 427: <D.24865>, case 428: <D.25433>, case 430: <D.26204>, case 433: <D.25078>, case 434: <D.25094>, case 435: <D.25289>, case 436: <D.25126>, case 440: <D.25105>, case 441: <D.25137>, case 442: <D.25143>, case 443: <D.25155>, case 444: <D.25150>, case 445: <D.25152>, case 446: <D.25644>, case 448: <D.25439>, case 449: <D.25058>, case 450: <D.25654>, case 451: <D.25657>, case 452: <D.25658>, case 453: <D.25655>, case 454: <D.25656>, case 455: <D.25666>, case 456: <D.25672>, case 457: <D.25670>, case 458: <D.25674>, case 459: <D.25668>, case 460: <D.25667>, case 461: <D.25673>, case 462: <D.25671>, case 463: <D.25675>, case 464: <D.25669>, case 465: <D.25721>, case 466: <D.25722>, case 467: <D.25723>, case 468: <D.25724>, case 469: <D.25676>, case 470: <D.25682>, case 471: <D.25680>, case 472: <D.25684>, case 473: <D.25678>, case 474: <D.25677>, case 475: <D.25683>, case 476: <D.25681>, case 477: <D.25685>, case 478: <D.25679>, case 479: <D.25760>, case 480: <D.25761>, case 481: <D.25762>, case 482: <D.25763>, case 493: <D.25157>, case 494: <D.25194>, case 495: <D.25231>, case 509: <D.26102>, case 548: <D.25268>, case 549: <D.25274>, case 550: <D.25280>, case 565: <D.26009>, case 566: <D.26025>, case 567: <D.26041>, case 568: <D.26103>, case 569: <D.25074>, case 570: <D.25090>, case 571: <D.25288>, case 572: <D.25110>, case 573: <D.25118>, case 574: <D.25111>, case 575: <D.25119>, case 576: <D.25104>, case 577: <D.25136>, case 578: <D.25142>, case 579: <D.25148>, case 580: <D.25149>, case 581: <D.25154>, case 582: <D.25287>, case 583: <D.25286>, case 584: <D.24922>, case 585: <D.24925>, case 588: <D.25894>, case 589: <D.25910>, case 592: <D.25920>, case 594: <D.24930>, case 595: <D.24928>, case 601: <D.25328>, case 602: <D.25364>, case 623: <D.25076>, case 624: <D.25084>, case 625: <D.25092>, case 626: <D.25100>, case 627: <D.25073>, case 628: <D.25089>, case 629: <D.25079>, case 630: <D.25095>, case 631: <D.25290>, case 634: <D.25128>, case 636: <D.25106>, case 637: <D.25138>, case 638: <D.25144>, case 639: <D.25156>, case 640: <D.25151>, case 641: <D.25153>, case 642: <D.25660>, case 643: <D.25663>, case 644: <D.25664>, case 645: <D.25661>, case 646: <D.25662>, case 647: <D.25649>, case 648: <D.25650>, case 649: <D.25651>, case 650: <D.25652>, case 651: <D.25653>, case 652: <D.25799>, case 653: <D.25805>, case 654: <D.25803>, case 655: <D.25807>, case 656: <D.25801>, case 657: <D.25800>, case 658: <D.25806>, case 659: <D.25804>, case 660: <D.25808>, case 661: <D.25802>, case 662: <D.26891>, case 663: <D.27554>, case 664: <D.27357>, case 665: <D.27757>, case 666: <D.27127>, case 667: <D.26991>, case 668: <D.27690>, case 669: <D.27358>, case 670: <D.27860>, case 671: <D.27194>, case 672: <D.26205>, case 673: <D.26207>, case 674: <D.26209>, case 675: <D.26211>, case 677: <D.26323>, case 679: <D.26213>, case 681: <D.25959>, case 682: <D.25961>, case 683: <D.25963>, case 684: <D.25965>, case 685: <D.25946>, case 689: <D.25962>, case 690: <D.25960>, case 691: <D.25964>, case 718: <D.26362>, case 719: <D.26689>, case 720: <D.26690>, case 721: <D.26460>, case 722: <D.26461>, case 723: <D.26363>, case 724: <D.26791>, case 725: <D.26589>, case 732: <D.27963>, case 735: <D.25417>, case 736: <D.25415>, case 738: <D.25420>, case 739: <D.25605>, case 740: <D.25613>, case 741: <D.25633>, case 742: <D.25623>, case 743: <D.24795>, case 744: <D.24797>, case 745: <D.26318>, case 746: <D.26320>, case 751: <D.26317>, case 752: <D.26319>, case 755: <D.25075>, case 756: <D.25083>, case 757: <D.25091>, case 758: <D.25099>, case 759: <D.25072>, case 760: <D.25077>, case 761: <D.25088>, case 762: <D.25093>, case 763: <D.25648>, case 764: <D.24923>, case 765: <D.24926>, case 770: <D.25659>, case 778: <D.26214>, case 779: <D.26216>, case 780: <D.26218>, case 781: <D.26219>, case 782: <D.26313>, case 783: <D.26315>, case 784: <D.26316>, case 794: <D.28138>, case 795: <D.28035>, case 796: <D.28036>, case 797: <D.28037>, case 798: <D.28038>, case 799: <D.25419>, case 800: <D.25062>, case 801: <D.25063>, case 802: <D.25064>, case 803: <D.25065>, case 804: <D.28204>, case 805: <D.28205>, case 806: <D.28206>, case 807: <D.28207>, case 808: <D.28208>, case 809: <D.28209>, case 810: <D.28210>, case 811: <D.28211>, case 812: <D.28212>, case 813: <D.28213>, case 814: <D.28214>, case 815: <D.28219>, case 816: <D.28220>, case 817: <D.28218>, case 818: <D.28222>, case 819: <D.28221>, case 820: <D.28216>, case 821: <D.28215>, case 822: <D.28217>, case 823: <D.28223>, case 824: <D.28224>, case 825: <D.28225>, case 826: <D.28226>, case 827: <D.28227>, case 828: <D.28228>, case 829: <D.28229>, case 830: <D.28230>, case 831: <D.28231>, case 832: <D.28232>, case 833: <D.28233>, case 834: <D.28234>, case 835: <D.28235>, case 836: <D.28236>, case 837: <D.28237>, case 838: <D.28238>, case 839: <D.28241>, case 840: <D.28242>, case 841: <D.28240>, case 842: <D.28243>, case 843: <D.28239>, case 844: <D.28244>, case 845: <D.28245>, case 846: <D.28246>, case 847: <D.28247>, case 848: <D.28248>, case 849: <D.28249>, case 850: <D.28250>, case 851: <D.28251>, case 852: <D.28252>, case 853: <D.28253>, case 854: <D.28254>, case 855: <D.28255>, case 856: <D.28256>, case 857: <D.28257>, case 858: <D.28258>, case 859: <D.28259>, case 860: <D.28260>, case 861: <D.28261>, case 862: <D.28262>, case 863: <D.28263>, case 864: <D.28264>, case 865: <D.28265>, case 866: <D.28266>, case 867: <D.28267>, case 868: <D.28268>, case 869: <D.28269>, case 870: <D.28270>, case 871: <D.28271>, case 872: <D.28272>, case 873: <D.28273>, case 874: <D.28274>, case 875: <D.28275>, case 876: <D.28276>, case 877: <D.28277>, case 878: <D.28278>, case 879: <D.28279>, case 880: <D.28280>, case 881: <D.28281>, case 882: <D.28282>, case 883: <D.28283>, case 884: <D.28284>, case 885: <D.28285>, case 886: <D.28286>, case 887: <D.28287>, case 888: <D.28288>, case 889: <D.28289>, case 890: <D.28290>, case 891: <D.28291>, case 892: <D.28292>, case 893: <D.28293>, case 894: <D.28294>, case 895: <D.28299>, case 896: <D.28295>, case 897: <D.28301>, case 898: <D.28297>, case 899: <D.28300>, case 900: <D.28296>, case 901: <D.28302>, case 902: <D.28298>, case 903: <D.28303>, case 904: <D.28304>, case 905: <D.28305>, case 906: <D.28306>, case 907: <D.28307>, case 908: <D.28308>, case 909: <D.28309>, case 910: <D.28310>, case 911: <D.28311>, case 912: <D.28312>, case 913: <D.28313>, case 914: <D.28314>, case 915: <D.28315>, case 916: <D.28320>, case 917: <D.28321>, case 918: <D.28316>, case 919: <D.28317>, case 920: <D.28318>, case 921: <D.28319>, case 922: <D.28322>, case 923: <D.28323>, case 924: <D.28325>, case 925: <D.28396>, case 926: <D.28329>, case 927: <D.28330>, case 928: <D.28326>, case 929: <D.28327>, case 930: <D.28332>, case 937: <D.28342>, case 938: <D.28343>, case 939: <D.28344>, case 940: <D.28348>, case 941: <D.28349>, case 942: <D.28359>, case 944: <D.28408>, case 945: <D.28415>, case 946: <D.28324>, case 947: <D.28425>, case 948: <D.28431>, case 949: <D.28432>, case 950: <D.28433>, case 952: <D.28440>, case 953: <D.28390>, case 954: <D.28447>, case 955: <D.28448>, case 956: <D.28449>, case 957: <D.28450>, case 958: <D.28451>, case 959: <D.28452>, case 960: <D.28453>, case 961: <D.28454>, case 962: <D.28394>, case 963: <D.28395>, case 965: <D.28050>, case 966: <D.28065>, case 969: <D.28080>, case 975: <D.28039>, case 976: <D.28134>, case 978: <D.25842>, case 979: <D.25843>, case 980: <D.25844>, case 981: <D.25845>, case 982: <D.25846>, case 983: <D.25847>, case 984: <D.25848>, case 985: <D.25849>, case 986: <D.25850>, case 987: <D.25851>, case 998: <D.28455>, case 999: <D.28456>, case 1000: <D.28458>, case 1001: <D.28459>, case 1002: <D.28461>, case 1003: <D.28460>, case 1004: <D.28457>, case 1005: <D.24963>, case 1006: <D.24939>, case 1007: <D.24943>, case 1008: <D.24959>, case 1009: <D.24951>, case 1010: <D.24955>, case 1011: <D.25036>, case 1012: <D.25032>, case 1013: <D.25041>, case 1014: <D.25037>, case 1015: <D.24964>, case 1016: <D.24976>, case 1017: <D.24988>, case 1018: <D.24996>, case 1019: <D.25004>, case 1020: <D.25012>, case 1021: <D.25016>, case 1022: <D.25020>, case 1023: <D.25024>, case 1024: <D.25028>, case 1026: <D.24972>, case 1027: <D.24984>, case 1028: <D.25042>, case 1029: <D.25046>, case 1030: <D.25050>, case 1031: <D.25054>, case 1032: <D.25541>, case 1033: <D.25538>, case 1034: <D.25537>, case 1035: <D.25545>, case 1036: <D.25429>, case 1037: <D.25561>, case 1038: <D.25564>, case 1039: <D.25568>, case 1040: <D.26321>, case 1041: <D.25932>, case 1042: <D.25939>, case 1043: <D.24798>, case 1044: <D.24799>, case 1045: <D.26322>>
  <D.24795>:
  code.427 = code;
  code = code.427 + 1;
  *code.427 = 247;
  code.428 = code;
  code = code.428 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.31530 = D.31529 | -24;
  D.31531 = (unsigned char) D.31530;
  *code.428 = D.31531;
  goto <D.24796>;
  <D.24797>:
  code.429 = code;
  code = code.429 + 1;
  *code.429 = 247;
  code.430 = code;
  code = code.430 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.31534 = D.31529 | -32;
  D.31535 = (unsigned char) D.31534;
  *code.430 = D.31535;
  goto <D.24796>;
  <D.24798>:
  <D.24799>:
  code.431 = code;
  code = code.431 + 1;
  *code.431 = 15;
  if (1 != 0) goto <D.31537>; else goto <D.31538>;
  <D.31537>:
  code.432 = code;
  code = code.432 + 1;
  D.31501 = ins->opcode;
  D.31540 = D.31501 != 1043;
  D.31541 = (int) D.31540;
  D.31542 = x86_cc_signed_map[D.31541];
  D.31543 = D.31542 + 32;
  *code.432 = D.31543;
  goto <D.31544>;
  <D.31538>:
  code.433 = code;
  code = code.433 + 1;
  D.31501 = ins->opcode;
  D.31540 = D.31501 != 1043;
  D.31541 = (int) D.31540;
  D.31546 = x86_cc_unsigned_map[D.31541];
  D.31547 = D.31546 + 32;
  *code.433 = D.31547;
  <D.31544>:
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.31549>; else goto <D.31550>;
  <D.31549>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31552>; else goto <D.31553>;
  <D.31552>:
  code.434 = code;
  code = code.434 + 1;
  *code.434 = 4;
  code.435 = code;
  code = code.435 + 1;
  *code.435 = 36;
  goto <D.31556>;
  <D.31553>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31559>; else goto <D.31560>;
  <D.31559>:
  code.436 = code;
  code = code.436 + 1;
  *code.436 = 68;
  code.437 = code;
  code = code.437 + 1;
  *code.437 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31564>;
  <D.31560>:
  code.438 = code;
  code = code.438 + 1;
  *code.438 = 132;
  code.439 = code;
  code = code.439 + 1;
  *code.439 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.440 = code;
        code = code.440 + 1;
        D.31568 = imb.b[0];
        *code.440 = D.31568;
        code.441 = code;
        code = code.441 + 1;
        D.31570 = imb.b[1];
        *code.441 = D.31570;
        code.442 = code;
        code = code.442 + 1;
        D.31572 = imb.b[2];
        *code.442 = D.31572;
        code.443 = code;
        code = code.443 + 1;
        D.31574 = imb.b[3];
        *code.443 = D.31574;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31564>:
  <D.31556>:
  goto <D.24801>;
  <D.31550>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31575>; else goto <D.31576>;
  <D.31575>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.31577>; else goto <D.31578>;
  <D.31577>:
  code.444 = code;
  code = code.444 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.444 = D.31581;
  goto <D.24801>;
  <D.31578>:
  <D.31576>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31582>; else goto <D.31583>;
  <D.31582>:
  code.445 = code;
  code = code.445 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.445 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31589>;
  <D.31583>:
  code.446 = code;
  code = code.446 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.446 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.447 = code;
        code = code.447 + 1;
        D.31594 = imb.b[0];
        *code.447 = D.31594;
        code.448 = code;
        code = code.448 + 1;
        D.31596 = imb.b[1];
        *code.448 = D.31596;
        code.449 = code;
        code = code.449 + 1;
        D.31598 = imb.b[2];
        *code.449 = D.31598;
        code.450 = code;
        code = code.450 + 1;
        D.31600 = imb.b[3];
        *code.450 = D.31600;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31589>:
  <D.24801>:
  goto <D.24796>;
  <D.24803>:
  if (1 != 0) goto <D.31601>; else goto <D.31602>;
  <D.31601>:
  code.451 = code;
  code = code.451 + 1;
  *code.451 = 198;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31605>; else goto <D.31606>;
  <D.31605>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31607>; else goto <D.31608>;
  <D.31607>:
  code.452 = code;
  code = code.452 + 1;
  *code.452 = 4;
  code.453 = code;
  code = code.453 + 1;
  *code.453 = 36;
  goto <D.31611>;
  <D.31608>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31612>; else goto <D.31613>;
  <D.31612>:
  code.454 = code;
  code = code.454 + 1;
  *code.454 = 68;
  code.455 = code;
  code = code.455 + 1;
  *code.455 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31616>;
  <D.31613>:
  code.456 = code;
  code = code.456 + 1;
  *code.456 = 132;
  code.457 = code;
  code = code.457 + 1;
  *code.457 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.458 = code;
        code = code.458 + 1;
        D.31620 = imb.b[0];
        *code.458 = D.31620;
        code.459 = code;
        code = code.459 + 1;
        D.31622 = imb.b[1];
        *code.459 = D.31622;
        code.460 = code;
        code = code.460 + 1;
        D.31624 = imb.b[2];
        *code.460 = D.31624;
        code.461 = code;
        code = code.461 + 1;
        D.31626 = imb.b[3];
        *code.461 = D.31626;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31616>:
  <D.31611>:
  goto <D.24805>;
  <D.31606>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31627>; else goto <D.31628>;
  <D.31627>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31629>; else goto <D.31630>;
  <D.31629>:
  code.462 = code;
  code = code.462 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.462 = D.31633;
  goto <D.24805>;
  <D.31630>:
  <D.31628>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31634>; else goto <D.31635>;
  <D.31634>:
  code.463 = code;
  code = code.463 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.463 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31641>;
  <D.31635>:
  code.464 = code;
  code = code.464 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.464 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.465 = code;
        code = code.465 + 1;
        D.31646 = imb.b[0];
        *code.465 = D.31646;
        code.466 = code;
        code = code.466 + 1;
        D.31648 = imb.b[1];
        *code.466 = D.31648;
        code.467 = code;
        code = code.467 + 1;
        D.31650 = imb.b[2];
        *code.467 = D.31650;
        code.468 = code;
        code = code.468 + 1;
        D.31652 = imb.b[3];
        *code.468 = D.31652;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31641>:
  <D.24805>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.31655>;
  <D.31602>:
  if (0 != 0) goto <D.31656>; else goto <D.31657>;
  <D.31656>:
  code.469 = code;
  code = code.469 + 1;
  *code.469 = 102;
  code.470 = code;
  code = code.470 + 1;
  *code.470 = 199;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31660>; else goto <D.31661>;
  <D.31660>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31662>; else goto <D.31663>;
  <D.31662>:
  code.471 = code;
  code = code.471 + 1;
  *code.471 = 4;
  code.472 = code;
  code = code.472 + 1;
  *code.472 = 36;
  goto <D.31666>;
  <D.31663>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31667>; else goto <D.31668>;
  <D.31667>:
  code.473 = code;
  code = code.473 + 1;
  *code.473 = 68;
  code.474 = code;
  code = code.474 + 1;
  *code.474 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31671>;
  <D.31668>:
  code.475 = code;
  code = code.475 + 1;
  *code.475 = 132;
  code.476 = code;
  code = code.476 + 1;
  *code.476 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.477 = code;
        code = code.477 + 1;
        D.31675 = imb.b[0];
        *code.477 = D.31675;
        code.478 = code;
        code = code.478 + 1;
        D.31677 = imb.b[1];
        *code.478 = D.31677;
        code.479 = code;
        code = code.479 + 1;
        D.31679 = imb.b[2];
        *code.479 = D.31679;
        code.480 = code;
        code = code.480 + 1;
        D.31681 = imb.b[3];
        *code.480 = D.31681;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31671>:
  <D.31666>:
  goto <D.24808>;
  <D.31661>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31682>; else goto <D.31683>;
  <D.31682>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31684>; else goto <D.31685>;
  <D.31684>:
  code.481 = code;
  code = code.481 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.481 = D.31633;
  goto <D.24808>;
  <D.31685>:
  <D.31683>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31687>; else goto <D.31688>;
  <D.31687>:
  code.482 = code;
  code = code.482 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.482 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31690>;
  <D.31688>:
  code.483 = code;
  code = code.483 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.483 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.484 = code;
        code = code.484 + 1;
        D.31693 = imb.b[0];
        *code.484 = D.31693;
        code.485 = code;
        code = code.485 + 1;
        D.31695 = imb.b[1];
        *code.485 = D.31695;
        code.486 = code;
        code = code.486 + 1;
        D.31697 = imb.b[2];
        *code.486 = D.31697;
        code.487 = code;
        code = code.487 + 1;
        D.31699 = imb.b[3];
        *code.487 = D.31699;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31690>:
  <D.24808>:
  D.31653 = ins->data.op[1].const_val;
  D.31700 = (short int) D.31653;
  MEM[(short int *)code] = D.31700;
  code = code + 2;
  goto <D.31701>;
  <D.31657>:
  code.488 = code;
  code = code.488 + 1;
  *code.488 = 199;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31703>; else goto <D.31704>;
  <D.31703>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31705>; else goto <D.31706>;
  <D.31705>:
  code.489 = code;
  code = code.489 + 1;
  *code.489 = 4;
  code.490 = code;
  code = code.490 + 1;
  *code.490 = 36;
  goto <D.31709>;
  <D.31706>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31710>; else goto <D.31711>;
  <D.31710>:
  code.491 = code;
  code = code.491 + 1;
  *code.491 = 68;
  code.492 = code;
  code = code.492 + 1;
  *code.492 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31714>;
  <D.31711>:
  code.493 = code;
  code = code.493 + 1;
  *code.493 = 132;
  code.494 = code;
  code = code.494 + 1;
  *code.494 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.495 = code;
        code = code.495 + 1;
        D.31718 = imb.b[0];
        *code.495 = D.31718;
        code.496 = code;
        code = code.496 + 1;
        D.31720 = imb.b[1];
        *code.496 = D.31720;
        code.497 = code;
        code = code.497 + 1;
        D.31722 = imb.b[2];
        *code.497 = D.31722;
        code.498 = code;
        code = code.498 + 1;
        D.31724 = imb.b[3];
        *code.498 = D.31724;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31714>:
  <D.31709>:
  goto <D.24811>;
  <D.31704>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31725>; else goto <D.31726>;
  <D.31725>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31727>; else goto <D.31728>;
  <D.31727>:
  code.499 = code;
  code = code.499 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.499 = D.31633;
  goto <D.24811>;
  <D.31728>:
  <D.31726>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31730>; else goto <D.31731>;
  <D.31730>:
  code.500 = code;
  code = code.500 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.500 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31733>;
  <D.31731>:
  code.501 = code;
  code = code.501 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.501 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.502 = code;
        code = code.502 + 1;
        D.31736 = imb.b[0];
        *code.502 = D.31736;
        code.503 = code;
        code = code.503 + 1;
        D.31738 = imb.b[1];
        *code.503 = D.31738;
        code.504 = code;
        code = code.504 + 1;
        D.31740 = imb.b[2];
        *code.504 = D.31740;
        code.505 = code;
        code = code.505 + 1;
        D.31742 = imb.b[3];
        *code.505 = D.31742;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31733>:
  <D.24811>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.506 = code;
        code = code.506 + 1;
        D.31744 = imb.b[0];
        *code.506 = D.31744;
        code.507 = code;
        code = code.507 + 1;
        D.31746 = imb.b[1];
        *code.507 = D.31746;
        code.508 = code;
        code = code.508 + 1;
        D.31748 = imb.b[2];
        *code.508 = D.31748;
        code.509 = code;
        code = code.509 + 1;
        D.31750 = imb.b[3];
        *code.509 = D.31750;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31701>:
  <D.31655>:
  goto <D.24796>;
  <D.24814>:
  if (0 != 0) goto <D.31751>; else goto <D.31752>;
  <D.31751>:
  code.510 = code;
  code = code.510 + 1;
  *code.510 = 198;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31754>; else goto <D.31755>;
  <D.31754>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31756>; else goto <D.31757>;
  <D.31756>:
  code.511 = code;
  code = code.511 + 1;
  *code.511 = 4;
  code.512 = code;
  code = code.512 + 1;
  *code.512 = 36;
  goto <D.31760>;
  <D.31757>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31761>; else goto <D.31762>;
  <D.31761>:
  code.513 = code;
  code = code.513 + 1;
  *code.513 = 68;
  code.514 = code;
  code = code.514 + 1;
  *code.514 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31765>;
  <D.31762>:
  code.515 = code;
  code = code.515 + 1;
  *code.515 = 132;
  code.516 = code;
  code = code.516 + 1;
  *code.516 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.517 = code;
        code = code.517 + 1;
        D.31769 = imb.b[0];
        *code.517 = D.31769;
        code.518 = code;
        code = code.518 + 1;
        D.31771 = imb.b[1];
        *code.518 = D.31771;
        code.519 = code;
        code = code.519 + 1;
        D.31773 = imb.b[2];
        *code.519 = D.31773;
        code.520 = code;
        code = code.520 + 1;
        D.31775 = imb.b[3];
        *code.520 = D.31775;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31765>:
  <D.31760>:
  goto <D.24816>;
  <D.31755>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31776>; else goto <D.31777>;
  <D.31776>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31778>; else goto <D.31779>;
  <D.31778>:
  code.521 = code;
  code = code.521 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.521 = D.31633;
  goto <D.24816>;
  <D.31779>:
  <D.31777>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31781>; else goto <D.31782>;
  <D.31781>:
  code.522 = code;
  code = code.522 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.522 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31784>;
  <D.31782>:
  code.523 = code;
  code = code.523 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.523 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.524 = code;
        code = code.524 + 1;
        D.31787 = imb.b[0];
        *code.524 = D.31787;
        code.525 = code;
        code = code.525 + 1;
        D.31789 = imb.b[1];
        *code.525 = D.31789;
        code.526 = code;
        code = code.526 + 1;
        D.31791 = imb.b[2];
        *code.526 = D.31791;
        code.527 = code;
        code = code.527 + 1;
        D.31793 = imb.b[3];
        *code.527 = D.31793;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31784>:
  <D.24816>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.31794>;
  <D.31752>:
  if (1 != 0) goto <D.31795>; else goto <D.31796>;
  <D.31795>:
  code.528 = code;
  code = code.528 + 1;
  *code.528 = 102;
  code.529 = code;
  code = code.529 + 1;
  *code.529 = 199;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31799>; else goto <D.31800>;
  <D.31799>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31801>; else goto <D.31802>;
  <D.31801>:
  code.530 = code;
  code = code.530 + 1;
  *code.530 = 4;
  code.531 = code;
  code = code.531 + 1;
  *code.531 = 36;
  goto <D.31805>;
  <D.31802>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31806>; else goto <D.31807>;
  <D.31806>:
  code.532 = code;
  code = code.532 + 1;
  *code.532 = 68;
  code.533 = code;
  code = code.533 + 1;
  *code.533 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31810>;
  <D.31807>:
  code.534 = code;
  code = code.534 + 1;
  *code.534 = 132;
  code.535 = code;
  code = code.535 + 1;
  *code.535 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.536 = code;
        code = code.536 + 1;
        D.31814 = imb.b[0];
        *code.536 = D.31814;
        code.537 = code;
        code = code.537 + 1;
        D.31816 = imb.b[1];
        *code.537 = D.31816;
        code.538 = code;
        code = code.538 + 1;
        D.31818 = imb.b[2];
        *code.538 = D.31818;
        code.539 = code;
        code = code.539 + 1;
        D.31820 = imb.b[3];
        *code.539 = D.31820;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31810>:
  <D.31805>:
  goto <D.24819>;
  <D.31800>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31821>; else goto <D.31822>;
  <D.31821>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31823>; else goto <D.31824>;
  <D.31823>:
  code.540 = code;
  code = code.540 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.540 = D.31633;
  goto <D.24819>;
  <D.31824>:
  <D.31822>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31826>; else goto <D.31827>;
  <D.31826>:
  code.541 = code;
  code = code.541 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.541 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31829>;
  <D.31827>:
  code.542 = code;
  code = code.542 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.542 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.543 = code;
        code = code.543 + 1;
        D.31832 = imb.b[0];
        *code.543 = D.31832;
        code.544 = code;
        code = code.544 + 1;
        D.31834 = imb.b[1];
        *code.544 = D.31834;
        code.545 = code;
        code = code.545 + 1;
        D.31836 = imb.b[2];
        *code.545 = D.31836;
        code.546 = code;
        code = code.546 + 1;
        D.31838 = imb.b[3];
        *code.546 = D.31838;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31829>:
  <D.24819>:
  D.31653 = ins->data.op[1].const_val;
  D.31700 = (short int) D.31653;
  MEM[(short int *)code] = D.31700;
  code = code + 2;
  goto <D.31839>;
  <D.31796>:
  code.547 = code;
  code = code.547 + 1;
  *code.547 = 199;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31841>; else goto <D.31842>;
  <D.31841>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31843>; else goto <D.31844>;
  <D.31843>:
  code.548 = code;
  code = code.548 + 1;
  *code.548 = 4;
  code.549 = code;
  code = code.549 + 1;
  *code.549 = 36;
  goto <D.31847>;
  <D.31844>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31848>; else goto <D.31849>;
  <D.31848>:
  code.550 = code;
  code = code.550 + 1;
  *code.550 = 68;
  code.551 = code;
  code = code.551 + 1;
  *code.551 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31852>;
  <D.31849>:
  code.552 = code;
  code = code.552 + 1;
  *code.552 = 132;
  code.553 = code;
  code = code.553 + 1;
  *code.553 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.554 = code;
        code = code.554 + 1;
        D.31856 = imb.b[0];
        *code.554 = D.31856;
        code.555 = code;
        code = code.555 + 1;
        D.31858 = imb.b[1];
        *code.555 = D.31858;
        code.556 = code;
        code = code.556 + 1;
        D.31860 = imb.b[2];
        *code.556 = D.31860;
        code.557 = code;
        code = code.557 + 1;
        D.31862 = imb.b[3];
        *code.557 = D.31862;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31852>:
  <D.31847>:
  goto <D.24822>;
  <D.31842>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31863>; else goto <D.31864>;
  <D.31863>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31865>; else goto <D.31866>;
  <D.31865>:
  code.558 = code;
  code = code.558 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.558 = D.31633;
  goto <D.24822>;
  <D.31866>:
  <D.31864>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31868>; else goto <D.31869>;
  <D.31868>:
  code.559 = code;
  code = code.559 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.559 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31871>;
  <D.31869>:
  code.560 = code;
  code = code.560 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.560 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.561 = code;
        code = code.561 + 1;
        D.31874 = imb.b[0];
        *code.561 = D.31874;
        code.562 = code;
        code = code.562 + 1;
        D.31876 = imb.b[1];
        *code.562 = D.31876;
        code.563 = code;
        code = code.563 + 1;
        D.31878 = imb.b[2];
        *code.563 = D.31878;
        code.564 = code;
        code = code.564 + 1;
        D.31880 = imb.b[3];
        *code.564 = D.31880;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31871>:
  <D.24822>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.565 = code;
        code = code.565 + 1;
        D.31882 = imb.b[0];
        *code.565 = D.31882;
        code.566 = code;
        code = code.566 + 1;
        D.31884 = imb.b[1];
        *code.566 = D.31884;
        code.567 = code;
        code = code.567 + 1;
        D.31886 = imb.b[2];
        *code.567 = D.31886;
        code.568 = code;
        code = code.568 + 1;
        D.31888 = imb.b[3];
        *code.568 = D.31888;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31839>:
  <D.31794>:
  goto <D.24796>;
  <D.24825>:
  <D.24826>:
  if (0 != 0) goto <D.31889>; else goto <D.31890>;
  <D.31889>:
  code.569 = code;
  code = code.569 + 1;
  *code.569 = 198;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31892>; else goto <D.31893>;
  <D.31892>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31894>; else goto <D.31895>;
  <D.31894>:
  code.570 = code;
  code = code.570 + 1;
  *code.570 = 4;
  code.571 = code;
  code = code.571 + 1;
  *code.571 = 36;
  goto <D.31898>;
  <D.31895>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31899>; else goto <D.31900>;
  <D.31899>:
  code.572 = code;
  code = code.572 + 1;
  *code.572 = 68;
  code.573 = code;
  code = code.573 + 1;
  *code.573 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31903>;
  <D.31900>:
  code.574 = code;
  code = code.574 + 1;
  *code.574 = 132;
  code.575 = code;
  code = code.575 + 1;
  *code.575 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.576 = code;
        code = code.576 + 1;
        D.31907 = imb.b[0];
        *code.576 = D.31907;
        code.577 = code;
        code = code.577 + 1;
        D.31909 = imb.b[1];
        *code.577 = D.31909;
        code.578 = code;
        code = code.578 + 1;
        D.31911 = imb.b[2];
        *code.578 = D.31911;
        code.579 = code;
        code = code.579 + 1;
        D.31913 = imb.b[3];
        *code.579 = D.31913;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31903>:
  <D.31898>:
  goto <D.24828>;
  <D.31893>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31914>; else goto <D.31915>;
  <D.31914>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31916>; else goto <D.31917>;
  <D.31916>:
  code.580 = code;
  code = code.580 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.580 = D.31633;
  goto <D.24828>;
  <D.31917>:
  <D.31915>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31919>; else goto <D.31920>;
  <D.31919>:
  code.581 = code;
  code = code.581 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.581 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31922>;
  <D.31920>:
  code.582 = code;
  code = code.582 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.582 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.583 = code;
        code = code.583 + 1;
        D.31925 = imb.b[0];
        *code.583 = D.31925;
        code.584 = code;
        code = code.584 + 1;
        D.31927 = imb.b[1];
        *code.584 = D.31927;
        code.585 = code;
        code = code.585 + 1;
        D.31929 = imb.b[2];
        *code.585 = D.31929;
        code.586 = code;
        code = code.586 + 1;
        D.31931 = imb.b[3];
        *code.586 = D.31931;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31922>:
  <D.24828>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.31932>;
  <D.31890>:
  if (0 != 0) goto <D.31933>; else goto <D.31934>;
  <D.31933>:
  code.587 = code;
  code = code.587 + 1;
  *code.587 = 102;
  code.588 = code;
  code = code.588 + 1;
  *code.588 = 199;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31937>; else goto <D.31938>;
  <D.31937>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31939>; else goto <D.31940>;
  <D.31939>:
  code.589 = code;
  code = code.589 + 1;
  *code.589 = 4;
  code.590 = code;
  code = code.590 + 1;
  *code.590 = 36;
  goto <D.31943>;
  <D.31940>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31944>; else goto <D.31945>;
  <D.31944>:
  code.591 = code;
  code = code.591 + 1;
  *code.591 = 68;
  code.592 = code;
  code = code.592 + 1;
  *code.592 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31948>;
  <D.31945>:
  code.593 = code;
  code = code.593 + 1;
  *code.593 = 132;
  code.594 = code;
  code = code.594 + 1;
  *code.594 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.595 = code;
        code = code.595 + 1;
        D.31952 = imb.b[0];
        *code.595 = D.31952;
        code.596 = code;
        code = code.596 + 1;
        D.31954 = imb.b[1];
        *code.596 = D.31954;
        code.597 = code;
        code = code.597 + 1;
        D.31956 = imb.b[2];
        *code.597 = D.31956;
        code.598 = code;
        code = code.598 + 1;
        D.31958 = imb.b[3];
        *code.598 = D.31958;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31948>:
  <D.31943>:
  goto <D.24831>;
  <D.31938>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31959>; else goto <D.31960>;
  <D.31959>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.31961>; else goto <D.31962>;
  <D.31961>:
  code.599 = code;
  code = code.599 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.599 = D.31633;
  goto <D.24831>;
  <D.31962>:
  <D.31960>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31964>; else goto <D.31965>;
  <D.31964>:
  code.600 = code;
  code = code.600 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.600 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31967>;
  <D.31965>:
  code.601 = code;
  code = code.601 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.601 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.602 = code;
        code = code.602 + 1;
        D.31970 = imb.b[0];
        *code.602 = D.31970;
        code.603 = code;
        code = code.603 + 1;
        D.31972 = imb.b[1];
        *code.603 = D.31972;
        code.604 = code;
        code = code.604 + 1;
        D.31974 = imb.b[2];
        *code.604 = D.31974;
        code.605 = code;
        code = code.605 + 1;
        D.31976 = imb.b[3];
        *code.605 = D.31976;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31967>:
  <D.24831>:
  D.31653 = ins->data.op[1].const_val;
  D.31700 = (short int) D.31653;
  MEM[(short int *)code] = D.31700;
  code = code + 2;
  goto <D.31977>;
  <D.31934>:
  code.606 = code;
  code = code.606 + 1;
  *code.606 = 199;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.31979>; else goto <D.31980>;
  <D.31979>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.31981>; else goto <D.31982>;
  <D.31981>:
  code.607 = code;
  code = code.607 + 1;
  *code.607 = 4;
  code.608 = code;
  code = code.608 + 1;
  *code.608 = 36;
  goto <D.31985>;
  <D.31982>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.31986>; else goto <D.31987>;
  <D.31986>:
  code.609 = code;
  code = code.609 + 1;
  *code.609 = 68;
  code.610 = code;
  code = code.610 + 1;
  *code.610 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.31990>;
  <D.31987>:
  code.611 = code;
  code = code.611 + 1;
  *code.611 = 132;
  code.612 = code;
  code = code.612 + 1;
  *code.612 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.613 = code;
        code = code.613 + 1;
        D.31994 = imb.b[0];
        *code.613 = D.31994;
        code.614 = code;
        code = code.614 + 1;
        D.31996 = imb.b[1];
        *code.614 = D.31996;
        code.615 = code;
        code = code.615 + 1;
        D.31998 = imb.b[2];
        *code.615 = D.31998;
        code.616 = code;
        code = code.616 + 1;
        D.32000 = imb.b[3];
        *code.616 = D.32000;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31990>:
  <D.31985>:
  goto <D.24834>;
  <D.31980>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32001>; else goto <D.32002>;
  <D.32001>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.32003>; else goto <D.32004>;
  <D.32003>:
  code.617 = code;
  code = code.617 + 1;
  D.31604 = ins->dreg;
  D.31632 = (unsigned char) D.31604;
  D.31633 = D.31632 & 7;
  *code.617 = D.31633;
  goto <D.24834>;
  <D.32004>:
  <D.32002>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32006>; else goto <D.32007>;
  <D.32006>:
  code.618 = code;
  code = code.618 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31639 = D.31638 | 64;
  D.31640 = (unsigned char) D.31639;
  *code.618 = D.31640;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32009>;
  <D.32007>:
  code.619 = code;
  code = code.619 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.31643 = D.31638 | -128;
  D.31644 = (unsigned char) D.31643;
  *code.619 = D.31644;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.620 = code;
        code = code.620 + 1;
        D.32012 = imb.b[0];
        *code.620 = D.32012;
        code.621 = code;
        code = code.621 + 1;
        D.32014 = imb.b[1];
        *code.621 = D.32014;
        code.622 = code;
        code = code.622 + 1;
        D.32016 = imb.b[2];
        *code.622 = D.32016;
        code.623 = code;
        code = code.623 + 1;
        D.32018 = imb.b[3];
        *code.623 = D.32018;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32009>:
  <D.24834>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.624 = code;
        code = code.624 + 1;
        D.32020 = imb.b[0];
        *code.624 = D.32020;
        code.625 = code;
        code = code.625 + 1;
        D.32022 = imb.b[1];
        *code.625 = D.32022;
        code.626 = code;
        code = code.626 + 1;
        D.32024 = imb.b[2];
        *code.626 = D.32024;
        code.627 = code;
        code = code.627 + 1;
        D.32026 = imb.b[3];
        *code.627 = D.32026;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31977>:
  <D.31932>:
  goto <D.24796>;
  <D.24837>:
  switch (1) <default: <D.24842>, case 1: <D.24838>, case 2: <D.24840>, case 4: <D.24841>>
  <D.24838>:
  code.628 = code;
  code = code.628 + 1;
  *code.628 = 136;
  goto <D.24839>;
  <D.24840>:
  code.629 = code;
  code = code.629 + 1;
  *code.629 = 102;
  <D.24841>:
  code.630 = code;
  code = code.630 + 1;
  *code.630 = 137;
  goto <D.24839>;
  <D.24842>:
  __assert_fail ("0", "mini-x86.c", 2697, &__PRETTY_FUNCTION__);
  <D.24839>:
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.32030>; else goto <D.32031>;
  <D.32030>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32032>; else goto <D.32033>;
  <D.32032>:
  code.631 = code;
  code = code.631 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.631 = D.32039;
  code.632 = code;
  code = code.632 + 1;
  *code.632 = 36;
  goto <D.32041>;
  <D.32033>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32042>; else goto <D.32043>;
  <D.32042>:
  code.633 = code;
  code = code.633 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.633 = D.32046;
  code.634 = code;
  code = code.634 + 1;
  *code.634 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32048>;
  <D.32043>:
  code.635 = code;
  code = code.635 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.635 = D.32051;
  code.636 = code;
  code = code.636 + 1;
  *code.636 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.637 = code;
        code = code.637 + 1;
        D.32054 = imb.b[0];
        *code.637 = D.32054;
        code.638 = code;
        code = code.638 + 1;
        D.32056 = imb.b[1];
        *code.638 = D.32056;
        code.639 = code;
        code = code.639 + 1;
        D.32058 = imb.b[2];
        *code.639 = D.32058;
        code.640 = code;
        code = code.640 + 1;
        D.32060 = imb.b[3];
        *code.640 = D.32060;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32048>:
  <D.32041>:
  goto <D.24844>;
  <D.32031>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32061>; else goto <D.32062>;
  <D.32061>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.32063>; else goto <D.32064>;
  <D.32063>:
  code.641 = code;
  code = code.641 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32066 = D.32037 | D.31638;
  D.32067 = (unsigned char) D.32066;
  *code.641 = D.32067;
  goto <D.24844>;
  <D.32064>:
  <D.32062>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32068>; else goto <D.32069>;
  <D.32068>:
  code.642 = code;
  code = code.642 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32072 = D.32071 | D.31638;
  D.32073 = (unsigned char) D.32072;
  *code.642 = D.32073;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32074>;
  <D.32069>:
  code.643 = code;
  code = code.643 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32077 = D.32076 | D.31638;
  D.32078 = (unsigned char) D.32077;
  *code.643 = D.32078;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.644 = code;
        code = code.644 + 1;
        D.32080 = imb.b[0];
        *code.644 = D.32080;
        code.645 = code;
        code = code.645 + 1;
        D.32082 = imb.b[1];
        *code.645 = D.32082;
        code.646 = code;
        code = code.646 + 1;
        D.32084 = imb.b[2];
        *code.646 = D.32084;
        code.647 = code;
        code = code.647 + 1;
        D.32086 = imb.b[3];
        *code.647 = D.32086;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32074>:
  <D.24844>:
  goto <D.24796>;
  <D.24846>:
  switch (2) <default: <D.24851>, case 1: <D.24847>, case 2: <D.24849>, case 4: <D.24850>>
  <D.24847>:
  code.648 = code;
  code = code.648 + 1;
  *code.648 = 136;
  goto <D.24848>;
  <D.24849>:
  code.649 = code;
  code = code.649 + 1;
  *code.649 = 102;
  <D.24850>:
  code.650 = code;
  code = code.650 + 1;
  *code.650 = 137;
  goto <D.24848>;
  <D.24851>:
  __assert_fail ("0", "mini-x86.c", 2700, &__PRETTY_FUNCTION__);
  <D.24848>:
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.32090>; else goto <D.32091>;
  <D.32090>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32092>; else goto <D.32093>;
  <D.32092>:
  code.651 = code;
  code = code.651 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.651 = D.32039;
  code.652 = code;
  code = code.652 + 1;
  *code.652 = 36;
  goto <D.32096>;
  <D.32093>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32097>; else goto <D.32098>;
  <D.32097>:
  code.653 = code;
  code = code.653 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.653 = D.32046;
  code.654 = code;
  code = code.654 + 1;
  *code.654 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32101>;
  <D.32098>:
  code.655 = code;
  code = code.655 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.655 = D.32051;
  code.656 = code;
  code = code.656 + 1;
  *code.656 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.657 = code;
        code = code.657 + 1;
        D.32105 = imb.b[0];
        *code.657 = D.32105;
        code.658 = code;
        code = code.658 + 1;
        D.32107 = imb.b[1];
        *code.658 = D.32107;
        code.659 = code;
        code = code.659 + 1;
        D.32109 = imb.b[2];
        *code.659 = D.32109;
        code.660 = code;
        code = code.660 + 1;
        D.32111 = imb.b[3];
        *code.660 = D.32111;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32101>:
  <D.32096>:
  goto <D.24853>;
  <D.32091>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32112>; else goto <D.32113>;
  <D.32112>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.32114>; else goto <D.32115>;
  <D.32114>:
  code.661 = code;
  code = code.661 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32066 = D.32037 | D.31638;
  D.32067 = (unsigned char) D.32066;
  *code.661 = D.32067;
  goto <D.24853>;
  <D.32115>:
  <D.32113>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32117>; else goto <D.32118>;
  <D.32117>:
  code.662 = code;
  code = code.662 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32072 = D.32071 | D.31638;
  D.32073 = (unsigned char) D.32072;
  *code.662 = D.32073;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32120>;
  <D.32118>:
  code.663 = code;
  code = code.663 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32077 = D.32076 | D.31638;
  D.32078 = (unsigned char) D.32077;
  *code.663 = D.32078;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.664 = code;
        code = code.664 + 1;
        D.32123 = imb.b[0];
        *code.664 = D.32123;
        code.665 = code;
        code = code.665 + 1;
        D.32125 = imb.b[1];
        *code.665 = D.32125;
        code.666 = code;
        code = code.666 + 1;
        D.32127 = imb.b[2];
        *code.666 = D.32127;
        code.667 = code;
        code = code.667 + 1;
        D.32129 = imb.b[3];
        *code.667 = D.32129;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32120>:
  <D.24853>:
  goto <D.24796>;
  <D.24855>:
  <D.24856>:
  switch (4) <default: <D.24861>, case 1: <D.24857>, case 2: <D.24859>, case 4: <D.24860>>
  <D.24857>:
  code.668 = code;
  code = code.668 + 1;
  *code.668 = 136;
  goto <D.24858>;
  <D.24859>:
  code.669 = code;
  code = code.669 + 1;
  *code.669 = 102;
  <D.24860>:
  code.670 = code;
  code = code.670 + 1;
  *code.670 = 137;
  goto <D.24858>;
  <D.24861>:
  __assert_fail ("0", "mini-x86.c", 2704, &__PRETTY_FUNCTION__);
  <D.24858>:
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.32133>; else goto <D.32134>;
  <D.32133>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32135>; else goto <D.32136>;
  <D.32135>:
  code.671 = code;
  code = code.671 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.671 = D.32039;
  code.672 = code;
  code = code.672 + 1;
  *code.672 = 36;
  goto <D.32139>;
  <D.32136>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32140>; else goto <D.32141>;
  <D.32140>:
  code.673 = code;
  code = code.673 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.673 = D.32046;
  code.674 = code;
  code = code.674 + 1;
  *code.674 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32144>;
  <D.32141>:
  code.675 = code;
  code = code.675 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.675 = D.32051;
  code.676 = code;
  code = code.676 + 1;
  *code.676 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.677 = code;
        code = code.677 + 1;
        D.32148 = imb.b[0];
        *code.677 = D.32148;
        code.678 = code;
        code = code.678 + 1;
        D.32150 = imb.b[1];
        *code.678 = D.32150;
        code.679 = code;
        code = code.679 + 1;
        D.32152 = imb.b[2];
        *code.679 = D.32152;
        code.680 = code;
        code = code.680 + 1;
        D.32154 = imb.b[3];
        *code.680 = D.32154;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32144>:
  <D.32139>:
  goto <D.24863>;
  <D.32134>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32155>; else goto <D.32156>;
  <D.32155>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.32157>; else goto <D.32158>;
  <D.32157>:
  code.681 = code;
  code = code.681 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32066 = D.32037 | D.31638;
  D.32067 = (unsigned char) D.32066;
  *code.681 = D.32067;
  goto <D.24863>;
  <D.32158>:
  <D.32156>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32160>; else goto <D.32161>;
  <D.32160>:
  code.682 = code;
  code = code.682 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32072 = D.32071 | D.31638;
  D.32073 = (unsigned char) D.32072;
  *code.682 = D.32073;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32163>;
  <D.32161>:
  code.683 = code;
  code = code.683 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32077 = D.32076 | D.31638;
  D.32078 = (unsigned char) D.32077;
  *code.683 = D.32078;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.684 = code;
        code = code.684 + 1;
        D.32166 = imb.b[0];
        *code.684 = D.32166;
        code.685 = code;
        code = code.685 + 1;
        D.32168 = imb.b[1];
        *code.685 = D.32168;
        code.686 = code;
        code = code.686 + 1;
        D.32170 = imb.b[2];
        *code.686 = D.32170;
        code.687 = code;
        code = code.687 + 1;
        D.32172 = imb.b[3];
        *code.687 = D.32172;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32163>:
  <D.24863>:
  goto <D.24796>;
  <D.24865>:
  if (0 != 0) goto <D.32173>; else goto <D.32174>;
  <D.32173>:
  code.688 = code;
  code = code.688 + 1;
  *code.688 = 198;
  code.689 = code;
  code = code.689 + 1;
  *code.689 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.32177 = ins->data.op[0].p;
        D.32178 = (int) D.32177;
        imb.val = D.32178;
        code.690 = code;
        code = code.690 + 1;
        D.32180 = imb.b[0];
        *code.690 = D.32180;
        code.691 = code;
        code = code.691 + 1;
        D.32182 = imb.b[1];
        *code.691 = D.32182;
        code.692 = code;
        code = code.692 + 1;
        D.32184 = imb.b[2];
        *code.692 = D.32184;
        code.693 = code;
        code = code.693 + 1;
        D.32186 = imb.b[3];
        *code.693 = D.32186;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32187>;
  <D.32174>:
  if (0 != 0) goto <D.32188>; else goto <D.32189>;
  <D.32188>:
  code.694 = code;
  code = code.694 + 1;
  *code.694 = 102;
  code.695 = code;
  code = code.695 + 1;
  *code.695 = 199;
  code.696 = code;
  code = code.696 + 1;
  *code.696 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.32177 = ins->data.op[0].p;
        D.32178 = (int) D.32177;
        imb.val = D.32178;
        code.697 = code;
        code = code.697 + 1;
        D.32194 = imb.b[0];
        *code.697 = D.32194;
        code.698 = code;
        code = code.698 + 1;
        D.32196 = imb.b[1];
        *code.698 = D.32196;
        code.699 = code;
        code = code.699 + 1;
        D.32198 = imb.b[2];
        *code.699 = D.32198;
        code.700 = code;
        code = code.700 + 1;
        D.32200 = imb.b[3];
        *code.700 = D.32200;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.31551 = ins->data.op[0].const_val;
  D.32201 = (short int) D.31551;
  MEM[(short int *)code] = D.32201;
  code = code + 2;
  goto <D.32202>;
  <D.32189>:
  code.701 = code;
  code = code.701 + 1;
  *code.701 = 199;
  code.702 = code;
  code = code.702 + 1;
  *code.702 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.32177 = ins->data.op[0].p;
        D.32178 = (int) D.32177;
        imb.val = D.32178;
        code.703 = code;
        code = code.703 + 1;
        D.32206 = imb.b[0];
        *code.703 = D.32206;
        code.704 = code;
        code = code.704 + 1;
        D.32208 = imb.b[1];
        *code.704 = D.32208;
        code.705 = code;
        code = code.705 + 1;
        D.32210 = imb.b[2];
        *code.705 = D.32210;
        code.706 = code;
        code = code.706 + 1;
        D.32212 = imb.b[3];
        *code.706 = D.32212;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.707 = code;
        code = code.707 + 1;
        D.32214 = imb.b[0];
        *code.707 = D.32214;
        code.708 = code;
        code = code.708 + 1;
        D.32216 = imb.b[1];
        *code.708 = D.32216;
        code.709 = code;
        code = code.709 + 1;
        D.32218 = imb.b[2];
        *code.709 = D.32218;
        code.710 = code;
        code = code.710 + 1;
        D.32220 = imb.b[3];
        *code.710 = D.32220;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32202>:
  <D.32187>:
  goto <D.24796>;
  <D.24870>:
  switch (4) <default: <D.24875>, case 1: <D.24871>, case 2: <D.24873>, case 4: <D.24874>>
  <D.24871>:
  code.711 = code;
  code = code.711 + 1;
  *code.711 = 138;
  goto <D.24872>;
  <D.24873>:
  code.712 = code;
  code = code.712 + 1;
  *code.712 = 102;
  <D.24874>:
  code.713 = code;
  code = code.713 + 1;
  *code.713 = 139;
  goto <D.24872>;
  <D.24875>:
  __assert_fail ("0", "mini-x86.c", 2710, &__PRETTY_FUNCTION__);
  <D.24872>:
  code.714 = code;
  code = code.714 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32228 = D.32227 | 5;
  D.32229 = (unsigned char) D.32228;
  *code.714 = D.32229;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.715 = code;
        code = code.715 + 1;
        D.32231 = imb.b[0];
        *code.715 = D.32231;
        code.716 = code;
        code = code.716 + 1;
        D.32233 = imb.b[1];
        *code.716 = D.32233;
        code.717 = code;
        code = code.717 + 1;
        D.32235 = imb.b[2];
        *code.717 = D.32235;
        code.718 = code;
        code = code.718 + 1;
        D.32237 = imb.b[3];
        *code.718 = D.32237;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24796>;
  <D.24877>:
  <D.24878>:
  switch (4) <default: <D.24883>, case 1: <D.24879>, case 2: <D.24881>, case 4: <D.24882>>
  <D.24879>:
  code.719 = code;
  code = code.719 + 1;
  *code.719 = 138;
  goto <D.24880>;
  <D.24881>:
  code.720 = code;
  code = code.720 + 1;
  *code.720 = 102;
  <D.24882>:
  code.721 = code;
  code = code.721 + 1;
  *code.721 = 139;
  goto <D.24880>;
  <D.24883>:
  __assert_fail ("0", "mini-x86.c", 2715, &__PRETTY_FUNCTION__);
  <D.24880>:
  code.722 = code;
  code = code.722 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32228 = D.32227 | 5;
  D.32229 = (unsigned char) D.32228;
  *code.722 = D.32229;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.723 = code;
        code = code.723 + 1;
        D.32243 = imb.b[0];
        *code.723 = D.32243;
        code.724 = code;
        code = code.724 + 1;
        D.32245 = imb.b[1];
        *code.724 = D.32245;
        code.725 = code;
        code = code.725 + 1;
        D.32247 = imb.b[2];
        *code.725 = D.32247;
        code.726 = code;
        code = code.726 + 1;
        D.32249 = imb.b[3];
        *code.726 = D.32249;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24796>;
  <D.24885>:
  {
    unsigned char op;

    op = 182;
    code.727 = code;
    code = code.727 + 1;
    *code.727 = 15;
    if (0 != 0) goto <D.32251>; else goto <D.32252>;
    <D.32251>:
    op = op + 8;
    <D.32252>:
    if (0 != 0) goto <D.32253>; else goto <D.32254>;
    <D.32253>:
    op = op + 1;
    <D.32254>:
    code.728 = code;
    code = code.728 + 1;
    *code.728 = op;
    code.729 = code;
    code = code.729 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32228 = D.32227 | 5;
    D.32229 = (unsigned char) D.32228;
    *code.729 = D.32229;
    {
      union x86_imm_buf imb;

      try
        {
          D.31653 = ins->data.op[1].const_val;
          imb.val = D.31653;
          code.730 = code;
          code = code.730 + 1;
          D.32258 = imb.b[0];
          *code.730 = D.32258;
          code.731 = code;
          code = code.731 + 1;
          D.32260 = imb.b[1];
          *code.731 = D.32260;
          code.732 = code;
          code = code.732 + 1;
          D.32262 = imb.b[2];
          *code.732 = D.32262;
          code.733 = code;
          code = code.733 + 1;
          D.32264 = imb.b[3];
          *code.733 = D.32264;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
  goto <D.24796>;
  <D.24888>:
  {
    unsigned char op;

    op = 182;
    code.734 = code;
    code = code.734 + 1;
    *code.734 = 15;
    if (0 != 0) goto <D.32266>; else goto <D.32267>;
    <D.32266>:
    op = op + 8;
    <D.32267>:
    if (1 != 0) goto <D.32268>; else goto <D.32269>;
    <D.32268>:
    op = op + 1;
    <D.32269>:
    code.735 = code;
    code = code.735 + 1;
    *code.735 = op;
    code.736 = code;
    code = code.736 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32228 = D.32227 | 5;
    D.32229 = (unsigned char) D.32228;
    *code.736 = D.32229;
    {
      union x86_imm_buf imb;

      try
        {
          D.31653 = ins->data.op[1].const_val;
          imb.val = D.31653;
          code.737 = code;
          code = code.737 + 1;
          D.32273 = imb.b[0];
          *code.737 = D.32273;
          code.738 = code;
          code = code.738 + 1;
          D.32275 = imb.b[1];
          *code.738 = D.32275;
          code.739 = code;
          code = code.739 + 1;
          D.32277 = imb.b[2];
          *code.739 = D.32277;
          code.740 = code;
          code = code.740 + 1;
          D.32279 = imb.b[3];
          *code.740 = D.32279;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
  goto <D.24796>;
  <D.24891>:
  <D.24892>:
  <D.24893>:
  switch (4) <default: <D.24898>, case 1: <D.24894>, case 2: <D.24896>, case 4: <D.24897>>
  <D.24894>:
  code.741 = code;
  code = code.741 + 1;
  *code.741 = 138;
  goto <D.24895>;
  <D.24896>:
  code.742 = code;
  code = code.742 + 1;
  *code.742 = 102;
  <D.24897>:
  code.743 = code;
  code = code.743 + 1;
  *code.743 = 139;
  goto <D.24895>;
  <D.24898>:
  __assert_fail ("0", "mini-x86.c", 2726, &__PRETTY_FUNCTION__);
  <D.24895>:
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32283>; else goto <D.32284>;
  <D.32283>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32285>; else goto <D.32286>;
  <D.32285>:
  code.744 = code;
  code = code.744 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.744 = D.32289;
  code.745 = code;
  code = code.745 + 1;
  *code.745 = 36;
  goto <D.32291>;
  <D.32286>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32292>; else goto <D.32293>;
  <D.32292>:
  code.746 = code;
  code = code.746 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.746 = D.32296;
  code.747 = code;
  code = code.747 + 1;
  *code.747 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32298>;
  <D.32293>:
  code.748 = code;
  code = code.748 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.748 = D.32301;
  code.749 = code;
  code = code.749 + 1;
  *code.749 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.750 = code;
        code = code.750 + 1;
        D.32304 = imb.b[0];
        *code.750 = D.32304;
        code.751 = code;
        code = code.751 + 1;
        D.32306 = imb.b[1];
        *code.751 = D.32306;
        code.752 = code;
        code = code.752 + 1;
        D.32308 = imb.b[2];
        *code.752 = D.32308;
        code.753 = code;
        code = code.753 + 1;
        D.32310 = imb.b[3];
        *code.753 = D.32310;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32298>:
  <D.32291>:
  goto <D.24900>;
  <D.32284>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32311>; else goto <D.32312>;
  <D.32311>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32313>; else goto <D.32314>;
  <D.32313>:
  code.754 = code;
  code = code.754 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32316 = D.32227 | D.31586;
  D.32317 = (unsigned char) D.32316;
  *code.754 = D.32317;
  goto <D.24900>;
  <D.32314>:
  <D.32312>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32318>; else goto <D.32319>;
  <D.32318>:
  code.755 = code;
  code = code.755 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32322 = D.32321 | D.31586;
  D.32323 = (unsigned char) D.32322;
  *code.755 = D.32323;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32324>;
  <D.32319>:
  code.756 = code;
  code = code.756 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32327 = D.32326 | D.31586;
  D.32328 = (unsigned char) D.32327;
  *code.756 = D.32328;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.757 = code;
        code = code.757 + 1;
        D.32330 = imb.b[0];
        *code.757 = D.32330;
        code.758 = code;
        code = code.758 + 1;
        D.32332 = imb.b[1];
        *code.758 = D.32332;
        code.759 = code;
        code = code.759 + 1;
        D.32334 = imb.b[2];
        *code.759 = D.32334;
        code.760 = code;
        code = code.760 + 1;
        D.32336 = imb.b[3];
        *code.760 = D.32336;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32324>:
  <D.24900>:
  goto <D.24796>;
  <D.24902>:
  {
    unsigned char op;

    op = 182;
    code.761 = code;
    code = code.761 + 1;
    *code.761 = 15;
    if (0 != 0) goto <D.32338>; else goto <D.32339>;
    <D.32338>:
    op = op + 8;
    <D.32339>:
    if (0 != 0) goto <D.32340>; else goto <D.32341>;
    <D.32340>:
    op = op + 1;
    <D.32341>:
    code.762 = code;
    code = code.762 + 1;
    *code.762 = op;
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.32343>; else goto <D.32344>;
    <D.32343>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32345>; else goto <D.32346>;
    <D.32345>:
    code.763 = code;
    code = code.763 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32288 = D.32227 | 4;
    D.32289 = (unsigned char) D.32288;
    *code.763 = D.32289;
    code.764 = code;
    code = code.764 + 1;
    *code.764 = 36;
    goto <D.32349>;
    <D.32346>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32350>; else goto <D.32351>;
    <D.32350>:
    code.765 = code;
    code = code.765 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32295 = D.32227 | 68;
    D.32296 = (unsigned char) D.32295;
    *code.765 = D.32296;
    code.766 = code;
    code = code.766 + 1;
    *code.766 = 36;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32354>;
    <D.32351>:
    code.767 = code;
    code = code.767 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32300 = D.32227 | -124;
    D.32301 = (unsigned char) D.32300;
    *code.767 = D.32301;
    code.768 = code;
    code = code.768 + 1;
    *code.768 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.769 = code;
          code = code.769 + 1;
          D.32358 = imb.b[0];
          *code.769 = D.32358;
          code.770 = code;
          code = code.770 + 1;
          D.32360 = imb.b[1];
          *code.770 = D.32360;
          code.771 = code;
          code = code.771 + 1;
          D.32362 = imb.b[2];
          *code.771 = D.32362;
          code.772 = code;
          code = code.772 + 1;
          D.32364 = imb.b[3];
          *code.772 = D.32364;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32354>:
    <D.32349>:
    goto <D.24905>;
    <D.32344>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32365>; else goto <D.32366>;
    <D.32365>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.32367>; else goto <D.32368>;
    <D.32367>:
    code.773 = code;
    code = code.773 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32316 = D.32227 | D.31586;
    D.32317 = (unsigned char) D.32316;
    *code.773 = D.32317;
    goto <D.24905>;
    <D.32368>:
    <D.32366>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32370>; else goto <D.32371>;
    <D.32370>:
    code.774 = code;
    code = code.774 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32321 = D.32227 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32322 = D.32321 | D.31586;
    D.32323 = (unsigned char) D.32322;
    *code.774 = D.32323;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32373>;
    <D.32371>:
    code.775 = code;
    code = code.775 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32326 = D.32227 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32327 = D.32326 | D.31586;
    D.32328 = (unsigned char) D.32327;
    *code.775 = D.32328;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.776 = code;
          code = code.776 + 1;
          D.32376 = imb.b[0];
          *code.776 = D.32376;
          code.777 = code;
          code = code.777 + 1;
          D.32378 = imb.b[1];
          *code.777 = D.32378;
          code.778 = code;
          code = code.778 + 1;
          D.32380 = imb.b[2];
          *code.778 = D.32380;
          code.779 = code;
          code = code.779 + 1;
          D.32382 = imb.b[3];
          *code.779 = D.32382;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32373>:
    <D.24905>:
  }
  goto <D.24796>;
  <D.24907>:
  {
    unsigned char op;

    op = 182;
    code.780 = code;
    code = code.780 + 1;
    *code.780 = 15;
    if (1 != 0) goto <D.32384>; else goto <D.32385>;
    <D.32384>:
    op = op + 8;
    <D.32385>:
    if (0 != 0) goto <D.32386>; else goto <D.32387>;
    <D.32386>:
    op = op + 1;
    <D.32387>:
    code.781 = code;
    code = code.781 + 1;
    *code.781 = op;
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.32389>; else goto <D.32390>;
    <D.32389>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32391>; else goto <D.32392>;
    <D.32391>:
    code.782 = code;
    code = code.782 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32288 = D.32227 | 4;
    D.32289 = (unsigned char) D.32288;
    *code.782 = D.32289;
    code.783 = code;
    code = code.783 + 1;
    *code.783 = 36;
    goto <D.32395>;
    <D.32392>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32396>; else goto <D.32397>;
    <D.32396>:
    code.784 = code;
    code = code.784 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32295 = D.32227 | 68;
    D.32296 = (unsigned char) D.32295;
    *code.784 = D.32296;
    code.785 = code;
    code = code.785 + 1;
    *code.785 = 36;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32400>;
    <D.32397>:
    code.786 = code;
    code = code.786 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32300 = D.32227 | -124;
    D.32301 = (unsigned char) D.32300;
    *code.786 = D.32301;
    code.787 = code;
    code = code.787 + 1;
    *code.787 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.788 = code;
          code = code.788 + 1;
          D.32404 = imb.b[0];
          *code.788 = D.32404;
          code.789 = code;
          code = code.789 + 1;
          D.32406 = imb.b[1];
          *code.789 = D.32406;
          code.790 = code;
          code = code.790 + 1;
          D.32408 = imb.b[2];
          *code.790 = D.32408;
          code.791 = code;
          code = code.791 + 1;
          D.32410 = imb.b[3];
          *code.791 = D.32410;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32400>:
    <D.32395>:
    goto <D.24910>;
    <D.32390>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32411>; else goto <D.32412>;
    <D.32411>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.32413>; else goto <D.32414>;
    <D.32413>:
    code.792 = code;
    code = code.792 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32316 = D.32227 | D.31586;
    D.32317 = (unsigned char) D.32316;
    *code.792 = D.32317;
    goto <D.24910>;
    <D.32414>:
    <D.32412>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32416>; else goto <D.32417>;
    <D.32416>:
    code.793 = code;
    code = code.793 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32321 = D.32227 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32322 = D.32321 | D.31586;
    D.32323 = (unsigned char) D.32322;
    *code.793 = D.32323;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32419>;
    <D.32417>:
    code.794 = code;
    code = code.794 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32326 = D.32227 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32327 = D.32326 | D.31586;
    D.32328 = (unsigned char) D.32327;
    *code.794 = D.32328;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.795 = code;
          code = code.795 + 1;
          D.32422 = imb.b[0];
          *code.795 = D.32422;
          code.796 = code;
          code = code.796 + 1;
          D.32424 = imb.b[1];
          *code.796 = D.32424;
          code.797 = code;
          code = code.797 + 1;
          D.32426 = imb.b[2];
          *code.797 = D.32426;
          code.798 = code;
          code = code.798 + 1;
          D.32428 = imb.b[3];
          *code.798 = D.32428;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32419>:
    <D.24910>:
  }
  goto <D.24796>;
  <D.24912>:
  {
    unsigned char op;

    op = 182;
    code.799 = code;
    code = code.799 + 1;
    *code.799 = 15;
    if (0 != 0) goto <D.32430>; else goto <D.32431>;
    <D.32430>:
    op = op + 8;
    <D.32431>:
    if (1 != 0) goto <D.32432>; else goto <D.32433>;
    <D.32432>:
    op = op + 1;
    <D.32433>:
    code.800 = code;
    code = code.800 + 1;
    *code.800 = op;
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.32435>; else goto <D.32436>;
    <D.32435>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32437>; else goto <D.32438>;
    <D.32437>:
    code.801 = code;
    code = code.801 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32288 = D.32227 | 4;
    D.32289 = (unsigned char) D.32288;
    *code.801 = D.32289;
    code.802 = code;
    code = code.802 + 1;
    *code.802 = 36;
    goto <D.32441>;
    <D.32438>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32442>; else goto <D.32443>;
    <D.32442>:
    code.803 = code;
    code = code.803 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32295 = D.32227 | 68;
    D.32296 = (unsigned char) D.32295;
    *code.803 = D.32296;
    code.804 = code;
    code = code.804 + 1;
    *code.804 = 36;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32446>;
    <D.32443>:
    code.805 = code;
    code = code.805 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32300 = D.32227 | -124;
    D.32301 = (unsigned char) D.32300;
    *code.805 = D.32301;
    code.806 = code;
    code = code.806 + 1;
    *code.806 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.807 = code;
          code = code.807 + 1;
          D.32450 = imb.b[0];
          *code.807 = D.32450;
          code.808 = code;
          code = code.808 + 1;
          D.32452 = imb.b[1];
          *code.808 = D.32452;
          code.809 = code;
          code = code.809 + 1;
          D.32454 = imb.b[2];
          *code.809 = D.32454;
          code.810 = code;
          code = code.810 + 1;
          D.32456 = imb.b[3];
          *code.810 = D.32456;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32446>:
    <D.32441>:
    goto <D.24915>;
    <D.32436>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32457>; else goto <D.32458>;
    <D.32457>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.32459>; else goto <D.32460>;
    <D.32459>:
    code.811 = code;
    code = code.811 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32316 = D.32227 | D.31586;
    D.32317 = (unsigned char) D.32316;
    *code.811 = D.32317;
    goto <D.24915>;
    <D.32460>:
    <D.32458>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32462>; else goto <D.32463>;
    <D.32462>:
    code.812 = code;
    code = code.812 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32321 = D.32227 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32322 = D.32321 | D.31586;
    D.32323 = (unsigned char) D.32322;
    *code.812 = D.32323;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32465>;
    <D.32463>:
    code.813 = code;
    code = code.813 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32326 = D.32227 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32327 = D.32326 | D.31586;
    D.32328 = (unsigned char) D.32327;
    *code.813 = D.32328;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.814 = code;
          code = code.814 + 1;
          D.32468 = imb.b[0];
          *code.814 = D.32468;
          code.815 = code;
          code = code.815 + 1;
          D.32470 = imb.b[1];
          *code.815 = D.32470;
          code.816 = code;
          code = code.816 + 1;
          D.32472 = imb.b[2];
          *code.816 = D.32472;
          code.817 = code;
          code = code.817 + 1;
          D.32474 = imb.b[3];
          *code.817 = D.32474;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32465>:
    <D.24915>:
  }
  goto <D.24796>;
  <D.24917>:
  {
    unsigned char op;

    op = 182;
    code.818 = code;
    code = code.818 + 1;
    *code.818 = 15;
    if (1 != 0) goto <D.32476>; else goto <D.32477>;
    <D.32476>:
    op = op + 8;
    <D.32477>:
    if (1 != 0) goto <D.32478>; else goto <D.32479>;
    <D.32478>:
    op = op + 1;
    <D.32479>:
    code.819 = code;
    code = code.819 + 1;
    *code.819 = op;
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.32481>; else goto <D.32482>;
    <D.32481>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32483>; else goto <D.32484>;
    <D.32483>:
    code.820 = code;
    code = code.820 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32288 = D.32227 | 4;
    D.32289 = (unsigned char) D.32288;
    *code.820 = D.32289;
    code.821 = code;
    code = code.821 + 1;
    *code.821 = 36;
    goto <D.32487>;
    <D.32484>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32488>; else goto <D.32489>;
    <D.32488>:
    code.822 = code;
    code = code.822 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32295 = D.32227 | 68;
    D.32296 = (unsigned char) D.32295;
    *code.822 = D.32296;
    code.823 = code;
    code = code.823 + 1;
    *code.823 = 36;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32492>;
    <D.32489>:
    code.824 = code;
    code = code.824 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32300 = D.32227 | -124;
    D.32301 = (unsigned char) D.32300;
    *code.824 = D.32301;
    code.825 = code;
    code = code.825 + 1;
    *code.825 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.826 = code;
          code = code.826 + 1;
          D.32496 = imb.b[0];
          *code.826 = D.32496;
          code.827 = code;
          code = code.827 + 1;
          D.32498 = imb.b[1];
          *code.827 = D.32498;
          code.828 = code;
          code = code.828 + 1;
          D.32500 = imb.b[2];
          *code.828 = D.32500;
          code.829 = code;
          code = code.829 + 1;
          D.32502 = imb.b[3];
          *code.829 = D.32502;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32492>:
    <D.32487>:
    goto <D.24920>;
    <D.32482>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.32503>; else goto <D.32504>;
    <D.32503>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.32505>; else goto <D.32506>;
    <D.32505>:
    code.830 = code;
    code = code.830 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32316 = D.32227 | D.31586;
    D.32317 = (unsigned char) D.32316;
    *code.830 = D.32317;
    goto <D.24920>;
    <D.32506>:
    <D.32504>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.32508>; else goto <D.32509>;
    <D.32508>:
    code.831 = code;
    code = code.831 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32321 = D.32227 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32322 = D.32321 | D.31586;
    D.32323 = (unsigned char) D.32322;
    *code.831 = D.32323;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.32511>;
    <D.32509>:
    code.832 = code;
    code = code.832 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32326 = D.32227 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32327 = D.32326 | D.31586;
    D.32328 = (unsigned char) D.32327;
    *code.832 = D.32328;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.833 = code;
          code = code.833 + 1;
          D.32514 = imb.b[0];
          *code.833 = D.32514;
          code.834 = code;
          code = code.834 + 1;
          D.32516 = imb.b[1];
          *code.834 = D.32516;
          code.835 = code;
          code = code.835 + 1;
          D.32518 = imb.b[2];
          *code.835 = D.32518;
          code.836 = code;
          code = code.836 + 1;
          D.32520 = imb.b[3];
          *code.836 = D.32520;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32511>:
    <D.24920>:
  }
  goto <D.24796>;
  <D.24922>:
  <D.24923>:
  {
    unsigned char op;

    op = 182;
    D.31548 = ins->sreg1;
    D.32521 = D.31548 > 3;
    D.32522 = (long int) D.32521;
    D.32523 = __builtin_expect (D.32522, 0);
    if (D.32523 != 0) goto <D.32524>; else goto <D.32525>;
    <D.32524>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2742, "0 || X86_IS_BYTE_REG (ins->sreg1)");
    <D.32525>:
    code.837 = code;
    code = code.837 + 1;
    *code.837 = 15;
    if (1 != 0) goto <D.32527>; else goto <D.32528>;
    <D.32527>:
    op = op + 8;
    <D.32528>:
    if (0 != 0) goto <D.32529>; else goto <D.32530>;
    <D.32529>:
    op = op + 1;
    <D.32530>:
    code.838 = code;
    code = code.838 + 1;
    *code.838 = op;
    code.839 = code;
    code = code.839 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32534 = D.32533 | D.31586;
    D.32535 = (unsigned char) D.32534;
    *code.839 = D.32535;
  }
  goto <D.24796>;
  <D.24925>:
  <D.24926>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.32536>; else goto <D.32537>;
    <D.32536>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2746, "1 || X86_IS_BYTE_REG (ins->sreg1)");
    <D.32537>:
    code.840 = code;
    code = code.840 + 1;
    *code.840 = 15;
    if (1 != 0) goto <D.32539>; else goto <D.32540>;
    <D.32539>:
    op = op + 8;
    <D.32540>:
    if (1 != 0) goto <D.32541>; else goto <D.32542>;
    <D.32541>:
    op = op + 1;
    <D.32542>:
    code.841 = code;
    code = code.841 + 1;
    *code.841 = op;
    code.842 = code;
    code = code.842 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32534 = D.32533 | D.31586;
    D.32535 = (unsigned char) D.32534;
    *code.842 = D.32535;
  }
  goto <D.24796>;
  <D.24928>:
  {
    unsigned char op;

    op = 182;
    D.31548 = ins->sreg1;
    D.32521 = D.31548 > 3;
    D.32522 = (long int) D.32521;
    D.32523 = __builtin_expect (D.32522, 0);
    if (D.32523 != 0) goto <D.32545>; else goto <D.32546>;
    <D.32545>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2749, "0 || X86_IS_BYTE_REG (ins->sreg1)");
    <D.32546>:
    code.843 = code;
    code = code.843 + 1;
    *code.843 = 15;
    if (0 != 0) goto <D.32548>; else goto <D.32549>;
    <D.32548>:
    op = op + 8;
    <D.32549>:
    if (0 != 0) goto <D.32550>; else goto <D.32551>;
    <D.32550>:
    op = op + 1;
    <D.32551>:
    code.844 = code;
    code = code.844 + 1;
    *code.844 = op;
    code.845 = code;
    code = code.845 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32534 = D.32533 | D.31586;
    D.32535 = (unsigned char) D.32534;
    *code.845 = D.32535;
  }
  goto <D.24796>;
  <D.24930>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.32554>; else goto <D.32555>;
    <D.32554>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2752, "1 || X86_IS_BYTE_REG (ins->sreg1)");
    <D.32555>:
    code.846 = code;
    code = code.846 + 1;
    *code.846 = 15;
    if (0 != 0) goto <D.32557>; else goto <D.32558>;
    <D.32557>:
    op = op + 8;
    <D.32558>:
    if (1 != 0) goto <D.32559>; else goto <D.32560>;
    <D.32559>:
    op = op + 1;
    <D.32560>:
    code.847 = code;
    code = code.847 + 1;
    *code.847 = op;
    code.848 = code;
    code = code.848 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32534 = D.32533 | D.31586;
    D.32535 = (unsigned char) D.32534;
    *code.848 = D.32535;
  }
  goto <D.24796>;
  <D.24932>:
  <D.24933>:
  code.849 = code;
  code = code.849 + 1;
  *code.849 = 59;
  code.850 = code;
  code = code.850 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.850 = D.32567;
  goto <D.24796>;
  <D.24934>:
  <D.24935>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.32568>; else goto <D.32569>;
  <D.32568>:
  code.851 = code;
  code = code.851 + 1;
  *code.851 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.852 = code;
        code = code.852 + 1;
        D.32572 = imb.b[0];
        *code.852 = D.32572;
        code.853 = code;
        code = code.853 + 1;
        D.32574 = imb.b[1];
        *code.853 = D.32574;
        code.854 = code;
        code = code.854 + 1;
        D.32576 = imb.b[2];
        *code.854 = D.32576;
        code.855 = code;
        code = code.855 + 1;
        D.32578 = imb.b[3];
        *code.855 = D.32578;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24937>;
  <D.32569>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.32581>; else goto <D.32582>;
  <D.32581>:
  code.856 = code;
  code = code.856 + 1;
  *code.856 = 131;
  code.857 = code;
  code = code.857 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.32585 = D.31585 | -8;
  D.32586 = (unsigned char) D.32585;
  *code.857 = D.32586;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.32587>;
  <D.32582>:
  code.858 = code;
  code = code.858 + 1;
  *code.858 = 129;
  code.859 = code;
  code = code.859 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.32585 = D.31585 | -8;
  D.32586 = (unsigned char) D.32585;
  *code.859 = D.32586;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.860 = code;
        code = code.860 + 1;
        D.32591 = imb.b[0];
        *code.860 = D.32591;
        code.861 = code;
        code = code.861 + 1;
        D.32593 = imb.b[1];
        *code.861 = D.32593;
        code.862 = code;
        code = code.862 + 1;
        D.32595 = imb.b[2];
        *code.862 = D.32595;
        code.863 = code;
        code = code.863 + 1;
        D.32597 = imb.b[3];
        *code.863 = D.32597;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32587>:
  <D.24937>:
  goto <D.24796>;
  <D.24939>:
  code.864 = code;
  code = code.864 + 1;
  *code.864 = 57;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32599>; else goto <D.32600>;
  <D.32599>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32601>; else goto <D.32602>;
  <D.32601>:
  code.865 = code;
  code = code.865 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.865 = D.32608;
  code.866 = code;
  code = code.866 + 1;
  *code.866 = 36;
  goto <D.32610>;
  <D.32602>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32611>; else goto <D.32612>;
  <D.32611>:
  code.867 = code;
  code = code.867 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.867 = D.32615;
  code.868 = code;
  code = code.868 + 1;
  *code.868 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32617>;
  <D.32612>:
  code.869 = code;
  code = code.869 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.869 = D.32620;
  code.870 = code;
  code = code.870 + 1;
  *code.870 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.871 = code;
        code = code.871 + 1;
        D.32623 = imb.b[0];
        *code.871 = D.32623;
        code.872 = code;
        code = code.872 + 1;
        D.32625 = imb.b[1];
        *code.872 = D.32625;
        code.873 = code;
        code = code.873 + 1;
        D.32627 = imb.b[2];
        *code.873 = D.32627;
        code.874 = code;
        code = code.874 + 1;
        D.32629 = imb.b[3];
        *code.874 = D.32629;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32617>:
  <D.32610>:
  goto <D.24941>;
  <D.32600>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32630>; else goto <D.32631>;
  <D.32630>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32632>; else goto <D.32633>;
  <D.32632>:
  code.875 = code;
  code = code.875 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.875 = D.32636;
  goto <D.24941>;
  <D.32633>:
  <D.32631>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32637>; else goto <D.32638>;
  <D.32637>:
  code.876 = code;
  code = code.876 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.876 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32643>;
  <D.32638>:
  code.877 = code;
  code = code.877 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.877 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.878 = code;
        code = code.878 + 1;
        D.32649 = imb.b[0];
        *code.878 = D.32649;
        code.879 = code;
        code = code.879 + 1;
        D.32651 = imb.b[1];
        *code.879 = D.32651;
        code.880 = code;
        code = code.880 + 1;
        D.32653 = imb.b[2];
        *code.880 = D.32653;
        code.881 = code;
        code = code.881 + 1;
        D.32655 = imb.b[3];
        *code.881 = D.32655;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32643>:
  <D.24941>:
  goto <D.24796>;
  <D.24943>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.32656>; else goto <D.32657>;
  <D.32656>:
  code.882 = code;
  code = code.882 + 1;
  *code.882 = 131;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32659>; else goto <D.32660>;
  <D.32659>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32661>; else goto <D.32662>;
  <D.32661>:
  code.883 = code;
  code = code.883 + 1;
  *code.883 = 60;
  code.884 = code;
  code = code.884 + 1;
  *code.884 = 36;
  goto <D.32665>;
  <D.32662>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32666>; else goto <D.32667>;
  <D.32666>:
  code.885 = code;
  code = code.885 + 1;
  *code.885 = 124;
  code.886 = code;
  code = code.886 + 1;
  *code.886 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32670>;
  <D.32667>:
  code.887 = code;
  code = code.887 + 1;
  *code.887 = 188;
  code.888 = code;
  code = code.888 + 1;
  *code.888 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.889 = code;
        code = code.889 + 1;
        D.32674 = imb.b[0];
        *code.889 = D.32674;
        code.890 = code;
        code = code.890 + 1;
        D.32676 = imb.b[1];
        *code.890 = D.32676;
        code.891 = code;
        code = code.891 + 1;
        D.32678 = imb.b[2];
        *code.891 = D.32678;
        code.892 = code;
        code = code.892 + 1;
        D.32680 = imb.b[3];
        *code.892 = D.32680;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32670>:
  <D.32665>:
  goto <D.24945>;
  <D.32660>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32681>; else goto <D.32682>;
  <D.32681>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32683>; else goto <D.32684>;
  <D.32683>:
  code.893 = code;
  code = code.893 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32686 = D.31586 | 56;
  D.32687 = (unsigned char) D.32686;
  *code.893 = D.32687;
  goto <D.24945>;
  <D.32684>:
  <D.32682>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32688>; else goto <D.32689>;
  <D.32688>:
  code.894 = code;
  code = code.894 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32691 = D.31586 | 120;
  D.32692 = (unsigned char) D.32691;
  *code.894 = D.32692;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32693>;
  <D.32689>:
  code.895 = code;
  code = code.895 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32695 = D.31586 | -72;
  D.32696 = (unsigned char) D.32695;
  *code.895 = D.32696;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.896 = code;
        code = code.896 + 1;
        D.32698 = imb.b[0];
        *code.896 = D.32698;
        code.897 = code;
        code = code.897 + 1;
        D.32700 = imb.b[1];
        *code.897 = D.32700;
        code.898 = code;
        code = code.898 + 1;
        D.32702 = imb.b[2];
        *code.898 = D.32702;
        code.899 = code;
        code = code.899 + 1;
        D.32704 = imb.b[3];
        *code.899 = D.32704;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32693>:
  <D.24945>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.32705>;
  <D.32657>:
  code.900 = code;
  code = code.900 + 1;
  *code.900 = 129;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32707>; else goto <D.32708>;
  <D.32707>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32709>; else goto <D.32710>;
  <D.32709>:
  code.901 = code;
  code = code.901 + 1;
  *code.901 = 60;
  code.902 = code;
  code = code.902 + 1;
  *code.902 = 36;
  goto <D.32713>;
  <D.32710>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32714>; else goto <D.32715>;
  <D.32714>:
  code.903 = code;
  code = code.903 + 1;
  *code.903 = 124;
  code.904 = code;
  code = code.904 + 1;
  *code.904 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32718>;
  <D.32715>:
  code.905 = code;
  code = code.905 + 1;
  *code.905 = 188;
  code.906 = code;
  code = code.906 + 1;
  *code.906 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.907 = code;
        code = code.907 + 1;
        D.32722 = imb.b[0];
        *code.907 = D.32722;
        code.908 = code;
        code = code.908 + 1;
        D.32724 = imb.b[1];
        *code.908 = D.32724;
        code.909 = code;
        code = code.909 + 1;
        D.32726 = imb.b[2];
        *code.909 = D.32726;
        code.910 = code;
        code = code.910 + 1;
        D.32728 = imb.b[3];
        *code.910 = D.32728;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32718>:
  <D.32713>:
  goto <D.24948>;
  <D.32708>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32729>; else goto <D.32730>;
  <D.32729>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32731>; else goto <D.32732>;
  <D.32731>:
  code.911 = code;
  code = code.911 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32686 = D.31586 | 56;
  D.32687 = (unsigned char) D.32686;
  *code.911 = D.32687;
  goto <D.24948>;
  <D.32732>:
  <D.32730>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32734>; else goto <D.32735>;
  <D.32734>:
  code.912 = code;
  code = code.912 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32691 = D.31586 | 120;
  D.32692 = (unsigned char) D.32691;
  *code.912 = D.32692;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32737>;
  <D.32735>:
  code.913 = code;
  code = code.913 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32695 = D.31586 | -72;
  D.32696 = (unsigned char) D.32695;
  *code.913 = D.32696;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.914 = code;
        code = code.914 + 1;
        D.32740 = imb.b[0];
        *code.914 = D.32740;
        code.915 = code;
        code = code.915 + 1;
        D.32742 = imb.b[1];
        *code.915 = D.32742;
        code.916 = code;
        code = code.916 + 1;
        D.32744 = imb.b[2];
        *code.916 = D.32744;
        code.917 = code;
        code = code.917 + 1;
        D.32746 = imb.b[3];
        *code.917 = D.32746;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32737>:
  <D.24948>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.918 = code;
        code = code.918 + 1;
        D.32748 = imb.b[0];
        *code.918 = D.32748;
        code.919 = code;
        code = code.919 + 1;
        D.32750 = imb.b[1];
        *code.919 = D.32750;
        code.920 = code;
        code = code.920 + 1;
        D.32752 = imb.b[2];
        *code.920 = D.32752;
        code.921 = code;
        code = code.921 + 1;
        D.32754 = imb.b[3];
        *code.921 = D.32754;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32705>:
  goto <D.24796>;
  <D.24951>:
  code.922 = code;
  code = code.922 + 1;
  *code.922 = 128;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32756>; else goto <D.32757>;
  <D.32756>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32758>; else goto <D.32759>;
  <D.32758>:
  code.923 = code;
  code = code.923 + 1;
  *code.923 = 60;
  code.924 = code;
  code = code.924 + 1;
  *code.924 = 36;
  goto <D.32762>;
  <D.32759>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32763>; else goto <D.32764>;
  <D.32763>:
  code.925 = code;
  code = code.925 + 1;
  *code.925 = 124;
  code.926 = code;
  code = code.926 + 1;
  *code.926 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32767>;
  <D.32764>:
  code.927 = code;
  code = code.927 + 1;
  *code.927 = 188;
  code.928 = code;
  code = code.928 + 1;
  *code.928 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.929 = code;
        code = code.929 + 1;
        D.32771 = imb.b[0];
        *code.929 = D.32771;
        code.930 = code;
        code = code.930 + 1;
        D.32773 = imb.b[1];
        *code.930 = D.32773;
        code.931 = code;
        code = code.931 + 1;
        D.32775 = imb.b[2];
        *code.931 = D.32775;
        code.932 = code;
        code = code.932 + 1;
        D.32777 = imb.b[3];
        *code.932 = D.32777;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32767>:
  <D.32762>:
  goto <D.24953>;
  <D.32757>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32778>; else goto <D.32779>;
  <D.32778>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32780>; else goto <D.32781>;
  <D.32780>:
  code.933 = code;
  code = code.933 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32686 = D.31586 | 56;
  D.32687 = (unsigned char) D.32686;
  *code.933 = D.32687;
  goto <D.24953>;
  <D.32781>:
  <D.32779>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32783>; else goto <D.32784>;
  <D.32783>:
  code.934 = code;
  code = code.934 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32691 = D.31586 | 120;
  D.32692 = (unsigned char) D.32691;
  *code.934 = D.32692;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32786>;
  <D.32784>:
  code.935 = code;
  code = code.935 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32695 = D.31586 | -72;
  D.32696 = (unsigned char) D.32695;
  *code.935 = D.32696;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.936 = code;
        code = code.936 + 1;
        D.32789 = imb.b[0];
        *code.936 = D.32789;
        code.937 = code;
        code = code.937 + 1;
        D.32791 = imb.b[1];
        *code.937 = D.32791;
        code.938 = code;
        code = code.938 + 1;
        D.32793 = imb.b[2];
        *code.938 = D.32793;
        code.939 = code;
        code = code.939 + 1;
        D.32795 = imb.b[3];
        *code.939 = D.32795;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32786>:
  <D.24953>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.24955>:
  code.940 = code;
  code = code.940 + 1;
  *code.940 = 59;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.32797>; else goto <D.32798>;
  <D.32797>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32799>; else goto <D.32800>;
  <D.32799>:
  code.941 = code;
  code = code.941 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.941 = D.32039;
  code.942 = code;
  code = code.942 + 1;
  *code.942 = 36;
  goto <D.32803>;
  <D.32800>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32804>; else goto <D.32805>;
  <D.32804>:
  code.943 = code;
  code = code.943 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.943 = D.32046;
  code.944 = code;
  code = code.944 + 1;
  *code.944 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32808>;
  <D.32805>:
  code.945 = code;
  code = code.945 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.945 = D.32051;
  code.946 = code;
  code = code.946 + 1;
  *code.946 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.947 = code;
        code = code.947 + 1;
        D.32812 = imb.b[0];
        *code.947 = D.32812;
        code.948 = code;
        code = code.948 + 1;
        D.32814 = imb.b[1];
        *code.948 = D.32814;
        code.949 = code;
        code = code.949 + 1;
        D.32816 = imb.b[2];
        *code.949 = D.32816;
        code.950 = code;
        code = code.950 + 1;
        D.32818 = imb.b[3];
        *code.950 = D.32818;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32808>:
  <D.32803>:
  goto <D.24957>;
  <D.32798>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32819>; else goto <D.32820>;
  <D.32819>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.32821>; else goto <D.32822>;
  <D.32821>:
  code.951 = code;
  code = code.951 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.951 = D.32825;
  goto <D.24957>;
  <D.32822>:
  <D.32820>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32826>; else goto <D.32827>;
  <D.32826>:
  code.952 = code;
  code = code.952 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.952 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32831>;
  <D.32827>:
  code.953 = code;
  code = code.953 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.953 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.954 = code;
        code = code.954 + 1;
        D.32836 = imb.b[0];
        *code.954 = D.32836;
        code.955 = code;
        code = code.955 + 1;
        D.32838 = imb.b[1];
        *code.955 = D.32838;
        code.956 = code;
        code = code.956 + 1;
        D.32840 = imb.b[2];
        *code.956 = D.32840;
        code.957 = code;
        code = code.957 + 1;
        D.32842 = imb.b[3];
        *code.957 = D.32842;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32831>:
  <D.24957>:
  goto <D.24796>;
  <D.24959>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.32843>; else goto <D.32844>;
  <D.32843>:
  code.958 = code;
  code = code.958 + 1;
  *code.958 = 131;
  code.959 = code;
  code = code.959 + 1;
  *code.959 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.960 = code;
        code = code.960 + 1;
        D.32848 = imb.b[0];
        *code.960 = D.32848;
        code.961 = code;
        code = code.961 + 1;
        D.32850 = imb.b[1];
        *code.961 = D.32850;
        code.962 = code;
        code = code.962 + 1;
        D.32852 = imb.b[2];
        *code.962 = D.32852;
        code.963 = code;
        code = code.963 + 1;
        D.32854 = imb.b[3];
        *code.963 = D.32854;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.32855>;
  <D.32844>:
  code.964 = code;
  code = code.964 + 1;
  *code.964 = 129;
  code.965 = code;
  code = code.965 + 1;
  *code.965 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.966 = code;
        code = code.966 + 1;
        D.32859 = imb.b[0];
        *code.966 = D.32859;
        code.967 = code;
        code = code.967 + 1;
        D.32861 = imb.b[1];
        *code.967 = D.32861;
        code.968 = code;
        code = code.968 + 1;
        D.32863 = imb.b[2];
        *code.968 = D.32863;
        code.969 = code;
        code = code.969 + 1;
        D.32865 = imb.b[3];
        *code.969 = D.32865;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.970 = code;
        code = code.970 + 1;
        D.32867 = imb.b[0];
        *code.970 = D.32867;
        code.971 = code;
        code = code.971 + 1;
        D.32869 = imb.b[1];
        *code.971 = D.32869;
        code.972 = code;
        code = code.972 + 1;
        D.32871 = imb.b[2];
        *code.972 = D.32871;
        code.973 = code;
        code = code.973 + 1;
        D.32873 = imb.b[3];
        *code.973 = D.32873;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32855>:
  goto <D.24796>;
  <D.24963>:
  code.974 = code;
  code = code.974 + 1;
  *code.974 = 133;
  code.975 = code;
  code = code.975 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32876 = D.32565 | D.31586;
  D.32877 = (unsigned char) D.32876;
  *code.975 = D.32877;
  goto <D.24796>;
  <D.24964>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.32878>; else goto <D.32879>;
  <D.32878>:
  code.976 = code;
  code = code.976 + 1;
  *code.976 = 131;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32881>; else goto <D.32882>;
  <D.32881>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32883>; else goto <D.32884>;
  <D.32883>:
  code.977 = code;
  code = code.977 + 1;
  *code.977 = 4;
  code.978 = code;
  code = code.978 + 1;
  *code.978 = 36;
  goto <D.32887>;
  <D.32884>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32888>; else goto <D.32889>;
  <D.32888>:
  code.979 = code;
  code = code.979 + 1;
  *code.979 = 68;
  code.980 = code;
  code = code.980 + 1;
  *code.980 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32892>;
  <D.32889>:
  code.981 = code;
  code = code.981 + 1;
  *code.981 = 132;
  code.982 = code;
  code = code.982 + 1;
  *code.982 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.983 = code;
        code = code.983 + 1;
        D.32896 = imb.b[0];
        *code.983 = D.32896;
        code.984 = code;
        code = code.984 + 1;
        D.32898 = imb.b[1];
        *code.984 = D.32898;
        code.985 = code;
        code = code.985 + 1;
        D.32900 = imb.b[2];
        *code.985 = D.32900;
        code.986 = code;
        code = code.986 + 1;
        D.32902 = imb.b[3];
        *code.986 = D.32902;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32892>:
  <D.32887>:
  goto <D.24966>;
  <D.32882>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32903>; else goto <D.32904>;
  <D.32903>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32905>; else goto <D.32906>;
  <D.32905>:
  code.987 = code;
  code = code.987 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.987 = D.31581;
  goto <D.24966>;
  <D.32906>:
  <D.32904>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32908>; else goto <D.32909>;
  <D.32908>:
  code.988 = code;
  code = code.988 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.988 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32911>;
  <D.32909>:
  code.989 = code;
  code = code.989 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.989 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.990 = code;
        code = code.990 + 1;
        D.32914 = imb.b[0];
        *code.990 = D.32914;
        code.991 = code;
        code = code.991 + 1;
        D.32916 = imb.b[1];
        *code.991 = D.32916;
        code.992 = code;
        code = code.992 + 1;
        D.32918 = imb.b[2];
        *code.992 = D.32918;
        code.993 = code;
        code = code.993 + 1;
        D.32920 = imb.b[3];
        *code.993 = D.32920;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32911>:
  <D.24966>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.32921>;
  <D.32879>:
  code.994 = code;
  code = code.994 + 1;
  *code.994 = 129;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.32923>; else goto <D.32924>;
  <D.32923>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32925>; else goto <D.32926>;
  <D.32925>:
  code.995 = code;
  code = code.995 + 1;
  *code.995 = 4;
  code.996 = code;
  code = code.996 + 1;
  *code.996 = 36;
  goto <D.32929>;
  <D.32926>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32930>; else goto <D.32931>;
  <D.32930>:
  code.997 = code;
  code = code.997 + 1;
  *code.997 = 68;
  code.998 = code;
  code = code.998 + 1;
  *code.998 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32934>;
  <D.32931>:
  code.999 = code;
  code = code.999 + 1;
  *code.999 = 132;
  code.1000 = code;
  code = code.1000 + 1;
  *code.1000 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1001 = code;
        code = code.1001 + 1;
        D.32938 = imb.b[0];
        *code.1001 = D.32938;
        code.1002 = code;
        code = code.1002 + 1;
        D.32940 = imb.b[1];
        *code.1002 = D.32940;
        code.1003 = code;
        code = code.1003 + 1;
        D.32942 = imb.b[2];
        *code.1003 = D.32942;
        code.1004 = code;
        code = code.1004 + 1;
        D.32944 = imb.b[3];
        *code.1004 = D.32944;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32934>:
  <D.32929>:
  goto <D.24969>;
  <D.32924>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32945>; else goto <D.32946>;
  <D.32945>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.32947>; else goto <D.32948>;
  <D.32947>:
  code.1005 = code;
  code = code.1005 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.1005 = D.31581;
  goto <D.24969>;
  <D.32948>:
  <D.32946>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32950>; else goto <D.32951>;
  <D.32950>:
  code.1006 = code;
  code = code.1006 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.1006 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32953>;
  <D.32951>:
  code.1007 = code;
  code = code.1007 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.1007 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1008 = code;
        code = code.1008 + 1;
        D.32956 = imb.b[0];
        *code.1008 = D.32956;
        code.1009 = code;
        code = code.1009 + 1;
        D.32958 = imb.b[1];
        *code.1009 = D.32958;
        code.1010 = code;
        code = code.1010 + 1;
        D.32960 = imb.b[2];
        *code.1010 = D.32960;
        code.1011 = code;
        code = code.1011 + 1;
        D.32962 = imb.b[3];
        *code.1011 = D.32962;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32953>:
  <D.24969>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1012 = code;
        code = code.1012 + 1;
        D.32964 = imb.b[0];
        *code.1012 = D.32964;
        code.1013 = code;
        code = code.1013 + 1;
        D.32966 = imb.b[1];
        *code.1013 = D.32966;
        code.1014 = code;
        code = code.1014 + 1;
        D.32968 = imb.b[2];
        *code.1014 = D.32968;
        code.1015 = code;
        code = code.1015 + 1;
        D.32970 = imb.b[3];
        *code.1015 = D.32970;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32921>:
  goto <D.24796>;
  <D.24972>:
  code.1016 = code;
  code = code.1016 + 1;
  *code.1016 = 3;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.32972>; else goto <D.32973>;
  <D.32972>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32974>; else goto <D.32975>;
  <D.32974>:
  code.1017 = code;
  code = code.1017 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.1017 = D.32039;
  code.1018 = code;
  code = code.1018 + 1;
  *code.1018 = 36;
  goto <D.32978>;
  <D.32975>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32979>; else goto <D.32980>;
  <D.32979>:
  code.1019 = code;
  code = code.1019 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.1019 = D.32046;
  code.1020 = code;
  code = code.1020 + 1;
  *code.1020 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.32983>;
  <D.32980>:
  code.1021 = code;
  code = code.1021 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.1021 = D.32051;
  code.1022 = code;
  code = code.1022 + 1;
  *code.1022 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1023 = code;
        code = code.1023 + 1;
        D.32987 = imb.b[0];
        *code.1023 = D.32987;
        code.1024 = code;
        code = code.1024 + 1;
        D.32989 = imb.b[1];
        *code.1024 = D.32989;
        code.1025 = code;
        code = code.1025 + 1;
        D.32991 = imb.b[2];
        *code.1025 = D.32991;
        code.1026 = code;
        code = code.1026 + 1;
        D.32993 = imb.b[3];
        *code.1026 = D.32993;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32983>:
  <D.32978>:
  goto <D.24974>;
  <D.32973>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.32994>; else goto <D.32995>;
  <D.32994>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.32996>; else goto <D.32997>;
  <D.32996>:
  code.1027 = code;
  code = code.1027 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.1027 = D.32825;
  goto <D.24974>;
  <D.32997>:
  <D.32995>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.32999>; else goto <D.33000>;
  <D.32999>:
  code.1028 = code;
  code = code.1028 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.1028 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33002>;
  <D.33000>:
  code.1029 = code;
  code = code.1029 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.1029 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1030 = code;
        code = code.1030 + 1;
        D.33005 = imb.b[0];
        *code.1030 = D.33005;
        code.1031 = code;
        code = code.1031 + 1;
        D.33007 = imb.b[1];
        *code.1031 = D.33007;
        code.1032 = code;
        code = code.1032 + 1;
        D.33009 = imb.b[2];
        *code.1032 = D.33009;
        code.1033 = code;
        code = code.1033 + 1;
        D.33011 = imb.b[3];
        *code.1033 = D.33011;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33002>:
  <D.24974>:
  goto <D.24796>;
  <D.24976>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.33012>; else goto <D.33013>;
  <D.33012>:
  code.1034 = code;
  code = code.1034 + 1;
  *code.1034 = 131;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33015>; else goto <D.33016>;
  <D.33015>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33017>; else goto <D.33018>;
  <D.33017>:
  code.1035 = code;
  code = code.1035 + 1;
  *code.1035 = 44;
  code.1036 = code;
  code = code.1036 + 1;
  *code.1036 = 36;
  goto <D.33021>;
  <D.33018>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33022>; else goto <D.33023>;
  <D.33022>:
  code.1037 = code;
  code = code.1037 + 1;
  *code.1037 = 108;
  code.1038 = code;
  code = code.1038 + 1;
  *code.1038 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33026>;
  <D.33023>:
  code.1039 = code;
  code = code.1039 + 1;
  *code.1039 = 172;
  code.1040 = code;
  code = code.1040 + 1;
  *code.1040 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1041 = code;
        code = code.1041 + 1;
        D.33030 = imb.b[0];
        *code.1041 = D.33030;
        code.1042 = code;
        code = code.1042 + 1;
        D.33032 = imb.b[1];
        *code.1042 = D.33032;
        code.1043 = code;
        code = code.1043 + 1;
        D.33034 = imb.b[2];
        *code.1043 = D.33034;
        code.1044 = code;
        code = code.1044 + 1;
        D.33036 = imb.b[3];
        *code.1044 = D.33036;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33026>:
  <D.33021>:
  goto <D.24978>;
  <D.33016>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33037>; else goto <D.33038>;
  <D.33037>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33039>; else goto <D.33040>;
  <D.33039>:
  code.1045 = code;
  code = code.1045 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33042 = D.31586 | 40;
  D.33043 = (unsigned char) D.33042;
  *code.1045 = D.33043;
  goto <D.24978>;
  <D.33040>:
  <D.33038>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33044>; else goto <D.33045>;
  <D.33044>:
  code.1046 = code;
  code = code.1046 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33047 = D.31586 | 104;
  D.33048 = (unsigned char) D.33047;
  *code.1046 = D.33048;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33049>;
  <D.33045>:
  code.1047 = code;
  code = code.1047 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33051 = D.31586 | -88;
  D.33052 = (unsigned char) D.33051;
  *code.1047 = D.33052;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1048 = code;
        code = code.1048 + 1;
        D.33054 = imb.b[0];
        *code.1048 = D.33054;
        code.1049 = code;
        code = code.1049 + 1;
        D.33056 = imb.b[1];
        *code.1049 = D.33056;
        code.1050 = code;
        code = code.1050 + 1;
        D.33058 = imb.b[2];
        *code.1050 = D.33058;
        code.1051 = code;
        code = code.1051 + 1;
        D.33060 = imb.b[3];
        *code.1051 = D.33060;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33049>:
  <D.24978>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.33061>;
  <D.33013>:
  code.1052 = code;
  code = code.1052 + 1;
  *code.1052 = 129;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33063>; else goto <D.33064>;
  <D.33063>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33065>; else goto <D.33066>;
  <D.33065>:
  code.1053 = code;
  code = code.1053 + 1;
  *code.1053 = 44;
  code.1054 = code;
  code = code.1054 + 1;
  *code.1054 = 36;
  goto <D.33069>;
  <D.33066>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33070>; else goto <D.33071>;
  <D.33070>:
  code.1055 = code;
  code = code.1055 + 1;
  *code.1055 = 108;
  code.1056 = code;
  code = code.1056 + 1;
  *code.1056 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33074>;
  <D.33071>:
  code.1057 = code;
  code = code.1057 + 1;
  *code.1057 = 172;
  code.1058 = code;
  code = code.1058 + 1;
  *code.1058 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1059 = code;
        code = code.1059 + 1;
        D.33078 = imb.b[0];
        *code.1059 = D.33078;
        code.1060 = code;
        code = code.1060 + 1;
        D.33080 = imb.b[1];
        *code.1060 = D.33080;
        code.1061 = code;
        code = code.1061 + 1;
        D.33082 = imb.b[2];
        *code.1061 = D.33082;
        code.1062 = code;
        code = code.1062 + 1;
        D.33084 = imb.b[3];
        *code.1062 = D.33084;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33074>:
  <D.33069>:
  goto <D.24981>;
  <D.33064>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33085>; else goto <D.33086>;
  <D.33085>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33087>; else goto <D.33088>;
  <D.33087>:
  code.1063 = code;
  code = code.1063 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33042 = D.31586 | 40;
  D.33043 = (unsigned char) D.33042;
  *code.1063 = D.33043;
  goto <D.24981>;
  <D.33088>:
  <D.33086>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33090>; else goto <D.33091>;
  <D.33090>:
  code.1064 = code;
  code = code.1064 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33047 = D.31586 | 104;
  D.33048 = (unsigned char) D.33047;
  *code.1064 = D.33048;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33093>;
  <D.33091>:
  code.1065 = code;
  code = code.1065 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33051 = D.31586 | -88;
  D.33052 = (unsigned char) D.33051;
  *code.1065 = D.33052;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1066 = code;
        code = code.1066 + 1;
        D.33096 = imb.b[0];
        *code.1066 = D.33096;
        code.1067 = code;
        code = code.1067 + 1;
        D.33098 = imb.b[1];
        *code.1067 = D.33098;
        code.1068 = code;
        code = code.1068 + 1;
        D.33100 = imb.b[2];
        *code.1068 = D.33100;
        code.1069 = code;
        code = code.1069 + 1;
        D.33102 = imb.b[3];
        *code.1069 = D.33102;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33093>:
  <D.24981>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1070 = code;
        code = code.1070 + 1;
        D.33104 = imb.b[0];
        *code.1070 = D.33104;
        code.1071 = code;
        code = code.1071 + 1;
        D.33106 = imb.b[1];
        *code.1071 = D.33106;
        code.1072 = code;
        code = code.1072 + 1;
        D.33108 = imb.b[2];
        *code.1072 = D.33108;
        code.1073 = code;
        code = code.1073 + 1;
        D.33110 = imb.b[3];
        *code.1073 = D.33110;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33061>:
  goto <D.24796>;
  <D.24984>:
  code.1074 = code;
  code = code.1074 + 1;
  *code.1074 = 43;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.33112>; else goto <D.33113>;
  <D.33112>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33114>; else goto <D.33115>;
  <D.33114>:
  code.1075 = code;
  code = code.1075 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.1075 = D.32039;
  code.1076 = code;
  code = code.1076 + 1;
  *code.1076 = 36;
  goto <D.33118>;
  <D.33115>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33119>; else goto <D.33120>;
  <D.33119>:
  code.1077 = code;
  code = code.1077 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.1077 = D.32046;
  code.1078 = code;
  code = code.1078 + 1;
  *code.1078 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33123>;
  <D.33120>:
  code.1079 = code;
  code = code.1079 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.1079 = D.32051;
  code.1080 = code;
  code = code.1080 + 1;
  *code.1080 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1081 = code;
        code = code.1081 + 1;
        D.33127 = imb.b[0];
        *code.1081 = D.33127;
        code.1082 = code;
        code = code.1082 + 1;
        D.33129 = imb.b[1];
        *code.1082 = D.33129;
        code.1083 = code;
        code = code.1083 + 1;
        D.33131 = imb.b[2];
        *code.1083 = D.33131;
        code.1084 = code;
        code = code.1084 + 1;
        D.33133 = imb.b[3];
        *code.1084 = D.33133;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33123>:
  <D.33118>:
  goto <D.24986>;
  <D.33113>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33134>; else goto <D.33135>;
  <D.33134>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.33136>; else goto <D.33137>;
  <D.33136>:
  code.1085 = code;
  code = code.1085 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.1085 = D.32825;
  goto <D.24986>;
  <D.33137>:
  <D.33135>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33139>; else goto <D.33140>;
  <D.33139>:
  code.1086 = code;
  code = code.1086 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.1086 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33142>;
  <D.33140>:
  code.1087 = code;
  code = code.1087 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.1087 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1088 = code;
        code = code.1088 + 1;
        D.33145 = imb.b[0];
        *code.1088 = D.33145;
        code.1089 = code;
        code = code.1089 + 1;
        D.33147 = imb.b[1];
        *code.1089 = D.33147;
        code.1090 = code;
        code = code.1090 + 1;
        D.33149 = imb.b[2];
        *code.1090 = D.33149;
        code.1091 = code;
        code = code.1091 + 1;
        D.33151 = imb.b[3];
        *code.1091 = D.33151;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33142>:
  <D.24986>:
  goto <D.24796>;
  <D.24988>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.33152>; else goto <D.33153>;
  <D.33152>:
  code.1092 = code;
  code = code.1092 + 1;
  *code.1092 = 131;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33155>; else goto <D.33156>;
  <D.33155>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33157>; else goto <D.33158>;
  <D.33157>:
  code.1093 = code;
  code = code.1093 + 1;
  *code.1093 = 36;
  code.1094 = code;
  code = code.1094 + 1;
  *code.1094 = 36;
  goto <D.33161>;
  <D.33158>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33162>; else goto <D.33163>;
  <D.33162>:
  code.1095 = code;
  code = code.1095 + 1;
  *code.1095 = 100;
  code.1096 = code;
  code = code.1096 + 1;
  *code.1096 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33166>;
  <D.33163>:
  code.1097 = code;
  code = code.1097 + 1;
  *code.1097 = 164;
  code.1098 = code;
  code = code.1098 + 1;
  *code.1098 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1099 = code;
        code = code.1099 + 1;
        D.33170 = imb.b[0];
        *code.1099 = D.33170;
        code.1100 = code;
        code = code.1100 + 1;
        D.33172 = imb.b[1];
        *code.1100 = D.33172;
        code.1101 = code;
        code = code.1101 + 1;
        D.33174 = imb.b[2];
        *code.1101 = D.33174;
        code.1102 = code;
        code = code.1102 + 1;
        D.33176 = imb.b[3];
        *code.1102 = D.33176;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33166>:
  <D.33161>:
  goto <D.24990>;
  <D.33156>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33177>; else goto <D.33178>;
  <D.33177>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33179>; else goto <D.33180>;
  <D.33179>:
  code.1103 = code;
  code = code.1103 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33182 = D.31586 | 32;
  D.33183 = (unsigned char) D.33182;
  *code.1103 = D.33183;
  goto <D.24990>;
  <D.33180>:
  <D.33178>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33184>; else goto <D.33185>;
  <D.33184>:
  code.1104 = code;
  code = code.1104 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33187 = D.31586 | 96;
  D.33188 = (unsigned char) D.33187;
  *code.1104 = D.33188;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33189>;
  <D.33185>:
  code.1105 = code;
  code = code.1105 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33191 = D.31586 | -96;
  D.33192 = (unsigned char) D.33191;
  *code.1105 = D.33192;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1106 = code;
        code = code.1106 + 1;
        D.33194 = imb.b[0];
        *code.1106 = D.33194;
        code.1107 = code;
        code = code.1107 + 1;
        D.33196 = imb.b[1];
        *code.1107 = D.33196;
        code.1108 = code;
        code = code.1108 + 1;
        D.33198 = imb.b[2];
        *code.1108 = D.33198;
        code.1109 = code;
        code = code.1109 + 1;
        D.33200 = imb.b[3];
        *code.1109 = D.33200;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33189>:
  <D.24990>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.33201>;
  <D.33153>:
  code.1110 = code;
  code = code.1110 + 1;
  *code.1110 = 129;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33203>; else goto <D.33204>;
  <D.33203>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33205>; else goto <D.33206>;
  <D.33205>:
  code.1111 = code;
  code = code.1111 + 1;
  *code.1111 = 36;
  code.1112 = code;
  code = code.1112 + 1;
  *code.1112 = 36;
  goto <D.33209>;
  <D.33206>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33210>; else goto <D.33211>;
  <D.33210>:
  code.1113 = code;
  code = code.1113 + 1;
  *code.1113 = 100;
  code.1114 = code;
  code = code.1114 + 1;
  *code.1114 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33214>;
  <D.33211>:
  code.1115 = code;
  code = code.1115 + 1;
  *code.1115 = 164;
  code.1116 = code;
  code = code.1116 + 1;
  *code.1116 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1117 = code;
        code = code.1117 + 1;
        D.33218 = imb.b[0];
        *code.1117 = D.33218;
        code.1118 = code;
        code = code.1118 + 1;
        D.33220 = imb.b[1];
        *code.1118 = D.33220;
        code.1119 = code;
        code = code.1119 + 1;
        D.33222 = imb.b[2];
        *code.1119 = D.33222;
        code.1120 = code;
        code = code.1120 + 1;
        D.33224 = imb.b[3];
        *code.1120 = D.33224;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33214>:
  <D.33209>:
  goto <D.24993>;
  <D.33204>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33225>; else goto <D.33226>;
  <D.33225>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33227>; else goto <D.33228>;
  <D.33227>:
  code.1121 = code;
  code = code.1121 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33182 = D.31586 | 32;
  D.33183 = (unsigned char) D.33182;
  *code.1121 = D.33183;
  goto <D.24993>;
  <D.33228>:
  <D.33226>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33230>; else goto <D.33231>;
  <D.33230>:
  code.1122 = code;
  code = code.1122 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33187 = D.31586 | 96;
  D.33188 = (unsigned char) D.33187;
  *code.1122 = D.33188;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33233>;
  <D.33231>:
  code.1123 = code;
  code = code.1123 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33191 = D.31586 | -96;
  D.33192 = (unsigned char) D.33191;
  *code.1123 = D.33192;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1124 = code;
        code = code.1124 + 1;
        D.33236 = imb.b[0];
        *code.1124 = D.33236;
        code.1125 = code;
        code = code.1125 + 1;
        D.33238 = imb.b[1];
        *code.1125 = D.33238;
        code.1126 = code;
        code = code.1126 + 1;
        D.33240 = imb.b[2];
        *code.1126 = D.33240;
        code.1127 = code;
        code = code.1127 + 1;
        D.33242 = imb.b[3];
        *code.1127 = D.33242;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33233>:
  <D.24993>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1128 = code;
        code = code.1128 + 1;
        D.33244 = imb.b[0];
        *code.1128 = D.33244;
        code.1129 = code;
        code = code.1129 + 1;
        D.33246 = imb.b[1];
        *code.1129 = D.33246;
        code.1130 = code;
        code = code.1130 + 1;
        D.33248 = imb.b[2];
        *code.1130 = D.33248;
        code.1131 = code;
        code = code.1131 + 1;
        D.33250 = imb.b[3];
        *code.1131 = D.33250;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33201>:
  goto <D.24796>;
  <D.24996>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.33251>; else goto <D.33252>;
  <D.33251>:
  code.1132 = code;
  code = code.1132 + 1;
  *code.1132 = 131;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33254>; else goto <D.33255>;
  <D.33254>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33256>; else goto <D.33257>;
  <D.33256>:
  code.1133 = code;
  code = code.1133 + 1;
  *code.1133 = 12;
  code.1134 = code;
  code = code.1134 + 1;
  *code.1134 = 36;
  goto <D.33260>;
  <D.33257>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33261>; else goto <D.33262>;
  <D.33261>:
  code.1135 = code;
  code = code.1135 + 1;
  *code.1135 = 76;
  code.1136 = code;
  code = code.1136 + 1;
  *code.1136 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33265>;
  <D.33262>:
  code.1137 = code;
  code = code.1137 + 1;
  *code.1137 = 140;
  code.1138 = code;
  code = code.1138 + 1;
  *code.1138 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1139 = code;
        code = code.1139 + 1;
        D.33269 = imb.b[0];
        *code.1139 = D.33269;
        code.1140 = code;
        code = code.1140 + 1;
        D.33271 = imb.b[1];
        *code.1140 = D.33271;
        code.1141 = code;
        code = code.1141 + 1;
        D.33273 = imb.b[2];
        *code.1141 = D.33273;
        code.1142 = code;
        code = code.1142 + 1;
        D.33275 = imb.b[3];
        *code.1142 = D.33275;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33265>:
  <D.33260>:
  goto <D.24998>;
  <D.33255>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33276>; else goto <D.33277>;
  <D.33276>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33278>; else goto <D.33279>;
  <D.33278>:
  code.1143 = code;
  code = code.1143 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33281 = D.31586 | 8;
  D.33282 = (unsigned char) D.33281;
  *code.1143 = D.33282;
  goto <D.24998>;
  <D.33279>:
  <D.33277>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33283>; else goto <D.33284>;
  <D.33283>:
  code.1144 = code;
  code = code.1144 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33286 = D.31586 | 72;
  D.33287 = (unsigned char) D.33286;
  *code.1144 = D.33287;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33288>;
  <D.33284>:
  code.1145 = code;
  code = code.1145 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33290 = D.31586 | -120;
  D.33291 = (unsigned char) D.33290;
  *code.1145 = D.33291;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1146 = code;
        code = code.1146 + 1;
        D.33293 = imb.b[0];
        *code.1146 = D.33293;
        code.1147 = code;
        code = code.1147 + 1;
        D.33295 = imb.b[1];
        *code.1147 = D.33295;
        code.1148 = code;
        code = code.1148 + 1;
        D.33297 = imb.b[2];
        *code.1148 = D.33297;
        code.1149 = code;
        code = code.1149 + 1;
        D.33299 = imb.b[3];
        *code.1149 = D.33299;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33288>:
  <D.24998>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.33300>;
  <D.33252>:
  code.1150 = code;
  code = code.1150 + 1;
  *code.1150 = 129;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33302>; else goto <D.33303>;
  <D.33302>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33304>; else goto <D.33305>;
  <D.33304>:
  code.1151 = code;
  code = code.1151 + 1;
  *code.1151 = 12;
  code.1152 = code;
  code = code.1152 + 1;
  *code.1152 = 36;
  goto <D.33308>;
  <D.33305>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33309>; else goto <D.33310>;
  <D.33309>:
  code.1153 = code;
  code = code.1153 + 1;
  *code.1153 = 76;
  code.1154 = code;
  code = code.1154 + 1;
  *code.1154 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33313>;
  <D.33310>:
  code.1155 = code;
  code = code.1155 + 1;
  *code.1155 = 140;
  code.1156 = code;
  code = code.1156 + 1;
  *code.1156 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1157 = code;
        code = code.1157 + 1;
        D.33317 = imb.b[0];
        *code.1157 = D.33317;
        code.1158 = code;
        code = code.1158 + 1;
        D.33319 = imb.b[1];
        *code.1158 = D.33319;
        code.1159 = code;
        code = code.1159 + 1;
        D.33321 = imb.b[2];
        *code.1159 = D.33321;
        code.1160 = code;
        code = code.1160 + 1;
        D.33323 = imb.b[3];
        *code.1160 = D.33323;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33313>:
  <D.33308>:
  goto <D.25001>;
  <D.33303>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33324>; else goto <D.33325>;
  <D.33324>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33326>; else goto <D.33327>;
  <D.33326>:
  code.1161 = code;
  code = code.1161 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33281 = D.31586 | 8;
  D.33282 = (unsigned char) D.33281;
  *code.1161 = D.33282;
  goto <D.25001>;
  <D.33327>:
  <D.33325>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33329>; else goto <D.33330>;
  <D.33329>:
  code.1162 = code;
  code = code.1162 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33286 = D.31586 | 72;
  D.33287 = (unsigned char) D.33286;
  *code.1162 = D.33287;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33332>;
  <D.33330>:
  code.1163 = code;
  code = code.1163 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33290 = D.31586 | -120;
  D.33291 = (unsigned char) D.33290;
  *code.1163 = D.33291;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1164 = code;
        code = code.1164 + 1;
        D.33335 = imb.b[0];
        *code.1164 = D.33335;
        code.1165 = code;
        code = code.1165 + 1;
        D.33337 = imb.b[1];
        *code.1165 = D.33337;
        code.1166 = code;
        code = code.1166 + 1;
        D.33339 = imb.b[2];
        *code.1166 = D.33339;
        code.1167 = code;
        code = code.1167 + 1;
        D.33341 = imb.b[3];
        *code.1167 = D.33341;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33332>:
  <D.25001>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1168 = code;
        code = code.1168 + 1;
        D.33343 = imb.b[0];
        *code.1168 = D.33343;
        code.1169 = code;
        code = code.1169 + 1;
        D.33345 = imb.b[1];
        *code.1169 = D.33345;
        code.1170 = code;
        code = code.1170 + 1;
        D.33347 = imb.b[2];
        *code.1170 = D.33347;
        code.1171 = code;
        code = code.1171 + 1;
        D.33349 = imb.b[3];
        *code.1171 = D.33349;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33300>:
  goto <D.24796>;
  <D.25004>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.33350>; else goto <D.33351>;
  <D.33350>:
  code.1172 = code;
  code = code.1172 + 1;
  *code.1172 = 131;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33353>; else goto <D.33354>;
  <D.33353>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33355>; else goto <D.33356>;
  <D.33355>:
  code.1173 = code;
  code = code.1173 + 1;
  *code.1173 = 52;
  code.1174 = code;
  code = code.1174 + 1;
  *code.1174 = 36;
  goto <D.33359>;
  <D.33356>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33360>; else goto <D.33361>;
  <D.33360>:
  code.1175 = code;
  code = code.1175 + 1;
  *code.1175 = 116;
  code.1176 = code;
  code = code.1176 + 1;
  *code.1176 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33364>;
  <D.33361>:
  code.1177 = code;
  code = code.1177 + 1;
  *code.1177 = 180;
  code.1178 = code;
  code = code.1178 + 1;
  *code.1178 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1179 = code;
        code = code.1179 + 1;
        D.33368 = imb.b[0];
        *code.1179 = D.33368;
        code.1180 = code;
        code = code.1180 + 1;
        D.33370 = imb.b[1];
        *code.1180 = D.33370;
        code.1181 = code;
        code = code.1181 + 1;
        D.33372 = imb.b[2];
        *code.1181 = D.33372;
        code.1182 = code;
        code = code.1182 + 1;
        D.33374 = imb.b[3];
        *code.1182 = D.33374;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33364>:
  <D.33359>:
  goto <D.25006>;
  <D.33354>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33375>; else goto <D.33376>;
  <D.33375>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33377>; else goto <D.33378>;
  <D.33377>:
  code.1183 = code;
  code = code.1183 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33380 = D.31586 | 48;
  D.33381 = (unsigned char) D.33380;
  *code.1183 = D.33381;
  goto <D.25006>;
  <D.33378>:
  <D.33376>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33382>; else goto <D.33383>;
  <D.33382>:
  code.1184 = code;
  code = code.1184 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33385 = D.31586 | 112;
  D.33386 = (unsigned char) D.33385;
  *code.1184 = D.33386;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33387>;
  <D.33383>:
  code.1185 = code;
  code = code.1185 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33389 = D.31586 | -80;
  D.33390 = (unsigned char) D.33389;
  *code.1185 = D.33390;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1186 = code;
        code = code.1186 + 1;
        D.33392 = imb.b[0];
        *code.1186 = D.33392;
        code.1187 = code;
        code = code.1187 + 1;
        D.33394 = imb.b[1];
        *code.1187 = D.33394;
        code.1188 = code;
        code = code.1188 + 1;
        D.33396 = imb.b[2];
        *code.1188 = D.33396;
        code.1189 = code;
        code = code.1189 + 1;
        D.33398 = imb.b[3];
        *code.1189 = D.33398;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33387>:
  <D.25006>:
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.33399>;
  <D.33351>:
  code.1190 = code;
  code = code.1190 + 1;
  *code.1190 = 129;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33401>; else goto <D.33402>;
  <D.33401>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33403>; else goto <D.33404>;
  <D.33403>:
  code.1191 = code;
  code = code.1191 + 1;
  *code.1191 = 52;
  code.1192 = code;
  code = code.1192 + 1;
  *code.1192 = 36;
  goto <D.33407>;
  <D.33404>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33408>; else goto <D.33409>;
  <D.33408>:
  code.1193 = code;
  code = code.1193 + 1;
  *code.1193 = 116;
  code.1194 = code;
  code = code.1194 + 1;
  *code.1194 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33412>;
  <D.33409>:
  code.1195 = code;
  code = code.1195 + 1;
  *code.1195 = 180;
  code.1196 = code;
  code = code.1196 + 1;
  *code.1196 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1197 = code;
        code = code.1197 + 1;
        D.33416 = imb.b[0];
        *code.1197 = D.33416;
        code.1198 = code;
        code = code.1198 + 1;
        D.33418 = imb.b[1];
        *code.1198 = D.33418;
        code.1199 = code;
        code = code.1199 + 1;
        D.33420 = imb.b[2];
        *code.1199 = D.33420;
        code.1200 = code;
        code = code.1200 + 1;
        D.33422 = imb.b[3];
        *code.1200 = D.33422;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33412>:
  <D.33407>:
  goto <D.25009>;
  <D.33402>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33423>; else goto <D.33424>;
  <D.33423>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33425>; else goto <D.33426>;
  <D.33425>:
  code.1201 = code;
  code = code.1201 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33380 = D.31586 | 48;
  D.33381 = (unsigned char) D.33380;
  *code.1201 = D.33381;
  goto <D.25009>;
  <D.33426>:
  <D.33424>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33428>; else goto <D.33429>;
  <D.33428>:
  code.1202 = code;
  code = code.1202 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33385 = D.31586 | 112;
  D.33386 = (unsigned char) D.33385;
  *code.1202 = D.33386;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33431>;
  <D.33429>:
  code.1203 = code;
  code = code.1203 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33389 = D.31586 | -80;
  D.33390 = (unsigned char) D.33389;
  *code.1203 = D.33390;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1204 = code;
        code = code.1204 + 1;
        D.33434 = imb.b[0];
        *code.1204 = D.33434;
        code.1205 = code;
        code = code.1205 + 1;
        D.33436 = imb.b[1];
        *code.1205 = D.33436;
        code.1206 = code;
        code = code.1206 + 1;
        D.33438 = imb.b[2];
        *code.1206 = D.33438;
        code.1207 = code;
        code = code.1207 + 1;
        D.33440 = imb.b[3];
        *code.1207 = D.33440;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33431>:
  <D.25009>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1208 = code;
        code = code.1208 + 1;
        D.33442 = imb.b[0];
        *code.1208 = D.33442;
        code.1209 = code;
        code = code.1209 + 1;
        D.33444 = imb.b[1];
        *code.1209 = D.33444;
        code.1210 = code;
        code = code.1210 + 1;
        D.33446 = imb.b[2];
        *code.1210 = D.33446;
        code.1211 = code;
        code = code.1211 + 1;
        D.33448 = imb.b[3];
        *code.1211 = D.33448;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33399>:
  goto <D.24796>;
  <D.25012>:
  code.1212 = code;
  code = code.1212 + 1;
  *code.1212 = 1;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33450>; else goto <D.33451>;
  <D.33450>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33452>; else goto <D.33453>;
  <D.33452>:
  code.1213 = code;
  code = code.1213 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.1213 = D.32608;
  code.1214 = code;
  code = code.1214 + 1;
  *code.1214 = 36;
  goto <D.33456>;
  <D.33453>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33457>; else goto <D.33458>;
  <D.33457>:
  code.1215 = code;
  code = code.1215 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.1215 = D.32615;
  code.1216 = code;
  code = code.1216 + 1;
  *code.1216 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33461>;
  <D.33458>:
  code.1217 = code;
  code = code.1217 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.1217 = D.32620;
  code.1218 = code;
  code = code.1218 + 1;
  *code.1218 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1219 = code;
        code = code.1219 + 1;
        D.33465 = imb.b[0];
        *code.1219 = D.33465;
        code.1220 = code;
        code = code.1220 + 1;
        D.33467 = imb.b[1];
        *code.1220 = D.33467;
        code.1221 = code;
        code = code.1221 + 1;
        D.33469 = imb.b[2];
        *code.1221 = D.33469;
        code.1222 = code;
        code = code.1222 + 1;
        D.33471 = imb.b[3];
        *code.1222 = D.33471;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33461>:
  <D.33456>:
  goto <D.25014>;
  <D.33451>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33472>; else goto <D.33473>;
  <D.33472>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33474>; else goto <D.33475>;
  <D.33474>:
  code.1223 = code;
  code = code.1223 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.1223 = D.32636;
  goto <D.25014>;
  <D.33475>:
  <D.33473>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33477>; else goto <D.33478>;
  <D.33477>:
  code.1224 = code;
  code = code.1224 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.1224 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33480>;
  <D.33478>:
  code.1225 = code;
  code = code.1225 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.1225 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1226 = code;
        code = code.1226 + 1;
        D.33483 = imb.b[0];
        *code.1226 = D.33483;
        code.1227 = code;
        code = code.1227 + 1;
        D.33485 = imb.b[1];
        *code.1227 = D.33485;
        code.1228 = code;
        code = code.1228 + 1;
        D.33487 = imb.b[2];
        *code.1228 = D.33487;
        code.1229 = code;
        code = code.1229 + 1;
        D.33489 = imb.b[3];
        *code.1229 = D.33489;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33480>:
  <D.25014>:
  goto <D.24796>;
  <D.25016>:
  code.1230 = code;
  code = code.1230 + 1;
  *code.1230 = 41;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33491>; else goto <D.33492>;
  <D.33491>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33493>; else goto <D.33494>;
  <D.33493>:
  code.1231 = code;
  code = code.1231 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.1231 = D.32608;
  code.1232 = code;
  code = code.1232 + 1;
  *code.1232 = 36;
  goto <D.33497>;
  <D.33494>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33498>; else goto <D.33499>;
  <D.33498>:
  code.1233 = code;
  code = code.1233 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.1233 = D.32615;
  code.1234 = code;
  code = code.1234 + 1;
  *code.1234 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33502>;
  <D.33499>:
  code.1235 = code;
  code = code.1235 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.1235 = D.32620;
  code.1236 = code;
  code = code.1236 + 1;
  *code.1236 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1237 = code;
        code = code.1237 + 1;
        D.33506 = imb.b[0];
        *code.1237 = D.33506;
        code.1238 = code;
        code = code.1238 + 1;
        D.33508 = imb.b[1];
        *code.1238 = D.33508;
        code.1239 = code;
        code = code.1239 + 1;
        D.33510 = imb.b[2];
        *code.1239 = D.33510;
        code.1240 = code;
        code = code.1240 + 1;
        D.33512 = imb.b[3];
        *code.1240 = D.33512;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33502>:
  <D.33497>:
  goto <D.25018>;
  <D.33492>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33513>; else goto <D.33514>;
  <D.33513>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33515>; else goto <D.33516>;
  <D.33515>:
  code.1241 = code;
  code = code.1241 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.1241 = D.32636;
  goto <D.25018>;
  <D.33516>:
  <D.33514>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33518>; else goto <D.33519>;
  <D.33518>:
  code.1242 = code;
  code = code.1242 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.1242 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33521>;
  <D.33519>:
  code.1243 = code;
  code = code.1243 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.1243 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1244 = code;
        code = code.1244 + 1;
        D.33524 = imb.b[0];
        *code.1244 = D.33524;
        code.1245 = code;
        code = code.1245 + 1;
        D.33526 = imb.b[1];
        *code.1245 = D.33526;
        code.1246 = code;
        code = code.1246 + 1;
        D.33528 = imb.b[2];
        *code.1246 = D.33528;
        code.1247 = code;
        code = code.1247 + 1;
        D.33530 = imb.b[3];
        *code.1247 = D.33530;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33521>:
  <D.25018>:
  goto <D.24796>;
  <D.25020>:
  code.1248 = code;
  code = code.1248 + 1;
  *code.1248 = 33;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33532>; else goto <D.33533>;
  <D.33532>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33534>; else goto <D.33535>;
  <D.33534>:
  code.1249 = code;
  code = code.1249 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.1249 = D.32608;
  code.1250 = code;
  code = code.1250 + 1;
  *code.1250 = 36;
  goto <D.33538>;
  <D.33535>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33539>; else goto <D.33540>;
  <D.33539>:
  code.1251 = code;
  code = code.1251 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.1251 = D.32615;
  code.1252 = code;
  code = code.1252 + 1;
  *code.1252 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33543>;
  <D.33540>:
  code.1253 = code;
  code = code.1253 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.1253 = D.32620;
  code.1254 = code;
  code = code.1254 + 1;
  *code.1254 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1255 = code;
        code = code.1255 + 1;
        D.33547 = imb.b[0];
        *code.1255 = D.33547;
        code.1256 = code;
        code = code.1256 + 1;
        D.33549 = imb.b[1];
        *code.1256 = D.33549;
        code.1257 = code;
        code = code.1257 + 1;
        D.33551 = imb.b[2];
        *code.1257 = D.33551;
        code.1258 = code;
        code = code.1258 + 1;
        D.33553 = imb.b[3];
        *code.1258 = D.33553;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33543>:
  <D.33538>:
  goto <D.25022>;
  <D.33533>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33554>; else goto <D.33555>;
  <D.33554>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33556>; else goto <D.33557>;
  <D.33556>:
  code.1259 = code;
  code = code.1259 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.1259 = D.32636;
  goto <D.25022>;
  <D.33557>:
  <D.33555>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33559>; else goto <D.33560>;
  <D.33559>:
  code.1260 = code;
  code = code.1260 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.1260 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33562>;
  <D.33560>:
  code.1261 = code;
  code = code.1261 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.1261 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1262 = code;
        code = code.1262 + 1;
        D.33565 = imb.b[0];
        *code.1262 = D.33565;
        code.1263 = code;
        code = code.1263 + 1;
        D.33567 = imb.b[1];
        *code.1263 = D.33567;
        code.1264 = code;
        code = code.1264 + 1;
        D.33569 = imb.b[2];
        *code.1264 = D.33569;
        code.1265 = code;
        code = code.1265 + 1;
        D.33571 = imb.b[3];
        *code.1265 = D.33571;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33562>:
  <D.25022>:
  goto <D.24796>;
  <D.25024>:
  code.1266 = code;
  code = code.1266 + 1;
  *code.1266 = 9;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33573>; else goto <D.33574>;
  <D.33573>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33575>; else goto <D.33576>;
  <D.33575>:
  code.1267 = code;
  code = code.1267 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.1267 = D.32608;
  code.1268 = code;
  code = code.1268 + 1;
  *code.1268 = 36;
  goto <D.33579>;
  <D.33576>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33580>; else goto <D.33581>;
  <D.33580>:
  code.1269 = code;
  code = code.1269 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.1269 = D.32615;
  code.1270 = code;
  code = code.1270 + 1;
  *code.1270 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33584>;
  <D.33581>:
  code.1271 = code;
  code = code.1271 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.1271 = D.32620;
  code.1272 = code;
  code = code.1272 + 1;
  *code.1272 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1273 = code;
        code = code.1273 + 1;
        D.33588 = imb.b[0];
        *code.1273 = D.33588;
        code.1274 = code;
        code = code.1274 + 1;
        D.33590 = imb.b[1];
        *code.1274 = D.33590;
        code.1275 = code;
        code = code.1275 + 1;
        D.33592 = imb.b[2];
        *code.1275 = D.33592;
        code.1276 = code;
        code = code.1276 + 1;
        D.33594 = imb.b[3];
        *code.1276 = D.33594;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33584>:
  <D.33579>:
  goto <D.25026>;
  <D.33574>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33595>; else goto <D.33596>;
  <D.33595>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33597>; else goto <D.33598>;
  <D.33597>:
  code.1277 = code;
  code = code.1277 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.1277 = D.32636;
  goto <D.25026>;
  <D.33598>:
  <D.33596>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33600>; else goto <D.33601>;
  <D.33600>:
  code.1278 = code;
  code = code.1278 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.1278 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33603>;
  <D.33601>:
  code.1279 = code;
  code = code.1279 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.1279 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1280 = code;
        code = code.1280 + 1;
        D.33606 = imb.b[0];
        *code.1280 = D.33606;
        code.1281 = code;
        code = code.1281 + 1;
        D.33608 = imb.b[1];
        *code.1281 = D.33608;
        code.1282 = code;
        code = code.1282 + 1;
        D.33610 = imb.b[2];
        *code.1282 = D.33610;
        code.1283 = code;
        code = code.1283 + 1;
        D.33612 = imb.b[3];
        *code.1283 = D.33612;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33603>:
  <D.25026>:
  goto <D.24796>;
  <D.25028>:
  code.1284 = code;
  code = code.1284 + 1;
  *code.1284 = 49;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33614>; else goto <D.33615>;
  <D.33614>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33616>; else goto <D.33617>;
  <D.33616>:
  code.1285 = code;
  code = code.1285 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.1285 = D.32608;
  code.1286 = code;
  code = code.1286 + 1;
  *code.1286 = 36;
  goto <D.33620>;
  <D.33617>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33621>; else goto <D.33622>;
  <D.33621>:
  code.1287 = code;
  code = code.1287 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.1287 = D.32615;
  code.1288 = code;
  code = code.1288 + 1;
  *code.1288 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33625>;
  <D.33622>:
  code.1289 = code;
  code = code.1289 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.1289 = D.32620;
  code.1290 = code;
  code = code.1290 + 1;
  *code.1290 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1291 = code;
        code = code.1291 + 1;
        D.33629 = imb.b[0];
        *code.1291 = D.33629;
        code.1292 = code;
        code = code.1292 + 1;
        D.33631 = imb.b[1];
        *code.1292 = D.33631;
        code.1293 = code;
        code = code.1293 + 1;
        D.33633 = imb.b[2];
        *code.1293 = D.33633;
        code.1294 = code;
        code = code.1294 + 1;
        D.33635 = imb.b[3];
        *code.1294 = D.33635;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33625>:
  <D.33620>:
  goto <D.25030>;
  <D.33615>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33636>; else goto <D.33637>;
  <D.33636>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33638>; else goto <D.33639>;
  <D.33638>:
  code.1295 = code;
  code = code.1295 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.1295 = D.32636;
  goto <D.25030>;
  <D.33639>:
  <D.33637>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33641>; else goto <D.33642>;
  <D.33641>:
  code.1296 = code;
  code = code.1296 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.1296 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33644>;
  <D.33642>:
  code.1297 = code;
  code = code.1297 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.1297 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1298 = code;
        code = code.1298 + 1;
        D.33647 = imb.b[0];
        *code.1298 = D.33647;
        code.1299 = code;
        code = code.1299 + 1;
        D.33649 = imb.b[1];
        *code.1299 = D.33649;
        code.1300 = code;
        code = code.1300 + 1;
        D.33651 = imb.b[2];
        *code.1300 = D.33651;
        code.1301 = code;
        code = code.1301 + 1;
        D.33653 = imb.b[3];
        *code.1301 = D.33653;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33644>:
  <D.25030>:
  goto <D.24796>;
  <D.25032>:
  code.1302 = code;
  code = code.1302 + 1;
  *code.1302 = 255;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33655>; else goto <D.33656>;
  <D.33655>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33657>; else goto <D.33658>;
  <D.33657>:
  code.1303 = code;
  code = code.1303 + 1;
  *code.1303 = 4;
  code.1304 = code;
  code = code.1304 + 1;
  *code.1304 = 36;
  goto <D.33661>;
  <D.33658>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33662>; else goto <D.33663>;
  <D.33662>:
  code.1305 = code;
  code = code.1305 + 1;
  *code.1305 = 68;
  code.1306 = code;
  code = code.1306 + 1;
  *code.1306 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33666>;
  <D.33663>:
  code.1307 = code;
  code = code.1307 + 1;
  *code.1307 = 132;
  code.1308 = code;
  code = code.1308 + 1;
  *code.1308 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1309 = code;
        code = code.1309 + 1;
        D.33670 = imb.b[0];
        *code.1309 = D.33670;
        code.1310 = code;
        code = code.1310 + 1;
        D.33672 = imb.b[1];
        *code.1310 = D.33672;
        code.1311 = code;
        code = code.1311 + 1;
        D.33674 = imb.b[2];
        *code.1311 = D.33674;
        code.1312 = code;
        code = code.1312 + 1;
        D.33676 = imb.b[3];
        *code.1312 = D.33676;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33666>:
  <D.33661>:
  goto <D.25034>;
  <D.33656>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33677>; else goto <D.33678>;
  <D.33677>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33679>; else goto <D.33680>;
  <D.33679>:
  code.1313 = code;
  code = code.1313 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.1313 = D.31581;
  goto <D.25034>;
  <D.33680>:
  <D.33678>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33682>; else goto <D.33683>;
  <D.33682>:
  code.1314 = code;
  code = code.1314 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.1314 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33685>;
  <D.33683>:
  code.1315 = code;
  code = code.1315 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.1315 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1316 = code;
        code = code.1316 + 1;
        D.33688 = imb.b[0];
        *code.1316 = D.33688;
        code.1317 = code;
        code = code.1317 + 1;
        D.33690 = imb.b[1];
        *code.1317 = D.33690;
        code.1318 = code;
        code = code.1318 + 1;
        D.33692 = imb.b[2];
        *code.1318 = D.33692;
        code.1319 = code;
        code = code.1319 + 1;
        D.33694 = imb.b[3];
        *code.1319 = D.33694;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33685>:
  <D.25034>:
  goto <D.24796>;
  <D.25036>:
  code.1320 = code;
  code = code.1320 + 1;
  D.31604 = ins->dreg;
  D.33696 = (unsigned char) D.31604;
  D.33697 = D.33696 + 64;
  *code.1320 = D.33697;
  goto <D.24796>;
  <D.25037>:
  code.1321 = code;
  code = code.1321 + 1;
  *code.1321 = 255;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.33699>; else goto <D.33700>;
  <D.33699>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33701>; else goto <D.33702>;
  <D.33701>:
  code.1322 = code;
  code = code.1322 + 1;
  *code.1322 = 12;
  code.1323 = code;
  code = code.1323 + 1;
  *code.1323 = 36;
  goto <D.33705>;
  <D.33702>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33706>; else goto <D.33707>;
  <D.33706>:
  code.1324 = code;
  code = code.1324 + 1;
  *code.1324 = 76;
  code.1325 = code;
  code = code.1325 + 1;
  *code.1325 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33710>;
  <D.33707>:
  code.1326 = code;
  code = code.1326 + 1;
  *code.1326 = 140;
  code.1327 = code;
  code = code.1327 + 1;
  *code.1327 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1328 = code;
        code = code.1328 + 1;
        D.33714 = imb.b[0];
        *code.1328 = D.33714;
        code.1329 = code;
        code = code.1329 + 1;
        D.33716 = imb.b[1];
        *code.1329 = D.33716;
        code.1330 = code;
        code = code.1330 + 1;
        D.33718 = imb.b[2];
        *code.1330 = D.33718;
        code.1331 = code;
        code = code.1331 + 1;
        D.33720 = imb.b[3];
        *code.1331 = D.33720;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33710>:
  <D.33705>:
  goto <D.25039>;
  <D.33700>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33721>; else goto <D.33722>;
  <D.33721>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.33723>; else goto <D.33724>;
  <D.33723>:
  code.1332 = code;
  code = code.1332 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33281 = D.31586 | 8;
  D.33282 = (unsigned char) D.33281;
  *code.1332 = D.33282;
  goto <D.25039>;
  <D.33724>:
  <D.33722>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33726>; else goto <D.33727>;
  <D.33726>:
  code.1333 = code;
  code = code.1333 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33286 = D.31586 | 72;
  D.33287 = (unsigned char) D.33286;
  *code.1333 = D.33287;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33729>;
  <D.33727>:
  code.1334 = code;
  code = code.1334 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33290 = D.31586 | -120;
  D.33291 = (unsigned char) D.33290;
  *code.1334 = D.33291;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1335 = code;
        code = code.1335 + 1;
        D.33732 = imb.b[0];
        *code.1335 = D.33732;
        code.1336 = code;
        code = code.1336 + 1;
        D.33734 = imb.b[1];
        *code.1336 = D.33734;
        code.1337 = code;
        code = code.1337 + 1;
        D.33736 = imb.b[2];
        *code.1337 = D.33736;
        code.1338 = code;
        code = code.1338 + 1;
        D.33738 = imb.b[3];
        *code.1338 = D.33738;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33729>:
  <D.25039>:
  goto <D.24796>;
  <D.25041>:
  code.1339 = code;
  code = code.1339 + 1;
  D.31604 = ins->dreg;
  D.33696 = (unsigned char) D.31604;
  D.33740 = D.33696 + 72;
  *code.1339 = D.33740;
  goto <D.24796>;
  <D.25042>:
  code.1340 = code;
  code = code.1340 + 1;
  *code.1340 = 15;
  code.1341 = code;
  code = code.1341 + 1;
  *code.1341 = 175;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.33743>; else goto <D.33744>;
  <D.33743>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33745>; else goto <D.33746>;
  <D.33745>:
  code.1342 = code;
  code = code.1342 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.1342 = D.32039;
  code.1343 = code;
  code = code.1343 + 1;
  *code.1343 = 36;
  goto <D.33749>;
  <D.33746>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33750>; else goto <D.33751>;
  <D.33750>:
  code.1344 = code;
  code = code.1344 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.1344 = D.32046;
  code.1345 = code;
  code = code.1345 + 1;
  *code.1345 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33754>;
  <D.33751>:
  code.1346 = code;
  code = code.1346 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.1346 = D.32051;
  code.1347 = code;
  code = code.1347 + 1;
  *code.1347 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1348 = code;
        code = code.1348 + 1;
        D.33758 = imb.b[0];
        *code.1348 = D.33758;
        code.1349 = code;
        code = code.1349 + 1;
        D.33760 = imb.b[1];
        *code.1349 = D.33760;
        code.1350 = code;
        code = code.1350 + 1;
        D.33762 = imb.b[2];
        *code.1350 = D.33762;
        code.1351 = code;
        code = code.1351 + 1;
        D.33764 = imb.b[3];
        *code.1351 = D.33764;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33754>:
  <D.33749>:
  goto <D.25044>;
  <D.33744>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33765>; else goto <D.33766>;
  <D.33765>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.33767>; else goto <D.33768>;
  <D.33767>:
  code.1352 = code;
  code = code.1352 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.1352 = D.32825;
  goto <D.25044>;
  <D.33768>:
  <D.33766>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33770>; else goto <D.33771>;
  <D.33770>:
  code.1353 = code;
  code = code.1353 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.1353 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33773>;
  <D.33771>:
  code.1354 = code;
  code = code.1354 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.1354 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1355 = code;
        code = code.1355 + 1;
        D.33776 = imb.b[0];
        *code.1355 = D.33776;
        code.1356 = code;
        code = code.1356 + 1;
        D.33778 = imb.b[1];
        *code.1356 = D.33778;
        code.1357 = code;
        code = code.1357 + 1;
        D.33780 = imb.b[2];
        *code.1357 = D.33780;
        code.1358 = code;
        code = code.1358 + 1;
        D.33782 = imb.b[3];
        *code.1358 = D.33782;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33773>:
  <D.25044>:
  goto <D.24796>;
  <D.25046>:
  code.1359 = code;
  code = code.1359 + 1;
  *code.1359 = 35;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.33784>; else goto <D.33785>;
  <D.33784>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33786>; else goto <D.33787>;
  <D.33786>:
  code.1360 = code;
  code = code.1360 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.1360 = D.32039;
  code.1361 = code;
  code = code.1361 + 1;
  *code.1361 = 36;
  goto <D.33790>;
  <D.33787>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33791>; else goto <D.33792>;
  <D.33791>:
  code.1362 = code;
  code = code.1362 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.1362 = D.32046;
  code.1363 = code;
  code = code.1363 + 1;
  *code.1363 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33795>;
  <D.33792>:
  code.1364 = code;
  code = code.1364 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.1364 = D.32051;
  code.1365 = code;
  code = code.1365 + 1;
  *code.1365 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1366 = code;
        code = code.1366 + 1;
        D.33799 = imb.b[0];
        *code.1366 = D.33799;
        code.1367 = code;
        code = code.1367 + 1;
        D.33801 = imb.b[1];
        *code.1367 = D.33801;
        code.1368 = code;
        code = code.1368 + 1;
        D.33803 = imb.b[2];
        *code.1368 = D.33803;
        code.1369 = code;
        code = code.1369 + 1;
        D.33805 = imb.b[3];
        *code.1369 = D.33805;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33795>:
  <D.33790>:
  goto <D.25048>;
  <D.33785>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33806>; else goto <D.33807>;
  <D.33806>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.33808>; else goto <D.33809>;
  <D.33808>:
  code.1370 = code;
  code = code.1370 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.1370 = D.32825;
  goto <D.25048>;
  <D.33809>:
  <D.33807>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33811>; else goto <D.33812>;
  <D.33811>:
  code.1371 = code;
  code = code.1371 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.1371 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33814>;
  <D.33812>:
  code.1372 = code;
  code = code.1372 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.1372 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1373 = code;
        code = code.1373 + 1;
        D.33817 = imb.b[0];
        *code.1373 = D.33817;
        code.1374 = code;
        code = code.1374 + 1;
        D.33819 = imb.b[1];
        *code.1374 = D.33819;
        code.1375 = code;
        code = code.1375 + 1;
        D.33821 = imb.b[2];
        *code.1375 = D.33821;
        code.1376 = code;
        code = code.1376 + 1;
        D.33823 = imb.b[3];
        *code.1376 = D.33823;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33814>:
  <D.25048>:
  goto <D.24796>;
  <D.25050>:
  code.1377 = code;
  code = code.1377 + 1;
  *code.1377 = 11;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.33825>; else goto <D.33826>;
  <D.33825>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33827>; else goto <D.33828>;
  <D.33827>:
  code.1378 = code;
  code = code.1378 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.1378 = D.32039;
  code.1379 = code;
  code = code.1379 + 1;
  *code.1379 = 36;
  goto <D.33831>;
  <D.33828>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33832>; else goto <D.33833>;
  <D.33832>:
  code.1380 = code;
  code = code.1380 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.1380 = D.32046;
  code.1381 = code;
  code = code.1381 + 1;
  *code.1381 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33836>;
  <D.33833>:
  code.1382 = code;
  code = code.1382 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.1382 = D.32051;
  code.1383 = code;
  code = code.1383 + 1;
  *code.1383 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1384 = code;
        code = code.1384 + 1;
        D.33840 = imb.b[0];
        *code.1384 = D.33840;
        code.1385 = code;
        code = code.1385 + 1;
        D.33842 = imb.b[1];
        *code.1385 = D.33842;
        code.1386 = code;
        code = code.1386 + 1;
        D.33844 = imb.b[2];
        *code.1386 = D.33844;
        code.1387 = code;
        code = code.1387 + 1;
        D.33846 = imb.b[3];
        *code.1387 = D.33846;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33836>:
  <D.33831>:
  goto <D.25052>;
  <D.33826>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33847>; else goto <D.33848>;
  <D.33847>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.33849>; else goto <D.33850>;
  <D.33849>:
  code.1388 = code;
  code = code.1388 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.1388 = D.32825;
  goto <D.25052>;
  <D.33850>:
  <D.33848>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33852>; else goto <D.33853>;
  <D.33852>:
  code.1389 = code;
  code = code.1389 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.1389 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33855>;
  <D.33853>:
  code.1390 = code;
  code = code.1390 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.1390 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1391 = code;
        code = code.1391 + 1;
        D.33858 = imb.b[0];
        *code.1391 = D.33858;
        code.1392 = code;
        code = code.1392 + 1;
        D.33860 = imb.b[1];
        *code.1392 = D.33860;
        code.1393 = code;
        code = code.1393 + 1;
        D.33862 = imb.b[2];
        *code.1393 = D.33862;
        code.1394 = code;
        code = code.1394 + 1;
        D.33864 = imb.b[3];
        *code.1394 = D.33864;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33855>:
  <D.25052>:
  goto <D.24796>;
  <D.25054>:
  code.1395 = code;
  code = code.1395 + 1;
  *code.1395 = 51;
  D.31527 = ins->sreg2;
  if (D.31527 == 4) goto <D.33866>; else goto <D.33867>;
  <D.33866>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33868>; else goto <D.33869>;
  <D.33868>:
  code.1396 = code;
  code = code.1396 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.1396 = D.32039;
  code.1397 = code;
  code = code.1397 + 1;
  *code.1397 = 36;
  goto <D.33872>;
  <D.33869>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33873>; else goto <D.33874>;
  <D.33873>:
  code.1398 = code;
  code = code.1398 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.1398 = D.32046;
  code.1399 = code;
  code = code.1399 + 1;
  *code.1399 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33877>;
  <D.33874>:
  code.1400 = code;
  code = code.1400 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.1400 = D.32051;
  code.1401 = code;
  code = code.1401 + 1;
  *code.1401 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1402 = code;
        code = code.1402 + 1;
        D.33881 = imb.b[0];
        *code.1402 = D.33881;
        code.1403 = code;
        code = code.1403 + 1;
        D.33883 = imb.b[1];
        *code.1403 = D.33883;
        code.1404 = code;
        code = code.1404 + 1;
        D.33885 = imb.b[2];
        *code.1404 = D.33885;
        code.1405 = code;
        code = code.1405 + 1;
        D.33887 = imb.b[3];
        *code.1405 = D.33887;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33877>:
  <D.33872>:
  goto <D.25056>;
  <D.33867>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.33888>; else goto <D.33889>;
  <D.33888>:
  D.31527 = ins->sreg2;
  if (D.31527 != 5) goto <D.33890>; else goto <D.33891>;
  <D.33890>:
  code.1406 = code;
  code = code.1406 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32824 = D.32037 | D.31529;
  D.32825 = (unsigned char) D.32824;
  *code.1406 = D.32825;
  goto <D.25056>;
  <D.33891>:
  <D.33889>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.33893>; else goto <D.33894>;
  <D.33893>:
  code.1407 = code;
  code = code.1407 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32829 = D.32071 | D.31529;
  D.32830 = (unsigned char) D.32829;
  *code.1407 = D.32830;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.33896>;
  <D.33894>:
  code.1408 = code;
  code = code.1408 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32833 = D.32076 | D.31529;
  D.32834 = (unsigned char) D.32833;
  *code.1408 = D.32834;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.1409 = code;
        code = code.1409 + 1;
        D.33899 = imb.b[0];
        *code.1409 = D.33899;
        code.1410 = code;
        code = code.1410 + 1;
        D.33901 = imb.b[1];
        *code.1410 = D.33901;
        code.1411 = code;
        code = code.1411 + 1;
        D.33903 = imb.b[2];
        *code.1411 = D.33903;
        code.1412 = code;
        code = code.1412 + 1;
        D.33905 = imb.b[3];
        *code.1412 = D.33905;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33896>:
  <D.25056>:
  goto <D.24796>;
  <D.25058>:
  code.1413 = code;
  code = code.1413 + 1;
  *code.1413 = 204;
  goto <D.24796>;
  <D.25059>:
  code.1414 = code;
  code = code.1414 + 1;
  *code.1414 = 243;
  code.1415 = code;
  code = code.1415 + 1;
  *code.1415 = 144;
  goto <D.24796>;
  <D.25060>:
  code.1416 = code;
  code = code.1416 + 1;
  *code.1416 = 144;
  goto <D.24796>;
  <D.25061>:
  <D.25062>:
  <D.25063>:
  <D.25064>:
  <D.25065>:
  goto <D.24796>;
  <D.25066>:
  {
    int i;

    D.31466 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.31467 = D.31466 & 64;
    if (D.31467 != 0) goto <D.33910>; else goto <D.33911>;
    <D.33910>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 2860);
    <D.33911>:
    D.33912 = ins->flags;
    D.33913 = (int) D.33912;
    D.33914 = D.33913 & 1;
    if (D.33914 != 0) goto <D.33915>; else goto <D.33916>;
    <D.33915>:
    code.1417 = code;
    code = code.1417 + 1;
    *code.1417 = 59;
    code.1418 = code;
    code = code.1418 + 1;
    *code.1418 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          ss_trigger_page.1419 = ss_trigger_page;
          ss_trigger_page.1420 = (int) ss_trigger_page.1419;
          imb.val = ss_trigger_page.1420;
          code.1421 = code;
          code = code.1421 + 1;
          D.33922 = imb.b[0];
          *code.1421 = D.33922;
          code.1422 = code;
          code = code.1422 + 1;
          D.33924 = imb.b[1];
          *code.1422 = D.33924;
          code.1423 = code;
          code = code.1423 + 1;
          D.33926 = imb.b[2];
          *code.1423 = D.33926;
          code.1424 = code;
          code = code.1424 + 1;
          D.33928 = imb.b[3];
          *code.1424 = D.33928;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33916>:
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_seq_point (cfg, bb, ins, D.31489);
    i = 0;
    goto <D.25070>;
    <D.25069>:
    code.1425 = code;
    code = code.1425 + 1;
    *code.1425 = 144;
    i = i + 1;
    <D.25070>:
    if (i <= 5) goto <D.25069>; else goto <D.25071>;
    <D.25071>:
    code.1426 = code;
    code = code.1426 + 1;
    *code.1426 = 144;
    goto <D.24796>;
  }
  <D.25072>:
  <D.25073>:
  <D.25074>:
  code.1427 = code;
  code = code.1427 + 1;
  *code.1427 = 3;
  code.1428 = code;
  code = code.1428 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1428 = D.32567;
  goto <D.24796>;
  <D.25075>:
  <D.25076>:
  code.1429 = code;
  code = code.1429 + 1;
  *code.1429 = 19;
  code.1430 = code;
  code = code.1430 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1430 = D.32567;
  goto <D.24796>;
  <D.25077>:
  <D.25078>:
  <D.25079>:
  D.31604 = ins->dreg;
  if (D.31604 == 0) goto <D.33935>; else goto <D.33936>;
  <D.33935>:
  code.1431 = code;
  code = code.1431 + 1;
  *code.1431 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1432 = code;
        code = code.1432 + 1;
        D.33939 = imb.b[0];
        *code.1432 = D.33939;
        code.1433 = code;
        code = code.1433 + 1;
        D.33941 = imb.b[1];
        *code.1433 = D.33941;
        code.1434 = code;
        code = code.1434 + 1;
        D.33943 = imb.b[2];
        *code.1434 = D.33943;
        code.1435 = code;
        code = code.1435 + 1;
        D.33945 = imb.b[3];
        *code.1435 = D.33945;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25081>;
  <D.33936>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.33946>; else goto <D.33947>;
  <D.33946>:
  code.1436 = code;
  code = code.1436 + 1;
  *code.1436 = 131;
  code.1437 = code;
  code = code.1437 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.1437 = D.33951;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.33952>;
  <D.33947>:
  code.1438 = code;
  code = code.1438 + 1;
  *code.1438 = 129;
  code.1439 = code;
  code = code.1439 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.1439 = D.33951;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1440 = code;
        code = code.1440 + 1;
        D.33956 = imb.b[0];
        *code.1440 = D.33956;
        code.1441 = code;
        code = code.1441 + 1;
        D.33958 = imb.b[1];
        *code.1441 = D.33958;
        code.1442 = code;
        code = code.1442 + 1;
        D.33960 = imb.b[2];
        *code.1442 = D.33960;
        code.1443 = code;
        code = code.1443 + 1;
        D.33962 = imb.b[3];
        *code.1443 = D.33962;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33952>:
  <D.25081>:
  goto <D.24796>;
  <D.25083>:
  <D.25084>:
  D.31604 = ins->dreg;
  if (D.31604 == 0) goto <D.33963>; else goto <D.33964>;
  <D.33963>:
  code.1444 = code;
  code = code.1444 + 1;
  *code.1444 = 21;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1445 = code;
        code = code.1445 + 1;
        D.33967 = imb.b[0];
        *code.1445 = D.33967;
        code.1446 = code;
        code = code.1446 + 1;
        D.33969 = imb.b[1];
        *code.1446 = D.33969;
        code.1447 = code;
        code = code.1447 + 1;
        D.33971 = imb.b[2];
        *code.1447 = D.33971;
        code.1448 = code;
        code = code.1448 + 1;
        D.33973 = imb.b[3];
        *code.1448 = D.33973;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25086>;
  <D.33964>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.33974>; else goto <D.33975>;
  <D.33974>:
  code.1449 = code;
  code = code.1449 + 1;
  *code.1449 = 131;
  code.1450 = code;
  code = code.1450 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33978 = D.31638 | -48;
  D.33979 = (unsigned char) D.33978;
  *code.1450 = D.33979;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.33980>;
  <D.33975>:
  code.1451 = code;
  code = code.1451 + 1;
  *code.1451 = 129;
  code.1452 = code;
  code = code.1452 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33978 = D.31638 | -48;
  D.33979 = (unsigned char) D.33978;
  *code.1452 = D.33979;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1453 = code;
        code = code.1453 + 1;
        D.33984 = imb.b[0];
        *code.1453 = D.33984;
        code.1454 = code;
        code = code.1454 + 1;
        D.33986 = imb.b[1];
        *code.1454 = D.33986;
        code.1455 = code;
        code = code.1455 + 1;
        D.33988 = imb.b[2];
        *code.1455 = D.33988;
        code.1456 = code;
        code = code.1456 + 1;
        D.33990 = imb.b[3];
        *code.1456 = D.33990;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33980>:
  <D.25086>:
  goto <D.24796>;
  <D.25088>:
  <D.25089>:
  <D.25090>:
  code.1457 = code;
  code = code.1457 + 1;
  *code.1457 = 43;
  code.1458 = code;
  code = code.1458 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1458 = D.32567;
  goto <D.24796>;
  <D.25091>:
  <D.25092>:
  code.1459 = code;
  code = code.1459 + 1;
  *code.1459 = 27;
  code.1460 = code;
  code = code.1460 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1460 = D.32567;
  goto <D.24796>;
  <D.25093>:
  <D.25094>:
  <D.25095>:
  D.31604 = ins->dreg;
  if (D.31604 == 0) goto <D.33995>; else goto <D.33996>;
  <D.33995>:
  code.1461 = code;
  code = code.1461 + 1;
  *code.1461 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1462 = code;
        code = code.1462 + 1;
        D.33999 = imb.b[0];
        *code.1462 = D.33999;
        code.1463 = code;
        code = code.1463 + 1;
        D.34001 = imb.b[1];
        *code.1463 = D.34001;
        code.1464 = code;
        code = code.1464 + 1;
        D.34003 = imb.b[2];
        *code.1464 = D.34003;
        code.1465 = code;
        code = code.1465 + 1;
        D.34005 = imb.b[3];
        *code.1465 = D.34005;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25097>;
  <D.33996>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.34006>; else goto <D.34007>;
  <D.34006>:
  code.1466 = code;
  code = code.1466 + 1;
  *code.1466 = 131;
  code.1467 = code;
  code = code.1467 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.1467 = D.34011;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.34012>;
  <D.34007>:
  code.1468 = code;
  code = code.1468 + 1;
  *code.1468 = 129;
  code.1469 = code;
  code = code.1469 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.1469 = D.34011;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1470 = code;
        code = code.1470 + 1;
        D.34016 = imb.b[0];
        *code.1470 = D.34016;
        code.1471 = code;
        code = code.1471 + 1;
        D.34018 = imb.b[1];
        *code.1471 = D.34018;
        code.1472 = code;
        code = code.1472 + 1;
        D.34020 = imb.b[2];
        *code.1472 = D.34020;
        code.1473 = code;
        code = code.1473 + 1;
        D.34022 = imb.b[3];
        *code.1473 = D.34022;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34012>:
  <D.25097>:
  goto <D.24796>;
  <D.25099>:
  <D.25100>:
  D.31604 = ins->dreg;
  if (D.31604 == 0) goto <D.34023>; else goto <D.34024>;
  <D.34023>:
  code.1474 = code;
  code = code.1474 + 1;
  *code.1474 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1475 = code;
        code = code.1475 + 1;
        D.34027 = imb.b[0];
        *code.1475 = D.34027;
        code.1476 = code;
        code = code.1476 + 1;
        D.34029 = imb.b[1];
        *code.1476 = D.34029;
        code.1477 = code;
        code = code.1477 + 1;
        D.34031 = imb.b[2];
        *code.1477 = D.34031;
        code.1478 = code;
        code = code.1478 + 1;
        D.34033 = imb.b[3];
        *code.1478 = D.34033;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25102>;
  <D.34024>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.34034>; else goto <D.34035>;
  <D.34034>:
  code.1479 = code;
  code = code.1479 + 1;
  *code.1479 = 131;
  code.1480 = code;
  code = code.1480 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34038 = D.31638 | -40;
  D.34039 = (unsigned char) D.34038;
  *code.1480 = D.34039;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.34040>;
  <D.34035>:
  code.1481 = code;
  code = code.1481 + 1;
  *code.1481 = 129;
  code.1482 = code;
  code = code.1482 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34038 = D.31638 | -40;
  D.34039 = (unsigned char) D.34038;
  *code.1482 = D.34039;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1483 = code;
        code = code.1483 + 1;
        D.34044 = imb.b[0];
        *code.1483 = D.34044;
        code.1484 = code;
        code = code.1484 + 1;
        D.34046 = imb.b[1];
        *code.1484 = D.34046;
        code.1485 = code;
        code = code.1485 + 1;
        D.34048 = imb.b[2];
        *code.1485 = D.34048;
        code.1486 = code;
        code = code.1486 + 1;
        D.34050 = imb.b[3];
        *code.1486 = D.34050;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34040>:
  <D.25102>:
  goto <D.24796>;
  <D.25104>:
  code.1487 = code;
  code = code.1487 + 1;
  *code.1487 = 35;
  code.1488 = code;
  code = code.1488 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1488 = D.32567;
  goto <D.24796>;
  <D.25105>:
  <D.25106>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.34053>; else goto <D.34054>;
  <D.34053>:
  code.1489 = code;
  code = code.1489 + 1;
  *code.1489 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1490 = code;
        code = code.1490 + 1;
        D.34057 = imb.b[0];
        *code.1490 = D.34057;
        code.1491 = code;
        code = code.1491 + 1;
        D.34059 = imb.b[1];
        *code.1491 = D.34059;
        code.1492 = code;
        code = code.1492 + 1;
        D.34061 = imb.b[2];
        *code.1492 = D.34061;
        code.1493 = code;
        code = code.1493 + 1;
        D.34063 = imb.b[3];
        *code.1493 = D.34063;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25108>;
  <D.34054>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.34064>; else goto <D.34065>;
  <D.34064>:
  code.1494 = code;
  code = code.1494 + 1;
  *code.1494 = 131;
  code.1495 = code;
  code = code.1495 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.1495 = D.34069;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.34070>;
  <D.34065>:
  code.1496 = code;
  code = code.1496 + 1;
  *code.1496 = 129;
  code.1497 = code;
  code = code.1497 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.1497 = D.34069;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1498 = code;
        code = code.1498 + 1;
        D.34074 = imb.b[0];
        *code.1498 = D.34074;
        code.1499 = code;
        code = code.1499 + 1;
        D.34076 = imb.b[1];
        *code.1499 = D.34076;
        code.1500 = code;
        code = code.1500 + 1;
        D.34078 = imb.b[2];
        *code.1500 = D.34078;
        code.1501 = code;
        code = code.1501 + 1;
        D.34080 = imb.b[3];
        *code.1501 = D.34080;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34070>:
  <D.25108>:
  goto <D.24796>;
  <D.25110>:
  <D.25111>:
  D.31527 = ins->sreg2;
  if (D.31527 == 2) goto <D.34081>; else goto <D.34082>;
  <D.34081>:
  code.1502 = code;
  code = code.1502 + 1;
  D.31527 = ins->sreg2;
  D.34084 = (unsigned char) D.31527;
  D.34085 = D.34084 + 80;
  *code.1502 = D.34085;
  code.1503 = code;
  code = code.1503 + 1;
  *code.1503 = 153;
  code.1504 = code;
  code = code.1504 + 1;
  *code.1504 = 247;
  if (1 != 0) goto <D.34088>; else goto <D.34089>;
  <D.34088>:
  if (1 != 0) goto <D.34090>; else goto <D.34091>;
  <D.34090>:
  code.1505 = code;
  code = code.1505 + 1;
  *code.1505 = 60;
  code.1506 = code;
  code = code.1506 + 1;
  *code.1506 = 36;
  goto <D.34094>;
  <D.34091>:
  if (1 != 0) goto <D.34095>; else goto <D.34096>;
  <D.34095>:
  code.1507 = code;
  code = code.1507 + 1;
  *code.1507 = 124;
  code.1508 = code;
  code = code.1508 + 1;
  *code.1508 = 36;
  *code = 0;
  code = code + 1;
  goto <D.34099>;
  <D.34096>:
  code.1509 = code;
  code = code.1509 + 1;
  *code.1509 = 188;
  code.1510 = code;
  code = code.1510 + 1;
  *code.1510 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1511 = code;
        code = code.1511 + 1;
        D.34103 = imb.b[0];
        *code.1511 = D.34103;
        code.1512 = code;
        code = code.1512 + 1;
        D.34105 = imb.b[1];
        *code.1512 = D.34105;
        code.1513 = code;
        code = code.1513 + 1;
        D.34107 = imb.b[2];
        *code.1513 = D.34107;
        code.1514 = code;
        code = code.1514 + 1;
        D.34109 = imb.b[3];
        *code.1514 = D.34109;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34099>:
  <D.34094>:
  goto <D.25113>;
  <D.34089>:
  if (1 != 0) goto <D.34110>; else goto <D.34111>;
  <D.34110>:
  code.1515 = code;
  code = code.1515 + 1;
  *code.1515 = 60;
  goto <D.25113>;
  <D.34111>:
  if (1 != 0) goto <D.34113>; else goto <D.34114>;
  <D.34113>:
  code.1516 = code;
  code = code.1516 + 1;
  *code.1516 = 124;
  *code = 0;
  code = code + 1;
  goto <D.34116>;
  <D.34114>:
  code.1517 = code;
  code = code.1517 + 1;
  *code.1517 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1518 = code;
        code = code.1518 + 1;
        D.34119 = imb.b[0];
        *code.1518 = D.34119;
        code.1519 = code;
        code = code.1519 + 1;
        D.34121 = imb.b[1];
        *code.1519 = D.34121;
        code.1520 = code;
        code = code.1520 + 1;
        D.34123 = imb.b[2];
        *code.1520 = D.34123;
        code.1521 = code;
        code = code.1521 + 1;
        D.34125 = imb.b[3];
        *code.1521 = D.34125;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34116>:
  <D.25113>:
  if (0 != 0) goto <D.34126>; else goto <D.34127>;
  <D.34126>:
  code.1522 = code;
  code = code.1522 + 1;
  *code.1522 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.1523 = code;
        code = code.1523 + 1;
        D.34130 = imb.b[0];
        *code.1523 = D.34130;
        code.1524 = code;
        code = code.1524 + 1;
        D.34132 = imb.b[1];
        *code.1524 = D.34132;
        code.1525 = code;
        code = code.1525 + 1;
        D.34134 = imb.b[2];
        *code.1525 = D.34134;
        code.1526 = code;
        code = code.1526 + 1;
        D.34136 = imb.b[3];
        *code.1526 = D.34136;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25116>;
  <D.34127>:
  if (1 != 0) goto <D.34137>; else goto <D.34138>;
  <D.34137>:
  code.1527 = code;
  code = code.1527 + 1;
  *code.1527 = 131;
  code.1528 = code;
  code = code.1528 + 1;
  *code.1528 = 196;
  *code = 4;
  code = code + 1;
  goto <D.34141>;
  <D.34138>:
  code.1529 = code;
  code = code.1529 + 1;
  *code.1529 = 129;
  code.1530 = code;
  code = code.1530 + 1;
  *code.1530 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.1531 = code;
        code = code.1531 + 1;
        D.34145 = imb.b[0];
        *code.1531 = D.34145;
        code.1532 = code;
        code = code.1532 + 1;
        D.34147 = imb.b[1];
        *code.1532 = D.34147;
        code.1533 = code;
        code = code.1533 + 1;
        D.34149 = imb.b[2];
        *code.1533 = D.34149;
        code.1534 = code;
        code = code.1534 + 1;
        D.34151 = imb.b[3];
        *code.1534 = D.34151;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34141>:
  <D.25116>:
  goto <D.34152>;
  <D.34082>:
  code.1535 = code;
  code = code.1535 + 1;
  *code.1535 = 153;
  code.1536 = code;
  code = code.1536 + 1;
  *code.1536 = 247;
  code.1537 = code;
  code = code.1537 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.34156 = D.31528 | -8;
  D.34157 = (unsigned char) D.34156;
  *code.1537 = D.34157;
  <D.34152>:
  goto <D.24796>;
  <D.25118>:
  <D.25119>:
  D.31527 = ins->sreg2;
  if (D.31527 == 2) goto <D.34158>; else goto <D.34159>;
  <D.34158>:
  code.1538 = code;
  code = code.1538 + 1;
  D.31527 = ins->sreg2;
  D.34084 = (unsigned char) D.31527;
  D.34085 = D.34084 + 80;
  *code.1538 = D.34085;
  code.1539 = code;
  code = code.1539 + 1;
  *code.1539 = 51;
  code.1540 = code;
  code = code.1540 + 1;
  *code.1540 = 210;
  code.1541 = code;
  code = code.1541 + 1;
  *code.1541 = 247;
  if (1 != 0) goto <D.34164>; else goto <D.34165>;
  <D.34164>:
  if (1 != 0) goto <D.34166>; else goto <D.34167>;
  <D.34166>:
  code.1542 = code;
  code = code.1542 + 1;
  *code.1542 = 52;
  code.1543 = code;
  code = code.1543 + 1;
  *code.1543 = 36;
  goto <D.34170>;
  <D.34167>:
  if (1 != 0) goto <D.34171>; else goto <D.34172>;
  <D.34171>:
  code.1544 = code;
  code = code.1544 + 1;
  *code.1544 = 116;
  code.1545 = code;
  code = code.1545 + 1;
  *code.1545 = 36;
  *code = 0;
  code = code + 1;
  goto <D.34175>;
  <D.34172>:
  code.1546 = code;
  code = code.1546 + 1;
  *code.1546 = 180;
  code.1547 = code;
  code = code.1547 + 1;
  *code.1547 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1548 = code;
        code = code.1548 + 1;
        D.34179 = imb.b[0];
        *code.1548 = D.34179;
        code.1549 = code;
        code = code.1549 + 1;
        D.34181 = imb.b[1];
        *code.1549 = D.34181;
        code.1550 = code;
        code = code.1550 + 1;
        D.34183 = imb.b[2];
        *code.1550 = D.34183;
        code.1551 = code;
        code = code.1551 + 1;
        D.34185 = imb.b[3];
        *code.1551 = D.34185;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34175>:
  <D.34170>:
  goto <D.25121>;
  <D.34165>:
  if (1 != 0) goto <D.34186>; else goto <D.34187>;
  <D.34186>:
  code.1552 = code;
  code = code.1552 + 1;
  *code.1552 = 52;
  goto <D.25121>;
  <D.34187>:
  if (1 != 0) goto <D.34189>; else goto <D.34190>;
  <D.34189>:
  code.1553 = code;
  code = code.1553 + 1;
  *code.1553 = 116;
  *code = 0;
  code = code + 1;
  goto <D.34192>;
  <D.34190>:
  code.1554 = code;
  code = code.1554 + 1;
  *code.1554 = 180;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1555 = code;
        code = code.1555 + 1;
        D.34195 = imb.b[0];
        *code.1555 = D.34195;
        code.1556 = code;
        code = code.1556 + 1;
        D.34197 = imb.b[1];
        *code.1556 = D.34197;
        code.1557 = code;
        code = code.1557 + 1;
        D.34199 = imb.b[2];
        *code.1557 = D.34199;
        code.1558 = code;
        code = code.1558 + 1;
        D.34201 = imb.b[3];
        *code.1558 = D.34201;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34192>:
  <D.25121>:
  if (0 != 0) goto <D.34202>; else goto <D.34203>;
  <D.34202>:
  code.1559 = code;
  code = code.1559 + 1;
  *code.1559 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.1560 = code;
        code = code.1560 + 1;
        D.34206 = imb.b[0];
        *code.1560 = D.34206;
        code.1561 = code;
        code = code.1561 + 1;
        D.34208 = imb.b[1];
        *code.1561 = D.34208;
        code.1562 = code;
        code = code.1562 + 1;
        D.34210 = imb.b[2];
        *code.1562 = D.34210;
        code.1563 = code;
        code = code.1563 + 1;
        D.34212 = imb.b[3];
        *code.1563 = D.34212;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25124>;
  <D.34203>:
  if (1 != 0) goto <D.34213>; else goto <D.34214>;
  <D.34213>:
  code.1564 = code;
  code = code.1564 + 1;
  *code.1564 = 131;
  code.1565 = code;
  code = code.1565 + 1;
  *code.1565 = 196;
  *code = 4;
  code = code + 1;
  goto <D.34217>;
  <D.34214>:
  code.1566 = code;
  code = code.1566 + 1;
  *code.1566 = 129;
  code.1567 = code;
  code = code.1567 + 1;
  *code.1567 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.1568 = code;
        code = code.1568 + 1;
        D.34221 = imb.b[0];
        *code.1568 = D.34221;
        code.1569 = code;
        code = code.1569 + 1;
        D.34223 = imb.b[1];
        *code.1569 = D.34223;
        code.1570 = code;
        code = code.1570 + 1;
        D.34225 = imb.b[2];
        *code.1570 = D.34225;
        code.1571 = code;
        code = code.1571 + 1;
        D.34227 = imb.b[3];
        *code.1571 = D.34227;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34217>:
  <D.25124>:
  goto <D.34228>;
  <D.34159>:
  code.1572 = code;
  code = code.1572 + 1;
  *code.1572 = 51;
  code.1573 = code;
  code = code.1573 + 1;
  *code.1573 = 210;
  code.1574 = code;
  code = code.1574 + 1;
  *code.1574 = 247;
  code.1575 = code;
  code = code.1575 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.34233 = D.31529 | -16;
  D.34234 = (unsigned char) D.34233;
  *code.1575 = D.34234;
  <D.34228>:
  goto <D.24796>;
  <D.25126>:
  code.1576 = code;
  code = code.1576 + 1;
  D.31527 = ins->sreg2;
  D.34084 = (unsigned char) D.31527;
  D.34236 = D.34084 + 184;
  *code.1576 = D.34236;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1577 = code;
        code = code.1577 + 1;
        D.34238 = imb.b[0];
        *code.1577 = D.34238;
        code.1578 = code;
        code = code.1578 + 1;
        D.34240 = imb.b[1];
        *code.1578 = D.34240;
        code.1579 = code;
        code = code.1579 + 1;
        D.34242 = imb.b[2];
        *code.1579 = D.34242;
        code.1580 = code;
        code = code.1580 + 1;
        D.34244 = imb.b[3];
        *code.1580 = D.34244;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  code.1581 = code;
  code = code.1581 + 1;
  *code.1581 = 153;
  code.1582 = code;
  code = code.1582 + 1;
  *code.1582 = 247;
  code.1583 = code;
  code = code.1583 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.34156 = D.31528 | -8;
  D.34157 = (unsigned char) D.34156;
  *code.1583 = D.34157;
  goto <D.24796>;
  <D.25128>:
  {
    int power;

    D.31653 = ins->data.op[1].const_val;
    D.34248 = (unsigned int) D.31653;
    power = mono_is_power_of_two (D.34248);
    D.31548 = ins->sreg1;
    D.34249 = D.31548 != 0;
    D.34250 = (long int) D.34249;
    D.34251 = __builtin_expect (D.34250, 0);
    if (D.34251 != 0) goto <D.34252>; else goto <D.34253>;
    <D.34252>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2981, "ins->sreg1 == X86_EAX");
    <D.34253>:
    D.31604 = ins->dreg;
    D.34254 = D.31604 != 0;
    D.34255 = (long int) D.34254;
    D.34256 = __builtin_expect (D.34255, 0);
    if (D.34256 != 0) goto <D.34257>; else goto <D.34258>;
    <D.34257>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2982, "ins->dreg == X86_EAX");
    <D.34258>:
    D.34259 = power < 0;
    D.34260 = (long int) D.34259;
    D.34261 = __builtin_expect (D.34260, 0);
    if (D.34261 != 0) goto <D.34262>; else goto <D.34263>;
    <D.34262>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2983, "power >= 0");
    <D.34263>:
    if (power == 1) goto <D.34264>; else goto <D.34265>;
    <D.34264>:
    code.1584 = code;
    code = code.1584 + 1;
    *code.1584 = 153;
    if (1 != 0) goto <D.34267>; else goto <D.34268>;
    <D.34267>:
    code.1585 = code;
    code = code.1585 + 1;
    *code.1585 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1;
          code.1586 = code;
          code = code.1586 + 1;
          D.34271 = imb.b[0];
          *code.1586 = D.34271;
          code.1587 = code;
          code = code.1587 + 1;
          D.34273 = imb.b[1];
          *code.1587 = D.34273;
          code.1588 = code;
          code = code.1588 + 1;
          D.34275 = imb.b[2];
          *code.1588 = D.34275;
          code.1589 = code;
          code = code.1589 + 1;
          D.34277 = imb.b[3];
          *code.1589 = D.34277;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.25131>;
    <D.34268>:
    if (1 != 0) goto <D.34278>; else goto <D.34279>;
    <D.34278>:
    code.1590 = code;
    code = code.1590 + 1;
    *code.1590 = 131;
    code.1591 = code;
    code = code.1591 + 1;
    *code.1591 = 224;
    *code = 1;
    code = code + 1;
    goto <D.34282>;
    <D.34279>:
    code.1592 = code;
    code = code.1592 + 1;
    *code.1592 = 129;
    code.1593 = code;
    code = code.1593 + 1;
    *code.1593 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1;
          code.1594 = code;
          code = code.1594 + 1;
          D.34286 = imb.b[0];
          *code.1594 = D.34286;
          code.1595 = code;
          code = code.1595 + 1;
          D.34288 = imb.b[1];
          *code.1595 = D.34288;
          code.1596 = code;
          code = code.1596 + 1;
          D.34290 = imb.b[2];
          *code.1596 = D.34290;
          code.1597 = code;
          code = code.1597 + 1;
          D.34292 = imb.b[3];
          *code.1597 = D.34292;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.34282>:
    <D.25131>:
    code.1598 = code;
    code = code.1598 + 1;
    *code.1598 = 51;
    code.1599 = code;
    code = code.1599 + 1;
    *code.1599 = 194;
    code.1600 = code;
    code = code.1600 + 1;
    *code.1600 = 43;
    code.1601 = code;
    code = code.1601 + 1;
    *code.1601 = 194;
    goto <D.34297>;
    <D.34265>:
    if (power == 0) goto <D.34298>; else goto <D.34299>;
    <D.34298>:
    code.1602 = code;
    code = code.1602 + 1;
    *code.1602 = 51;
    code.1603 = code;
    code = code.1603 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.1603 = D.34303;
    goto <D.34304>;
    <D.34299>:
    code.1604 = code;
    code = code.1604 + 1;
    *code.1604 = 153;
    D.34306 = 32 - power;
    if (D.34306 == 1) goto <D.34307>; else goto <D.34308>;
    <D.34307>:
    code.1605 = code;
    code = code.1605 + 1;
    *code.1605 = 209;
    code.1606 = code;
    code = code.1606 + 1;
    *code.1606 = 234;
    goto <D.34311>;
    <D.34308>:
    code.1607 = code;
    code = code.1607 + 1;
    *code.1607 = 193;
    code.1608 = code;
    code = code.1608 + 1;
    *code.1608 = 234;
    D.34314 = (unsigned char) power;
    D.34315 = 32 - D.34314;
    *code = D.34315;
    code = code + 1;
    <D.34311>:
    code.1609 = code;
    code = code.1609 + 1;
    *code.1609 = 3;
    code.1610 = code;
    code = code.1610 + 1;
    *code.1610 = 194;
    if (1 != 0) goto <D.34318>; else goto <D.34319>;
    <D.34318>:
    code.1611 = code;
    code = code.1611 + 1;
    *code.1611 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          D.34321 = 1 << power;
          D.34322 = D.34321 + -1;
          imb.val = D.34322;
          code.1612 = code;
          code = code.1612 + 1;
          D.34324 = imb.b[0];
          *code.1612 = D.34324;
          code.1613 = code;
          code = code.1613 + 1;
          D.34326 = imb.b[1];
          *code.1613 = D.34326;
          code.1614 = code;
          code = code.1614 + 1;
          D.34328 = imb.b[2];
          *code.1614 = D.34328;
          code.1615 = code;
          code = code.1615 + 1;
          D.34330 = imb.b[3];
          *code.1615 = D.34330;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.25134>;
    <D.34319>:
    D.34321 = 1 << power;
    D.34331 = (unsigned int) D.34321;
    D.34332 = D.34331 + 127;
    if (D.34332 <= 255) goto <D.34333>; else goto <D.34334>;
    <D.34333>:
    code.1616 = code;
    code = code.1616 + 1;
    *code.1616 = 131;
    code.1617 = code;
    code = code.1617 + 1;
    *code.1617 = 224;
    D.34321 = 1 << power;
    D.34337 = (unsigned char) D.34321;
    D.34338 = D.34337 + 255;
    *code = D.34338;
    code = code + 1;
    goto <D.34339>;
    <D.34334>:
    code.1618 = code;
    code = code.1618 + 1;
    *code.1618 = 129;
    code.1619 = code;
    code = code.1619 + 1;
    *code.1619 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          D.34321 = 1 << power;
          D.34322 = D.34321 + -1;
          imb.val = D.34322;
          code.1620 = code;
          code = code.1620 + 1;
          D.34343 = imb.b[0];
          *code.1620 = D.34343;
          code.1621 = code;
          code = code.1621 + 1;
          D.34345 = imb.b[1];
          *code.1621 = D.34345;
          code.1622 = code;
          code = code.1622 + 1;
          D.34347 = imb.b[2];
          *code.1622 = D.34347;
          code.1623 = code;
          code = code.1623 + 1;
          D.34349 = imb.b[3];
          *code.1623 = D.34349;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.34339>:
    <D.25134>:
    code.1624 = code;
    code = code.1624 + 1;
    *code.1624 = 43;
    code.1625 = code;
    code = code.1625 + 1;
    *code.1625 = 194;
    <D.34304>:
    <D.34297>:
    goto <D.24796>;
  }
  <D.25136>:
  code.1626 = code;
  code = code.1626 + 1;
  *code.1626 = 11;
  code.1627 = code;
  code = code.1627 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1627 = D.32567;
  goto <D.24796>;
  <D.25137>:
  <D.25138>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.34354>; else goto <D.34355>;
  <D.34354>:
  code.1628 = code;
  code = code.1628 + 1;
  *code.1628 = 13;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1629 = code;
        code = code.1629 + 1;
        D.34358 = imb.b[0];
        *code.1629 = D.34358;
        code.1630 = code;
        code = code.1630 + 1;
        D.34360 = imb.b[1];
        *code.1630 = D.34360;
        code.1631 = code;
        code = code.1631 + 1;
        D.34362 = imb.b[2];
        *code.1631 = D.34362;
        code.1632 = code;
        code = code.1632 + 1;
        D.34364 = imb.b[3];
        *code.1632 = D.34364;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25140>;
  <D.34355>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.34365>; else goto <D.34366>;
  <D.34365>:
  code.1633 = code;
  code = code.1633 + 1;
  *code.1633 = 131;
  code.1634 = code;
  code = code.1634 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34369 = D.31586 | -56;
  D.34370 = (unsigned char) D.34369;
  *code.1634 = D.34370;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.34371>;
  <D.34366>:
  code.1635 = code;
  code = code.1635 + 1;
  *code.1635 = 129;
  code.1636 = code;
  code = code.1636 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34369 = D.31586 | -56;
  D.34370 = (unsigned char) D.34369;
  *code.1636 = D.34370;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1637 = code;
        code = code.1637 + 1;
        D.34375 = imb.b[0];
        *code.1637 = D.34375;
        code.1638 = code;
        code = code.1638 + 1;
        D.34377 = imb.b[1];
        *code.1638 = D.34377;
        code.1639 = code;
        code = code.1639 + 1;
        D.34379 = imb.b[2];
        *code.1639 = D.34379;
        code.1640 = code;
        code = code.1640 + 1;
        D.34381 = imb.b[3];
        *code.1640 = D.34381;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34371>:
  <D.25140>:
  goto <D.24796>;
  <D.25142>:
  code.1641 = code;
  code = code.1641 + 1;
  *code.1641 = 51;
  code.1642 = code;
  code = code.1642 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1642 = D.32567;
  goto <D.24796>;
  <D.25143>:
  <D.25144>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.34384>; else goto <D.34385>;
  <D.34384>:
  code.1643 = code;
  code = code.1643 + 1;
  *code.1643 = 53;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1644 = code;
        code = code.1644 + 1;
        D.34388 = imb.b[0];
        *code.1644 = D.34388;
        code.1645 = code;
        code = code.1645 + 1;
        D.34390 = imb.b[1];
        *code.1645 = D.34390;
        code.1646 = code;
        code = code.1646 + 1;
        D.34392 = imb.b[2];
        *code.1646 = D.34392;
        code.1647 = code;
        code = code.1647 + 1;
        D.34394 = imb.b[3];
        *code.1647 = D.34394;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25146>;
  <D.34385>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.34395>; else goto <D.34396>;
  <D.34395>:
  code.1648 = code;
  code = code.1648 + 1;
  *code.1648 = 131;
  code.1649 = code;
  code = code.1649 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34399 = D.31586 | -16;
  D.34400 = (unsigned char) D.34399;
  *code.1649 = D.34400;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.34401>;
  <D.34396>:
  code.1650 = code;
  code = code.1650 + 1;
  *code.1650 = 129;
  code.1651 = code;
  code = code.1651 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34399 = D.31586 | -16;
  D.34400 = (unsigned char) D.34399;
  *code.1651 = D.34400;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.1652 = code;
        code = code.1652 + 1;
        D.34405 = imb.b[0];
        *code.1652 = D.34405;
        code.1653 = code;
        code = code.1653 + 1;
        D.34407 = imb.b[1];
        *code.1653 = D.34407;
        code.1654 = code;
        code = code.1654 + 1;
        D.34409 = imb.b[2];
        *code.1654 = D.34409;
        code.1655 = code;
        code = code.1655 + 1;
        D.34411 = imb.b[3];
        *code.1655 = D.34411;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34401>:
  <D.25146>:
  goto <D.24796>;
  <D.25148>:
  D.31527 = ins->sreg2;
  D.34412 = D.31527 != 1;
  D.34413 = (long int) D.34412;
  D.34414 = __builtin_expect (D.34413, 0);
  if (D.34414 != 0) goto <D.34415>; else goto <D.34416>;
  <D.34415>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3026, "ins->sreg2 == X86_ECX");
  <D.34416>:
  code.1656 = code;
  code = code.1656 + 1;
  *code.1656 = 211;
  code.1657 = code;
  code = code.1657 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1657 = D.34420;
  goto <D.24796>;
  <D.25149>:
  D.31527 = ins->sreg2;
  D.34412 = D.31527 != 1;
  D.34413 = (long int) D.34412;
  D.34414 = __builtin_expect (D.34413, 0);
  if (D.34414 != 0) goto <D.34421>; else goto <D.34422>;
  <D.34421>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3030, "ins->sreg2 == X86_ECX");
  <D.34422>:
  code.1658 = code;
  code = code.1658 + 1;
  *code.1658 = 211;
  code.1659 = code;
  code = code.1659 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.34425 = D.31637 | -8;
  D.34426 = (unsigned char) D.34425;
  *code.1659 = D.34426;
  goto <D.24796>;
  <D.25150>:
  <D.25151>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 1) goto <D.34427>; else goto <D.34428>;
  <D.34427>:
  code.1660 = code;
  code = code.1660 + 1;
  *code.1660 = 209;
  code.1661 = code;
  code = code.1661 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.34425 = D.31637 | -8;
  D.34426 = (unsigned char) D.34425;
  *code.1661 = D.34426;
  goto <D.34431>;
  <D.34428>:
  code.1662 = code;
  code = code.1662 + 1;
  *code.1662 = 193;
  code.1663 = code;
  code = code.1663 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.34425 = D.31637 | -8;
  D.34426 = (unsigned char) D.34425;
  *code.1663 = D.34426;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  <D.34431>:
  goto <D.24796>;
  <D.25152>:
  <D.25153>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 1) goto <D.34434>; else goto <D.34435>;
  <D.34434>:
  code.1664 = code;
  code = code.1664 + 1;
  *code.1664 = 209;
  code.1665 = code;
  code = code.1665 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.1665 = D.34011;
  goto <D.34438>;
  <D.34435>:
  code.1666 = code;
  code = code.1666 + 1;
  *code.1666 = 193;
  code.1667 = code;
  code = code.1667 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.1667 = D.34011;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  <D.34438>:
  goto <D.24796>;
  <D.25154>:
  D.31527 = ins->sreg2;
  D.34412 = D.31527 != 1;
  D.34413 = (long int) D.34412;
  D.34414 = __builtin_expect (D.34413, 0);
  if (D.34414 != 0) goto <D.34441>; else goto <D.34442>;
  <D.34441>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3042, "ins->sreg2 == X86_ECX");
  <D.34442>:
  code.1668 = code;
  code = code.1668 + 1;
  *code.1668 = 211;
  code.1669 = code;
  code = code.1669 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.1669 = D.34011;
  goto <D.24796>;
  <D.25155>:
  <D.25156>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 1) goto <D.34445>; else goto <D.34446>;
  <D.34445>:
  code.1670 = code;
  code = code.1670 + 1;
  *code.1670 = 209;
  code.1671 = code;
  code = code.1671 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1671 = D.34420;
  goto <D.34449>;
  <D.34446>:
  code.1672 = code;
  code = code.1672 + 1;
  *code.1672 = 193;
  code.1673 = code;
  code = code.1673 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1673 = D.34420;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  <D.34449>:
  goto <D.24796>;
  <D.25157>:
  {
    guint8 * jump_to_end;

    code.1674 = code;
    code = code.1674 + 1;
    *code.1674 = 15;
    code.1675 = code;
    code = code.1675 + 1;
    *code.1675 = 165;
    code.1676 = code;
    code = code.1676 + 1;
    D.31548 = ins->sreg1;
    D.32035 = D.31548 & 7;
    D.32036 = D.32035 << 3;
    D.32037 = (signed char) D.32036;
    D.32565 = D.32037 | -64;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34457 = D.34456 & 7;
    D.34458 = D.32565 | D.34457;
    D.34459 = (unsigned char) D.34458;
    *code.1676 = D.34459;
    code.1677 = code;
    code = code.1677 + 1;
    *code.1677 = 211;
    code.1678 = code;
    code = code.1678 + 1;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.34068 = D.31586 | -32;
    D.34069 = (unsigned char) D.34068;
    *code.1678 = D.34069;
    if (0 != 0) goto <D.34462>; else goto <D.34463>;
    <D.34462>:
    code.1679 = code;
    code = code.1679 + 1;
    *code.1679 = 169;
    goto <D.34465>;
    <D.34463>:
    code.1680 = code;
    code = code.1680 + 1;
    *code.1680 = 247;
    code.1681 = code;
    code = code.1681 + 1;
    *code.1681 = 193;
    <D.34465>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 32;
          code.1682 = code;
          code = code.1682 + 1;
          D.34469 = imb.b[0];
          *code.1682 = D.34469;
          code.1683 = code;
          code = code.1683 + 1;
          D.34471 = imb.b[1];
          *code.1683 = D.34471;
          code.1684 = code;
          code = code.1684 + 1;
          D.34473 = imb.b[2];
          *code.1684 = D.34473;
          code.1685 = code;
          code = code.1685 + 1;
          D.34475 = imb.b[3];
          *code.1685 = D.34475;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    jump_to_end = code;
    if (1 != 0) goto <D.34476>; else goto <D.34477>;
    <D.34476>:
    code.1686 = code;
    code = code.1686 + 1;
    D.34479 = 116;
    *code.1686 = D.34479;
    goto <D.34480>;
    <D.34477>:
    code.1687 = code;
    code = code.1687 + 1;
    D.34482 = 116;
    *code.1687 = D.34482;
    <D.34480>:
    *code = 0;
    code = code + 1;
    switch (4) <default: <D.25164>, case 1: <D.25160>, case 2: <D.25162>, case 4: <D.25163>>
    <D.25160>:
    code.1688 = code;
    code = code.1688 + 1;
    *code.1688 = 138;
    goto <D.25161>;
    <D.25162>:
    code.1689 = code;
    code = code.1689 + 1;
    *code.1689 = 102;
    <D.25163>:
    code.1690 = code;
    code = code.1690 + 1;
    *code.1690 = 139;
    goto <D.25161>;
    <D.25164>:
    __assert_fail ("0", "mini-x86.c", 3060, &__PRETTY_FUNCTION__);
    <D.25161>:
    code.1691 = code;
    code = code.1691 + 1;
    D.34455 = ins->backend.reg3;
    D.34487 = D.34455 & 7;
    D.34488 = D.34487 << 3;
    D.34489 = (signed char) D.34488;
    D.34490 = D.34489 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.34491 = D.34490 | D.31586;
    D.34492 = (unsigned char) D.34491;
    *code.1691 = D.34492;
    code.1692 = code;
    code = code.1692 + 1;
    *code.1692 = 51;
    code.1693 = code;
    code = code.1693 + 1;
    D.31548 = ins->sreg1;
    D.32035 = D.31548 & 7;
    D.32036 = D.32035 << 3;
    D.32037 = (signed char) D.32036;
    D.32565 = D.32037 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.32876 = D.32565 | D.31586;
    D.32877 = (unsigned char) D.32876;
    *code.1693 = D.32877;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump_to_end + 1;
      size = 0;
      D.34495 = MEM[(unsigned char *)jump_to_end];
      D.34496 = (int) D.34495;
      switch (D.34496) <default: <D.25192>, case 15: <D.25171>, case 112: <D.25176>, case 113: <D.25177>, case 114: <D.25178>, case 115: <D.25179>, case 116: <D.25180>, case 117: <D.25181>, case 118: <D.25182>, case 119: <D.25183>, case 120: <D.25184>, case 121: <D.25185>, case 122: <D.25186>, case 123: <D.25187>, case 124: <D.25188>, case 125: <D.25189>, case 126: <D.25190>, case 127: <D.25191>, case 224: <D.25172>, case 225: <D.25173>, case 226: <D.25174>, case 232: <D.25168>, case 233: <D.25169>, case 235: <D.25175>>
      <D.25168>:
      <D.25169>:
      size = size + 1;
      goto <D.25170>;
      <D.25171>:
      D.34497 = *pos;
      D.34498 = D.34497 + 144;
      if (D.34498 > 31) goto <D.34499>; else goto <D.34500>;
      <D.34499>:
      __assert_fail ("0", "mini-x86.c", 3063, &__PRETTY_FUNCTION__);
      <D.34500>:
      size = size + 1;
      pos = pos + 1;
      goto <D.25170>;
      <D.25172>:
      <D.25173>:
      <D.25174>:
      <D.25175>:
      <D.25176>:
      <D.25177>:
      <D.25178>:
      <D.25179>:
      <D.25180>:
      <D.25181>:
      <D.25182>:
      <D.25183>:
      <D.25184>:
      <D.25185>:
      <D.25186>:
      <D.25187>:
      <D.25188>:
      <D.25189>:
      <D.25190>:
      <D.25191>:
      goto <D.25170>;
      <D.25192>:
      __assert_fail ("0", "mini-x86.c", 3063, &__PRETTY_FUNCTION__);
      <D.25170>:
      code.422 = (int) code;
      pos.1694 = (int) pos;
      disp = code.422 - pos.1694;
      if (size != 0) goto <D.34502>; else goto <D.34503>;
      <D.34502>:
      {
        union x86_imm_buf imb;

        try
          {
            D.34504 = disp + -4;
            imb.val = D.34504;
            pos.1695 = pos;
            pos = pos.1695 + 1;
            D.34506 = imb.b[0];
            *pos.1695 = D.34506;
            pos.1696 = pos;
            pos = pos.1696 + 1;
            D.34508 = imb.b[1];
            *pos.1696 = D.34508;
            pos.1697 = pos;
            pos = pos.1697 + 1;
            D.34510 = imb.b[2];
            *pos.1697 = D.34510;
            pos.1698 = pos;
            pos = pos.1698 + 1;
            D.34512 = imb.b[3];
            *pos.1698 = D.34512;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.34513>;
      <D.34503>:
      disp.1699 = (unsigned int) disp;
      D.34515 = disp.1699 + 127;
      if (D.34515 <= 255) goto <D.34516>; else goto <D.34517>;
      <D.34516>:
      D.34518 = (unsigned char) disp;
      D.34519 = D.34518 + 255;
      *pos = D.34519;
      pos = pos + 1;
      goto <D.34520>;
      <D.34517>:
      __assert_fail ("0", "mini-x86.c", 3063, &__PRETTY_FUNCTION__);
      <D.34520>:
      <D.34513>:
    }
  }
  goto <D.24796>;
  <D.25194>:
  {
    guint8 * jump_to_end;

    code.1700 = code;
    code = code.1700 + 1;
    *code.1700 = 15;
    code.1701 = code;
    code = code.1701 + 1;
    *code.1701 = 173;
    code.1702 = code;
    code = code.1702 + 1;
    D.34455 = ins->backend.reg3;
    D.34487 = D.34455 & 7;
    D.34488 = D.34487 << 3;
    D.34489 = (signed char) D.34488;
    D.34490 = D.34489 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.34491 = D.34490 | D.31586;
    D.34492 = (unsigned char) D.34491;
    *code.1702 = D.34492;
    code.1703 = code;
    code = code.1703 + 1;
    *code.1703 = 211;
    code.1704 = code;
    code = code.1704 + 1;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34526 = D.34456 | -8;
    D.34527 = (unsigned char) D.34526;
    *code.1704 = D.34527;
    if (0 != 0) goto <D.34528>; else goto <D.34529>;
    <D.34528>:
    code.1705 = code;
    code = code.1705 + 1;
    *code.1705 = 169;
    goto <D.34531>;
    <D.34529>:
    code.1706 = code;
    code = code.1706 + 1;
    *code.1706 = 247;
    code.1707 = code;
    code = code.1707 + 1;
    *code.1707 = 193;
    <D.34531>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 32;
          code.1708 = code;
          code = code.1708 + 1;
          D.34535 = imb.b[0];
          *code.1708 = D.34535;
          code.1709 = code;
          code = code.1709 + 1;
          D.34537 = imb.b[1];
          *code.1709 = D.34537;
          code.1710 = code;
          code = code.1710 + 1;
          D.34539 = imb.b[2];
          *code.1710 = D.34539;
          code.1711 = code;
          code = code.1711 + 1;
          D.34541 = imb.b[3];
          *code.1711 = D.34541;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    jump_to_end = code;
    if (0 != 0) goto <D.34542>; else goto <D.34543>;
    <D.34542>:
    code.1712 = code;
    code = code.1712 + 1;
    D.34479 = 116;
    *code.1712 = D.34479;
    goto <D.34545>;
    <D.34543>:
    code.1713 = code;
    code = code.1713 + 1;
    D.34482 = 116;
    *code.1713 = D.34482;
    <D.34545>:
    *code = 0;
    code = code + 1;
    switch (4) <default: <D.25201>, case 1: <D.25197>, case 2: <D.25199>, case 4: <D.25200>>
    <D.25197>:
    code.1714 = code;
    code = code.1714 + 1;
    *code.1714 = 138;
    goto <D.25198>;
    <D.25199>:
    code.1715 = code;
    code = code.1715 + 1;
    *code.1715 = 102;
    <D.25200>:
    code.1716 = code;
    code = code.1716 + 1;
    *code.1716 = 139;
    goto <D.25198>;
    <D.25201>:
    __assert_fail ("0", "mini-x86.c", 3077, &__PRETTY_FUNCTION__);
    <D.25198>:
    code.1717 = code;
    code = code.1717 + 1;
    D.31548 = ins->sreg1;
    D.32035 = D.31548 & 7;
    D.32036 = D.32035 << 3;
    D.32037 = (signed char) D.32036;
    D.32565 = D.32037 | -64;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34457 = D.34456 & 7;
    D.34458 = D.32565 | D.34457;
    D.34459 = (unsigned char) D.34458;
    *code.1717 = D.34459;
    if (0 != 0) goto <D.34551>; else goto <D.34552>;
    <D.34551>:
    code.1718 = code;
    code = code.1718 + 1;
    *code.1718 = 209;
    code.1719 = code;
    code = code.1719 + 1;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34526 = D.34456 | -8;
    D.34527 = (unsigned char) D.34526;
    *code.1719 = D.34527;
    goto <D.34555>;
    <D.34552>:
    code.1720 = code;
    code = code.1720 + 1;
    *code.1720 = 193;
    code.1721 = code;
    code = code.1721 + 1;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34526 = D.34456 | -8;
    D.34527 = (unsigned char) D.34526;
    *code.1721 = D.34527;
    *code = 31;
    code = code + 1;
    <D.34555>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump_to_end + 1;
      size = 0;
      D.34558 = MEM[(unsigned char *)jump_to_end];
      D.34559 = (int) D.34558;
      switch (D.34559) <default: <D.25229>, case 15: <D.25208>, case 112: <D.25213>, case 113: <D.25214>, case 114: <D.25215>, case 115: <D.25216>, case 116: <D.25217>, case 117: <D.25218>, case 118: <D.25219>, case 119: <D.25220>, case 120: <D.25221>, case 121: <D.25222>, case 122: <D.25223>, case 123: <D.25224>, case 124: <D.25225>, case 125: <D.25226>, case 126: <D.25227>, case 127: <D.25228>, case 224: <D.25209>, case 225: <D.25210>, case 226: <D.25211>, case 232: <D.25205>, case 233: <D.25206>, case 235: <D.25212>>
      <D.25205>:
      <D.25206>:
      size = size + 1;
      goto <D.25207>;
      <D.25208>:
      D.34560 = *pos;
      D.34561 = D.34560 + 144;
      if (D.34561 > 31) goto <D.34562>; else goto <D.34563>;
      <D.34562>:
      __assert_fail ("0", "mini-x86.c", 3080, &__PRETTY_FUNCTION__);
      <D.34563>:
      size = size + 1;
      pos = pos + 1;
      goto <D.25207>;
      <D.25209>:
      <D.25210>:
      <D.25211>:
      <D.25212>:
      <D.25213>:
      <D.25214>:
      <D.25215>:
      <D.25216>:
      <D.25217>:
      <D.25218>:
      <D.25219>:
      <D.25220>:
      <D.25221>:
      <D.25222>:
      <D.25223>:
      <D.25224>:
      <D.25225>:
      <D.25226>:
      <D.25227>:
      <D.25228>:
      goto <D.25207>;
      <D.25229>:
      __assert_fail ("0", "mini-x86.c", 3080, &__PRETTY_FUNCTION__);
      <D.25207>:
      code.422 = (int) code;
      pos.1722 = (int) pos;
      disp = code.422 - pos.1722;
      if (size != 0) goto <D.34565>; else goto <D.34566>;
      <D.34565>:
      {
        union x86_imm_buf imb;

        try
          {
            D.34567 = disp + -4;
            imb.val = D.34567;
            pos.1723 = pos;
            pos = pos.1723 + 1;
            D.34569 = imb.b[0];
            *pos.1723 = D.34569;
            pos.1724 = pos;
            pos = pos.1724 + 1;
            D.34571 = imb.b[1];
            *pos.1724 = D.34571;
            pos.1725 = pos;
            pos = pos.1725 + 1;
            D.34573 = imb.b[2];
            *pos.1725 = D.34573;
            pos.1726 = pos;
            pos = pos.1726 + 1;
            D.34575 = imb.b[3];
            *pos.1726 = D.34575;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.34576>;
      <D.34566>:
      disp.1727 = (unsigned int) disp;
      D.34578 = disp.1727 + 127;
      if (D.34578 <= 255) goto <D.34579>; else goto <D.34580>;
      <D.34579>:
      D.34581 = (unsigned char) disp;
      D.34582 = D.34581 + 255;
      *pos = D.34582;
      pos = pos + 1;
      goto <D.34583>;
      <D.34580>:
      __assert_fail ("0", "mini-x86.c", 3080, &__PRETTY_FUNCTION__);
      <D.34583>:
      <D.34576>:
    }
  }
  goto <D.24796>;
  <D.25231>:
  {
    guint8 * jump_to_end;

    code.1728 = code;
    code = code.1728 + 1;
    *code.1728 = 15;
    code.1729 = code;
    code = code.1729 + 1;
    *code.1729 = 173;
    code.1730 = code;
    code = code.1730 + 1;
    D.34455 = ins->backend.reg3;
    D.34487 = D.34455 & 7;
    D.34488 = D.34487 << 3;
    D.34489 = (signed char) D.34488;
    D.34490 = D.34489 | -64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.34491 = D.34490 | D.31586;
    D.34492 = (unsigned char) D.34491;
    *code.1730 = D.34492;
    code.1731 = code;
    code = code.1731 + 1;
    *code.1731 = 211;
    code.1732 = code;
    code = code.1732 + 1;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34457 = D.34456 & 7;
    D.34589 = D.34457 | -24;
    D.34590 = (unsigned char) D.34589;
    *code.1732 = D.34590;
    if (0 != 0) goto <D.34591>; else goto <D.34592>;
    <D.34591>:
    code.1733 = code;
    code = code.1733 + 1;
    *code.1733 = 169;
    goto <D.34594>;
    <D.34592>:
    code.1734 = code;
    code = code.1734 + 1;
    *code.1734 = 247;
    code.1735 = code;
    code = code.1735 + 1;
    *code.1735 = 193;
    <D.34594>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 32;
          code.1736 = code;
          code = code.1736 + 1;
          D.34598 = imb.b[0];
          *code.1736 = D.34598;
          code.1737 = code;
          code = code.1737 + 1;
          D.34600 = imb.b[1];
          *code.1737 = D.34600;
          code.1738 = code;
          code = code.1738 + 1;
          D.34602 = imb.b[2];
          *code.1738 = D.34602;
          code.1739 = code;
          code = code.1739 + 1;
          D.34604 = imb.b[3];
          *code.1739 = D.34604;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    jump_to_end = code;
    if (0 != 0) goto <D.34605>; else goto <D.34606>;
    <D.34605>:
    code.1740 = code;
    code = code.1740 + 1;
    D.34479 = 116;
    *code.1740 = D.34479;
    goto <D.34608>;
    <D.34606>:
    code.1741 = code;
    code = code.1741 + 1;
    D.34482 = 116;
    *code.1741 = D.34482;
    <D.34608>:
    *code = 0;
    code = code + 1;
    switch (4) <default: <D.25238>, case 1: <D.25234>, case 2: <D.25236>, case 4: <D.25237>>
    <D.25234>:
    code.1742 = code;
    code = code.1742 + 1;
    *code.1742 = 138;
    goto <D.25235>;
    <D.25236>:
    code.1743 = code;
    code = code.1743 + 1;
    *code.1743 = 102;
    <D.25237>:
    code.1744 = code;
    code = code.1744 + 1;
    *code.1744 = 139;
    goto <D.25235>;
    <D.25238>:
    __assert_fail ("0", "mini-x86.c", 3094, &__PRETTY_FUNCTION__);
    <D.25235>:
    code.1745 = code;
    code = code.1745 + 1;
    D.31548 = ins->sreg1;
    D.32035 = D.31548 & 7;
    D.32036 = D.32035 << 3;
    D.32037 = (signed char) D.32036;
    D.32565 = D.32037 | -64;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34457 = D.34456 & 7;
    D.34458 = D.32565 | D.34457;
    D.34459 = (unsigned char) D.34458;
    *code.1745 = D.34459;
    code.1746 = code;
    code = code.1746 + 1;
    *code.1746 = 51;
    code.1747 = code;
    code = code.1747 + 1;
    D.34455 = ins->backend.reg3;
    D.34487 = D.34455 & 7;
    D.34488 = D.34487 << 3;
    D.34489 = (signed char) D.34488;
    D.34490 = D.34489 | -64;
    D.34455 = ins->backend.reg3;
    D.34456 = (signed char) D.34455;
    D.34457 = D.34456 & 7;
    D.34616 = D.34490 | D.34457;
    D.34617 = (unsigned char) D.34616;
    *code.1747 = D.34617;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump_to_end + 1;
      size = 0;
      D.34618 = MEM[(unsigned char *)jump_to_end];
      D.34619 = (int) D.34618;
      switch (D.34619) <default: <D.25266>, case 15: <D.25245>, case 112: <D.25250>, case 113: <D.25251>, case 114: <D.25252>, case 115: <D.25253>, case 116: <D.25254>, case 117: <D.25255>, case 118: <D.25256>, case 119: <D.25257>, case 120: <D.25258>, case 121: <D.25259>, case 122: <D.25260>, case 123: <D.25261>, case 124: <D.25262>, case 125: <D.25263>, case 126: <D.25264>, case 127: <D.25265>, case 224: <D.25246>, case 225: <D.25247>, case 226: <D.25248>, case 232: <D.25242>, case 233: <D.25243>, case 235: <D.25249>>
      <D.25242>:
      <D.25243>:
      size = size + 1;
      goto <D.25244>;
      <D.25245>:
      D.34620 = *pos;
      D.34621 = D.34620 + 144;
      if (D.34621 > 31) goto <D.34622>; else goto <D.34623>;
      <D.34622>:
      __assert_fail ("0", "mini-x86.c", 3097, &__PRETTY_FUNCTION__);
      <D.34623>:
      size = size + 1;
      pos = pos + 1;
      goto <D.25244>;
      <D.25246>:
      <D.25247>:
      <D.25248>:
      <D.25249>:
      <D.25250>:
      <D.25251>:
      <D.25252>:
      <D.25253>:
      <D.25254>:
      <D.25255>:
      <D.25256>:
      <D.25257>:
      <D.25258>:
      <D.25259>:
      <D.25260>:
      <D.25261>:
      <D.25262>:
      <D.25263>:
      <D.25264>:
      <D.25265>:
      goto <D.25244>;
      <D.25266>:
      __assert_fail ("0", "mini-x86.c", 3097, &__PRETTY_FUNCTION__);
      <D.25244>:
      code.422 = (int) code;
      pos.1748 = (int) pos;
      disp = code.422 - pos.1748;
      if (size != 0) goto <D.34625>; else goto <D.34626>;
      <D.34625>:
      {
        union x86_imm_buf imb;

        try
          {
            D.34627 = disp + -4;
            imb.val = D.34627;
            pos.1749 = pos;
            pos = pos.1749 + 1;
            D.34629 = imb.b[0];
            *pos.1749 = D.34629;
            pos.1750 = pos;
            pos = pos.1750 + 1;
            D.34631 = imb.b[1];
            *pos.1750 = D.34631;
            pos.1751 = pos;
            pos = pos.1751 + 1;
            D.34633 = imb.b[2];
            *pos.1751 = D.34633;
            pos.1752 = pos;
            pos = pos.1752 + 1;
            D.34635 = imb.b[3];
            *pos.1752 = D.34635;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.34636>;
      <D.34626>:
      disp.1753 = (unsigned int) disp;
      D.34638 = disp.1753 + 127;
      if (D.34638 <= 255) goto <D.34639>; else goto <D.34640>;
      <D.34639>:
      D.34641 = (unsigned char) disp;
      D.34642 = D.34641 + 255;
      *pos = D.34642;
      pos = pos + 1;
      goto <D.34643>;
      <D.34640>:
      __assert_fail ("0", "mini-x86.c", 3097, &__PRETTY_FUNCTION__);
      <D.34643>:
      <D.34636>:
    }
  }
  goto <D.24796>;
  <D.25268>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 > 31) goto <D.34644>; else goto <D.34645>;
  <D.34644>:
  switch (4) <default: <D.25273>, case 1: <D.25269>, case 2: <D.25271>, case 4: <D.25272>>
  <D.25269>:
  code.1754 = code;
  code = code.1754 + 1;
  *code.1754 = 138;
  goto <D.25270>;
  <D.25271>:
  code.1755 = code;
  code = code.1755 + 1;
  *code.1755 = 102;
  <D.25272>:
  code.1756 = code;
  code = code.1756 + 1;
  *code.1756 = 139;
  goto <D.25270>;
  <D.25273>:
  __assert_fail ("0", "mini-x86.c", 3102, &__PRETTY_FUNCTION__);
  <D.25270>:
  code.1757 = code;
  code = code.1757 + 1;
  D.34455 = ins->backend.reg3;
  D.34487 = D.34455 & 7;
  D.34488 = D.34487 << 3;
  D.34489 = (signed char) D.34488;
  D.34490 = D.34489 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34491 = D.34490 | D.31586;
  D.34492 = (unsigned char) D.34491;
  *code.1757 = D.34492;
  code.1758 = code;
  code = code.1758 + 1;
  *code.1758 = 51;
  code.1759 = code;
  code = code.1759 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32876 = D.32565 | D.31586;
  D.32877 = (unsigned char) D.32876;
  *code.1759 = D.32877;
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 33) goto <D.34652>; else goto <D.34653>;
  <D.34652>:
  code.1760 = code;
  code = code.1760 + 1;
  *code.1760 = 209;
  code.1761 = code;
  code = code.1761 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34656 = D.34457 | -32;
  D.34657 = (unsigned char) D.34656;
  *code.1761 = D.34657;
  goto <D.34658>;
  <D.34653>:
  code.1762 = code;
  code = code.1762 + 1;
  *code.1762 = 193;
  code.1763 = code;
  code = code.1763 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34656 = D.34457 | -32;
  D.34657 = (unsigned char) D.34656;
  *code.1763 = D.34657;
  D.31653 = ins->data.op[1].const_val;
  D.34661 = (unsigned char) D.31653;
  D.34662 = D.34661 + 224;
  *code = D.34662;
  code = code + 1;
  <D.34658>:
  goto <D.34663>;
  <D.34645>:
  code.1764 = code;
  code = code.1764 + 1;
  *code.1764 = 15;
  code.1765 = code;
  code = code.1765 + 1;
  *code.1765 = 164;
  code.1766 = code;
  code = code.1766 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34458 = D.32565 | D.34457;
  D.34459 = (unsigned char) D.34458;
  *code.1766 = D.34459;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 1) goto <D.34667>; else goto <D.34668>;
  <D.34667>:
  code.1767 = code;
  code = code.1767 + 1;
  *code.1767 = 209;
  code.1768 = code;
  code = code.1768 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.1768 = D.34069;
  goto <D.34671>;
  <D.34668>:
  code.1769 = code;
  code = code.1769 + 1;
  *code.1769 = 193;
  code.1770 = code;
  code = code.1770 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.1770 = D.34069;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  <D.34671>:
  <D.34663>:
  goto <D.24796>;
  <D.25274>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 > 31) goto <D.34674>; else goto <D.34675>;
  <D.34674>:
  switch (4) <default: <D.25279>, case 1: <D.25275>, case 2: <D.25277>, case 4: <D.25278>>
  <D.25275>:
  code.1771 = code;
  code = code.1771 + 1;
  *code.1771 = 138;
  goto <D.25276>;
  <D.25277>:
  code.1772 = code;
  code = code.1772 + 1;
  *code.1772 = 102;
  <D.25278>:
  code.1773 = code;
  code = code.1773 + 1;
  *code.1773 = 139;
  goto <D.25276>;
  <D.25279>:
  __assert_fail ("0", "mini-x86.c", 3112, &__PRETTY_FUNCTION__);
  <D.25276>:
  code.1774 = code;
  code = code.1774 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34458 = D.32565 | D.34457;
  D.34459 = (unsigned char) D.34458;
  *code.1774 = D.34459;
  if (0 != 0) goto <D.34680>; else goto <D.34681>;
  <D.34680>:
  code.1775 = code;
  code = code.1775 + 1;
  *code.1775 = 209;
  code.1776 = code;
  code = code.1776 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34526 = D.34456 | -8;
  D.34527 = (unsigned char) D.34526;
  *code.1776 = D.34527;
  goto <D.34684>;
  <D.34681>:
  code.1777 = code;
  code = code.1777 + 1;
  *code.1777 = 193;
  code.1778 = code;
  code = code.1778 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34526 = D.34456 | -8;
  D.34527 = (unsigned char) D.34526;
  *code.1778 = D.34527;
  *code = 31;
  code = code + 1;
  <D.34684>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 33) goto <D.34687>; else goto <D.34688>;
  <D.34687>:
  code.1779 = code;
  code = code.1779 + 1;
  *code.1779 = 209;
  code.1780 = code;
  code = code.1780 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.32585 = D.31585 | -8;
  D.32586 = (unsigned char) D.32585;
  *code.1780 = D.32586;
  goto <D.34691>;
  <D.34688>:
  code.1781 = code;
  code = code.1781 + 1;
  *code.1781 = 193;
  code.1782 = code;
  code = code.1782 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.32585 = D.31585 | -8;
  D.32586 = (unsigned char) D.32585;
  *code.1782 = D.32586;
  D.31653 = ins->data.op[1].const_val;
  D.34661 = (unsigned char) D.31653;
  D.34662 = D.34661 + 224;
  *code = D.34662;
  code = code + 1;
  <D.34691>:
  goto <D.34694>;
  <D.34675>:
  code.1783 = code;
  code = code.1783 + 1;
  *code.1783 = 15;
  code.1784 = code;
  code = code.1784 + 1;
  *code.1784 = 172;
  code.1785 = code;
  code = code.1785 + 1;
  D.34455 = ins->backend.reg3;
  D.34487 = D.34455 & 7;
  D.34488 = D.34487 << 3;
  D.34489 = (signed char) D.34488;
  D.34490 = D.34489 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34491 = D.34490 | D.31586;
  D.34492 = (unsigned char) D.34491;
  *code.1785 = D.34492;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 1) goto <D.34698>; else goto <D.34699>;
  <D.34698>:
  code.1786 = code;
  code = code.1786 + 1;
  *code.1786 = 209;
  code.1787 = code;
  code = code.1787 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34526 = D.34456 | -8;
  D.34527 = (unsigned char) D.34526;
  *code.1787 = D.34527;
  goto <D.34702>;
  <D.34699>:
  code.1788 = code;
  code = code.1788 + 1;
  *code.1788 = 193;
  code.1789 = code;
  code = code.1789 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34526 = D.34456 | -8;
  D.34527 = (unsigned char) D.34526;
  *code.1789 = D.34527;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  <D.34702>:
  <D.34694>:
  goto <D.24796>;
  <D.25280>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 > 31) goto <D.34705>; else goto <D.34706>;
  <D.34705>:
  switch (4) <default: <D.25285>, case 1: <D.25281>, case 2: <D.25283>, case 4: <D.25284>>
  <D.25281>:
  code.1790 = code;
  code = code.1790 + 1;
  *code.1790 = 138;
  goto <D.25282>;
  <D.25283>:
  code.1791 = code;
  code = code.1791 + 1;
  *code.1791 = 102;
  <D.25284>:
  code.1792 = code;
  code = code.1792 + 1;
  *code.1792 = 139;
  goto <D.25282>;
  <D.25285>:
  __assert_fail ("0", "mini-x86.c", 3122, &__PRETTY_FUNCTION__);
  <D.25282>:
  code.1793 = code;
  code = code.1793 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34458 = D.32565 | D.34457;
  D.34459 = (unsigned char) D.34458;
  *code.1793 = D.34459;
  code.1794 = code;
  code = code.1794 + 1;
  *code.1794 = 51;
  code.1795 = code;
  code = code.1795 + 1;
  D.34455 = ins->backend.reg3;
  D.34487 = D.34455 & 7;
  D.34488 = D.34487 << 3;
  D.34489 = (signed char) D.34488;
  D.34490 = D.34489 | -64;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34616 = D.34490 | D.34457;
  D.34617 = (unsigned char) D.34616;
  *code.1795 = D.34617;
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 33) goto <D.34713>; else goto <D.34714>;
  <D.34713>:
  code.1796 = code;
  code = code.1796 + 1;
  *code.1796 = 209;
  code.1797 = code;
  code = code.1797 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34717 = D.31586 | -24;
  D.34718 = (unsigned char) D.34717;
  *code.1797 = D.34718;
  goto <D.34719>;
  <D.34714>:
  code.1798 = code;
  code = code.1798 + 1;
  *code.1798 = 193;
  code.1799 = code;
  code = code.1799 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34717 = D.31586 | -24;
  D.34718 = (unsigned char) D.34717;
  *code.1799 = D.34718;
  D.31653 = ins->data.op[1].const_val;
  D.34661 = (unsigned char) D.31653;
  D.34662 = D.34661 + 224;
  *code = D.34662;
  code = code + 1;
  <D.34719>:
  goto <D.34722>;
  <D.34706>:
  code.1800 = code;
  code = code.1800 + 1;
  *code.1800 = 15;
  code.1801 = code;
  code = code.1801 + 1;
  *code.1801 = 172;
  code.1802 = code;
  code = code.1802 + 1;
  D.34455 = ins->backend.reg3;
  D.34487 = D.34455 & 7;
  D.34488 = D.34487 << 3;
  D.34489 = (signed char) D.34488;
  D.34490 = D.34489 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34491 = D.34490 | D.31586;
  D.34492 = (unsigned char) D.34491;
  *code.1802 = D.34492;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 1) goto <D.34726>; else goto <D.34727>;
  <D.34726>:
  code.1803 = code;
  code = code.1803 + 1;
  *code.1803 = 209;
  code.1804 = code;
  code = code.1804 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34589 = D.34457 | -24;
  D.34590 = (unsigned char) D.34589;
  *code.1804 = D.34590;
  goto <D.34730>;
  <D.34727>:
  code.1805 = code;
  code = code.1805 + 1;
  *code.1805 = 193;
  code.1806 = code;
  code = code.1806 + 1;
  D.34455 = ins->backend.reg3;
  D.34456 = (signed char) D.34455;
  D.34457 = D.34456 & 7;
  D.34589 = D.34457 | -24;
  D.34590 = (unsigned char) D.34589;
  *code.1806 = D.34590;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  <D.34730>:
  <D.34722>:
  goto <D.24796>;
  <D.25286>:
  code.1807 = code;
  code = code.1807 + 1;
  *code.1807 = 247;
  code.1808 = code;
  code = code.1808 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34735 = D.31586 | -48;
  D.34736 = (unsigned char) D.34735;
  *code.1808 = D.34736;
  goto <D.24796>;
  <D.25287>:
  code.1809 = code;
  code = code.1809 + 1;
  *code.1809 = 247;
  code.1810 = code;
  code = code.1810 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34739 = D.31586 | -40;
  D.34740 = (unsigned char) D.34739;
  *code.1810 = D.34740;
  goto <D.24796>;
  <D.25288>:
  code.1811 = code;
  code = code.1811 + 1;
  *code.1811 = 15;
  code.1812 = code;
  code = code.1812 + 1;
  *code.1812 = 175;
  code.1813 = code;
  code = code.1813 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.1813 = D.32567;
  goto <D.24796>;
  <D.25289>:
  <D.25290>:
  D.31653 = ins->data.op[1].const_val;
  switch (D.31653) <default: <D.25326>, case 2: <D.25291>, case 3: <D.25298>, case 5: <D.25301>, case 6: <D.25304>, case 9: <D.25307>, case 10: <D.25310>, case 12: <D.25313>, case 25: <D.25316>, case 100: <D.25321>>
  <D.25291>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  if (D.31604 != D.31548) goto <D.34744>; else goto <D.34745>;
  <D.34744>:
  switch (4) <default: <D.25296>, case 1: <D.25292>, case 2: <D.25294>, case 4: <D.25295>>
  <D.25292>:
  code.1814 = code;
  code = code.1814 + 1;
  *code.1814 = 138;
  goto <D.25293>;
  <D.25294>:
  code.1815 = code;
  code = code.1815 + 1;
  *code.1815 = 102;
  <D.25295>:
  code.1816 = code;
  code = code.1816 + 1;
  *code.1816 = 139;
  goto <D.25293>;
  <D.25296>:
  __assert_fail ("0", "mini-x86.c", 3147, &__PRETTY_FUNCTION__);
  <D.25293>:
  code.1817 = code;
  code = code.1817 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.1817 = D.32535;
  <D.34745>:
  code.1818 = code;
  code = code.1818 + 1;
  *code.1818 = 3;
  code.1819 = code;
  code = code.1819 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.1819 = D.34303;
  goto <D.25297>;
  <D.25298>:
  code.1820 = code;
  code = code.1820 + 1;
  *code.1820 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34753>; else goto <D.34754>;
  <D.34753>:
  code.1821 = code;
  code = code.1821 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1821 = D.32289;
  code.1822 = code;
  code = code.1822 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34757 = D.32037 | 69;
  D.34758 = (unsigned char) D.34757;
  *code.1822 = D.34758;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1823 = code;
        code = code.1823 + 1;
        D.34760 = imb.b[0];
        *code.1823 = D.34760;
        code.1824 = code;
        code = code.1824 + 1;
        D.34762 = imb.b[1];
        *code.1824 = D.34762;
        code.1825 = code;
        code = code.1825 + 1;
        D.34764 = imb.b[2];
        *code.1825 = D.34764;
        code.1826 = code;
        code = code.1826 + 1;
        D.34766 = imb.b[3];
        *code.1826 = D.34766;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34767>;
  <D.34754>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34768>; else goto <D.34769>;
  <D.34768>:
  code.1827 = code;
  code = code.1827 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1827 = D.32289;
  code.1828 = code;
  code = code.1828 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1828 = D.34773;
  goto <D.34774>;
  <D.34769>:
  if (1 != 0) goto <D.34775>; else goto <D.34776>;
  <D.34775>:
  code.1829 = code;
  code = code.1829 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1829 = D.32296;
  code.1830 = code;
  code = code.1830 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1830 = D.34773;
  *code = 0;
  code = code + 1;
  goto <D.34779>;
  <D.34776>:
  code.1831 = code;
  code = code.1831 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1831 = D.32301;
  code.1832 = code;
  code = code.1832 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1832 = D.34773;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1833 = code;
        code = code.1833 + 1;
        D.34783 = imb.b[0];
        *code.1833 = D.34783;
        code.1834 = code;
        code = code.1834 + 1;
        D.34785 = imb.b[1];
        *code.1834 = D.34785;
        code.1835 = code;
        code = code.1835 + 1;
        D.34787 = imb.b[2];
        *code.1835 = D.34787;
        code.1836 = code;
        code = code.1836 + 1;
        D.34789 = imb.b[3];
        *code.1836 = D.34789;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34779>:
  <D.34774>:
  <D.34767>:
  goto <D.25297>;
  <D.25301>:
  code.1837 = code;
  code = code.1837 + 1;
  *code.1837 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34791>; else goto <D.34792>;
  <D.34791>:
  code.1838 = code;
  code = code.1838 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1838 = D.32289;
  code.1839 = code;
  code = code.1839 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34795 = D.32037 | -123;
  D.34796 = (unsigned char) D.34795;
  *code.1839 = D.34796;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1840 = code;
        code = code.1840 + 1;
        D.34798 = imb.b[0];
        *code.1840 = D.34798;
        code.1841 = code;
        code = code.1841 + 1;
        D.34800 = imb.b[1];
        *code.1841 = D.34800;
        code.1842 = code;
        code = code.1842 + 1;
        D.34802 = imb.b[2];
        *code.1842 = D.34802;
        code.1843 = code;
        code = code.1843 + 1;
        D.34804 = imb.b[3];
        *code.1843 = D.34804;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34805>;
  <D.34792>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34806>; else goto <D.34807>;
  <D.34806>:
  code.1844 = code;
  code = code.1844 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1844 = D.32289;
  code.1845 = code;
  code = code.1845 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1845 = D.34811;
  goto <D.34812>;
  <D.34807>:
  if (1 != 0) goto <D.34813>; else goto <D.34814>;
  <D.34813>:
  code.1846 = code;
  code = code.1846 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1846 = D.32296;
  code.1847 = code;
  code = code.1847 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1847 = D.34811;
  *code = 0;
  code = code + 1;
  goto <D.34817>;
  <D.34814>:
  code.1848 = code;
  code = code.1848 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1848 = D.32301;
  code.1849 = code;
  code = code.1849 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1849 = D.34811;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1850 = code;
        code = code.1850 + 1;
        D.34821 = imb.b[0];
        *code.1850 = D.34821;
        code.1851 = code;
        code = code.1851 + 1;
        D.34823 = imb.b[1];
        *code.1851 = D.34823;
        code.1852 = code;
        code = code.1852 + 1;
        D.34825 = imb.b[2];
        *code.1852 = D.34825;
        code.1853 = code;
        code = code.1853 + 1;
        D.34827 = imb.b[3];
        *code.1853 = D.34827;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34817>:
  <D.34812>:
  <D.34805>:
  goto <D.25297>;
  <D.25304>:
  code.1854 = code;
  code = code.1854 + 1;
  *code.1854 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34829>; else goto <D.34830>;
  <D.34829>:
  code.1855 = code;
  code = code.1855 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1855 = D.32289;
  code.1856 = code;
  code = code.1856 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34757 = D.32037 | 69;
  D.34758 = (unsigned char) D.34757;
  *code.1856 = D.34758;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1857 = code;
        code = code.1857 + 1;
        D.34834 = imb.b[0];
        *code.1857 = D.34834;
        code.1858 = code;
        code = code.1858 + 1;
        D.34836 = imb.b[1];
        *code.1858 = D.34836;
        code.1859 = code;
        code = code.1859 + 1;
        D.34838 = imb.b[2];
        *code.1859 = D.34838;
        code.1860 = code;
        code = code.1860 + 1;
        D.34840 = imb.b[3];
        *code.1860 = D.34840;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34841>;
  <D.34830>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34842>; else goto <D.34843>;
  <D.34842>:
  code.1861 = code;
  code = code.1861 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1861 = D.32289;
  code.1862 = code;
  code = code.1862 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1862 = D.34773;
  goto <D.34846>;
  <D.34843>:
  if (1 != 0) goto <D.34847>; else goto <D.34848>;
  <D.34847>:
  code.1863 = code;
  code = code.1863 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1863 = D.32296;
  code.1864 = code;
  code = code.1864 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1864 = D.34773;
  *code = 0;
  code = code + 1;
  goto <D.34851>;
  <D.34848>:
  code.1865 = code;
  code = code.1865 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1865 = D.32301;
  code.1866 = code;
  code = code.1866 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1866 = D.34773;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1867 = code;
        code = code.1867 + 1;
        D.34855 = imb.b[0];
        *code.1867 = D.34855;
        code.1868 = code;
        code = code.1868 + 1;
        D.34857 = imb.b[1];
        *code.1868 = D.34857;
        code.1869 = code;
        code = code.1869 + 1;
        D.34859 = imb.b[2];
        *code.1869 = D.34859;
        code.1870 = code;
        code = code.1870 + 1;
        D.34861 = imb.b[3];
        *code.1870 = D.34861;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34851>:
  <D.34846>:
  <D.34841>:
  code.1871 = code;
  code = code.1871 + 1;
  *code.1871 = 3;
  code.1872 = code;
  code = code.1872 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.1872 = D.34303;
  goto <D.25297>;
  <D.25307>:
  code.1873 = code;
  code = code.1873 + 1;
  *code.1873 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34865>; else goto <D.34866>;
  <D.34865>:
  code.1874 = code;
  code = code.1874 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1874 = D.32289;
  code.1875 = code;
  code = code.1875 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34869 = D.32037 | -59;
  D.34870 = (unsigned char) D.34869;
  *code.1875 = D.34870;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1876 = code;
        code = code.1876 + 1;
        D.34872 = imb.b[0];
        *code.1876 = D.34872;
        code.1877 = code;
        code = code.1877 + 1;
        D.34874 = imb.b[1];
        *code.1877 = D.34874;
        code.1878 = code;
        code = code.1878 + 1;
        D.34876 = imb.b[2];
        *code.1878 = D.34876;
        code.1879 = code;
        code = code.1879 + 1;
        D.34878 = imb.b[3];
        *code.1879 = D.34878;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34879>;
  <D.34866>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34880>; else goto <D.34881>;
  <D.34880>:
  code.1880 = code;
  code = code.1880 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1880 = D.32289;
  code.1881 = code;
  code = code.1881 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32876 = D.32565 | D.31586;
  D.32877 = (unsigned char) D.32876;
  *code.1881 = D.32877;
  goto <D.34884>;
  <D.34881>:
  if (1 != 0) goto <D.34885>; else goto <D.34886>;
  <D.34885>:
  code.1882 = code;
  code = code.1882 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1882 = D.32296;
  code.1883 = code;
  code = code.1883 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32876 = D.32565 | D.31586;
  D.32877 = (unsigned char) D.32876;
  *code.1883 = D.32877;
  *code = 0;
  code = code + 1;
  goto <D.34889>;
  <D.34886>:
  code.1884 = code;
  code = code.1884 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1884 = D.32301;
  code.1885 = code;
  code = code.1885 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32876 = D.32565 | D.31586;
  D.32877 = (unsigned char) D.32876;
  *code.1885 = D.32877;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1886 = code;
        code = code.1886 + 1;
        D.34893 = imb.b[0];
        *code.1886 = D.34893;
        code.1887 = code;
        code = code.1887 + 1;
        D.34895 = imb.b[1];
        *code.1887 = D.34895;
        code.1888 = code;
        code = code.1888 + 1;
        D.34897 = imb.b[2];
        *code.1888 = D.34897;
        code.1889 = code;
        code = code.1889 + 1;
        D.34899 = imb.b[3];
        *code.1889 = D.34899;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34889>:
  <D.34884>:
  <D.34879>:
  goto <D.25297>;
  <D.25310>:
  code.1890 = code;
  code = code.1890 + 1;
  *code.1890 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34901>; else goto <D.34902>;
  <D.34901>:
  code.1891 = code;
  code = code.1891 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1891 = D.32289;
  code.1892 = code;
  code = code.1892 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34795 = D.32037 | -123;
  D.34796 = (unsigned char) D.34795;
  *code.1892 = D.34796;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1893 = code;
        code = code.1893 + 1;
        D.34906 = imb.b[0];
        *code.1893 = D.34906;
        code.1894 = code;
        code = code.1894 + 1;
        D.34908 = imb.b[1];
        *code.1894 = D.34908;
        code.1895 = code;
        code = code.1895 + 1;
        D.34910 = imb.b[2];
        *code.1895 = D.34910;
        code.1896 = code;
        code = code.1896 + 1;
        D.34912 = imb.b[3];
        *code.1896 = D.34912;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34913>;
  <D.34902>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34914>; else goto <D.34915>;
  <D.34914>:
  code.1897 = code;
  code = code.1897 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1897 = D.32289;
  code.1898 = code;
  code = code.1898 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1898 = D.34811;
  goto <D.34918>;
  <D.34915>:
  if (1 != 0) goto <D.34919>; else goto <D.34920>;
  <D.34919>:
  code.1899 = code;
  code = code.1899 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1899 = D.32296;
  code.1900 = code;
  code = code.1900 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1900 = D.34811;
  *code = 0;
  code = code + 1;
  goto <D.34923>;
  <D.34920>:
  code.1901 = code;
  code = code.1901 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1901 = D.32301;
  code.1902 = code;
  code = code.1902 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1902 = D.34811;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1903 = code;
        code = code.1903 + 1;
        D.34927 = imb.b[0];
        *code.1903 = D.34927;
        code.1904 = code;
        code = code.1904 + 1;
        D.34929 = imb.b[1];
        *code.1904 = D.34929;
        code.1905 = code;
        code = code.1905 + 1;
        D.34931 = imb.b[2];
        *code.1905 = D.34931;
        code.1906 = code;
        code = code.1906 + 1;
        D.34933 = imb.b[3];
        *code.1906 = D.34933;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34923>:
  <D.34918>:
  <D.34913>:
  code.1907 = code;
  code = code.1907 + 1;
  *code.1907 = 3;
  code.1908 = code;
  code = code.1908 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.1908 = D.34303;
  goto <D.25297>;
  <D.25313>:
  code.1909 = code;
  code = code.1909 + 1;
  *code.1909 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34937>; else goto <D.34938>;
  <D.34937>:
  code.1910 = code;
  code = code.1910 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1910 = D.32289;
  code.1911 = code;
  code = code.1911 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34757 = D.32037 | 69;
  D.34758 = (unsigned char) D.34757;
  *code.1911 = D.34758;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1912 = code;
        code = code.1912 + 1;
        D.34942 = imb.b[0];
        *code.1912 = D.34942;
        code.1913 = code;
        code = code.1913 + 1;
        D.34944 = imb.b[1];
        *code.1913 = D.34944;
        code.1914 = code;
        code = code.1914 + 1;
        D.34946 = imb.b[2];
        *code.1914 = D.34946;
        code.1915 = code;
        code = code.1915 + 1;
        D.34948 = imb.b[3];
        *code.1915 = D.34948;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34949>;
  <D.34938>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34950>; else goto <D.34951>;
  <D.34950>:
  code.1916 = code;
  code = code.1916 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1916 = D.32289;
  code.1917 = code;
  code = code.1917 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1917 = D.34773;
  goto <D.34954>;
  <D.34951>:
  if (1 != 0) goto <D.34955>; else goto <D.34956>;
  <D.34955>:
  code.1918 = code;
  code = code.1918 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1918 = D.32296;
  code.1919 = code;
  code = code.1919 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1919 = D.34773;
  *code = 0;
  code = code + 1;
  goto <D.34959>;
  <D.34956>:
  code.1920 = code;
  code = code.1920 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1920 = D.32301;
  code.1921 = code;
  code = code.1921 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.1921 = D.34773;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1922 = code;
        code = code.1922 + 1;
        D.34963 = imb.b[0];
        *code.1922 = D.34963;
        code.1923 = code;
        code = code.1923 + 1;
        D.34965 = imb.b[1];
        *code.1923 = D.34965;
        code.1924 = code;
        code = code.1924 + 1;
        D.34967 = imb.b[2];
        *code.1924 = D.34967;
        code.1925 = code;
        code = code.1925 + 1;
        D.34969 = imb.b[3];
        *code.1925 = D.34969;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34959>:
  <D.34954>:
  <D.34949>:
  if (0 != 0) goto <D.34970>; else goto <D.34971>;
  <D.34970>:
  code.1926 = code;
  code = code.1926 + 1;
  *code.1926 = 209;
  code.1927 = code;
  code = code.1927 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1927 = D.34420;
  goto <D.34974>;
  <D.34971>:
  code.1928 = code;
  code = code.1928 + 1;
  *code.1928 = 193;
  code.1929 = code;
  code = code.1929 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1929 = D.34420;
  *code = 2;
  code = code + 1;
  <D.34974>:
  goto <D.25297>;
  <D.25316>:
  code.1930 = code;
  code = code.1930 + 1;
  *code.1930 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.34978>; else goto <D.34979>;
  <D.34978>:
  code.1931 = code;
  code = code.1931 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1931 = D.32289;
  code.1932 = code;
  code = code.1932 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34795 = D.32037 | -123;
  D.34796 = (unsigned char) D.34795;
  *code.1932 = D.34796;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1933 = code;
        code = code.1933 + 1;
        D.34983 = imb.b[0];
        *code.1933 = D.34983;
        code.1934 = code;
        code = code.1934 + 1;
        D.34985 = imb.b[1];
        *code.1934 = D.34985;
        code.1935 = code;
        code = code.1935 + 1;
        D.34987 = imb.b[2];
        *code.1935 = D.34987;
        code.1936 = code;
        code = code.1936 + 1;
        D.34989 = imb.b[3];
        *code.1936 = D.34989;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34990>;
  <D.34979>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.34991>; else goto <D.34992>;
  <D.34991>:
  code.1937 = code;
  code = code.1937 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1937 = D.32289;
  code.1938 = code;
  code = code.1938 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1938 = D.34811;
  goto <D.34995>;
  <D.34992>:
  if (1 != 0) goto <D.34996>; else goto <D.34997>;
  <D.34996>:
  code.1939 = code;
  code = code.1939 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1939 = D.32296;
  code.1940 = code;
  code = code.1940 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1940 = D.34811;
  *code = 0;
  code = code + 1;
  goto <D.35000>;
  <D.34997>:
  code.1941 = code;
  code = code.1941 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1941 = D.32301;
  code.1942 = code;
  code = code.1942 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1942 = D.34811;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1943 = code;
        code = code.1943 + 1;
        D.35004 = imb.b[0];
        *code.1943 = D.35004;
        code.1944 = code;
        code = code.1944 + 1;
        D.35006 = imb.b[1];
        *code.1944 = D.35006;
        code.1945 = code;
        code = code.1945 + 1;
        D.35008 = imb.b[2];
        *code.1945 = D.35008;
        code.1946 = code;
        code = code.1946 + 1;
        D.35010 = imb.b[3];
        *code.1946 = D.35010;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35000>:
  <D.34995>:
  <D.34990>:
  code.1947 = code;
  code = code.1947 + 1;
  *code.1947 = 141;
  D.31604 = ins->dreg;
  if (D.31604 == -1) goto <D.35012>; else goto <D.35013>;
  <D.35012>:
  code.1948 = code;
  code = code.1948 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1948 = D.32289;
  code.1949 = code;
  code = code.1949 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.35016 = D.32227 | -123;
  D.35017 = (unsigned char) D.35016;
  *code.1949 = D.35017;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1950 = code;
        code = code.1950 + 1;
        D.35019 = imb.b[0];
        *code.1950 = D.35019;
        code.1951 = code;
        code = code.1951 + 1;
        D.35021 = imb.b[1];
        *code.1951 = D.35021;
        code.1952 = code;
        code = code.1952 + 1;
        D.35023 = imb.b[2];
        *code.1952 = D.35023;
        code.1953 = code;
        code = code.1953 + 1;
        D.35025 = imb.b[3];
        *code.1953 = D.35025;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35026>;
  <D.35013>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.35027>; else goto <D.35028>;
  <D.35027>:
  code.1954 = code;
  code = code.1954 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1954 = D.32289;
  code.1955 = code;
  code = code.1955 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.35031 = D.32326 | D.31638;
  D.35032 = (unsigned char) D.35031;
  *code.1955 = D.35032;
  goto <D.35033>;
  <D.35028>:
  if (1 != 0) goto <D.35034>; else goto <D.35035>;
  <D.35034>:
  code.1956 = code;
  code = code.1956 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1956 = D.32296;
  code.1957 = code;
  code = code.1957 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.35031 = D.32326 | D.31638;
  D.35032 = (unsigned char) D.35031;
  *code.1957 = D.35032;
  *code = 0;
  code = code + 1;
  goto <D.35038>;
  <D.35035>:
  code.1958 = code;
  code = code.1958 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1958 = D.32301;
  code.1959 = code;
  code = code.1959 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.35031 = D.32326 | D.31638;
  D.35032 = (unsigned char) D.35031;
  *code.1959 = D.35032;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1960 = code;
        code = code.1960 + 1;
        D.35042 = imb.b[0];
        *code.1960 = D.35042;
        code.1961 = code;
        code = code.1961 + 1;
        D.35044 = imb.b[1];
        *code.1961 = D.35044;
        code.1962 = code;
        code = code.1962 + 1;
        D.35046 = imb.b[2];
        *code.1962 = D.35046;
        code.1963 = code;
        code = code.1963 + 1;
        D.35048 = imb.b[3];
        *code.1963 = D.35048;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35038>:
  <D.35033>:
  <D.35026>:
  goto <D.25297>;
  <D.25321>:
  code.1964 = code;
  code = code.1964 + 1;
  *code.1964 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.35050>; else goto <D.35051>;
  <D.35050>:
  code.1965 = code;
  code = code.1965 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1965 = D.32289;
  code.1966 = code;
  code = code.1966 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.34795 = D.32037 | -123;
  D.34796 = (unsigned char) D.34795;
  *code.1966 = D.34796;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1967 = code;
        code = code.1967 + 1;
        D.35055 = imb.b[0];
        *code.1967 = D.35055;
        code.1968 = code;
        code = code.1968 + 1;
        D.35057 = imb.b[1];
        *code.1968 = D.35057;
        code.1969 = code;
        code = code.1969 + 1;
        D.35059 = imb.b[2];
        *code.1969 = D.35059;
        code.1970 = code;
        code = code.1970 + 1;
        D.35061 = imb.b[3];
        *code.1970 = D.35061;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35062>;
  <D.35051>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.35063>; else goto <D.35064>;
  <D.35063>:
  code.1971 = code;
  code = code.1971 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1971 = D.32289;
  code.1972 = code;
  code = code.1972 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1972 = D.34811;
  goto <D.35067>;
  <D.35064>:
  if (1 != 0) goto <D.35068>; else goto <D.35069>;
  <D.35068>:
  code.1973 = code;
  code = code.1973 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1973 = D.32296;
  code.1974 = code;
  code = code.1974 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1974 = D.34811;
  *code = 0;
  code = code + 1;
  goto <D.35072>;
  <D.35069>:
  code.1975 = code;
  code = code.1975 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1975 = D.32301;
  code.1976 = code;
  code = code.1976 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.1976 = D.34811;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1977 = code;
        code = code.1977 + 1;
        D.35076 = imb.b[0];
        *code.1977 = D.35076;
        code.1978 = code;
        code = code.1978 + 1;
        D.35078 = imb.b[1];
        *code.1978 = D.35078;
        code.1979 = code;
        code = code.1979 + 1;
        D.35080 = imb.b[2];
        *code.1979 = D.35080;
        code.1980 = code;
        code = code.1980 + 1;
        D.35082 = imb.b[3];
        *code.1980 = D.35082;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35072>:
  <D.35067>:
  <D.35062>:
  if (0 != 0) goto <D.35083>; else goto <D.35084>;
  <D.35083>:
  code.1981 = code;
  code = code.1981 + 1;
  *code.1981 = 209;
  code.1982 = code;
  code = code.1982 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1982 = D.34420;
  goto <D.35087>;
  <D.35084>:
  code.1983 = code;
  code = code.1983 + 1;
  *code.1983 = 193;
  code.1984 = code;
  code = code.1984 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.1984 = D.34420;
  *code = 2;
  code = code + 1;
  <D.35087>:
  code.1985 = code;
  code = code.1985 + 1;
  *code.1985 = 141;
  D.31604 = ins->dreg;
  if (D.31604 == -1) goto <D.35091>; else goto <D.35092>;
  <D.35091>:
  code.1986 = code;
  code = code.1986 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1986 = D.32289;
  code.1987 = code;
  code = code.1987 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.35016 = D.32227 | -123;
  D.35017 = (unsigned char) D.35016;
  *code.1987 = D.35017;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1988 = code;
        code = code.1988 + 1;
        D.35096 = imb.b[0];
        *code.1988 = D.35096;
        code.1989 = code;
        code = code.1989 + 1;
        D.35098 = imb.b[1];
        *code.1989 = D.35098;
        code.1990 = code;
        code = code.1990 + 1;
        D.35100 = imb.b[2];
        *code.1990 = D.35100;
        code.1991 = code;
        code = code.1991 + 1;
        D.35102 = imb.b[3];
        *code.1991 = D.35102;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35103>;
  <D.35092>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.35104>; else goto <D.35105>;
  <D.35104>:
  code.1992 = code;
  code = code.1992 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.1992 = D.32289;
  code.1993 = code;
  code = code.1993 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.35031 = D.32326 | D.31638;
  D.35032 = (unsigned char) D.35031;
  *code.1993 = D.35032;
  goto <D.35108>;
  <D.35105>:
  if (1 != 0) goto <D.35109>; else goto <D.35110>;
  <D.35109>:
  code.1994 = code;
  code = code.1994 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.1994 = D.32296;
  code.1995 = code;
  code = code.1995 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.35031 = D.32326 | D.31638;
  D.35032 = (unsigned char) D.35031;
  *code.1995 = D.35032;
  *code = 0;
  code = code + 1;
  goto <D.35113>;
  <D.35110>:
  code.1996 = code;
  code = code.1996 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.1996 = D.32301;
  code.1997 = code;
  code = code.1997 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.35031 = D.32326 | D.31638;
  D.35032 = (unsigned char) D.35031;
  *code.1997 = D.35032;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1998 = code;
        code = code.1998 + 1;
        D.35117 = imb.b[0];
        *code.1998 = D.35117;
        code.1999 = code;
        code = code.1999 + 1;
        D.35119 = imb.b[1];
        *code.1999 = D.35119;
        code.2000 = code;
        code = code.2000 + 1;
        D.35121 = imb.b[2];
        *code.2000 = D.35121;
        code.2001 = code;
        code = code.2001 + 1;
        D.35123 = imb.b[3];
        *code.2001 = D.35123;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35113>:
  <D.35108>:
  <D.35103>:
  goto <D.25297>;
  <D.25326>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.35124>; else goto <D.35125>;
  <D.35124>:
  code.2002 = code;
  code = code.2002 + 1;
  *code.2002 = 107;
  code.2003 = code;
  code = code.2003 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.2003 = D.32535;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.35128>;
  <D.35125>:
  code.2004 = code;
  code = code.2004 + 1;
  *code.2004 = 105;
  code.2005 = code;
  code = code.2005 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.2005 = D.32535;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2006 = code;
        code = code.2006 + 1;
        D.35132 = imb.b[0];
        *code.2006 = D.35132;
        code.2007 = code;
        code = code.2007 + 1;
        D.35134 = imb.b[1];
        *code.2007 = D.35134;
        code.2008 = code;
        code = code.2008 + 1;
        D.35136 = imb.b[2];
        *code.2008 = D.35136;
        code.2009 = code;
        code = code.2009 + 1;
        D.35138 = imb.b[3];
        *code.2009 = D.35138;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35128>:
  goto <D.25297>;
  <D.25297>:
  goto <D.24796>;
  <D.25328>:
  code.2010 = code;
  code = code.2010 + 1;
  *code.2010 = 15;
  code.2011 = code;
  code = code.2011 + 1;
  *code.2011 = 175;
  code.2012 = code;
  code = code.2012 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.2012 = D.32567;
  {
    struct MonoInst * tins;

    tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
    if (tins == 0B) goto <D.35142>; else goto <D.35143>;
    <D.35142>:
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 9, "OverflowException");
    code.2013 = code;
    code = code.2013 + 1;
    *code.2013 = 15;
    if (0 != 0) goto <D.35145>; else goto <D.35146>;
    <D.35145>:
    code.2014 = code;
    code = code.2014 + 1;
    D.35148 = 112;
    D.35149 = D.35148 + 16;
    *code.2014 = D.35149;
    goto <D.35150>;
    <D.35146>:
    code.2015 = code;
    code = code.2015 + 1;
    D.35152 = 112;
    D.35153 = D.35152 + 16;
    *code.2015 = D.35153;
    <D.35150>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2016 = code;
          code = code.2016 + 1;
          D.35155 = imb.b[0];
          *code.2016 = D.35155;
          code.2017 = code;
          code = code.2017 + 1;
          D.35157 = imb.b[1];
          *code.2017 = D.35157;
          code.2018 = code;
          code = code.2018 + 1;
          D.35159 = imb.b[2];
          *code.2018 = D.35159;
          code.2019 = code;
          code = code.2019 + 1;
          D.35161 = imb.b[3];
          *code.2019 = D.35161;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.35162>;
    <D.35143>:
    D.35163 = tins->data.op[1].many_blocks;
    D.35164 = *D.35163;
    D.35165 = D.35164->native_offset;
    if (D.35165 != 0) goto <D.35166>; else goto <D.35167>;
    <D.35166>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.35163 = tins->data.op[1].many_blocks;
      D.35164 = *D.35163;
      D.35165 = D.35164->native_offset;
      D.35168 = (sizetype) D.35165;
      D.35169 = D.31409 + D.35168;
      D.35170 = (int) D.35169;
      code.422 = (int) code;
      D.35171 = D.35170 - code.422;
      offset = D.35171 + -2;
      branch_start = code;
      offset.2020 = (unsigned int) offset;
      D.35173 = offset.2020 + 128;
      if (D.35173 <= 255) goto <D.35174>; else goto <D.35175>;
      <D.35174>:
      if (0 != 0) goto <D.35176>; else goto <D.35177>;
      <D.35176>:
      code.2021 = code;
      code = code.2021 + 1;
      D.35148 = 112;
      *code.2021 = D.35148;
      goto <D.35179>;
      <D.35177>:
      code.2022 = code;
      code = code.2022 + 1;
      D.35152 = 112;
      *code.2022 = D.35152;
      <D.35179>:
      D.35181 = (unsigned char) offset;
      *code = D.35181;
      code = code + 1;
      goto <D.35182>;
      <D.35175>:
      D.31409 = cfg->native_code;
      D.35163 = tins->data.op[1].many_blocks;
      D.35164 = *D.35163;
      D.35165 = D.35164->native_offset;
      D.35168 = (sizetype) D.35165;
      D.35169 = D.31409 + D.35168;
      D.35170 = (int) D.35169;
      code.422 = (int) code;
      D.35171 = D.35170 - code.422;
      offset = D.35171 + -6;
      code.2023 = code;
      code = code.2023 + 1;
      *code.2023 = 15;
      if (0 != 0) goto <D.35184>; else goto <D.35185>;
      <D.35184>:
      code.2024 = code;
      code = code.2024 + 1;
      D.35148 = 112;
      D.35149 = D.35148 + 16;
      *code.2024 = D.35149;
      goto <D.35187>;
      <D.35185>:
      code.2025 = code;
      code = code.2025 + 1;
      D.35152 = 112;
      D.35153 = D.35152 + 16;
      *code.2025 = D.35153;
      <D.35187>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.2026 = code;
            code = code.2026 + 1;
            D.35190 = imb.b[0];
            *code.2026 = D.35190;
            code.2027 = code;
            code = code.2027 + 1;
            D.35192 = imb.b[1];
            *code.2027 = D.35192;
            code.2028 = code;
            code = code.2028 + 1;
            D.35194 = imb.b[2];
            *code.2028 = D.35194;
            code.2029 = code;
            code = code.2029 + 1;
            D.35196 = imb.b[3];
            *code.2029 = D.35196;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.35182>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.35197 = MEM[(unsigned char *)branch_start];
        D.35198 = (int) D.35197;
        switch (D.35198) <default: <D.25361>, case 15: <D.25340>, case 112: <D.25345>, case 113: <D.25346>, case 114: <D.25347>, case 115: <D.25348>, case 116: <D.25349>, case 117: <D.25350>, case 118: <D.25351>, case 119: <D.25352>, case 120: <D.25353>, case 121: <D.25354>, case 122: <D.25355>, case 123: <D.25356>, case 124: <D.25357>, case 125: <D.25358>, case 126: <D.25359>, case 127: <D.25360>, case 224: <D.25341>, case 225: <D.25342>, case 226: <D.25343>, case 232: <D.25337>, case 233: <D.25338>, case 235: <D.25344>>
        <D.25337>:
        <D.25338>:
        size = size + 1;
        goto <D.25339>;
        <D.25340>:
        D.35199 = *pos;
        D.35200 = D.35199 + 144;
        if (D.35200 > 31) goto <D.35201>; else goto <D.35202>;
        <D.35201>:
        __assert_fail ("0", "mini-x86.c", 3201, &__PRETTY_FUNCTION__);
        <D.35202>:
        size = size + 1;
        pos = pos + 1;
        goto <D.25339>;
        <D.25341>:
        <D.25342>:
        <D.25343>:
        <D.25344>:
        <D.25345>:
        <D.25346>:
        <D.25347>:
        <D.25348>:
        <D.25349>:
        <D.25350>:
        <D.25351>:
        <D.25352>:
        <D.25353>:
        <D.25354>:
        <D.25355>:
        <D.25356>:
        <D.25357>:
        <D.25358>:
        <D.25359>:
        <D.25360>:
        goto <D.25339>;
        <D.25361>:
        __assert_fail ("0", "mini-x86.c", 3201, &__PRETTY_FUNCTION__);
        <D.25339>:
        D.31409 = cfg->native_code;
        D.35163 = tins->data.op[1].many_blocks;
        D.35164 = *D.35163;
        D.35165 = D.35164->native_offset;
        D.35168 = (sizetype) D.35165;
        D.35169 = D.31409 + D.35168;
        D.35170 = (int) D.35169;
        pos.2030 = (int) pos;
        disp = D.35170 - pos.2030;
        if (size != 0) goto <D.35204>; else goto <D.35205>;
        <D.35204>:
        {
          union x86_imm_buf imb;

          try
            {
              D.35206 = disp + -4;
              imb.val = D.35206;
              pos.2031 = pos;
              pos = pos.2031 + 1;
              D.35208 = imb.b[0];
              *pos.2031 = D.35208;
              pos.2032 = pos;
              pos = pos.2032 + 1;
              D.35210 = imb.b[1];
              *pos.2032 = D.35210;
              pos.2033 = pos;
              pos = pos.2033 + 1;
              D.35212 = imb.b[2];
              *pos.2033 = D.35212;
              pos.2034 = pos;
              pos = pos.2034 + 1;
              D.35214 = imb.b[3];
              *pos.2034 = D.35214;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.35215>;
        <D.35205>:
        disp.2035 = (unsigned int) disp;
        D.35217 = disp.2035 + 127;
        if (D.35217 <= 255) goto <D.35218>; else goto <D.35219>;
        <D.35218>:
        D.35220 = (unsigned char) disp;
        D.35221 = D.35220 + 255;
        *pos = D.35221;
        pos = pos + 1;
        goto <D.35222>;
        <D.35219>:
        __assert_fail ("0", "mini-x86.c", 3201, &__PRETTY_FUNCTION__);
        <D.35222>:
        <D.35215>:
      }
    }
    goto <D.35223>;
    <D.35167>:
    D.35163 = tins->data.op[1].many_blocks;
    D.35164 = *D.35163;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.35164);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.35227>; else goto <D.35224>;
    <D.35227>:
    D.35163 = tins->data.op[1].many_blocks;
    D.35164 = *D.35163;
    D.35228 = D.35164->max_offset;
    D.35229 = D.35228 - cpos;
    D.35230 = (unsigned int) D.35229;
    D.35231 = D.35230 + 128;
    if (D.35231 <= 255) goto <D.35232>; else goto <D.35224>;
    <D.35232>:
    if (0 != 0) goto <D.35233>; else goto <D.35234>;
    <D.35233>:
    code.2036 = code;
    code = code.2036 + 1;
    D.35148 = 112;
    *code.2036 = D.35148;
    goto <D.35236>;
    <D.35234>:
    code.2037 = code;
    code = code.2037 + 1;
    D.35152 = 112;
    *code.2037 = D.35152;
    <D.35236>:
    *code = 0;
    code = code + 1;
    goto <D.35225>;
    <D.35224>:
    code.2038 = code;
    code = code.2038 + 1;
    *code.2038 = 15;
    if (0 != 0) goto <D.35239>; else goto <D.35240>;
    <D.35239>:
    code.2039 = code;
    code = code.2039 + 1;
    D.35148 = 112;
    D.35149 = D.35148 + 16;
    *code.2039 = D.35149;
    goto <D.35242>;
    <D.35240>:
    code.2040 = code;
    code = code.2040 + 1;
    D.35152 = 112;
    D.35153 = D.35152 + 16;
    *code.2040 = D.35153;
    <D.35242>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2041 = code;
          code = code.2041 + 1;
          D.35245 = imb.b[0];
          *code.2041 = D.35245;
          code.2042 = code;
          code = code.2042 + 1;
          D.35247 = imb.b[1];
          *code.2042 = D.35247;
          code.2043 = code;
          code = code.2043 + 1;
          D.35249 = imb.b[2];
          *code.2043 = D.35249;
          code.2044 = code;
          code = code.2044 + 1;
          D.35251 = imb.b[3];
          *code.2044 = D.35251;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35225>:
    <D.35223>:
    <D.35162>:
  }
  goto <D.24796>;
  <D.25364>:
  {
    int non_eax_reg;
    int saved_eax;
    int saved_edx;

    saved_eax = 0;
    saved_edx = 0;
    D.31527 = ins->sreg2;
    if (D.31527 == 0) goto <D.35252>; else goto <D.35253>;
    <D.35252>:
    non_eax_reg = ins->sreg1;
    goto <D.35254>;
    <D.35253>:
    D.31548 = ins->sreg1;
    if (D.31548 == 0) goto <D.35255>; else goto <D.35256>;
    <D.35255>:
    non_eax_reg = ins->sreg2;
    goto <D.35257>;
    <D.35256>:
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.35258>; else goto <D.35259>;
    <D.35258>:
    saved_eax = 1;
    code.2045 = code;
    code = code.2045 + 1;
    *code.2045 = 80;
    <D.35259>:
    switch (4) <default: <D.25372>, case 1: <D.25368>, case 2: <D.25370>, case 4: <D.25371>>
    <D.25368>:
    code.2046 = code;
    code = code.2046 + 1;
    *code.2046 = 138;
    goto <D.25369>;
    <D.25370>:
    code.2047 = code;
    code = code.2047 + 1;
    *code.2047 = 102;
    <D.25371>:
    code.2048 = code;
    code = code.2048 + 1;
    *code.2048 = 139;
    goto <D.25369>;
    <D.25372>:
    __assert_fail ("0", "mini-x86.c", 3218, &__PRETTY_FUNCTION__);
    <D.25369>:
    code.2049 = code;
    code = code.2049 + 1;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.35265 = D.31586 | -64;
    D.35266 = (unsigned char) D.35265;
    *code.2049 = D.35266;
    non_eax_reg = ins->sreg2;
    <D.35257>:
    <D.35254>:
    D.31604 = ins->dreg;
    if (D.31604 == 2) goto <D.35267>; else goto <D.35268>;
    <D.35267>:
    if (saved_eax == 0) goto <D.35269>; else goto <D.35270>;
    <D.35269>:
    saved_eax = 1;
    code.2050 = code;
    code = code.2050 + 1;
    *code.2050 = 80;
    <D.35270>:
    goto <D.35272>;
    <D.35268>:
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.35273>; else goto <D.35274>;
    <D.35273>:
    saved_edx = 1;
    code.2051 = code;
    code = code.2051 + 1;
    *code.2051 = 82;
    <D.35274>:
    <D.35272>:
    code.2052 = code;
    code = code.2052 + 1;
    *code.2052 = 247;
    code.2053 = code;
    code = code.2053 + 1;
    D.35278 = (signed char) non_eax_reg;
    D.35279 = D.35278 & 7;
    D.35280 = D.35279 | -32;
    D.35281 = (unsigned char) D.35280;
    *code.2053 = D.35281;
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.35282>; else goto <D.35283>;
    <D.35282>:
    switch (4) <default: <D.25377>, case 1: <D.25373>, case 2: <D.25375>, case 4: <D.25376>>
    <D.25373>:
    code.2054 = code;
    code = code.2054 + 1;
    *code.2054 = 138;
    goto <D.25374>;
    <D.25375>:
    code.2055 = code;
    code = code.2055 + 1;
    *code.2055 = 102;
    <D.25376>:
    code.2056 = code;
    code = code.2056 + 1;
    *code.2056 = 139;
    goto <D.25374>;
    <D.25377>:
    __assert_fail ("0", "mini-x86.c", 3233, &__PRETTY_FUNCTION__);
    <D.25374>:
    code.2057 = code;
    code = code.2057 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.35288 = (unsigned char) D.32533;
    *code.2057 = D.35288;
    <D.35283>:
    if (saved_edx != 0) goto <D.35289>; else goto <D.35290>;
    <D.35289>:
    code.2058 = code;
    code = code.2058 + 1;
    *code.2058 = 90;
    <D.35290>:
    if (saved_eax != 0) goto <D.35292>; else goto <D.35293>;
    <D.35292>:
    code.2059 = code;
    code = code.2059 + 1;
    *code.2059 = 88;
    <D.35293>:
    {
      struct MonoInst * tins;

      tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
      if (tins == 0B) goto <D.35295>; else goto <D.35296>;
      <D.35295>:
      code.422 = (int) code;
      D.31409 = cfg->native_code;
      D.31488 = (int) D.31409;
      D.31489 = code.422 - D.31488;
      mono_add_patch_info (cfg, D.31489, 9, "OverflowException");
      code.2060 = code;
      code = code.2060 + 1;
      *code.2060 = 15;
      if (0 != 0) goto <D.35298>; else goto <D.35299>;
      <D.35298>:
      code.2061 = code;
      code = code.2061 + 1;
      D.35148 = 112;
      D.35149 = D.35148 + 16;
      *code.2061 = D.35149;
      goto <D.35301>;
      <D.35299>:
      code.2062 = code;
      code = code.2062 + 1;
      D.35152 = 112;
      D.35153 = D.35152 + 16;
      *code.2062 = D.35153;
      <D.35301>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2063 = code;
            code = code.2063 + 1;
            D.35304 = imb.b[0];
            *code.2063 = D.35304;
            code.2064 = code;
            code = code.2064 + 1;
            D.35306 = imb.b[1];
            *code.2064 = D.35306;
            code.2065 = code;
            code = code.2065 + 1;
            D.35308 = imb.b[2];
            *code.2065 = D.35308;
            code.2066 = code;
            code = code.2066 + 1;
            D.35310 = imb.b[3];
            *code.2066 = D.35310;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.35311>;
      <D.35296>:
      D.35312 = tins->data.op[1].many_blocks;
      D.35313 = *D.35312;
      D.35314 = D.35313->native_offset;
      if (D.35314 != 0) goto <D.35315>; else goto <D.35316>;
      <D.35315>:
      {
        int offset;
        guint8 * branch_start;

        D.31409 = cfg->native_code;
        D.35312 = tins->data.op[1].many_blocks;
        D.35313 = *D.35312;
        D.35314 = D.35313->native_offset;
        D.35317 = (sizetype) D.35314;
        D.35318 = D.31409 + D.35317;
        D.35319 = (int) D.35318;
        code.422 = (int) code;
        D.35320 = D.35319 - code.422;
        offset = D.35320 + -2;
        branch_start = code;
        offset.2067 = (unsigned int) offset;
        D.35322 = offset.2067 + 128;
        if (D.35322 <= 255) goto <D.35323>; else goto <D.35324>;
        <D.35323>:
        if (0 != 0) goto <D.35325>; else goto <D.35326>;
        <D.35325>:
        code.2068 = code;
        code = code.2068 + 1;
        D.35148 = 112;
        *code.2068 = D.35148;
        goto <D.35328>;
        <D.35326>:
        code.2069 = code;
        code = code.2069 + 1;
        D.35152 = 112;
        *code.2069 = D.35152;
        <D.35328>:
        D.35330 = (unsigned char) offset;
        *code = D.35330;
        code = code + 1;
        goto <D.35331>;
        <D.35324>:
        D.31409 = cfg->native_code;
        D.35312 = tins->data.op[1].many_blocks;
        D.35313 = *D.35312;
        D.35314 = D.35313->native_offset;
        D.35317 = (sizetype) D.35314;
        D.35318 = D.31409 + D.35317;
        D.35319 = (int) D.35318;
        code.422 = (int) code;
        D.35320 = D.35319 - code.422;
        offset = D.35320 + -6;
        code.2070 = code;
        code = code.2070 + 1;
        *code.2070 = 15;
        if (0 != 0) goto <D.35333>; else goto <D.35334>;
        <D.35333>:
        code.2071 = code;
        code = code.2071 + 1;
        D.35148 = 112;
        D.35149 = D.35148 + 16;
        *code.2071 = D.35149;
        goto <D.35336>;
        <D.35334>:
        code.2072 = code;
        code = code.2072 + 1;
        D.35152 = 112;
        D.35153 = D.35152 + 16;
        *code.2072 = D.35153;
        <D.35336>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = offset;
              code.2073 = code;
              code = code.2073 + 1;
              D.35339 = imb.b[0];
              *code.2073 = D.35339;
              code.2074 = code;
              code = code.2074 + 1;
              D.35341 = imb.b[1];
              *code.2074 = D.35341;
              code.2075 = code;
              code = code.2075 + 1;
              D.35343 = imb.b[2];
              *code.2075 = D.35343;
              code.2076 = code;
              code = code.2076 + 1;
              D.35345 = imb.b[3];
              *code.2076 = D.35345;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.35331>:
        {
          unsigned char * pos;
          int disp;
          int size;

          pos = branch_start + 1;
          size = 0;
          D.35346 = MEM[(unsigned char *)branch_start];
          D.35347 = (int) D.35346;
          switch (D.35347) <default: <D.25410>, case 15: <D.25389>, case 112: <D.25394>, case 113: <D.25395>, case 114: <D.25396>, case 115: <D.25397>, case 116: <D.25398>, case 117: <D.25399>, case 118: <D.25400>, case 119: <D.25401>, case 120: <D.25402>, case 121: <D.25403>, case 122: <D.25404>, case 123: <D.25405>, case 124: <D.25406>, case 125: <D.25407>, case 126: <D.25408>, case 127: <D.25409>, case 224: <D.25390>, case 225: <D.25391>, case 226: <D.25392>, case 232: <D.25386>, case 233: <D.25387>, case 235: <D.25393>>
          <D.25386>:
          <D.25387>:
          size = size + 1;
          goto <D.25388>;
          <D.25389>:
          D.35348 = *pos;
          D.35349 = D.35348 + 144;
          if (D.35349 > 31) goto <D.35350>; else goto <D.35351>;
          <D.35350>:
          __assert_fail ("0", "mini-x86.c", 3238, &__PRETTY_FUNCTION__);
          <D.35351>:
          size = size + 1;
          pos = pos + 1;
          goto <D.25388>;
          <D.25390>:
          <D.25391>:
          <D.25392>:
          <D.25393>:
          <D.25394>:
          <D.25395>:
          <D.25396>:
          <D.25397>:
          <D.25398>:
          <D.25399>:
          <D.25400>:
          <D.25401>:
          <D.25402>:
          <D.25403>:
          <D.25404>:
          <D.25405>:
          <D.25406>:
          <D.25407>:
          <D.25408>:
          <D.25409>:
          goto <D.25388>;
          <D.25410>:
          __assert_fail ("0", "mini-x86.c", 3238, &__PRETTY_FUNCTION__);
          <D.25388>:
          D.31409 = cfg->native_code;
          D.35312 = tins->data.op[1].many_blocks;
          D.35313 = *D.35312;
          D.35314 = D.35313->native_offset;
          D.35317 = (sizetype) D.35314;
          D.35318 = D.31409 + D.35317;
          D.35319 = (int) D.35318;
          pos.2077 = (int) pos;
          disp = D.35319 - pos.2077;
          if (size != 0) goto <D.35353>; else goto <D.35354>;
          <D.35353>:
          {
            union x86_imm_buf imb;

            try
              {
                D.35355 = disp + -4;
                imb.val = D.35355;
                pos.2078 = pos;
                pos = pos.2078 + 1;
                D.35357 = imb.b[0];
                *pos.2078 = D.35357;
                pos.2079 = pos;
                pos = pos.2079 + 1;
                D.35359 = imb.b[1];
                *pos.2079 = D.35359;
                pos.2080 = pos;
                pos = pos.2080 + 1;
                D.35361 = imb.b[2];
                *pos.2080 = D.35361;
                pos.2081 = pos;
                pos = pos.2081 + 1;
                D.35363 = imb.b[3];
                *pos.2081 = D.35363;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.35364>;
          <D.35354>:
          disp.2082 = (unsigned int) disp;
          D.35366 = disp.2082 + 127;
          if (D.35366 <= 255) goto <D.35367>; else goto <D.35368>;
          <D.35367>:
          D.35369 = (unsigned char) disp;
          D.35370 = D.35369 + 255;
          *pos = D.35370;
          pos = pos + 1;
          goto <D.35371>;
          <D.35368>:
          __assert_fail ("0", "mini-x86.c", 3238, &__PRETTY_FUNCTION__);
          <D.35371>:
          <D.35364>:
        }
      }
      goto <D.35372>;
      <D.35316>:
      D.35312 = tins->data.op[1].many_blocks;
      D.35313 = *D.35312;
      code.422 = (int) code;
      D.31409 = cfg->native_code;
      D.31488 = (int) D.31409;
      D.31489 = code.422 - D.31488;
      mono_add_patch_info (cfg, D.31489, 0, D.35313);
      D.31411 = cfg->opt;
      D.35226 = D.31411 & 2;
      if (D.35226 != 0) goto <D.35375>; else goto <D.35373>;
      <D.35375>:
      D.35312 = tins->data.op[1].many_blocks;
      D.35313 = *D.35312;
      D.35376 = D.35313->max_offset;
      D.35377 = D.35376 - cpos;
      D.35378 = (unsigned int) D.35377;
      D.35379 = D.35378 + 128;
      if (D.35379 <= 255) goto <D.35380>; else goto <D.35373>;
      <D.35380>:
      if (0 != 0) goto <D.35381>; else goto <D.35382>;
      <D.35381>:
      code.2083 = code;
      code = code.2083 + 1;
      D.35148 = 112;
      *code.2083 = D.35148;
      goto <D.35384>;
      <D.35382>:
      code.2084 = code;
      code = code.2084 + 1;
      D.35152 = 112;
      *code.2084 = D.35152;
      <D.35384>:
      *code = 0;
      code = code + 1;
      goto <D.35374>;
      <D.35373>:
      code.2085 = code;
      code = code.2085 + 1;
      *code.2085 = 15;
      if (0 != 0) goto <D.35387>; else goto <D.35388>;
      <D.35387>:
      code.2086 = code;
      code = code.2086 + 1;
      D.35148 = 112;
      D.35149 = D.35148 + 16;
      *code.2086 = D.35149;
      goto <D.35390>;
      <D.35388>:
      code.2087 = code;
      code = code.2087 + 1;
      D.35152 = 112;
      D.35153 = D.35152 + 16;
      *code.2087 = D.35153;
      <D.35390>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2088 = code;
            code = code.2088 + 1;
            D.35393 = imb.b[0];
            *code.2088 = D.35393;
            code.2089 = code;
            code = code.2089 + 1;
            D.35395 = imb.b[1];
            *code.2089 = D.35395;
            code.2090 = code;
            code = code.2090 + 1;
            D.35397 = imb.b[2];
            *code.2090 = D.35397;
            code.2091 = code;
            code = code.2091 + 1;
            D.35399 = imb.b[3];
            *code.2091 = D.35399;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.35374>:
      <D.35372>:
      <D.35311>:
    }
    goto <D.24796>;
  }
  <D.25413>:
  code.2092 = code;
  code = code.2092 + 1;
  D.31604 = ins->dreg;
  D.33696 = (unsigned char) D.31604;
  D.35401 = D.33696 + 184;
  *code.2092 = D.35401;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2093 = code;
        code = code.2093 + 1;
        D.35403 = imb.b[0];
        *code.2093 = D.35403;
        code.2094 = code;
        code = code.2094 + 1;
        D.35405 = imb.b[1];
        *code.2094 = D.35405;
        code.2095 = code;
        code = code.2095 + 1;
        D.35407 = imb.b[2];
        *code.2095 = D.35407;
        code.2096 = code;
        code = code.2096 + 1;
        D.35409 = imb.b[3];
        *code.2096 = D.35409;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24796>;
  <D.25415>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 3245);
  D.32177 = ins->data.op[0].p;
  D.35410 = ins->data.op[1].src;
  D.35411 = (<unnamed type>) D.35410;
  offset.2097 = (int) offset;
  mono_add_patch_info (cfg, offset.2097, D.35411, D.32177);
  code.2098 = code;
  code = code.2098 + 1;
  D.31604 = ins->dreg;
  D.33696 = (unsigned char) D.31604;
  D.35401 = D.33696 + 184;
  *code.2098 = D.35401;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2099 = code;
        code = code.2099 + 1;
        D.35415 = imb.b[0];
        *code.2099 = D.35415;
        code.2100 = code;
        code = code.2100 + 1;
        D.35417 = imb.b[1];
        *code.2100 = D.35417;
        code.2101 = code;
        code = code.2101 + 1;
        D.35419 = imb.b[2];
        *code.2101 = D.35419;
        code.2102 = code;
        code = code.2102 + 1;
        D.35421 = imb.b[3];
        *code.2102 = D.35421;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24796>;
  <D.25417>:
  D.32177 = ins->data.op[0].p;
  D.35410 = ins->data.op[1].src;
  D.35411 = (<unnamed type>) D.35410;
  offset.2097 = (int) offset;
  mono_add_patch_info (cfg, offset.2097, D.35411, D.32177);
  code.2103 = code;
  code = code.2103 + 1;
  D.31604 = ins->dreg;
  D.33696 = (unsigned char) D.31604;
  D.35401 = D.33696 + 184;
  *code.2103 = D.35401;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2104 = code;
        code = code.2104 + 1;
        D.35424 = imb.b[0];
        *code.2104 = D.35424;
        code.2105 = code;
        code = code.2105 + 1;
        D.35426 = imb.b[1];
        *code.2105 = D.35426;
        code.2106 = code;
        code = code.2106 + 1;
        D.35428 = imb.b[2];
        *code.2106 = D.35428;
        code.2107 = code;
        code = code.2107 + 1;
        D.35430 = imb.b[3];
        *code.2107 = D.35430;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24796>;
  <D.25419>:
  D.31604 = ins->dreg;
  D.35431 = D.31604 != 3;
  D.35432 = (long int) D.35431;
  D.35433 = __builtin_expect (D.35432, 0);
  if (D.35433 != 0) goto <D.35434>; else goto <D.35435>;
  <D.35434>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3254, "ins->dreg == MONO_ARCH_GOT_REG");
  <D.35435>:
  D.31409 = cfg->native_code;
  code = mono_arch_emit_load_got_addr (D.31409, code, cfg, 0B);
  goto <D.24796>;
  <D.25420>:
  D.35410 = ins->data.op[1].src;
  D.35436 = D.35410->data.op[0].p;
  D.35410 = ins->data.op[1].src;
  D.35437 = D.35410->data.op[1].src;
  D.35438 = (<unnamed type>) D.35437;
  offset.2097 = (int) offset;
  mono_add_patch_info (cfg, offset.2097, D.35438, D.35436);
  switch (4) <default: <D.25425>, case 1: <D.25421>, case 2: <D.25423>, case 4: <D.25424>>
  <D.25421>:
  code.2108 = code;
  code = code.2108 + 1;
  *code.2108 = 138;
  goto <D.25422>;
  <D.25423>:
  code.2109 = code;
  code = code.2109 + 1;
  *code.2109 = 102;
  <D.25424>:
  code.2110 = code;
  code = code.2110 + 1;
  *code.2110 = 139;
  goto <D.25422>;
  <D.25425>:
  __assert_fail ("0", "mini-x86.c", 3259, &__PRETTY_FUNCTION__);
  <D.25422>:
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.35442>; else goto <D.35443>;
  <D.35442>:
  if (0 != 0) goto <D.35444>; else goto <D.35445>;
  <D.35444>:
  code.2111 = code;
  code = code.2111 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.2111 = D.32289;
  code.2112 = code;
  code = code.2112 + 1;
  *code.2112 = 36;
  goto <D.35448>;
  <D.35445>:
  if (0 != 0) goto <D.35449>; else goto <D.35450>;
  <D.35449>:
  code.2113 = code;
  code = code.2113 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.2113 = D.32296;
  code.2114 = code;
  code = code.2114 + 1;
  *code.2114 = 36;
  *code = 240;
  code = code + 1;
  goto <D.35453>;
  <D.35450>:
  code.2115 = code;
  code = code.2115 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.2115 = D.32301;
  code.2116 = code;
  code = code.2116 + 1;
  *code.2116 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.2117 = code;
        code = code.2117 + 1;
        D.35457 = imb.b[0];
        *code.2117 = D.35457;
        code.2118 = code;
        code = code.2118 + 1;
        D.35459 = imb.b[1];
        *code.2118 = D.35459;
        code.2119 = code;
        code = code.2119 + 1;
        D.35461 = imb.b[2];
        *code.2119 = D.35461;
        code.2120 = code;
        code = code.2120 + 1;
        D.35463 = imb.b[3];
        *code.2120 = D.35463;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35453>:
  <D.35448>:
  goto <D.25427>;
  <D.35443>:
  if (0 != 0) goto <D.35464>; else goto <D.35465>;
  <D.35464>:
  code.2121 = code;
  code = code.2121 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32316 = D.32227 | D.31586;
  D.32317 = (unsigned char) D.32316;
  *code.2121 = D.32317;
  goto <D.25427>;
  <D.35465>:
  if (0 != 0) goto <D.35467>; else goto <D.35468>;
  <D.35467>:
  code.2122 = code;
  code = code.2122 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32322 = D.32321 | D.31586;
  D.32323 = (unsigned char) D.32322;
  *code.2122 = D.32323;
  *code = 240;
  code = code + 1;
  goto <D.35470>;
  <D.35468>:
  code.2123 = code;
  code = code.2123 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32327 = D.32326 | D.31586;
  D.32328 = (unsigned char) D.32327;
  *code.2123 = D.32328;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.2124 = code;
        code = code.2124 + 1;
        D.35473 = imb.b[0];
        *code.2124 = D.35473;
        code.2125 = code;
        code = code.2125 + 1;
        D.35475 = imb.b[1];
        *code.2125 = D.35475;
        code.2126 = code;
        code = code.2126 + 1;
        D.35477 = imb.b[2];
        *code.2126 = D.35477;
        code.2127 = code;
        code = code.2127 + 1;
        D.35479 = imb.b[3];
        *code.2127 = D.35479;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35470>:
  <D.25427>:
  goto <D.24796>;
  <D.25429>:
  D.35410 = ins->data.op[1].src;
  D.35436 = D.35410->data.op[0].p;
  D.35410 = ins->data.op[1].src;
  D.35437 = D.35410->data.op[1].src;
  D.35438 = (<unnamed type>) D.35437;
  offset.2097 = (int) offset;
  mono_add_patch_info (cfg, offset.2097, D.35438, D.35436);
  code.2128 = code;
  code = code.2128 + 1;
  *code.2128 = 255;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.35481>; else goto <D.35482>;
  <D.35481>:
  if (0 != 0) goto <D.35483>; else goto <D.35484>;
  <D.35483>:
  code.2129 = code;
  code = code.2129 + 1;
  *code.2129 = 52;
  code.2130 = code;
  code = code.2130 + 1;
  *code.2130 = 36;
  goto <D.35487>;
  <D.35484>:
  if (0 != 0) goto <D.35488>; else goto <D.35489>;
  <D.35488>:
  code.2131 = code;
  code = code.2131 + 1;
  *code.2131 = 116;
  code.2132 = code;
  code = code.2132 + 1;
  *code.2132 = 36;
  *code = 240;
  code = code + 1;
  goto <D.35492>;
  <D.35489>:
  code.2133 = code;
  code = code.2133 + 1;
  *code.2133 = 180;
  code.2134 = code;
  code = code.2134 + 1;
  *code.2134 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.2135 = code;
        code = code.2135 + 1;
        D.35496 = imb.b[0];
        *code.2135 = D.35496;
        code.2136 = code;
        code = code.2136 + 1;
        D.35498 = imb.b[1];
        *code.2136 = D.35498;
        code.2137 = code;
        code = code.2137 + 1;
        D.35500 = imb.b[2];
        *code.2137 = D.35500;
        code.2138 = code;
        code = code.2138 + 1;
        D.35502 = imb.b[3];
        *code.2138 = D.35502;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35492>:
  <D.35487>:
  goto <D.25431>;
  <D.35482>:
  if (0 != 0) goto <D.35503>; else goto <D.35504>;
  <D.35503>:
  code.2139 = code;
  code = code.2139 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33380 = D.31586 | 48;
  D.33381 = (unsigned char) D.33380;
  *code.2139 = D.33381;
  goto <D.25431>;
  <D.35504>:
  if (0 != 0) goto <D.35506>; else goto <D.35507>;
  <D.35506>:
  code.2140 = code;
  code = code.2140 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33385 = D.31586 | 112;
  D.33386 = (unsigned char) D.33385;
  *code.2140 = D.33386;
  *code = 240;
  code = code + 1;
  goto <D.35509>;
  <D.35507>:
  code.2141 = code;
  code = code.2141 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33389 = D.31586 | -80;
  D.33390 = (unsigned char) D.33389;
  *code.2141 = D.33390;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.2142 = code;
        code = code.2142 + 1;
        D.35512 = imb.b[0];
        *code.2142 = D.35512;
        code.2143 = code;
        code = code.2143 + 1;
        D.35514 = imb.b[1];
        *code.2143 = D.35514;
        code.2144 = code;
        code = code.2144 + 1;
        D.35516 = imb.b[2];
        *code.2144 = D.35516;
        code.2145 = code;
        code = code.2145 + 1;
        D.35518 = imb.b[3];
        *code.2145 = D.35518;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35509>:
  <D.25431>:
  goto <D.24796>;
  <D.25433>:
  switch (4) <default: <D.25438>, case 1: <D.25434>, case 2: <D.25436>, case 4: <D.25437>>
  <D.25434>:
  code.2146 = code;
  code = code.2146 + 1;
  *code.2146 = 138;
  goto <D.25435>;
  <D.25436>:
  code.2147 = code;
  code = code.2147 + 1;
  *code.2147 = 102;
  <D.25437>:
  code.2148 = code;
  code = code.2148 + 1;
  *code.2148 = 139;
  goto <D.25435>;
  <D.25438>:
  __assert_fail ("0", "mini-x86.c", 3266, &__PRETTY_FUNCTION__);
  <D.25435>:
  code.2149 = code;
  code = code.2149 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.2149 = D.32535;
  goto <D.24796>;
  <D.25439>:
  {
    struct MonoCallInst * call;
    int pos;
    int i;

    call = ins;
    pos = 0;
    D.33912 = ins->flags;
    D.35523 = D.33912 | 128;
    ins->flags = D.35523;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    ins->backend.pc_offset = D.31489;
    D.31462 = cfg->prof_options;
    D.35524 = D.31462 & 4096;
    if (D.35524 != 0) goto <D.35525>; else goto <D.35526>;
    <D.35525>:
    code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, 0);
    <D.35526>:
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    offset = (guint) D.31489;
    D.31493 = cfg->method;
    D.35527 = BIT_FIELD_REF <*D.31493, 8, 168>;
    D.35528 = D.35527 & 1;
    D.35529 = D.35528 != 0;
    D.35530 = (long int) D.35529;
    D.35531 = __builtin_expect (D.35530, 0);
    if (D.35531 != 0) goto <D.35532>; else goto <D.35533>;
    <D.35532>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3281, "!cfg->method->save_lmf");
    <D.35533>:
    i = 0;
    goto <D.25444>;
    <D.25443>:
    D.35536 = i == 3;
    D.35537 = i == 7;
    D.35538 = D.35536 | D.35537;
    if (D.35538 != 0) goto <D.35534>; else goto <D.35539>;
    <D.35539>:
    if (i == 6) goto <D.35534>; else goto <D.35535>;
    <D.35534>:
    D.35540 = cfg->used_int_regs;
    D.35541 = 1 << i;
    D.35542 = (unsigned int) D.35541;
    D.35543 = D.35540 & D.35542;
    if (D.35543 != 0) goto <D.35544>; else goto <D.35545>;
    <D.35544>:
    pos = pos + -4;
    <D.35545>:
    <D.35535>:
    i = i + 1;
    <D.25444>:
    if (i <= 7) goto <D.25443>; else goto <D.25445>;
    <D.25445>:
    D.35540 = cfg->used_int_regs;
    D.35546 = D.35540 & 64;
    if (D.35546 != 0) goto <D.35547>; else goto <D.35548>;
    <D.35547>:
    switch (4) <default: <D.25450>, case 1: <D.25446>, case 2: <D.25448>, case 4: <D.25449>>
    <D.25446>:
    code.2150 = code;
    code = code.2150 + 1;
    *code.2150 = 138;
    goto <D.25447>;
    <D.25448>:
    code.2151 = code;
    code = code.2151 + 1;
    *code.2151 = 102;
    <D.25449>:
    code.2152 = code;
    code = code.2152 + 1;
    *code.2152 = 139;
    goto <D.25447>;
    <D.25450>:
    __assert_fail ("0", "mini-x86.c", 3288, &__PRETTY_FUNCTION__);
    <D.25447>:
    if (0 != 0) goto <D.35552>; else goto <D.35553>;
    <D.35552>:
    if (pos == 0) goto <D.35554>; else goto <D.35555>;
    <D.35554>:
    code.2153 = code;
    code = code.2153 + 1;
    *code.2153 = 52;
    code.2154 = code;
    code = code.2154 + 1;
    *code.2154 = 36;
    goto <D.35558>;
    <D.35555>:
    pos.2155 = (unsigned int) pos;
    D.35560 = pos.2155 + 128;
    if (D.35560 <= 255) goto <D.35561>; else goto <D.35562>;
    <D.35561>:
    code.2156 = code;
    code = code.2156 + 1;
    *code.2156 = 116;
    code.2157 = code;
    code = code.2157 + 1;
    *code.2157 = 36;
    D.35565 = (unsigned char) pos;
    *code = D.35565;
    code = code + 1;
    goto <D.35566>;
    <D.35562>:
    code.2158 = code;
    code = code.2158 + 1;
    *code.2158 = 180;
    code.2159 = code;
    code = code.2159 + 1;
    *code.2159 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = pos;
          code.2160 = code;
          code = code.2160 + 1;
          D.35570 = imb.b[0];
          *code.2160 = D.35570;
          code.2161 = code;
          code = code.2161 + 1;
          D.35572 = imb.b[1];
          *code.2161 = D.35572;
          code.2162 = code;
          code = code.2162 + 1;
          D.35574 = imb.b[2];
          *code.2162 = D.35574;
          code.2163 = code;
          code = code.2163 + 1;
          D.35576 = imb.b[3];
          *code.2163 = D.35576;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35566>:
    <D.35558>:
    goto <D.25452>;
    <D.35553>:
    if (0 != 0) goto <D.35577>; else goto <D.35578>;
    <D.35577>:
    code.2164 = code;
    code = code.2164 + 1;
    *code.2164 = 53;
    goto <D.25452>;
    <D.35578>:
    pos.2155 = (unsigned int) pos;
    D.35560 = pos.2155 + 128;
    if (D.35560 <= 255) goto <D.35580>; else goto <D.35581>;
    <D.35580>:
    code.2165 = code;
    code = code.2165 + 1;
    *code.2165 = 117;
    D.35565 = (unsigned char) pos;
    *code = D.35565;
    code = code + 1;
    goto <D.35583>;
    <D.35581>:
    code.2166 = code;
    code = code.2166 + 1;
    *code.2166 = 181;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = pos;
          code.2167 = code;
          code = code.2167 + 1;
          D.35586 = imb.b[0];
          *code.2167 = D.35586;
          code.2168 = code;
          code = code.2168 + 1;
          D.35588 = imb.b[1];
          *code.2168 = D.35588;
          code.2169 = code;
          code = code.2169 + 1;
          D.35590 = imb.b[2];
          *code.2169 = D.35590;
          code.2170 = code;
          code = code.2170 + 1;
          D.35592 = imb.b[3];
          *code.2170 = D.35592;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35583>:
    <D.25452>:
    pos = pos + 4;
    <D.35548>:
    D.35540 = cfg->used_int_regs;
    D.35593 = D.35540 & 128;
    if (D.35593 != 0) goto <D.35594>; else goto <D.35595>;
    <D.35594>:
    switch (4) <default: <D.25458>, case 1: <D.25454>, case 2: <D.25456>, case 4: <D.25457>>
    <D.25454>:
    code.2171 = code;
    code = code.2171 + 1;
    *code.2171 = 138;
    goto <D.25455>;
    <D.25456>:
    code.2172 = code;
    code = code.2172 + 1;
    *code.2172 = 102;
    <D.25457>:
    code.2173 = code;
    code = code.2173 + 1;
    *code.2173 = 139;
    goto <D.25455>;
    <D.25458>:
    __assert_fail ("0", "mini-x86.c", 3292, &__PRETTY_FUNCTION__);
    <D.25455>:
    if (0 != 0) goto <D.35599>; else goto <D.35600>;
    <D.35599>:
    if (pos == 0) goto <D.35601>; else goto <D.35602>;
    <D.35601>:
    code.2174 = code;
    code = code.2174 + 1;
    *code.2174 = 60;
    code.2175 = code;
    code = code.2175 + 1;
    *code.2175 = 36;
    goto <D.35605>;
    <D.35602>:
    pos.2155 = (unsigned int) pos;
    D.35560 = pos.2155 + 128;
    if (D.35560 <= 255) goto <D.35606>; else goto <D.35607>;
    <D.35606>:
    code.2176 = code;
    code = code.2176 + 1;
    *code.2176 = 124;
    code.2177 = code;
    code = code.2177 + 1;
    *code.2177 = 36;
    D.35565 = (unsigned char) pos;
    *code = D.35565;
    code = code + 1;
    goto <D.35610>;
    <D.35607>:
    code.2178 = code;
    code = code.2178 + 1;
    *code.2178 = 188;
    code.2179 = code;
    code = code.2179 + 1;
    *code.2179 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = pos;
          code.2180 = code;
          code = code.2180 + 1;
          D.35614 = imb.b[0];
          *code.2180 = D.35614;
          code.2181 = code;
          code = code.2181 + 1;
          D.35616 = imb.b[1];
          *code.2181 = D.35616;
          code.2182 = code;
          code = code.2182 + 1;
          D.35618 = imb.b[2];
          *code.2182 = D.35618;
          code.2183 = code;
          code = code.2183 + 1;
          D.35620 = imb.b[3];
          *code.2183 = D.35620;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35610>:
    <D.35605>:
    goto <D.25460>;
    <D.35600>:
    if (0 != 0) goto <D.35621>; else goto <D.35622>;
    <D.35621>:
    code.2184 = code;
    code = code.2184 + 1;
    *code.2184 = 61;
    goto <D.25460>;
    <D.35622>:
    pos.2155 = (unsigned int) pos;
    D.35560 = pos.2155 + 128;
    if (D.35560 <= 255) goto <D.35624>; else goto <D.35625>;
    <D.35624>:
    code.2185 = code;
    code = code.2185 + 1;
    *code.2185 = 125;
    D.35565 = (unsigned char) pos;
    *code = D.35565;
    code = code + 1;
    goto <D.35627>;
    <D.35625>:
    code.2186 = code;
    code = code.2186 + 1;
    *code.2186 = 189;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = pos;
          code.2187 = code;
          code = code.2187 + 1;
          D.35630 = imb.b[0];
          *code.2187 = D.35630;
          code.2188 = code;
          code = code.2188 + 1;
          D.35632 = imb.b[1];
          *code.2188 = D.35632;
          code.2189 = code;
          code = code.2189 + 1;
          D.35634 = imb.b[2];
          *code.2189 = D.35634;
          code.2190 = code;
          code = code.2190 + 1;
          D.35636 = imb.b[3];
          *code.2190 = D.35636;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35627>:
    <D.25460>:
    pos = pos + 4;
    <D.35595>:
    D.35540 = cfg->used_int_regs;
    D.35637 = D.35540 & 8;
    if (D.35637 != 0) goto <D.35638>; else goto <D.35639>;
    <D.35638>:
    switch (4) <default: <D.25466>, case 1: <D.25462>, case 2: <D.25464>, case 4: <D.25465>>
    <D.25462>:
    code.2191 = code;
    code = code.2191 + 1;
    *code.2191 = 138;
    goto <D.25463>;
    <D.25464>:
    code.2192 = code;
    code = code.2192 + 1;
    *code.2192 = 102;
    <D.25465>:
    code.2193 = code;
    code = code.2193 + 1;
    *code.2193 = 139;
    goto <D.25463>;
    <D.25466>:
    __assert_fail ("0", "mini-x86.c", 3296, &__PRETTY_FUNCTION__);
    <D.25463>:
    if (0 != 0) goto <D.35643>; else goto <D.35644>;
    <D.35643>:
    if (pos == 0) goto <D.35645>; else goto <D.35646>;
    <D.35645>:
    code.2194 = code;
    code = code.2194 + 1;
    *code.2194 = 28;
    code.2195 = code;
    code = code.2195 + 1;
    *code.2195 = 36;
    goto <D.35649>;
    <D.35646>:
    pos.2155 = (unsigned int) pos;
    D.35560 = pos.2155 + 128;
    if (D.35560 <= 255) goto <D.35650>; else goto <D.35651>;
    <D.35650>:
    code.2196 = code;
    code = code.2196 + 1;
    *code.2196 = 92;
    code.2197 = code;
    code = code.2197 + 1;
    *code.2197 = 36;
    D.35565 = (unsigned char) pos;
    *code = D.35565;
    code = code + 1;
    goto <D.35654>;
    <D.35651>:
    code.2198 = code;
    code = code.2198 + 1;
    *code.2198 = 156;
    code.2199 = code;
    code = code.2199 + 1;
    *code.2199 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = pos;
          code.2200 = code;
          code = code.2200 + 1;
          D.35658 = imb.b[0];
          *code.2200 = D.35658;
          code.2201 = code;
          code = code.2201 + 1;
          D.35660 = imb.b[1];
          *code.2201 = D.35660;
          code.2202 = code;
          code = code.2202 + 1;
          D.35662 = imb.b[2];
          *code.2202 = D.35662;
          code.2203 = code;
          code = code.2203 + 1;
          D.35664 = imb.b[3];
          *code.2203 = D.35664;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35654>:
    <D.35649>:
    goto <D.25468>;
    <D.35644>:
    if (0 != 0) goto <D.35665>; else goto <D.35666>;
    <D.35665>:
    code.2204 = code;
    code = code.2204 + 1;
    *code.2204 = 29;
    goto <D.25468>;
    <D.35666>:
    pos.2155 = (unsigned int) pos;
    D.35560 = pos.2155 + 128;
    if (D.35560 <= 255) goto <D.35668>; else goto <D.35669>;
    <D.35668>:
    code.2205 = code;
    code = code.2205 + 1;
    *code.2205 = 93;
    D.35565 = (unsigned char) pos;
    *code = D.35565;
    code = code + 1;
    goto <D.35671>;
    <D.35669>:
    code.2206 = code;
    code = code.2206 + 1;
    *code.2206 = 157;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = pos;
          code.2207 = code;
          code = code.2207 + 1;
          D.35674 = imb.b[0];
          *code.2207 = D.35674;
          code.2208 = code;
          code = code.2208 + 1;
          D.35676 = imb.b[1];
          *code.2208 = D.35676;
          code.2209 = code;
          code = code.2209 + 1;
          D.35678 = imb.b[2];
          *code.2209 = D.35678;
          code.2210 = code;
          code = code.2210 + 1;
          D.35680 = imb.b[3];
          *code.2210 = D.35680;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35671>:
    <D.25468>:
    pos = pos + 4;
    <D.35639>:
    i = 0;
    goto <D.25487>;
    <D.25486>:
    switch (4) <default: <D.25474>, case 1: <D.25470>, case 2: <D.25472>, case 4: <D.25473>>
    <D.25470>:
    code.2211 = code;
    code = code.2211 + 1;
    *code.2211 = 138;
    goto <D.25471>;
    <D.25472>:
    code.2212 = code;
    code = code.2212 + 1;
    *code.2212 = 102;
    <D.25473>:
    code.2213 = code;
    code = code.2213 + 1;
    *code.2213 = 139;
    goto <D.25471>;
    <D.25474>:
    __assert_fail ("0", "mini-x86.c", 3302, &__PRETTY_FUNCTION__);
    <D.25471>:
    if (1 != 0) goto <D.35684>; else goto <D.35685>;
    <D.35684>:
    if (i == 0) goto <D.35686>; else goto <D.35687>;
    <D.35686>:
    code.2214 = code;
    code = code.2214 + 1;
    *code.2214 = 4;
    code.2215 = code;
    code = code.2215 + 1;
    *code.2215 = 36;
    goto <D.35690>;
    <D.35687>:
    i.2216 = (unsigned int) i;
    D.35692 = i.2216 + 128;
    if (D.35692 <= 255) goto <D.35693>; else goto <D.35694>;
    <D.35693>:
    code.2217 = code;
    code = code.2217 + 1;
    *code.2217 = 68;
    code.2218 = code;
    code = code.2218 + 1;
    *code.2218 = 36;
    D.35697 = (unsigned char) i;
    *code = D.35697;
    code = code + 1;
    goto <D.35698>;
    <D.35694>:
    code.2219 = code;
    code = code.2219 + 1;
    *code.2219 = 132;
    code.2220 = code;
    code = code.2220 + 1;
    *code.2220 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = i;
          code.2221 = code;
          code = code.2221 + 1;
          D.35702 = imb.b[0];
          *code.2221 = D.35702;
          code.2222 = code;
          code = code.2222 + 1;
          D.35704 = imb.b[1];
          *code.2222 = D.35704;
          code.2223 = code;
          code = code.2223 + 1;
          D.35706 = imb.b[2];
          *code.2223 = D.35706;
          code.2224 = code;
          code = code.2224 + 1;
          D.35708 = imb.b[3];
          *code.2224 = D.35708;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35698>:
    <D.35690>:
    goto <D.25476>;
    <D.35685>:
    if (i == 0) goto <D.35709>; else goto <D.35710>;
    <D.35709>:
    code.2225 = code;
    code = code.2225 + 1;
    *code.2225 = 4;
    goto <D.25476>;
    <D.35710>:
    i.2216 = (unsigned int) i;
    D.35692 = i.2216 + 128;
    if (D.35692 <= 255) goto <D.35712>; else goto <D.35713>;
    <D.35712>:
    code.2226 = code;
    code = code.2226 + 1;
    *code.2226 = 68;
    D.35697 = (unsigned char) i;
    *code = D.35697;
    code = code + 1;
    goto <D.35715>;
    <D.35713>:
    code.2227 = code;
    code = code.2227 + 1;
    *code.2227 = 132;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = i;
          code.2228 = code;
          code = code.2228 + 1;
          D.35718 = imb.b[0];
          *code.2228 = D.35718;
          code.2229 = code;
          code = code.2229 + 1;
          D.35720 = imb.b[1];
          *code.2229 = D.35720;
          code.2230 = code;
          code = code.2230 + 1;
          D.35722 = imb.b[2];
          *code.2230 = D.35722;
          code.2231 = code;
          code = code.2231 + 1;
          D.35724 = imb.b[3];
          *code.2231 = D.35724;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35715>:
    <D.25476>:
    switch (4) <default: <D.25482>, case 1: <D.25478>, case 2: <D.25480>, case 4: <D.25481>>
    <D.25478>:
    code.2232 = code;
    code = code.2232 + 1;
    *code.2232 = 136;
    goto <D.25479>;
    <D.25480>:
    code.2233 = code;
    code = code.2233 + 1;
    *code.2233 = 102;
    <D.25481>:
    code.2234 = code;
    code = code.2234 + 1;
    *code.2234 = 137;
    goto <D.25479>;
    <D.25482>:
    __assert_fail ("0", "mini-x86.c", 3303, &__PRETTY_FUNCTION__);
    <D.25479>:
    if (0 != 0) goto <D.35728>; else goto <D.35729>;
    <D.35728>:
    if (i == -8) goto <D.35730>; else goto <D.35731>;
    <D.35730>:
    code.2235 = code;
    code = code.2235 + 1;
    *code.2235 = 4;
    code.2236 = code;
    code = code.2236 + 1;
    *code.2236 = 36;
    goto <D.35734>;
    <D.35731>:
    i.2216 = (unsigned int) i;
    D.35735 = i.2216 + 136;
    if (D.35735 <= 255) goto <D.35736>; else goto <D.35737>;
    <D.35736>:
    code.2237 = code;
    code = code.2237 + 1;
    *code.2237 = 68;
    code.2238 = code;
    code = code.2238 + 1;
    *code.2238 = 36;
    D.35740 = (unsigned char) i;
    D.35741 = D.35740 + 8;
    *code = D.35741;
    code = code + 1;
    goto <D.35742>;
    <D.35737>:
    code.2239 = code;
    code = code.2239 + 1;
    *code.2239 = 132;
    code.2240 = code;
    code = code.2240 + 1;
    *code.2240 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.35745 = i + 8;
          imb.val = D.35745;
          code.2241 = code;
          code = code.2241 + 1;
          D.35747 = imb.b[0];
          *code.2241 = D.35747;
          code.2242 = code;
          code = code.2242 + 1;
          D.35749 = imb.b[1];
          *code.2242 = D.35749;
          code.2243 = code;
          code = code.2243 + 1;
          D.35751 = imb.b[2];
          *code.2243 = D.35751;
          code.2244 = code;
          code = code.2244 + 1;
          D.35753 = imb.b[3];
          *code.2244 = D.35753;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35742>:
    <D.35734>:
    goto <D.25484>;
    <D.35729>:
    if (0 != 0) goto <D.35754>; else goto <D.35755>;
    <D.35754>:
    code.2245 = code;
    code = code.2245 + 1;
    *code.2245 = 5;
    goto <D.25484>;
    <D.35755>:
    i.2216 = (unsigned int) i;
    D.35735 = i.2216 + 136;
    if (D.35735 <= 255) goto <D.35757>; else goto <D.35758>;
    <D.35757>:
    code.2246 = code;
    code = code.2246 + 1;
    *code.2246 = 69;
    D.35740 = (unsigned char) i;
    D.35741 = D.35740 + 8;
    *code = D.35741;
    code = code + 1;
    goto <D.35760>;
    <D.35758>:
    code.2247 = code;
    code = code.2247 + 1;
    *code.2247 = 133;
    {
      union x86_imm_buf imb;

      try
        {
          D.35745 = i + 8;
          imb.val = D.35745;
          code.2248 = code;
          code = code.2248 + 1;
          D.35763 = imb.b[0];
          *code.2248 = D.35763;
          code.2249 = code;
          code = code.2249 + 1;
          D.35765 = imb.b[1];
          *code.2249 = D.35765;
          code.2250 = code;
          code = code.2250 + 1;
          D.35767 = imb.b[2];
          *code.2250 = D.35767;
          code.2251 = code;
          code = code.2251 + 1;
          D.35769 = imb.b[3];
          *code.2251 = D.35769;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35760>:
    <D.25484>:
    i = i + 4;
    <D.25487>:
    i.2252 = (unsigned int) i;
    D.35771 = call->stack_usage;
    D.35772 = call->stack_align_amount;
    D.35773 = D.35771 - D.35772;
    if (i.2252 < D.35773) goto <D.25486>; else goto <D.25488>;
    <D.25488>:
    code.2253 = code;
    code = code.2253 + 1;
    *code.2253 = 201;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    offset = (guint) D.31489;
    D.35775 = call->method;
    offset.2097 = (int) offset;
    mono_add_patch_info (cfg, offset.2097, 4, D.35775);
    code.2254 = code;
    code = code.2254 + 1;
    *code.2254 = 233;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2255 = code;
          code = code.2255 + 1;
          D.35778 = imb.b[0];
          *code.2255 = D.35778;
          code.2256 = code;
          code = code.2256 + 1;
          D.35780 = imb.b[1];
          *code.2256 = D.35780;
          code.2257 = code;
          code = code.2257 + 1;
          D.35782 = imb.b[2];
          *code.2257 = D.35782;
          code.2258 = code;
          code = code.2258 + 1;
          D.35784 = imb.b[3];
          *code.2258 = D.35784;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    D.33912 = ins->flags;
    D.35523 = D.33912 | 128;
    ins->flags = D.35523;
    cfg->disable_aot = 1;
    goto <D.24796>;
  }
  <D.25490>:
  code.2259 = code;
  code = code.2259 + 1;
  *code.2259 = 57;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.35786>; else goto <D.35787>;
  <D.35786>:
  if (1 != 0) goto <D.35788>; else goto <D.35789>;
  <D.35788>:
  code.2260 = code;
  code = code.2260 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.2260 = D.32039;
  code.2261 = code;
  code = code.2261 + 1;
  *code.2261 = 36;
  goto <D.35792>;
  <D.35789>:
  if (1 != 0) goto <D.35793>; else goto <D.35794>;
  <D.35793>:
  code.2262 = code;
  code = code.2262 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.2262 = D.32046;
  code.2263 = code;
  code = code.2263 + 1;
  *code.2263 = 36;
  *code = 0;
  code = code + 1;
  goto <D.35797>;
  <D.35794>:
  code.2264 = code;
  code = code.2264 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.2264 = D.32051;
  code.2265 = code;
  code = code.2265 + 1;
  *code.2265 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2266 = code;
        code = code.2266 + 1;
        D.35801 = imb.b[0];
        *code.2266 = D.35801;
        code.2267 = code;
        code = code.2267 + 1;
        D.35803 = imb.b[1];
        *code.2267 = D.35803;
        code.2268 = code;
        code = code.2268 + 1;
        D.35805 = imb.b[2];
        *code.2268 = D.35805;
        code.2269 = code;
        code = code.2269 + 1;
        D.35807 = imb.b[3];
        *code.2269 = D.35807;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35797>:
  <D.35792>:
  goto <D.25492>;
  <D.35787>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.35808>; else goto <D.35809>;
  <D.35808>:
  code.2270 = code;
  code = code.2270 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.35811 = D.32037 | D.31586;
  D.35812 = (unsigned char) D.35811;
  *code.2270 = D.35812;
  goto <D.25492>;
  <D.35809>:
  if (1 != 0) goto <D.35813>; else goto <D.35814>;
  <D.35813>:
  code.2271 = code;
  code = code.2271 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34772 = D.32071 | D.31586;
  D.34773 = (unsigned char) D.34772;
  *code.2271 = D.34773;
  *code = 0;
  code = code + 1;
  goto <D.35816>;
  <D.35814>:
  code.2272 = code;
  code = code.2272 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34810 = D.32076 | D.31586;
  D.34811 = (unsigned char) D.34810;
  *code.2272 = D.34811;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2273 = code;
        code = code.2273 + 1;
        D.35819 = imb.b[0];
        *code.2273 = D.35819;
        code.2274 = code;
        code = code.2274 + 1;
        D.35821 = imb.b[1];
        *code.2274 = D.35821;
        code.2275 = code;
        code = code.2275 + 1;
        D.35823 = imb.b[2];
        *code.2275 = D.35823;
        code.2276 = code;
        code = code.2276 + 1;
        D.35825 = imb.b[3];
        *code.2276 = D.35825;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35816>:
  <D.25492>:
  goto <D.24796>;
  <D.25494>:
  {
    int hreg;

    D.31548 = ins->sreg1;
    D.35826 = D.31548 == 0;
    hreg = (int) D.35826;
    code.2277 = code;
    code = code.2277 + 1;
    D.35828 = (unsigned char) hreg;
    D.35829 = D.35828 + 80;
    *code.2277 = D.35829;
    code.2278 = code;
    code = code.2278 + 1;
    *code.2278 = 141;
    if (0 != 0) goto <D.35831>; else goto <D.35832>;
    <D.35831>:
    D.35833 = cfg->sig_cookie;
    if (D.35833 == 0) goto <D.35834>; else goto <D.35835>;
    <D.35834>:
    code.2279 = code;
    code = code.2279 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35840 = D.35839 | 4;
    D.35841 = (unsigned char) D.35840;
    *code.2279 = D.35841;
    code.2280 = code;
    code = code.2280 + 1;
    *code.2280 = 36;
    goto <D.35843>;
    <D.35835>:
    D.35833 = cfg->sig_cookie;
    D.35844 = (unsigned int) D.35833;
    D.35845 = D.35844 + 128;
    if (D.35845 <= 255) goto <D.35846>; else goto <D.35847>;
    <D.35846>:
    code.2281 = code;
    code = code.2281 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35849 = D.35839 | 68;
    D.35850 = (unsigned char) D.35849;
    *code.2281 = D.35850;
    code.2282 = code;
    code = code.2282 + 1;
    *code.2282 = 36;
    D.35833 = cfg->sig_cookie;
    D.35852 = (unsigned char) D.35833;
    *code = D.35852;
    code = code + 1;
    goto <D.35853>;
    <D.35847>:
    code.2283 = code;
    code = code.2283 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35855 = D.35839 | -124;
    D.35856 = (unsigned char) D.35855;
    *code.2283 = D.35856;
    code.2284 = code;
    code = code.2284 + 1;
    *code.2284 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.35833 = cfg->sig_cookie;
          imb.val = D.35833;
          code.2285 = code;
          code = code.2285 + 1;
          D.35859 = imb.b[0];
          *code.2285 = D.35859;
          code.2286 = code;
          code = code.2286 + 1;
          D.35861 = imb.b[1];
          *code.2286 = D.35861;
          code.2287 = code;
          code = code.2287 + 1;
          D.35863 = imb.b[2];
          *code.2287 = D.35863;
          code.2288 = code;
          code = code.2288 + 1;
          D.35865 = imb.b[3];
          *code.2288 = D.35865;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35853>:
    <D.35843>:
    goto <D.25497>;
    <D.35832>:
    if (0 != 0) goto <D.35866>; else goto <D.35867>;
    <D.35866>:
    code.2289 = code;
    code = code.2289 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35869 = D.35839 | 5;
    D.35870 = (unsigned char) D.35869;
    *code.2289 = D.35870;
    goto <D.25497>;
    <D.35867>:
    D.35833 = cfg->sig_cookie;
    D.35844 = (unsigned int) D.35833;
    D.35845 = D.35844 + 128;
    if (D.35845 <= 255) goto <D.35871>; else goto <D.35872>;
    <D.35871>:
    code.2290 = code;
    code = code.2290 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35874 = D.35839 | 69;
    D.35875 = (unsigned char) D.35874;
    *code.2290 = D.35875;
    D.35833 = cfg->sig_cookie;
    D.35852 = (unsigned char) D.35833;
    *code = D.35852;
    code = code + 1;
    goto <D.35876>;
    <D.35872>:
    code.2291 = code;
    code = code.2291 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35878 = D.35839 | -123;
    D.35879 = (unsigned char) D.35878;
    *code.2291 = D.35879;
    {
      union x86_imm_buf imb;

      try
        {
          D.35833 = cfg->sig_cookie;
          imb.val = D.35833;
          code.2292 = code;
          code = code.2292 + 1;
          D.35881 = imb.b[0];
          *code.2292 = D.35881;
          code.2293 = code;
          code = code.2293 + 1;
          D.35883 = imb.b[1];
          *code.2293 = D.35883;
          code.2294 = code;
          code = code.2294 + 1;
          D.35885 = imb.b[2];
          *code.2294 = D.35885;
          code.2295 = code;
          code = code.2295 + 1;
          D.35887 = imb.b[3];
          *code.2295 = D.35887;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35876>:
    <D.25497>:
    switch (4) <default: <D.25503>, case 1: <D.25499>, case 2: <D.25501>, case 4: <D.25502>>
    <D.25499>:
    code.2296 = code;
    code = code.2296 + 1;
    *code.2296 = 136;
    goto <D.25500>;
    <D.25501>:
    code.2297 = code;
    code = code.2297 + 1;
    *code.2297 = 102;
    <D.25502>:
    code.2298 = code;
    code = code.2298 + 1;
    *code.2298 = 137;
    goto <D.25500>;
    <D.25503>:
    __assert_fail ("0", "mini-x86.c", 3327, &__PRETTY_FUNCTION__);
    <D.25500>:
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.35891>; else goto <D.35892>;
    <D.35891>:
    if (1 != 0) goto <D.35893>; else goto <D.35894>;
    <D.35893>:
    code.2299 = code;
    code = code.2299 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35840 = D.35839 | 4;
    D.35841 = (unsigned char) D.35840;
    *code.2299 = D.35841;
    code.2300 = code;
    code = code.2300 + 1;
    *code.2300 = 36;
    goto <D.35897>;
    <D.35894>:
    if (1 != 0) goto <D.35898>; else goto <D.35899>;
    <D.35898>:
    code.2301 = code;
    code = code.2301 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35849 = D.35839 | 68;
    D.35850 = (unsigned char) D.35849;
    *code.2301 = D.35850;
    code.2302 = code;
    code = code.2302 + 1;
    *code.2302 = 36;
    *code = 0;
    code = code + 1;
    goto <D.35902>;
    <D.35899>:
    code.2303 = code;
    code = code.2303 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35855 = D.35839 | -124;
    D.35856 = (unsigned char) D.35855;
    *code.2303 = D.35856;
    code.2304 = code;
    code = code.2304 + 1;
    *code.2304 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2305 = code;
          code = code.2305 + 1;
          D.35906 = imb.b[0];
          *code.2305 = D.35906;
          code.2306 = code;
          code = code.2306 + 1;
          D.35908 = imb.b[1];
          *code.2306 = D.35908;
          code.2307 = code;
          code = code.2307 + 1;
          D.35910 = imb.b[2];
          *code.2307 = D.35910;
          code.2308 = code;
          code = code.2308 + 1;
          D.35912 = imb.b[3];
          *code.2308 = D.35912;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35902>:
    <D.35897>:
    goto <D.25505>;
    <D.35892>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.35913>; else goto <D.35914>;
    <D.35913>:
    code.2309 = code;
    code = code.2309 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.35916 = D.35839 | D.31586;
    D.35917 = (unsigned char) D.35916;
    *code.2309 = D.35917;
    goto <D.25505>;
    <D.35914>:
    if (1 != 0) goto <D.35918>; else goto <D.35919>;
    <D.35918>:
    code.2310 = code;
    code = code.2310 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35921 = D.35839 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.35922 = D.35921 | D.31586;
    D.35923 = (unsigned char) D.35922;
    *code.2310 = D.35923;
    *code = 0;
    code = code + 1;
    goto <D.35924>;
    <D.35919>:
    code.2311 = code;
    code = code.2311 + 1;
    D.35837 = hreg & 7;
    D.35838 = D.35837 << 3;
    D.35839 = (signed char) D.35838;
    D.35926 = D.35839 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.35927 = D.35926 | D.31586;
    D.35928 = (unsigned char) D.35927;
    *code.2311 = D.35928;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2312 = code;
          code = code.2312 + 1;
          D.35930 = imb.b[0];
          *code.2312 = D.35930;
          code.2313 = code;
          code = code.2313 + 1;
          D.35932 = imb.b[1];
          *code.2313 = D.35932;
          code.2314 = code;
          code = code.2314 + 1;
          D.35934 = imb.b[2];
          *code.2314 = D.35934;
          code.2315 = code;
          code = code.2315 + 1;
          D.35936 = imb.b[3];
          *code.2315 = D.35936;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.35924>:
    <D.25505>:
    code.2316 = code;
    code = code.2316 + 1;
    D.35828 = (unsigned char) hreg;
    D.35938 = D.35828 + 88;
    *code.2316 = D.35938;
    goto <D.24796>;
  }
  <D.25507>:
  <D.25508>:
  <D.25509>:
  <D.25510>:
  <D.25511>:
  <D.25512>:
  call = ins;
  D.33912 = ins->flags;
  D.33913 = (int) D.33912;
  D.33914 = D.33913 & 1;
  if (D.33914 != 0) goto <D.35939>; else goto <D.35940>;
  <D.35939>:
  D.35941 = call->method;
  code = emit_call (cfg, code, 3, D.35941);
  goto <D.35942>;
  <D.35940>:
  D.35943 = call->fptr;
  code = emit_call (cfg, code, 1, D.35943);
  <D.35942>:
  D.33912 = ins->flags;
  D.35523 = D.33912 | 128;
  ins->flags = D.35523;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  D.35944 = call->stack_usage;
  if (D.35944 != 0) goto <D.35945>; else goto <D.35946>;
  <D.35945>:
  D.35947 = call->signature;
  D.35948 = BIT_FIELD_REF <*D.35947, 8, 80>;
  D.35949 = D.35948 & 63;
  if (D.35949 != 2) goto <D.35950>; else goto <D.35951>;
  <D.35950>:
  D.35947 = call->signature;
  D.35952 = BIT_FIELD_REF <*D.35947, 16, 80>;
  D.35953 = D.35952 & 319;
  if (D.35953 != 259) goto <D.35954>; else goto <D.35955>;
  <D.35954>:
  D.35944 = call->stack_usage;
  if (D.35944 == 4) goto <D.35956>; else goto <D.35957>;
  <D.35956>:
  code.2317 = code;
  code = code.2317 + 1;
  *code.2317 = 89;
  goto <D.35959>;
  <D.35957>:
  if (0 != 0) goto <D.35960>; else goto <D.35961>;
  <D.35960>:
  code.2318 = code;
  code = code.2318 + 1;
  *code.2318 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.35944 = call->stack_usage;
        D.35963 = (int) D.35944;
        imb.val = D.35963;
        code.2319 = code;
        code = code.2319 + 1;
        D.35965 = imb.b[0];
        *code.2319 = D.35965;
        code.2320 = code;
        code = code.2320 + 1;
        D.35967 = imb.b[1];
        *code.2320 = D.35967;
        code.2321 = code;
        code = code.2321 + 1;
        D.35969 = imb.b[2];
        *code.2321 = D.35969;
        code.2322 = code;
        code = code.2322 + 1;
        D.35971 = imb.b[3];
        *code.2322 = D.35971;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25514>;
  <D.35961>:
  D.35944 = call->stack_usage;
  D.35963 = (int) D.35944;
  if (D.35963 >= -128) goto <D.35974>; else goto <D.35972>;
  <D.35974>:
  D.35944 = call->stack_usage;
  D.35963 = (int) D.35944;
  if (D.35963 <= 127) goto <D.35975>; else goto <D.35972>;
  <D.35975>:
  code.2323 = code;
  code = code.2323 + 1;
  *code.2323 = 131;
  code.2324 = code;
  code = code.2324 + 1;
  *code.2324 = 196;
  D.35944 = call->stack_usage;
  D.35978 = (unsigned char) D.35944;
  *code = D.35978;
  code = code + 1;
  goto <D.35973>;
  <D.35972>:
  code.2325 = code;
  code = code.2325 + 1;
  *code.2325 = 129;
  code.2326 = code;
  code = code.2326 + 1;
  *code.2326 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.35944 = call->stack_usage;
        D.35963 = (int) D.35944;
        imb.val = D.35963;
        code.2327 = code;
        code = code.2327 + 1;
        D.35982 = imb.b[0];
        *code.2327 = D.35982;
        code.2328 = code;
        code = code.2328 + 1;
        D.35984 = imb.b[1];
        *code.2328 = D.35984;
        code.2329 = code;
        code = code.2329 + 1;
        D.35986 = imb.b[2];
        *code.2329 = D.35986;
        code.2330 = code;
        code = code.2330 + 1;
        D.35988 = imb.b[3];
        *code.2330 = D.35988;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35973>:
  <D.25514>:
  <D.35959>:
  <D.35955>:
  <D.35951>:
  <D.35946>:
  code = emit_move_return_value (cfg, ins, code);
  goto <D.24796>;
  <D.25516>:
  <D.25517>:
  <D.25518>:
  <D.25519>:
  <D.25520>:
  <D.25521>:
  call = ins;
  code.2331 = code;
  code = code.2331 + 1;
  *code.2331 = 255;
  code.2332 = code;
  code = code.2332 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34735 = D.31586 | -48;
  D.34736 = (unsigned char) D.34735;
  *code.2332 = D.34736;
  D.33912 = ins->flags;
  D.35523 = D.33912 | 128;
  ins->flags = D.35523;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  D.35944 = call->stack_usage;
  if (D.35944 != 0) goto <D.35991>; else goto <D.35992>;
  <D.35991>:
  D.35947 = call->signature;
  D.35948 = BIT_FIELD_REF <*D.35947, 8, 80>;
  D.35949 = D.35948 & 63;
  if (D.35949 != 2) goto <D.35993>; else goto <D.35994>;
  <D.35993>:
  D.35947 = call->signature;
  D.35952 = BIT_FIELD_REF <*D.35947, 16, 80>;
  D.35953 = D.35952 & 319;
  if (D.35953 != 259) goto <D.35995>; else goto <D.35996>;
  <D.35995>:
  D.35944 = call->stack_usage;
  if (D.35944 == 4) goto <D.35997>; else goto <D.35998>;
  <D.35997>:
  code.2333 = code;
  code = code.2333 + 1;
  *code.2333 = 89;
  goto <D.36000>;
  <D.35998>:
  if (0 != 0) goto <D.36001>; else goto <D.36002>;
  <D.36001>:
  code.2334 = code;
  code = code.2334 + 1;
  *code.2334 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.35944 = call->stack_usage;
        D.35963 = (int) D.35944;
        imb.val = D.35963;
        code.2335 = code;
        code = code.2335 + 1;
        D.36005 = imb.b[0];
        *code.2335 = D.36005;
        code.2336 = code;
        code = code.2336 + 1;
        D.36007 = imb.b[1];
        *code.2336 = D.36007;
        code.2337 = code;
        code = code.2337 + 1;
        D.36009 = imb.b[2];
        *code.2337 = D.36009;
        code.2338 = code;
        code = code.2338 + 1;
        D.36011 = imb.b[3];
        *code.2338 = D.36011;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25523>;
  <D.36002>:
  D.35944 = call->stack_usage;
  D.35963 = (int) D.35944;
  if (D.35963 >= -128) goto <D.36014>; else goto <D.36012>;
  <D.36014>:
  D.35944 = call->stack_usage;
  D.35963 = (int) D.35944;
  if (D.35963 <= 127) goto <D.36015>; else goto <D.36012>;
  <D.36015>:
  code.2339 = code;
  code = code.2339 + 1;
  *code.2339 = 131;
  code.2340 = code;
  code = code.2340 + 1;
  *code.2340 = 196;
  D.35944 = call->stack_usage;
  D.35978 = (unsigned char) D.35944;
  *code = D.35978;
  code = code + 1;
  goto <D.36013>;
  <D.36012>:
  code.2341 = code;
  code = code.2341 + 1;
  *code.2341 = 129;
  code.2342 = code;
  code = code.2342 + 1;
  *code.2342 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.35944 = call->stack_usage;
        D.35963 = (int) D.35944;
        imb.val = D.35963;
        code.2343 = code;
        code = code.2343 + 1;
        D.36021 = imb.b[0];
        *code.2343 = D.36021;
        code.2344 = code;
        code = code.2344 + 1;
        D.36023 = imb.b[1];
        *code.2344 = D.36023;
        code.2345 = code;
        code = code.2345 + 1;
        D.36025 = imb.b[2];
        *code.2345 = D.36025;
        code.2346 = code;
        code = code.2346 + 1;
        D.36027 = imb.b[3];
        *code.2346 = D.36027;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36013>:
  <D.25523>:
  <D.36000>:
  <D.35996>:
  <D.35994>:
  <D.35992>:
  code = emit_move_return_value (cfg, ins, code);
  goto <D.24796>;
  <D.25525>:
  <D.25526>:
  <D.25527>:
  <D.25528>:
  <D.25529>:
  <D.25530>:
  call = ins;
  code.2347 = code;
  code = code.2347 + 1;
  *code.2347 = 255;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.36029>; else goto <D.36030>;
  <D.36029>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.36031>; else goto <D.36032>;
  <D.36031>:
  code.2348 = code;
  code = code.2348 + 1;
  *code.2348 = 20;
  code.2349 = code;
  code = code.2349 + 1;
  *code.2349 = 36;
  goto <D.36035>;
  <D.36032>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.36036>; else goto <D.36037>;
  <D.36036>:
  code.2350 = code;
  code = code.2350 + 1;
  *code.2350 = 84;
  code.2351 = code;
  code = code.2351 + 1;
  *code.2351 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.36040>;
  <D.36037>:
  code.2352 = code;
  code = code.2352 + 1;
  *code.2352 = 148;
  code.2353 = code;
  code = code.2353 + 1;
  *code.2353 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2354 = code;
        code = code.2354 + 1;
        D.36044 = imb.b[0];
        *code.2354 = D.36044;
        code.2355 = code;
        code = code.2355 + 1;
        D.36046 = imb.b[1];
        *code.2355 = D.36046;
        code.2356 = code;
        code = code.2356 + 1;
        D.36048 = imb.b[2];
        *code.2356 = D.36048;
        code.2357 = code;
        code = code.2357 + 1;
        D.36050 = imb.b[3];
        *code.2357 = D.36050;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36040>:
  <D.36035>:
  goto <D.25532>;
  <D.36030>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.36051>; else goto <D.36052>;
  <D.36051>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.36053>; else goto <D.36054>;
  <D.36053>:
  code.2358 = code;
  code = code.2358 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36056 = D.31586 | 16;
  D.36057 = (unsigned char) D.36056;
  *code.2358 = D.36057;
  goto <D.25532>;
  <D.36054>:
  <D.36052>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.36058>; else goto <D.36059>;
  <D.36058>:
  code.2359 = code;
  code = code.2359 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36061 = D.31586 | 80;
  D.36062 = (unsigned char) D.36061;
  *code.2359 = D.36062;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.36063>;
  <D.36059>:
  code.2360 = code;
  code = code.2360 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36065 = D.31586 | -112;
  D.36066 = (unsigned char) D.36065;
  *code.2360 = D.36066;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2361 = code;
        code = code.2361 + 1;
        D.36068 = imb.b[0];
        *code.2361 = D.36068;
        code.2362 = code;
        code = code.2362 + 1;
        D.36070 = imb.b[1];
        *code.2362 = D.36070;
        code.2363 = code;
        code = code.2363 + 1;
        D.36072 = imb.b[2];
        *code.2363 = D.36072;
        code.2364 = code;
        code = code.2364 + 1;
        D.36074 = imb.b[3];
        *code.2364 = D.36074;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36063>:
  <D.25532>:
  D.33912 = ins->flags;
  D.35523 = D.33912 | 128;
  ins->flags = D.35523;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  D.35944 = call->stack_usage;
  if (D.35944 != 0) goto <D.36075>; else goto <D.36076>;
  <D.36075>:
  D.35947 = call->signature;
  D.35948 = BIT_FIELD_REF <*D.35947, 8, 80>;
  D.35949 = D.35948 & 63;
  if (D.35949 != 2) goto <D.36077>; else goto <D.36078>;
  <D.36077>:
  D.35947 = call->signature;
  D.35952 = BIT_FIELD_REF <*D.35947, 16, 80>;
  D.35953 = D.35952 & 319;
  if (D.35953 != 259) goto <D.36079>; else goto <D.36080>;
  <D.36079>:
  D.35944 = call->stack_usage;
  if (D.35944 == 4) goto <D.36081>; else goto <D.36082>;
  <D.36081>:
  code.2365 = code;
  code = code.2365 + 1;
  *code.2365 = 89;
  goto <D.36084>;
  <D.36082>:
  if (0 != 0) goto <D.36085>; else goto <D.36086>;
  <D.36085>:
  code.2366 = code;
  code = code.2366 + 1;
  *code.2366 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.35944 = call->stack_usage;
        D.35963 = (int) D.35944;
        imb.val = D.35963;
        code.2367 = code;
        code = code.2367 + 1;
        D.36089 = imb.b[0];
        *code.2367 = D.36089;
        code.2368 = code;
        code = code.2368 + 1;
        D.36091 = imb.b[1];
        *code.2368 = D.36091;
        code.2369 = code;
        code = code.2369 + 1;
        D.36093 = imb.b[2];
        *code.2369 = D.36093;
        code.2370 = code;
        code = code.2370 + 1;
        D.36095 = imb.b[3];
        *code.2370 = D.36095;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25535>;
  <D.36086>:
  D.35944 = call->stack_usage;
  D.35963 = (int) D.35944;
  if (D.35963 >= -128) goto <D.36098>; else goto <D.36096>;
  <D.36098>:
  D.35944 = call->stack_usage;
  D.35963 = (int) D.35944;
  if (D.35963 <= 127) goto <D.36099>; else goto <D.36096>;
  <D.36099>:
  code.2371 = code;
  code = code.2371 + 1;
  *code.2371 = 131;
  code.2372 = code;
  code = code.2372 + 1;
  *code.2372 = 196;
  D.35944 = call->stack_usage;
  D.35978 = (unsigned char) D.35944;
  *code = D.35978;
  code = code + 1;
  goto <D.36097>;
  <D.36096>:
  code.2373 = code;
  code = code.2373 + 1;
  *code.2373 = 129;
  code.2374 = code;
  code = code.2374 + 1;
  *code.2374 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.35944 = call->stack_usage;
        D.35963 = (int) D.35944;
        imb.val = D.35963;
        code.2375 = code;
        code = code.2375 + 1;
        D.36105 = imb.b[0];
        *code.2375 = D.36105;
        code.2376 = code;
        code = code.2376 + 1;
        D.36107 = imb.b[1];
        *code.2376 = D.36107;
        code.2377 = code;
        code = code.2377 + 1;
        D.36109 = imb.b[2];
        *code.2377 = D.36109;
        code.2378 = code;
        code = code.2378 + 1;
        D.36111 = imb.b[3];
        *code.2378 = D.36111;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36097>:
  <D.25535>:
  <D.36084>:
  <D.36080>:
  <D.36078>:
  <D.36076>:
  code = emit_move_return_value (cfg, ins, code);
  goto <D.24796>;
  <D.25537>:
  code.2379 = code;
  code = code.2379 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.2379 = D.36114;
  goto <D.24796>;
  <D.25538>:
  {
    int _imm;

    _imm = ins->data.op[1].const_val;
    _imm.2380 = (unsigned int) _imm;
    D.36116 = _imm.2380 + 128;
    if (D.36116 <= 255) goto <D.36117>; else goto <D.36118>;
    <D.36117>:
    code.2381 = code;
    code = code.2381 + 1;
    *code.2381 = 106;
    D.36120 = (unsigned char) _imm;
    *code = D.36120;
    code = code + 1;
    goto <D.36121>;
    <D.36118>:
    code.2382 = code;
    code = code.2382 + 1;
    *code.2382 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.2383 = code;
          code = code.2383 + 1;
          D.36124 = imb.b[0];
          *code.2383 = D.36124;
          code.2384 = code;
          code = code.2384 + 1;
          D.36126 = imb.b[1];
          *code.2384 = D.36126;
          code.2385 = code;
          code = code.2385 + 1;
          D.36128 = imb.b[2];
          *code.2385 = D.36128;
          code.2386 = code;
          code = code.2386 + 1;
          D.36130 = imb.b[3];
          *code.2386 = D.36130;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36121>:
  }
  goto <D.24796>;
  <D.25541>:
  code.2387 = code;
  code = code.2387 + 1;
  *code.2387 = 255;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.36132>; else goto <D.36133>;
  <D.36132>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.36134>; else goto <D.36135>;
  <D.36134>:
  code.2388 = code;
  code = code.2388 + 1;
  *code.2388 = 52;
  code.2389 = code;
  code = code.2389 + 1;
  *code.2389 = 36;
  goto <D.36138>;
  <D.36135>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.36139>; else goto <D.36140>;
  <D.36139>:
  code.2390 = code;
  code = code.2390 + 1;
  *code.2390 = 116;
  code.2391 = code;
  code = code.2391 + 1;
  *code.2391 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.36143>;
  <D.36140>:
  code.2392 = code;
  code = code.2392 + 1;
  *code.2392 = 180;
  code.2393 = code;
  code = code.2393 + 1;
  *code.2393 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2394 = code;
        code = code.2394 + 1;
        D.36147 = imb.b[0];
        *code.2394 = D.36147;
        code.2395 = code;
        code = code.2395 + 1;
        D.36149 = imb.b[1];
        *code.2395 = D.36149;
        code.2396 = code;
        code = code.2396 + 1;
        D.36151 = imb.b[2];
        *code.2396 = D.36151;
        code.2397 = code;
        code = code.2397 + 1;
        D.36153 = imb.b[3];
        *code.2397 = D.36153;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36143>:
  <D.36138>:
  goto <D.25543>;
  <D.36133>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.36154>; else goto <D.36155>;
  <D.36154>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.36156>; else goto <D.36157>;
  <D.36156>:
  code.2398 = code;
  code = code.2398 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33380 = D.31586 | 48;
  D.33381 = (unsigned char) D.33380;
  *code.2398 = D.33381;
  goto <D.25543>;
  <D.36157>:
  <D.36155>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.36159>; else goto <D.36160>;
  <D.36159>:
  code.2399 = code;
  code = code.2399 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33385 = D.31586 | 112;
  D.33386 = (unsigned char) D.33385;
  *code.2399 = D.33386;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.36162>;
  <D.36160>:
  code.2400 = code;
  code = code.2400 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33389 = D.31586 | -80;
  D.33390 = (unsigned char) D.33389;
  *code.2400 = D.33390;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2401 = code;
        code = code.2401 + 1;
        D.36165 = imb.b[0];
        *code.2401 = D.36165;
        code.2402 = code;
        code = code.2402 + 1;
        D.36167 = imb.b[1];
        *code.2402 = D.36167;
        code.2403 = code;
        code = code.2403 + 1;
        D.36169 = imb.b[2];
        *code.2403 = D.36169;
        code.2404 = code;
        code = code.2404 + 1;
        D.36171 = imb.b[3];
        *code.2404 = D.36171;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36162>:
  <D.25543>:
  goto <D.24796>;
  <D.25545>:
  if (0 != 0) goto <D.36172>; else goto <D.36173>;
  <D.36172>:
  code.2405 = code;
  code = code.2405 + 1;
  *code.2405 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2406 = code;
        code = code.2406 + 1;
        D.36176 = imb.b[0];
        *code.2406 = D.36176;
        code.2407 = code;
        code = code.2407 + 1;
        D.36178 = imb.b[1];
        *code.2407 = D.36178;
        code.2408 = code;
        code = code.2408 + 1;
        D.36180 = imb.b[2];
        *code.2408 = D.36180;
        code.2409 = code;
        code = code.2409 + 1;
        D.36182 = imb.b[3];
        *code.2409 = D.36182;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25547>;
  <D.36173>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.36183>; else goto <D.36184>;
  <D.36183>:
  code.2410 = code;
  code = code.2410 + 1;
  *code.2410 = 131;
  code.2411 = code;
  code = code.2411 + 1;
  *code.2411 = 236;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.36187>;
  <D.36184>:
  code.2412 = code;
  code = code.2412 + 1;
  *code.2412 = 129;
  code.2413 = code;
  code = code.2413 + 1;
  *code.2413 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2414 = code;
        code = code.2414 + 1;
        D.36191 = imb.b[0];
        *code.2414 = D.36191;
        code.2415 = code;
        code = code.2415 + 1;
        D.36193 = imb.b[1];
        *code.2415 = D.36193;
        code.2416 = code;
        code = code.2416 + 1;
        D.36195 = imb.b[2];
        *code.2416 = D.36195;
        code.2417 = code;
        code = code.2417 + 1;
        D.36197 = imb.b[3];
        *code.2417 = D.36197;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36187>:
  <D.25547>:
  code.2418 = code;
  code = code.2418 + 1;
  *code.2418 = 87;
  code.2419 = code;
  code = code.2419 + 1;
  *code.2419 = 86;
  code.2420 = code;
  code = code.2420 + 1;
  *code.2420 = 81;
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 != 0) goto <D.36201>; else goto <D.36202>;
  <D.36201>:
  code.2421 = code;
  code = code.2421 + 1;
  *code.2421 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.36204>; else goto <D.36205>;
  <D.36204>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.36206>; else goto <D.36207>;
  <D.36206>:
  code.2422 = code;
  code = code.2422 + 1;
  *code.2422 = 52;
  code.2423 = code;
  code = code.2423 + 1;
  *code.2423 = 36;
  goto <D.36210>;
  <D.36207>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.36211>; else goto <D.36212>;
  <D.36211>:
  code.2424 = code;
  code = code.2424 + 1;
  *code.2424 = 116;
  code.2425 = code;
  code = code.2425 + 1;
  *code.2425 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.36215>;
  <D.36212>:
  code.2426 = code;
  code = code.2426 + 1;
  *code.2426 = 180;
  code.2427 = code;
  code = code.2427 + 1;
  *code.2427 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2428 = code;
        code = code.2428 + 1;
        D.36219 = imb.b[0];
        *code.2428 = D.36219;
        code.2429 = code;
        code = code.2429 + 1;
        D.36221 = imb.b[1];
        *code.2429 = D.36221;
        code.2430 = code;
        code = code.2430 + 1;
        D.36223 = imb.b[2];
        *code.2430 = D.36223;
        code.2431 = code;
        code = code.2431 + 1;
        D.36225 = imb.b[3];
        *code.2431 = D.36225;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36215>:
  <D.36210>:
  goto <D.25550>;
  <D.36205>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.36226>; else goto <D.36227>;
  <D.36226>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.36228>; else goto <D.36229>;
  <D.36228>:
  code.2432 = code;
  code = code.2432 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33380 = D.31586 | 48;
  D.33381 = (unsigned char) D.33380;
  *code.2432 = D.33381;
  goto <D.25550>;
  <D.36229>:
  <D.36227>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.36231>; else goto <D.36232>;
  <D.36231>:
  code.2433 = code;
  code = code.2433 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33385 = D.31586 | 112;
  D.33386 = (unsigned char) D.33385;
  *code.2433 = D.33386;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.36234>;
  <D.36232>:
  code.2434 = code;
  code = code.2434 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33389 = D.31586 | -80;
  D.33390 = (unsigned char) D.33389;
  *code.2434 = D.33390;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2435 = code;
        code = code.2435 + 1;
        D.36237 = imb.b[0];
        *code.2435 = D.36237;
        code.2436 = code;
        code = code.2436 + 1;
        D.36239 = imb.b[1];
        *code.2436 = D.36239;
        code.2437 = code;
        code = code.2437 + 1;
        D.36241 = imb.b[2];
        *code.2437 = D.36241;
        code.2438 = code;
        code = code.2438 + 1;
        D.36243 = imb.b[3];
        *code.2438 = D.36243;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36234>:
  <D.25550>:
  goto <D.36244>;
  <D.36202>:
  switch (4) <default: <D.25556>, case 1: <D.25552>, case 2: <D.25554>, case 4: <D.25555>>
  <D.25552>:
  code.2439 = code;
  code = code.2439 + 1;
  *code.2439 = 138;
  goto <D.25553>;
  <D.25554>:
  code.2440 = code;
  code = code.2440 + 1;
  *code.2440 = 102;
  <D.25555>:
  code.2441 = code;
  code = code.2441 + 1;
  *code.2441 = 139;
  goto <D.25553>;
  <D.25556>:
  __assert_fail ("0", "mini-x86.c", 3422, &__PRETTY_FUNCTION__);
  <D.25553>:
  code.2442 = code;
  code = code.2442 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34399 = D.31586 | -16;
  D.34400 = (unsigned char) D.34399;
  *code.2442 = D.34400;
  <D.36244>:
  code.2443 = code;
  code = code.2443 + 1;
  *code.2443 = 141;
  if (1 != 0) goto <D.36250>; else goto <D.36251>;
  <D.36250>:
  if (0 != 0) goto <D.36252>; else goto <D.36253>;
  <D.36252>:
  code.2444 = code;
  code = code.2444 + 1;
  *code.2444 = 60;
  code.2445 = code;
  code = code.2445 + 1;
  *code.2445 = 36;
  goto <D.36256>;
  <D.36253>:
  if (1 != 0) goto <D.36257>; else goto <D.36258>;
  <D.36257>:
  code.2446 = code;
  code = code.2446 + 1;
  *code.2446 = 124;
  code.2447 = code;
  code = code.2447 + 1;
  *code.2447 = 36;
  *code = 12;
  code = code + 1;
  goto <D.36261>;
  <D.36258>:
  code.2448 = code;
  code = code.2448 + 1;
  *code.2448 = 188;
  code.2449 = code;
  code = code.2449 + 1;
  *code.2449 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2450 = code;
        code = code.2450 + 1;
        D.36265 = imb.b[0];
        *code.2450 = D.36265;
        code.2451 = code;
        code = code.2451 + 1;
        D.36267 = imb.b[1];
        *code.2451 = D.36267;
        code.2452 = code;
        code = code.2452 + 1;
        D.36269 = imb.b[2];
        *code.2452 = D.36269;
        code.2453 = code;
        code = code.2453 + 1;
        D.36271 = imb.b[3];
        *code.2453 = D.36271;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36261>:
  <D.36256>:
  goto <D.25558>;
  <D.36251>:
  if (0 != 0) goto <D.36272>; else goto <D.36273>;
  <D.36272>:
  code.2454 = code;
  code = code.2454 + 1;
  *code.2454 = 60;
  goto <D.25558>;
  <D.36273>:
  if (1 != 0) goto <D.36275>; else goto <D.36276>;
  <D.36275>:
  code.2455 = code;
  code = code.2455 + 1;
  *code.2455 = 124;
  *code = 12;
  code = code + 1;
  goto <D.36278>;
  <D.36276>:
  code.2456 = code;
  code = code.2456 + 1;
  *code.2456 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2457 = code;
        code = code.2457 + 1;
        D.36281 = imb.b[0];
        *code.2457 = D.36281;
        code.2458 = code;
        code = code.2458 + 1;
        D.36283 = imb.b[1];
        *code.2458 = D.36283;
        code.2459 = code;
        code = code.2459 + 1;
        D.36285 = imb.b[2];
        *code.2459 = D.36285;
        code.2460 = code;
        code = code.2460 + 1;
        D.36287 = imb.b[3];
        *code.2460 = D.36287;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36278>:
  <D.25558>:
  code.2461 = code;
  code = code.2461 + 1;
  *code.2461 = 185;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        D.36289 = D.31653 >> 2;
        imb.val = D.36289;
        code.2462 = code;
        code = code.2462 + 1;
        D.36291 = imb.b[0];
        *code.2462 = D.36291;
        code.2463 = code;
        code = code.2463 + 1;
        D.36293 = imb.b[1];
        *code.2463 = D.36293;
        code.2464 = code;
        code = code.2464 + 1;
        D.36295 = imb.b[2];
        *code.2464 = D.36295;
        code.2465 = code;
        code = code.2465 + 1;
        D.36297 = imb.b[3];
        *code.2465 = D.36297;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  code.2466 = code;
  code = code.2466 + 1;
  *code.2466 = 252;
  code.2467 = code;
  code = code.2467 + 1;
  *code.2467 = 243;
  code.2468 = code;
  code = code.2468 + 1;
  *code.2468 = 165;
  code.2469 = code;
  code = code.2469 + 1;
  *code.2469 = 89;
  code.2470 = code;
  code = code.2470 + 1;
  *code.2470 = 94;
  code.2471 = code;
  code = code.2471 + 1;
  *code.2471 = 95;
  goto <D.24796>;
  <D.25561>:
  code.2472 = code;
  code = code.2472 + 1;
  *code.2472 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == -1) goto <D.36305>; else goto <D.36306>;
  <D.36305>:
  code.2473 = code;
  code = code.2473 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.2473 = D.32289;
  code.2474 = code;
  code = code.2474 + 1;
  D.36309 = ins->backend.shift_amount;
  D.36310 = D.36309 << 6;
  D.36311 = (signed char) D.36310;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.36312 = D.36311 | D.32606;
  D.36313 = D.36312 | 5;
  D.36314 = (unsigned char) D.36313;
  *code.2474 = D.36314;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2475 = code;
        code = code.2475 + 1;
        D.36316 = imb.b[0];
        *code.2475 = D.36316;
        code.2476 = code;
        code = code.2476 + 1;
        D.36318 = imb.b[1];
        *code.2476 = D.36318;
        code.2477 = code;
        code = code.2477 + 1;
        D.36320 = imb.b[2];
        *code.2477 = D.36320;
        code.2478 = code;
        code = code.2478 + 1;
        D.36322 = imb.b[3];
        *code.2478 = D.36322;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.36323>;
  <D.36306>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 0) goto <D.36326>; else goto <D.36324>;
  <D.36326>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.36327>; else goto <D.36324>;
  <D.36327>:
  code.2479 = code;
  code = code.2479 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.2479 = D.32289;
  code.2480 = code;
  code = code.2480 + 1;
  D.36309 = ins->backend.shift_amount;
  D.36310 = D.36309 << 6;
  D.36311 = (signed char) D.36310;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.36312 = D.36311 | D.32606;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36330 = D.36312 | D.31586;
  D.36331 = (unsigned char) D.36330;
  *code.2480 = D.36331;
  goto <D.36325>;
  <D.36324>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.36332>; else goto <D.36333>;
  <D.36332>:
  code.2481 = code;
  code = code.2481 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.2481 = D.32296;
  code.2482 = code;
  code = code.2482 + 1;
  D.36309 = ins->backend.shift_amount;
  D.36310 = D.36309 << 6;
  D.36311 = (signed char) D.36310;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.36312 = D.36311 | D.32606;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36330 = D.36312 | D.31586;
  D.36331 = (unsigned char) D.36330;
  *code.2482 = D.36331;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.36336>;
  <D.36333>:
  code.2483 = code;
  code = code.2483 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.2483 = D.32301;
  code.2484 = code;
  code = code.2484 + 1;
  D.36309 = ins->backend.shift_amount;
  D.36310 = D.36309 << 6;
  D.36311 = (signed char) D.36310;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.36312 = D.36311 | D.32606;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36330 = D.36312 | D.31586;
  D.36331 = (unsigned char) D.36330;
  *code.2484 = D.36331;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2485 = code;
        code = code.2485 + 1;
        D.36340 = imb.b[0];
        *code.2485 = D.36340;
        code.2486 = code;
        code = code.2486 + 1;
        D.36342 = imb.b[1];
        *code.2486 = D.36342;
        code.2487 = code;
        code = code.2487 + 1;
        D.36344 = imb.b[2];
        *code.2487 = D.36344;
        code.2488 = code;
        code = code.2488 + 1;
        D.36346 = imb.b[3];
        *code.2488 = D.36346;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36336>:
  <D.36325>:
  <D.36323>:
  goto <D.24796>;
  <D.25564>:
  code.2489 = code;
  code = code.2489 + 1;
  *code.2489 = 141;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.36348>; else goto <D.36349>;
  <D.36348>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 0) goto <D.36350>; else goto <D.36351>;
  <D.36350>:
  code.2490 = code;
  code = code.2490 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.2490 = D.32289;
  code.2491 = code;
  code = code.2491 + 1;
  *code.2491 = 36;
  goto <D.36354>;
  <D.36351>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.36355>; else goto <D.36356>;
  <D.36355>:
  code.2492 = code;
  code = code.2492 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.2492 = D.32296;
  code.2493 = code;
  code = code.2493 + 1;
  *code.2493 = 36;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.36359>;
  <D.36356>:
  code.2494 = code;
  code = code.2494 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.2494 = D.32301;
  code.2495 = code;
  code = code.2495 + 1;
  *code.2495 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2496 = code;
        code = code.2496 + 1;
        D.36363 = imb.b[0];
        *code.2496 = D.36363;
        code.2497 = code;
        code = code.2497 + 1;
        D.36365 = imb.b[1];
        *code.2497 = D.36365;
        code.2498 = code;
        code = code.2498 + 1;
        D.36367 = imb.b[2];
        *code.2498 = D.36367;
        code.2499 = code;
        code = code.2499 + 1;
        D.36369 = imb.b[3];
        *code.2499 = D.36369;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36359>:
  <D.36354>:
  goto <D.25566>;
  <D.36349>:
  D.31653 = ins->data.op[1].const_val;
  if (D.31653 == 0) goto <D.36370>; else goto <D.36371>;
  <D.36370>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.36372>; else goto <D.36373>;
  <D.36372>:
  code.2500 = code;
  code = code.2500 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32316 = D.32227 | D.31586;
  D.32317 = (unsigned char) D.32316;
  *code.2500 = D.32317;
  goto <D.25566>;
  <D.36373>:
  <D.36371>:
  D.31653 = ins->data.op[1].const_val;
  D.32579 = (unsigned int) D.31653;
  D.32580 = D.32579 + 128;
  if (D.32580 <= 255) goto <D.36375>; else goto <D.36376>;
  <D.36375>:
  code.2501 = code;
  code = code.2501 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32322 = D.32321 | D.31586;
  D.32323 = (unsigned char) D.32322;
  *code.2501 = D.32323;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.36378>;
  <D.36376>:
  code.2502 = code;
  code = code.2502 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32327 = D.32326 | D.31586;
  D.32328 = (unsigned char) D.32327;
  *code.2502 = D.32328;
  {
    union x86_imm_buf imb;

    try
      {
        D.31653 = ins->data.op[1].const_val;
        imb.val = D.31653;
        code.2503 = code;
        code = code.2503 + 1;
        D.36381 = imb.b[0];
        *code.2503 = D.36381;
        code.2504 = code;
        code = code.2504 + 1;
        D.36383 = imb.b[1];
        *code.2504 = D.36383;
        code.2505 = code;
        code = code.2505 + 1;
        D.36385 = imb.b[2];
        *code.2505 = D.36385;
        code.2506 = code;
        code = code.2506 + 1;
        D.36387 = imb.b[3];
        *code.2506 = D.36387;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36378>:
  <D.25566>:
  goto <D.24796>;
  <D.25568>:
  if (0 != 0) goto <D.36388>; else goto <D.36389>;
  <D.36388>:
  code.2507 = code;
  code = code.2507 + 1;
  *code.2507 = 134;
  goto <D.36391>;
  <D.36389>:
  code.2508 = code;
  code = code.2508 + 1;
  *code.2508 = 135;
  <D.36391>:
  code.2509 = code;
  code = code.2509 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.36394 = D.32606 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.36395 = D.36394 | D.31586;
  D.36396 = (unsigned char) D.36395;
  *code.2509 = D.36396;
  goto <D.24796>;
  <D.25569>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.36397>; else goto <D.36398>;
  <D.36397>:
  code.2510 = code;
  code = code.2510 + 1;
  *code.2510 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 15;
        code.2511 = code;
        code = code.2511 + 1;
        D.36401 = imb.b[0];
        *code.2511 = D.36401;
        code.2512 = code;
        code = code.2512 + 1;
        D.36403 = imb.b[1];
        *code.2512 = D.36403;
        code.2513 = code;
        code = code.2513 + 1;
        D.36405 = imb.b[2];
        *code.2513 = D.36405;
        code.2514 = code;
        code = code.2514 + 1;
        D.36407 = imb.b[3];
        *code.2514 = D.36407;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25571>;
  <D.36398>:
  if (1 != 0) goto <D.36408>; else goto <D.36409>;
  <D.36408>:
  code.2515 = code;
  code = code.2515 + 1;
  *code.2515 = 131;
  code.2516 = code;
  code = code.2516 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.35265 = D.31586 | -64;
  D.35266 = (unsigned char) D.35265;
  *code.2516 = D.35266;
  *code = 15;
  code = code + 1;
  goto <D.36412>;
  <D.36409>:
  code.2517 = code;
  code = code.2517 + 1;
  *code.2517 = 129;
  code.2518 = code;
  code = code.2518 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.35265 = D.31586 | -64;
  D.35266 = (unsigned char) D.35265;
  *code.2518 = D.35266;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 15;
        code.2519 = code;
        code = code.2519 + 1;
        D.36416 = imb.b[0];
        *code.2519 = D.36416;
        code.2520 = code;
        code = code.2520 + 1;
        D.36418 = imb.b[1];
        *code.2520 = D.36418;
        code.2521 = code;
        code = code.2521 + 1;
        D.36420 = imb.b[2];
        *code.2521 = D.36420;
        code.2522 = code;
        code = code.2522 + 1;
        D.36422 = imb.b[3];
        *code.2522 = D.36422;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36412>:
  <D.25571>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.36423>; else goto <D.36424>;
  <D.36423>:
  code.2523 = code;
  code = code.2523 + 1;
  *code.2523 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.2524 = code;
        code = code.2524 + 1;
        D.36427 = imb.b[0];
        *code.2524 = D.36427;
        code.2525 = code;
        code = code.2525 + 1;
        D.36429 = imb.b[1];
        *code.2525 = D.36429;
        code.2526 = code;
        code = code.2526 + 1;
        D.36431 = imb.b[2];
        *code.2526 = D.36431;
        code.2527 = code;
        code = code.2527 + 1;
        D.36433 = imb.b[3];
        *code.2527 = D.36433;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25574>;
  <D.36424>:
  if (1 != 0) goto <D.36434>; else goto <D.36435>;
  <D.36434>:
  code.2528 = code;
  code = code.2528 + 1;
  *code.2528 = 131;
  code.2529 = code;
  code = code.2529 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.2529 = D.34069;
  *code = 240;
  code = code + 1;
  goto <D.36438>;
  <D.36435>:
  code.2530 = code;
  code = code.2530 + 1;
  *code.2530 = 129;
  code.2531 = code;
  code = code.2531 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.2531 = D.34069;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.2532 = code;
        code = code.2532 + 1;
        D.36442 = imb.b[0];
        *code.2532 = D.36442;
        code.2533 = code;
        code = code.2533 + 1;
        D.36444 = imb.b[1];
        *code.2533 = D.36444;
        code.2534 = code;
        code = code.2534 + 1;
        D.36446 = imb.b[2];
        *code.2534 = D.36446;
        code.2535 = code;
        code = code.2535 + 1;
        D.36448 = imb.b[3];
        *code.2535 = D.36448;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36438>:
  <D.25574>:
  code = mono_emit_stack_alloc (code, ins);
  switch (4) <default: <D.25580>, case 1: <D.25576>, case 2: <D.25578>, case 4: <D.25579>>
  <D.25576>:
  code.2536 = code;
  code = code.2536 + 1;
  *code.2536 = 138;
  goto <D.25577>;
  <D.25578>:
  code.2537 = code;
  code = code.2537 + 1;
  *code.2537 = 102;
  <D.25579>:
  code.2538 = code;
  code = code.2538 + 1;
  *code.2538 = 139;
  goto <D.25577>;
  <D.25580>:
  __assert_fail ("0", "mini-x86.c", 3446, &__PRETTY_FUNCTION__);
  <D.25577>:
  code.2539 = code;
  code = code.2539 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.36453 = D.32227 | -60;
  D.36454 = (unsigned char) D.36453;
  *code.2539 = D.36454;
  goto <D.24796>;
  <D.25581>:
  {
    guint32 size;

    D.31653 = ins->data.op[1].const_val;
    size = (guint32) D.31653;
    D.36455 = size + 15;
    size = D.36455 & 4294967280;
    D.33912 = ins->flags;
    D.33913 = (int) D.33912;
    D.33914 = D.33913 & 1;
    if (D.33914 != 0) goto <D.36456>; else goto <D.36457>;
    <D.36456>:
    code.2540 = code;
    code = code.2540 + 1;
    D.31604 = ins->dreg;
    D.33696 = (unsigned char) D.31604;
    D.35401 = D.33696 + 184;
    *code.2540 = D.35401;
    {
      union x86_imm_buf imb;

      try
        {
          size.2541 = (int) size;
          imb.val = size.2541;
          code.2542 = code;
          code = code.2542 + 1;
          D.36461 = imb.b[0];
          *code.2542 = D.36461;
          code.2543 = code;
          code = code.2543 + 1;
          D.36463 = imb.b[1];
          *code.2543 = D.36463;
          code.2544 = code;
          code = code.2544 + 1;
          D.36465 = imb.b[2];
          *code.2544 = D.36465;
          code.2545 = code;
          code = code.2545 + 1;
          D.36467 = imb.b[3];
          *code.2545 = D.36467;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    D.31604 = ins->dreg;
    ins->sreg1 = D.31604;
    code = mono_emit_stack_alloc (code, ins);
    switch (4) <default: <D.25588>, case 1: <D.25584>, case 2: <D.25586>, case 4: <D.25587>>
    <D.25584>:
    code.2546 = code;
    code = code.2546 + 1;
    *code.2546 = 138;
    goto <D.25585>;
    <D.25586>:
    code.2547 = code;
    code = code.2547 + 1;
    *code.2547 = 102;
    <D.25587>:
    code.2548 = code;
    code = code.2548 + 1;
    *code.2548 = 139;
    goto <D.25585>;
    <D.25588>:
    __assert_fail ("0", "mini-x86.c", 3458, &__PRETTY_FUNCTION__);
    <D.25585>:
    code.2549 = code;
    code = code.2549 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.36453 = D.32227 | -60;
    D.36454 = (unsigned char) D.36453;
    *code.2549 = D.36454;
    goto <D.36472>;
    <D.36457>:
    if (0 != 0) goto <D.36473>; else goto <D.36474>;
    <D.36473>:
    code.2550 = code;
    code = code.2550 + 1;
    *code.2550 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          size.2541 = (int) size;
          imb.val = size.2541;
          code.2551 = code;
          code = code.2551 + 1;
          D.36477 = imb.b[0];
          *code.2551 = D.36477;
          code.2552 = code;
          code = code.2552 + 1;
          D.36479 = imb.b[1];
          *code.2552 = D.36479;
          code.2553 = code;
          code = code.2553 + 1;
          D.36481 = imb.b[2];
          *code.2553 = D.36481;
          code.2554 = code;
          code = code.2554 + 1;
          D.36483 = imb.b[3];
          *code.2554 = D.36483;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.25590>;
    <D.36474>:
    size.2541 = (int) size;
    D.36484 = size.2541 >= -128;
    size.2541 = (int) size;
    D.36485 = size.2541 <= 127;
    D.36486 = D.36484 & D.36485;
    if (D.36486 != 0) goto <D.36487>; else goto <D.36488>;
    <D.36487>:
    code.2555 = code;
    code = code.2555 + 1;
    *code.2555 = 131;
    code.2556 = code;
    code = code.2556 + 1;
    *code.2556 = 236;
    D.36491 = (unsigned char) size;
    *code = D.36491;
    code = code + 1;
    goto <D.36492>;
    <D.36488>:
    code.2557 = code;
    code = code.2557 + 1;
    *code.2557 = 129;
    code.2558 = code;
    code = code.2558 + 1;
    *code.2558 = 236;
    {
      union x86_imm_buf imb;

      try
        {
          size.2541 = (int) size;
          imb.val = size.2541;
          code.2559 = code;
          code = code.2559 + 1;
          D.36496 = imb.b[0];
          *code.2559 = D.36496;
          code.2560 = code;
          code = code.2560 + 1;
          D.36498 = imb.b[1];
          *code.2560 = D.36498;
          code.2561 = code;
          code = code.2561 + 1;
          D.36500 = imb.b[2];
          *code.2561 = D.36500;
          code.2562 = code;
          code = code.2562 + 1;
          D.36502 = imb.b[3];
          *code.2562 = D.36502;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36492>:
    <D.25590>:
    switch (4) <default: <D.25596>, case 1: <D.25592>, case 2: <D.25594>, case 4: <D.25595>>
    <D.25592>:
    code.2563 = code;
    code = code.2563 + 1;
    *code.2563 = 138;
    goto <D.25593>;
    <D.25594>:
    code.2564 = code;
    code = code.2564 + 1;
    *code.2564 = 102;
    <D.25595>:
    code.2565 = code;
    code = code.2565 + 1;
    *code.2565 = 139;
    goto <D.25593>;
    <D.25596>:
    __assert_fail ("0", "mini-x86.c", 3461, &__PRETTY_FUNCTION__);
    <D.25593>:
    code.2566 = code;
    code = code.2566 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.36453 = D.32227 | -60;
    D.36454 = (unsigned char) D.36453;
    *code.2566 = D.36454;
    <D.36472>:
    goto <D.24796>;
  }
  <D.25597>:
  if (0 != 0) goto <D.36507>; else goto <D.36508>;
  <D.36507>:
  code.2567 = code;
  code = code.2567 + 1;
  *code.2567 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2568 = code;
        code = code.2568 + 1;
        D.36511 = imb.b[0];
        *code.2568 = D.36511;
        code.2569 = code;
        code = code.2569 + 1;
        D.36513 = imb.b[1];
        *code.2569 = D.36513;
        code.2570 = code;
        code = code.2570 + 1;
        D.36515 = imb.b[2];
        *code.2570 = D.36515;
        code.2571 = code;
        code = code.2571 + 1;
        D.36517 = imb.b[3];
        *code.2571 = D.36517;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25599>;
  <D.36508>:
  if (1 != 0) goto <D.36518>; else goto <D.36519>;
  <D.36518>:
  code.2572 = code;
  code = code.2572 + 1;
  *code.2572 = 131;
  code.2573 = code;
  code = code.2573 + 1;
  *code.2573 = 236;
  *code = 12;
  code = code + 1;
  goto <D.36522>;
  <D.36519>:
  code.2574 = code;
  code = code.2574 + 1;
  *code.2574 = 129;
  code.2575 = code;
  code = code.2575 + 1;
  *code.2575 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2576 = code;
        code = code.2576 + 1;
        D.36526 = imb.b[0];
        *code.2576 = D.36526;
        code.2577 = code;
        code = code.2577 + 1;
        D.36528 = imb.b[1];
        *code.2577 = D.36528;
        code.2578 = code;
        code = code.2578 + 1;
        D.36530 = imb.b[2];
        *code.2578 = D.36530;
        code.2579 = code;
        code = code.2579 + 1;
        D.36532 = imb.b[3];
        *code.2579 = D.36532;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36522>:
  <D.25599>:
  code.2580 = code;
  code = code.2580 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.2580 = D.36114;
  code = emit_call (cfg, code, 7, "mono_arch_throw_exception");
  D.33912 = ins->flags;
  D.35523 = D.33912 | 128;
  ins->flags = D.35523;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  goto <D.24796>;
  <D.25601>:
  if (0 != 0) goto <D.36534>; else goto <D.36535>;
  <D.36534>:
  code.2581 = code;
  code = code.2581 + 1;
  *code.2581 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2582 = code;
        code = code.2582 + 1;
        D.36538 = imb.b[0];
        *code.2582 = D.36538;
        code.2583 = code;
        code = code.2583 + 1;
        D.36540 = imb.b[1];
        *code.2583 = D.36540;
        code.2584 = code;
        code = code.2584 + 1;
        D.36542 = imb.b[2];
        *code.2584 = D.36542;
        code.2585 = code;
        code = code.2585 + 1;
        D.36544 = imb.b[3];
        *code.2585 = D.36544;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25603>;
  <D.36535>:
  if (1 != 0) goto <D.36545>; else goto <D.36546>;
  <D.36545>:
  code.2586 = code;
  code = code.2586 + 1;
  *code.2586 = 131;
  code.2587 = code;
  code = code.2587 + 1;
  *code.2587 = 236;
  *code = 12;
  code = code + 1;
  goto <D.36549>;
  <D.36546>:
  code.2588 = code;
  code = code.2588 + 1;
  *code.2588 = 129;
  code.2589 = code;
  code = code.2589 + 1;
  *code.2589 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2590 = code;
        code = code.2590 + 1;
        D.36553 = imb.b[0];
        *code.2590 = D.36553;
        code.2591 = code;
        code = code.2591 + 1;
        D.36555 = imb.b[1];
        *code.2591 = D.36555;
        code.2592 = code;
        code = code.2592 + 1;
        D.36557 = imb.b[2];
        *code.2592 = D.36557;
        code.2593 = code;
        code = code.2593 + 1;
        D.36559 = imb.b[3];
        *code.2593 = D.36559;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36549>:
  <D.25603>:
  code.2594 = code;
  code = code.2594 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.2594 = D.36114;
  code = emit_call (cfg, code, 7, "mono_arch_rethrow_exception");
  D.33912 = ins->flags;
  D.35523 = D.33912 | 128;
  ins->flags = D.35523;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  goto <D.24796>;
  <D.25605>:
  if (0 != 0) goto <D.36561>; else goto <D.36562>;
  <D.36561>:
  code.2595 = code;
  code = code.2595 + 1;
  *code.2595 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2596 = code;
        code = code.2596 + 1;
        D.36565 = imb.b[0];
        *code.2596 = D.36565;
        code.2597 = code;
        code = code.2597 + 1;
        D.36567 = imb.b[1];
        *code.2597 = D.36567;
        code.2598 = code;
        code = code.2598 + 1;
        D.36569 = imb.b[2];
        *code.2598 = D.36569;
        code.2599 = code;
        code = code.2599 + 1;
        D.36571 = imb.b[3];
        *code.2599 = D.36571;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25607>;
  <D.36562>:
  if (1 != 0) goto <D.36572>; else goto <D.36573>;
  <D.36572>:
  code.2600 = code;
  code = code.2600 + 1;
  *code.2600 = 131;
  code.2601 = code;
  code = code.2601 + 1;
  *code.2601 = 236;
  *code = 12;
  code = code + 1;
  goto <D.36576>;
  <D.36573>:
  code.2602 = code;
  code = code.2602 + 1;
  *code.2602 = 129;
  code.2603 = code;
  code = code.2603 + 1;
  *code.2603 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2604 = code;
        code = code.2604 + 1;
        D.36580 = imb.b[0];
        *code.2604 = D.36580;
        code.2605 = code;
        code = code.2605 + 1;
        D.36582 = imb.b[1];
        *code.2605 = D.36582;
        code.2606 = code;
        code = code.2606 + 1;
        D.36584 = imb.b[2];
        *code.2606 = D.36584;
        code.2607 = code;
        code = code.2607 + 1;
        D.36586 = imb.b[3];
        *code.2607 = D.36586;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36576>:
  <D.25607>:
  D.36587 = ins->data.op[0].target_block;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.36587);
  code.2608 = code;
  code = code.2608 + 1;
  *code.2608 = 232;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2609 = code;
        code = code.2609 + 1;
        D.36590 = imb.b[0];
        *code.2609 = D.36590;
        code.2610 = code;
        code = code.2610 + 1;
        D.36592 = imb.b[1];
        *code.2610 = D.36592;
        code.2611 = code;
        code = code.2611 + 1;
        D.36594 = imb.b[2];
        *code.2611 = D.36594;
        code.2612 = code;
        code = code.2612 + 1;
        D.36596 = imb.b[3];
        *code.2612 = D.36596;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.36597 = ins->data.op[1].exception_clause;
  mono_cfg_add_try_hole (cfg, D.36597, code, bb);
  if (0 != 0) goto <D.36598>; else goto <D.36599>;
  <D.36598>:
  code.2613 = code;
  code = code.2613 + 1;
  *code.2613 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2614 = code;
        code = code.2614 + 1;
        D.36602 = imb.b[0];
        *code.2614 = D.36602;
        code.2615 = code;
        code = code.2615 + 1;
        D.36604 = imb.b[1];
        *code.2615 = D.36604;
        code.2616 = code;
        code = code.2616 + 1;
        D.36606 = imb.b[2];
        *code.2616 = D.36606;
        code.2617 = code;
        code = code.2617 + 1;
        D.36608 = imb.b[3];
        *code.2617 = D.36608;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25611>;
  <D.36599>:
  if (1 != 0) goto <D.36609>; else goto <D.36610>;
  <D.36609>:
  code.2618 = code;
  code = code.2618 + 1;
  *code.2618 = 131;
  code.2619 = code;
  code = code.2619 + 1;
  *code.2619 = 196;
  *code = 12;
  code = code + 1;
  goto <D.36613>;
  <D.36610>:
  code.2620 = code;
  code = code.2620 + 1;
  *code.2620 = 129;
  code.2621 = code;
  code = code.2621 + 1;
  *code.2621 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 12;
        code.2622 = code;
        code = code.2622 + 1;
        D.36617 = imb.b[0];
        *code.2622 = D.36617;
        code.2623 = code;
        code = code.2623 + 1;
        D.36619 = imb.b[1];
        *code.2623 = D.36619;
        code.2624 = code;
        code = code.2624 + 1;
        D.36621 = imb.b[2];
        *code.2624 = D.36621;
        code.2625 = code;
        code = code.2625 + 1;
        D.36623 = imb.b[3];
        *code.2625 = D.36623;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36613>:
  <D.25611>:
  goto <D.24796>;
  <D.25613>:
  {
    struct MonoInst * spvar;

    D.36624 = bb->region;
    D.36625 = (int) D.36624;
    spvar = mono_find_spvar_for_region (cfg, D.36625);
    switch (4) <default: <D.25619>, case 1: <D.25615>, case 2: <D.25617>, case 4: <D.25618>>
    <D.25615>:
    code.2626 = code;
    code = code.2626 + 1;
    *code.2626 = 136;
    goto <D.25616>;
    <D.25617>:
    code.2627 = code;
    code = code.2627 + 1;
    *code.2627 = 102;
    <D.25618>:
    code.2628 = code;
    code = code.2628 + 1;
    *code.2628 = 137;
    goto <D.25616>;
    <D.25619>:
    __assert_fail ("0", "mini-x86.c", 3492, &__PRETTY_FUNCTION__);
    <D.25616>:
    D.36629 = spvar->sreg1;
    if (D.36629 == 4) goto <D.36630>; else goto <D.36631>;
    <D.36630>:
    D.36632 = spvar->data.op[0].const_val;
    if (D.36632 == 0) goto <D.36633>; else goto <D.36634>;
    <D.36633>:
    code.2629 = code;
    code = code.2629 + 1;
    *code.2629 = 36;
    code.2630 = code;
    code = code.2630 + 1;
    *code.2630 = 36;
    goto <D.36637>;
    <D.36634>:
    D.36632 = spvar->data.op[0].const_val;
    D.36638 = (unsigned int) D.36632;
    D.36639 = D.36638 + 128;
    if (D.36639 <= 255) goto <D.36640>; else goto <D.36641>;
    <D.36640>:
    code.2631 = code;
    code = code.2631 + 1;
    *code.2631 = 100;
    code.2632 = code;
    code = code.2632 + 1;
    *code.2632 = 36;
    D.36632 = spvar->data.op[0].const_val;
    D.36644 = (unsigned char) D.36632;
    *code = D.36644;
    code = code + 1;
    goto <D.36645>;
    <D.36641>:
    code.2633 = code;
    code = code.2633 + 1;
    *code.2633 = 164;
    code.2634 = code;
    code = code.2634 + 1;
    *code.2634 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.36632 = spvar->data.op[0].const_val;
          imb.val = D.36632;
          code.2635 = code;
          code = code.2635 + 1;
          D.36649 = imb.b[0];
          *code.2635 = D.36649;
          code.2636 = code;
          code = code.2636 + 1;
          D.36651 = imb.b[1];
          *code.2636 = D.36651;
          code.2637 = code;
          code = code.2637 + 1;
          D.36653 = imb.b[2];
          *code.2637 = D.36653;
          code.2638 = code;
          code = code.2638 + 1;
          D.36655 = imb.b[3];
          *code.2638 = D.36655;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36645>:
    <D.36637>:
    goto <D.25621>;
    <D.36631>:
    D.36632 = spvar->data.op[0].const_val;
    if (D.36632 == 0) goto <D.36656>; else goto <D.36657>;
    <D.36656>:
    D.36629 = spvar->sreg1;
    if (D.36629 != 5) goto <D.36658>; else goto <D.36659>;
    <D.36658>:
    code.2639 = code;
    code = code.2639 + 1;
    D.36629 = spvar->sreg1;
    D.36661 = (signed char) D.36629;
    D.36662 = D.36661 & 7;
    D.36663 = D.36662 | 32;
    D.36664 = (unsigned char) D.36663;
    *code.2639 = D.36664;
    goto <D.25621>;
    <D.36659>:
    <D.36657>:
    D.36632 = spvar->data.op[0].const_val;
    D.36638 = (unsigned int) D.36632;
    D.36639 = D.36638 + 128;
    if (D.36639 <= 255) goto <D.36665>; else goto <D.36666>;
    <D.36665>:
    code.2640 = code;
    code = code.2640 + 1;
    D.36629 = spvar->sreg1;
    D.36661 = (signed char) D.36629;
    D.36662 = D.36661 & 7;
    D.36668 = D.36662 | 96;
    D.36669 = (unsigned char) D.36668;
    *code.2640 = D.36669;
    D.36632 = spvar->data.op[0].const_val;
    D.36644 = (unsigned char) D.36632;
    *code = D.36644;
    code = code + 1;
    goto <D.36670>;
    <D.36666>:
    code.2641 = code;
    code = code.2641 + 1;
    D.36629 = spvar->sreg1;
    D.36661 = (signed char) D.36629;
    D.36662 = D.36661 & 7;
    D.36672 = D.36662 | -96;
    D.36673 = (unsigned char) D.36672;
    *code.2641 = D.36673;
    {
      union x86_imm_buf imb;

      try
        {
          D.36632 = spvar->data.op[0].const_val;
          imb.val = D.36632;
          code.2642 = code;
          code = code.2642 + 1;
          D.36675 = imb.b[0];
          *code.2642 = D.36675;
          code.2643 = code;
          code = code.2643 + 1;
          D.36677 = imb.b[1];
          *code.2643 = D.36677;
          code.2644 = code;
          code = code.2644 + 1;
          D.36679 = imb.b[2];
          *code.2644 = D.36679;
          code.2645 = code;
          code = code.2645 + 1;
          D.36681 = imb.b[3];
          *code.2645 = D.36681;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36670>:
    <D.25621>:
    goto <D.24796>;
  }
  <D.25623>:
  {
    struct MonoInst * spvar;

    D.36624 = bb->region;
    D.36625 = (int) D.36624;
    spvar = mono_find_spvar_for_region (cfg, D.36625);
    switch (4) <default: <D.25629>, case 1: <D.25625>, case 2: <D.25627>, case 4: <D.25628>>
    <D.25625>:
    code.2646 = code;
    code = code.2646 + 1;
    *code.2646 = 138;
    goto <D.25626>;
    <D.25627>:
    code.2647 = code;
    code = code.2647 + 1;
    *code.2647 = 102;
    <D.25628>:
    code.2648 = code;
    code = code.2648 + 1;
    *code.2648 = 139;
    goto <D.25626>;
    <D.25629>:
    __assert_fail ("0", "mini-x86.c", 3497, &__PRETTY_FUNCTION__);
    <D.25626>:
    D.36685 = spvar->sreg1;
    if (D.36685 == 4) goto <D.36686>; else goto <D.36687>;
    <D.36686>:
    D.36688 = spvar->data.op[0].const_val;
    if (D.36688 == 0) goto <D.36689>; else goto <D.36690>;
    <D.36689>:
    code.2649 = code;
    code = code.2649 + 1;
    *code.2649 = 36;
    code.2650 = code;
    code = code.2650 + 1;
    *code.2650 = 36;
    goto <D.36693>;
    <D.36690>:
    D.36688 = spvar->data.op[0].const_val;
    D.36694 = (unsigned int) D.36688;
    D.36695 = D.36694 + 128;
    if (D.36695 <= 255) goto <D.36696>; else goto <D.36697>;
    <D.36696>:
    code.2651 = code;
    code = code.2651 + 1;
    *code.2651 = 100;
    code.2652 = code;
    code = code.2652 + 1;
    *code.2652 = 36;
    D.36688 = spvar->data.op[0].const_val;
    D.36700 = (unsigned char) D.36688;
    *code = D.36700;
    code = code + 1;
    goto <D.36701>;
    <D.36697>:
    code.2653 = code;
    code = code.2653 + 1;
    *code.2653 = 164;
    code.2654 = code;
    code = code.2654 + 1;
    *code.2654 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.36688 = spvar->data.op[0].const_val;
          imb.val = D.36688;
          code.2655 = code;
          code = code.2655 + 1;
          D.36705 = imb.b[0];
          *code.2655 = D.36705;
          code.2656 = code;
          code = code.2656 + 1;
          D.36707 = imb.b[1];
          *code.2656 = D.36707;
          code.2657 = code;
          code = code.2657 + 1;
          D.36709 = imb.b[2];
          *code.2657 = D.36709;
          code.2658 = code;
          code = code.2658 + 1;
          D.36711 = imb.b[3];
          *code.2658 = D.36711;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36701>:
    <D.36693>:
    goto <D.25631>;
    <D.36687>:
    D.36688 = spvar->data.op[0].const_val;
    if (D.36688 == 0) goto <D.36712>; else goto <D.36713>;
    <D.36712>:
    D.36685 = spvar->sreg1;
    if (D.36685 != 5) goto <D.36714>; else goto <D.36715>;
    <D.36714>:
    code.2659 = code;
    code = code.2659 + 1;
    D.36685 = spvar->sreg1;
    D.36717 = (signed char) D.36685;
    D.36718 = D.36717 & 7;
    D.36719 = D.36718 | 32;
    D.36720 = (unsigned char) D.36719;
    *code.2659 = D.36720;
    goto <D.25631>;
    <D.36715>:
    <D.36713>:
    D.36688 = spvar->data.op[0].const_val;
    D.36694 = (unsigned int) D.36688;
    D.36695 = D.36694 + 128;
    if (D.36695 <= 255) goto <D.36721>; else goto <D.36722>;
    <D.36721>:
    code.2660 = code;
    code = code.2660 + 1;
    D.36685 = spvar->sreg1;
    D.36717 = (signed char) D.36685;
    D.36718 = D.36717 & 7;
    D.36724 = D.36718 | 96;
    D.36725 = (unsigned char) D.36724;
    *code.2660 = D.36725;
    D.36688 = spvar->data.op[0].const_val;
    D.36700 = (unsigned char) D.36688;
    *code = D.36700;
    code = code + 1;
    goto <D.36726>;
    <D.36722>:
    code.2661 = code;
    code = code.2661 + 1;
    D.36685 = spvar->sreg1;
    D.36717 = (signed char) D.36685;
    D.36718 = D.36717 & 7;
    D.36728 = D.36718 | -96;
    D.36729 = (unsigned char) D.36728;
    *code.2661 = D.36729;
    {
      union x86_imm_buf imb;

      try
        {
          D.36688 = spvar->data.op[0].const_val;
          imb.val = D.36688;
          code.2662 = code;
          code = code.2662 + 1;
          D.36731 = imb.b[0];
          *code.2662 = D.36731;
          code.2663 = code;
          code = code.2663 + 1;
          D.36733 = imb.b[1];
          *code.2663 = D.36733;
          code.2664 = code;
          code = code.2664 + 1;
          D.36735 = imb.b[2];
          *code.2664 = D.36735;
          code.2665 = code;
          code = code.2665 + 1;
          D.36737 = imb.b[3];
          *code.2665 = D.36737;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36726>:
    <D.25631>:
    code.2666 = code;
    code = code.2666 + 1;
    *code.2666 = 195;
    goto <D.24796>;
  }
  <D.25633>:
  {
    struct MonoInst * spvar;

    D.36624 = bb->region;
    D.36625 = (int) D.36624;
    spvar = mono_find_spvar_for_region (cfg, D.36625);
    switch (4) <default: <D.25639>, case 1: <D.25635>, case 2: <D.25637>, case 4: <D.25638>>
    <D.25635>:
    code.2667 = code;
    code = code.2667 + 1;
    *code.2667 = 138;
    goto <D.25636>;
    <D.25637>:
    code.2668 = code;
    code = code.2668 + 1;
    *code.2668 = 102;
    <D.25638>:
    code.2669 = code;
    code = code.2669 + 1;
    *code.2669 = 139;
    goto <D.25636>;
    <D.25639>:
    __assert_fail ("0", "mini-x86.c", 3503, &__PRETTY_FUNCTION__);
    <D.25636>:
    D.36742 = spvar->sreg1;
    if (D.36742 == 4) goto <D.36743>; else goto <D.36744>;
    <D.36743>:
    D.36745 = spvar->data.op[0].const_val;
    if (D.36745 == 0) goto <D.36746>; else goto <D.36747>;
    <D.36746>:
    code.2670 = code;
    code = code.2670 + 1;
    *code.2670 = 36;
    code.2671 = code;
    code = code.2671 + 1;
    *code.2671 = 36;
    goto <D.36750>;
    <D.36747>:
    D.36745 = spvar->data.op[0].const_val;
    D.36751 = (unsigned int) D.36745;
    D.36752 = D.36751 + 128;
    if (D.36752 <= 255) goto <D.36753>; else goto <D.36754>;
    <D.36753>:
    code.2672 = code;
    code = code.2672 + 1;
    *code.2672 = 100;
    code.2673 = code;
    code = code.2673 + 1;
    *code.2673 = 36;
    D.36745 = spvar->data.op[0].const_val;
    D.36757 = (unsigned char) D.36745;
    *code = D.36757;
    code = code + 1;
    goto <D.36758>;
    <D.36754>:
    code.2674 = code;
    code = code.2674 + 1;
    *code.2674 = 164;
    code.2675 = code;
    code = code.2675 + 1;
    *code.2675 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.36745 = spvar->data.op[0].const_val;
          imb.val = D.36745;
          code.2676 = code;
          code = code.2676 + 1;
          D.36762 = imb.b[0];
          *code.2676 = D.36762;
          code.2677 = code;
          code = code.2677 + 1;
          D.36764 = imb.b[1];
          *code.2677 = D.36764;
          code.2678 = code;
          code = code.2678 + 1;
          D.36766 = imb.b[2];
          *code.2678 = D.36766;
          code.2679 = code;
          code = code.2679 + 1;
          D.36768 = imb.b[3];
          *code.2679 = D.36768;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36758>:
    <D.36750>:
    goto <D.25641>;
    <D.36744>:
    D.36745 = spvar->data.op[0].const_val;
    if (D.36745 == 0) goto <D.36769>; else goto <D.36770>;
    <D.36769>:
    D.36742 = spvar->sreg1;
    if (D.36742 != 5) goto <D.36771>; else goto <D.36772>;
    <D.36771>:
    code.2680 = code;
    code = code.2680 + 1;
    D.36742 = spvar->sreg1;
    D.36774 = (signed char) D.36742;
    D.36775 = D.36774 & 7;
    D.36776 = D.36775 | 32;
    D.36777 = (unsigned char) D.36776;
    *code.2680 = D.36777;
    goto <D.25641>;
    <D.36772>:
    <D.36770>:
    D.36745 = spvar->data.op[0].const_val;
    D.36751 = (unsigned int) D.36745;
    D.36752 = D.36751 + 128;
    if (D.36752 <= 255) goto <D.36778>; else goto <D.36779>;
    <D.36778>:
    code.2681 = code;
    code = code.2681 + 1;
    D.36742 = spvar->sreg1;
    D.36774 = (signed char) D.36742;
    D.36775 = D.36774 & 7;
    D.36781 = D.36775 | 96;
    D.36782 = (unsigned char) D.36781;
    *code.2681 = D.36782;
    D.36745 = spvar->data.op[0].const_val;
    D.36757 = (unsigned char) D.36745;
    *code = D.36757;
    code = code + 1;
    goto <D.36783>;
    <D.36779>:
    code.2682 = code;
    code = code.2682 + 1;
    D.36742 = spvar->sreg1;
    D.36774 = (signed char) D.36742;
    D.36775 = D.36774 & 7;
    D.36785 = D.36775 | -96;
    D.36786 = (unsigned char) D.36785;
    *code.2682 = D.36786;
    {
      union x86_imm_buf imb;

      try
        {
          D.36745 = spvar->data.op[0].const_val;
          imb.val = D.36745;
          code.2683 = code;
          code = code.2683 + 1;
          D.36788 = imb.b[0];
          *code.2683 = D.36788;
          code.2684 = code;
          code = code.2684 + 1;
          D.36790 = imb.b[1];
          *code.2684 = D.36790;
          code.2685 = code;
          code = code.2685 + 1;
          D.36792 = imb.b[2];
          *code.2685 = D.36792;
          code.2686 = code;
          code = code.2686 + 1;
          D.36794 = imb.b[3];
          *code.2686 = D.36794;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36783>:
    <D.25641>:
    code.2687 = code;
    code = code.2687 + 1;
    *code.2687 = 195;
    goto <D.24796>;
  }
  <D.25643>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->data.op[0].const_val = D.31489;
  goto <D.24796>;
  <D.25644>:
  D.36587 = ins->data.op[0].target_block;
  D.36796 = D.36587->native_offset;
  if (D.36796 != 0) goto <D.36797>; else goto <D.36798>;
  <D.36797>:
  {
    int t;

    D.31409 = cfg->native_code;
    D.36587 = ins->data.op[0].target_block;
    D.36796 = D.36587->native_offset;
    D.36799 = (sizetype) D.36796;
    D.36800 = D.31409 + D.36799;
    D.36801 = (int) D.36800;
    code.422 = (int) code;
    D.36802 = D.36801 - code.422;
    t = D.36802 + -2;
    t.2688 = (unsigned int) t;
    D.36804 = t.2688 + 128;
    if (D.36804 <= 255) goto <D.36805>; else goto <D.36806>;
    <D.36805>:
    code.2689 = code;
    code = code.2689 + 1;
    *code.2689 = 235;
    D.36808 = (unsigned char) t;
    *code = D.36808;
    code = code + 1;
    goto <D.36809>;
    <D.36806>:
    D.31409 = cfg->native_code;
    D.36587 = ins->data.op[0].target_block;
    D.36796 = D.36587->native_offset;
    D.36799 = (sizetype) D.36796;
    D.36800 = D.31409 + D.36799;
    D.36801 = (int) D.36800;
    code.422 = (int) code;
    D.36802 = D.36801 - code.422;
    t = D.36802 + -5;
    code.2690 = code;
    code = code.2690 + 1;
    *code.2690 = 233;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = t;
          code.2691 = code;
          code = code.2691 + 1;
          D.36812 = imb.b[0];
          *code.2691 = D.36812;
          code.2692 = code;
          code = code.2692 + 1;
          D.36814 = imb.b[1];
          *code.2692 = D.36814;
          code.2693 = code;
          code = code.2693 + 1;
          D.36816 = imb.b[2];
          *code.2693 = D.36816;
          code.2694 = code;
          code = code.2694 + 1;
          D.36818 = imb.b[3];
          *code.2694 = D.36818;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36809>:
  }
  goto <D.36819>;
  <D.36798>:
  D.36587 = ins->data.op[0].target_block;
  offset.2097 = (int) offset;
  mono_add_patch_info (cfg, offset.2097, 0, D.36587);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.36822>; else goto <D.36820>;
  <D.36822>:
  D.36587 = ins->data.op[0].target_block;
  D.36823 = D.36587->max_offset;
  D.36824 = D.36823 - cpos;
  D.36825 = (unsigned int) D.36824;
  D.36826 = D.36825 + 128;
  if (D.36826 <= 255) goto <D.36827>; else goto <D.36820>;
  <D.36827>:
  code.2695 = code;
  code = code.2695 + 1;
  *code.2695 = 235;
  *code = 0;
  code = code + 1;
  goto <D.36821>;
  <D.36820>:
  code.2696 = code;
  code = code.2696 + 1;
  *code.2696 = 233;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2697 = code;
        code = code.2697 + 1;
        D.36831 = imb.b[0];
        *code.2697 = D.36831;
        code.2698 = code;
        code = code.2698 + 1;
        D.36833 = imb.b[1];
        *code.2698 = D.36833;
        code.2699 = code;
        code = code.2699 + 1;
        D.36835 = imb.b[2];
        *code.2699 = D.36835;
        code.2700 = code;
        code = code.2700 + 1;
        D.36837 = imb.b[3];
        *code.2700 = D.36837;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36821>:
  <D.36819>:
  goto <D.24796>;
  <D.25648>:
  code.2701 = code;
  code = code.2701 + 1;
  *code.2701 = 255;
  code.2702 = code;
  code = code.2702 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.2702 = D.34069;
  goto <D.24796>;
  <D.25649>:
  <D.25650>:
  <D.25651>:
  <D.25652>:
  <D.25653>:
  <D.25654>:
  <D.25655>:
  <D.25656>:
  <D.25657>:
  <D.25658>:
  <D.25659>:
  <D.25660>:
  <D.25661>:
  <D.25662>:
  <D.25663>:
  <D.25664>:
  D.31604 = ins->dreg;
  D.36840 = D.31604 > 3;
  D.36841 = (long int) D.36840;
  D.36842 = __builtin_expect (D.36841, 0);
  if (D.36842 != 0) goto <D.36843>; else goto <D.36844>;
  <D.36843>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3544, "X86_IS_BYTE_REG (ins->dreg)");
  <D.36844>:
  code.2703 = code;
  code = code.2703 + 1;
  *code.2703 = 15;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.36846 = mono_opcode_to_cond (D.31502);
  D.36847 = cc_signed_table[D.36846];
  if (D.36847 != 0) goto <D.36848>; else goto <D.36849>;
  <D.36848>:
  code.2704 = code;
  code = code.2704 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.36851 = mono_opcode_to_cond (D.31502);
  D.36852 = cc_table[D.36851];
  D.36853 = x86_cc_signed_map[D.36852];
  D.36854 = D.36853 + 32;
  *code.2704 = D.36854;
  goto <D.36855>;
  <D.36849>:
  code.2705 = code;
  code = code.2705 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.36857 = mono_opcode_to_cond (D.31502);
  D.36858 = cc_table[D.36857];
  D.36859 = x86_cc_unsigned_map[D.36858];
  D.36860 = D.36859 + 32;
  *code.2705 = D.36860;
  <D.36855>:
  code.2706 = code;
  code = code.2706 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.2706 = D.33951;
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.36862>; else goto <D.36863>;
    <D.36862>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3545, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.36863>:
    code.2707 = code;
    code = code.2707 + 1;
    *code.2707 = 15;
    if (0 != 0) goto <D.36865>; else goto <D.36866>;
    <D.36865>:
    op = op + 8;
    <D.36866>:
    if (0 != 0) goto <D.36867>; else goto <D.36868>;
    <D.36867>:
    op = op + 1;
    <D.36868>:
    code.2708 = code;
    code = code.2708 + 1;
    *code.2708 = op;
    code.2709 = code;
    code = code.2709 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.2709 = D.34303;
  }
  goto <D.24796>;
  <D.25666>:
  <D.25667>:
  <D.25668>:
  <D.25669>:
  <D.25670>:
  <D.25671>:
  <D.25672>:
  <D.25673>:
  <D.25674>:
  <D.25675>:
  <D.25676>:
  <D.25677>:
  <D.25678>:
  <D.25679>:
  <D.25680>:
  <D.25681>:
  <D.25682>:
  <D.25683>:
  <D.25684>:
  <D.25685>:
  {
    struct MonoInst * tins;

    D.36871 = ins->data.op[1].p;
    tins = mono_branch_optimize_exception_target (cfg, bb, D.36871);
    if (tins == 0B) goto <D.36872>; else goto <D.36873>;
    <D.36872>:
    D.36871 = ins->data.op[1].p;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 9, D.36871);
    code.2710 = code;
    code = code.2710 + 1;
    *code.2710 = 15;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.36875 = mono_opcode_to_cond (D.31502);
    D.36876 = cc_signed_table[D.36875];
    if (D.36876 != 0) goto <D.36877>; else goto <D.36878>;
    <D.36877>:
    code.2711 = code;
    code = code.2711 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.36880 = mono_opcode_to_cond (D.31502);
    D.36881 = cc_table[D.36880];
    D.36882 = x86_cc_signed_map[D.36881];
    D.36883 = D.36882 + 16;
    *code.2711 = D.36883;
    goto <D.36884>;
    <D.36878>:
    code.2712 = code;
    code = code.2712 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.36886 = mono_opcode_to_cond (D.31502);
    D.36887 = cc_table[D.36886];
    D.36888 = x86_cc_unsigned_map[D.36887];
    D.36889 = D.36888 + 16;
    *code.2712 = D.36889;
    <D.36884>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2713 = code;
          code = code.2713 + 1;
          D.36891 = imb.b[0];
          *code.2713 = D.36891;
          code.2714 = code;
          code = code.2714 + 1;
          D.36893 = imb.b[1];
          *code.2714 = D.36893;
          code.2715 = code;
          code = code.2715 + 1;
          D.36895 = imb.b[2];
          *code.2715 = D.36895;
          code.2716 = code;
          code = code.2716 + 1;
          D.36897 = imb.b[3];
          *code.2716 = D.36897;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.36898>;
    <D.36873>:
    D.36899 = tins->data.op[1].many_blocks;
    D.36900 = *D.36899;
    D.36901 = D.36900->native_offset;
    if (D.36901 != 0) goto <D.36902>; else goto <D.36903>;
    <D.36902>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.36899 = tins->data.op[1].many_blocks;
      D.36900 = *D.36899;
      D.36901 = D.36900->native_offset;
      D.36904 = (sizetype) D.36901;
      D.36905 = D.31409 + D.36904;
      D.36906 = (int) D.36905;
      code.422 = (int) code;
      D.36907 = D.36906 - code.422;
      offset = D.36907 + -2;
      branch_start = code;
      offset.2717 = (unsigned int) offset;
      D.36909 = offset.2717 + 128;
      if (D.36909 <= 255) goto <D.36910>; else goto <D.36911>;
      <D.36910>:
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.36912 = mono_opcode_to_cond (D.31502);
      D.36913 = cc_signed_table[D.36912];
      if (D.36913 != 0) goto <D.36914>; else goto <D.36915>;
      <D.36914>:
      code.2718 = code;
      code = code.2718 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.36917 = mono_opcode_to_cond (D.31502);
      D.36918 = cc_table[D.36917];
      D.36919 = x86_cc_signed_map[D.36918];
      *code.2718 = D.36919;
      goto <D.36920>;
      <D.36915>:
      code.2719 = code;
      code = code.2719 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.36922 = mono_opcode_to_cond (D.31502);
      D.36923 = cc_table[D.36922];
      D.36924 = x86_cc_unsigned_map[D.36923];
      *code.2719 = D.36924;
      <D.36920>:
      D.36925 = (unsigned char) offset;
      *code = D.36925;
      code = code + 1;
      goto <D.36926>;
      <D.36911>:
      D.31409 = cfg->native_code;
      D.36899 = tins->data.op[1].many_blocks;
      D.36900 = *D.36899;
      D.36901 = D.36900->native_offset;
      D.36904 = (sizetype) D.36901;
      D.36905 = D.31409 + D.36904;
      D.36906 = (int) D.36905;
      code.422 = (int) code;
      D.36907 = D.36906 - code.422;
      offset = D.36907 + -6;
      code.2720 = code;
      code = code.2720 + 1;
      *code.2720 = 15;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.36928 = mono_opcode_to_cond (D.31502);
      D.36929 = cc_signed_table[D.36928];
      if (D.36929 != 0) goto <D.36930>; else goto <D.36931>;
      <D.36930>:
      code.2721 = code;
      code = code.2721 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.36933 = mono_opcode_to_cond (D.31502);
      D.36934 = cc_table[D.36933];
      D.36935 = x86_cc_signed_map[D.36934];
      D.36936 = D.36935 + 16;
      *code.2721 = D.36936;
      goto <D.36937>;
      <D.36931>:
      code.2722 = code;
      code = code.2722 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.36939 = mono_opcode_to_cond (D.31502);
      D.36940 = cc_table[D.36939];
      D.36941 = x86_cc_unsigned_map[D.36940];
      D.36942 = D.36941 + 16;
      *code.2722 = D.36942;
      <D.36937>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.2723 = code;
            code = code.2723 + 1;
            D.36944 = imb.b[0];
            *code.2723 = D.36944;
            code.2724 = code;
            code = code.2724 + 1;
            D.36946 = imb.b[1];
            *code.2724 = D.36946;
            code.2725 = code;
            code = code.2725 + 1;
            D.36948 = imb.b[2];
            *code.2725 = D.36948;
            code.2726 = code;
            code = code.2726 + 1;
            D.36950 = imb.b[3];
            *code.2726 = D.36950;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36926>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.36951 = MEM[(unsigned char *)branch_start];
        D.36952 = (int) D.36951;
        switch (D.36952) <default: <D.25718>, case 15: <D.25697>, case 112: <D.25702>, case 113: <D.25703>, case 114: <D.25704>, case 115: <D.25705>, case 116: <D.25706>, case 117: <D.25707>, case 118: <D.25708>, case 119: <D.25709>, case 120: <D.25710>, case 121: <D.25711>, case 122: <D.25712>, case 123: <D.25713>, case 124: <D.25714>, case 125: <D.25715>, case 126: <D.25716>, case 127: <D.25717>, case 224: <D.25698>, case 225: <D.25699>, case 226: <D.25700>, case 232: <D.25694>, case 233: <D.25695>, case 235: <D.25701>>
        <D.25694>:
        <D.25695>:
        size = size + 1;
        goto <D.25696>;
        <D.25697>:
        D.36953 = *pos;
        D.36954 = D.36953 + 144;
        if (D.36954 > 31) goto <D.36955>; else goto <D.36956>;
        <D.36955>:
        __assert_fail ("0", "mini-x86.c", 3567, &__PRETTY_FUNCTION__);
        <D.36956>:
        size = size + 1;
        pos = pos + 1;
        goto <D.25696>;
        <D.25698>:
        <D.25699>:
        <D.25700>:
        <D.25701>:
        <D.25702>:
        <D.25703>:
        <D.25704>:
        <D.25705>:
        <D.25706>:
        <D.25707>:
        <D.25708>:
        <D.25709>:
        <D.25710>:
        <D.25711>:
        <D.25712>:
        <D.25713>:
        <D.25714>:
        <D.25715>:
        <D.25716>:
        <D.25717>:
        goto <D.25696>;
        <D.25718>:
        __assert_fail ("0", "mini-x86.c", 3567, &__PRETTY_FUNCTION__);
        <D.25696>:
        D.31409 = cfg->native_code;
        D.36899 = tins->data.op[1].many_blocks;
        D.36900 = *D.36899;
        D.36901 = D.36900->native_offset;
        D.36904 = (sizetype) D.36901;
        D.36905 = D.31409 + D.36904;
        D.36906 = (int) D.36905;
        pos.2727 = (int) pos;
        disp = D.36906 - pos.2727;
        if (size != 0) goto <D.36958>; else goto <D.36959>;
        <D.36958>:
        {
          union x86_imm_buf imb;

          try
            {
              D.36960 = disp + -4;
              imb.val = D.36960;
              pos.2728 = pos;
              pos = pos.2728 + 1;
              D.36962 = imb.b[0];
              *pos.2728 = D.36962;
              pos.2729 = pos;
              pos = pos.2729 + 1;
              D.36964 = imb.b[1];
              *pos.2729 = D.36964;
              pos.2730 = pos;
              pos = pos.2730 + 1;
              D.36966 = imb.b[2];
              *pos.2730 = D.36966;
              pos.2731 = pos;
              pos = pos.2731 + 1;
              D.36968 = imb.b[3];
              *pos.2731 = D.36968;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.36969>;
        <D.36959>:
        disp.2732 = (unsigned int) disp;
        D.36971 = disp.2732 + 127;
        if (D.36971 <= 255) goto <D.36972>; else goto <D.36973>;
        <D.36972>:
        D.36974 = (unsigned char) disp;
        D.36975 = D.36974 + 255;
        *pos = D.36975;
        pos = pos + 1;
        goto <D.36976>;
        <D.36973>:
        __assert_fail ("0", "mini-x86.c", 3567, &__PRETTY_FUNCTION__);
        <D.36976>:
        <D.36969>:
      }
    }
    goto <D.36977>;
    <D.36903>:
    D.36899 = tins->data.op[1].many_blocks;
    D.36900 = *D.36899;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.36900);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.36980>; else goto <D.36978>;
    <D.36980>:
    D.36899 = tins->data.op[1].many_blocks;
    D.36900 = *D.36899;
    D.36981 = D.36900->max_offset;
    D.36982 = D.36981 - cpos;
    D.36983 = (unsigned int) D.36982;
    D.36984 = D.36983 + 128;
    if (D.36984 <= 255) goto <D.36985>; else goto <D.36978>;
    <D.36985>:
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.36986 = mono_opcode_to_cond (D.31502);
    D.36987 = cc_signed_table[D.36986];
    if (D.36987 != 0) goto <D.36988>; else goto <D.36989>;
    <D.36988>:
    code.2733 = code;
    code = code.2733 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.36991 = mono_opcode_to_cond (D.31502);
    D.36992 = cc_table[D.36991];
    D.36993 = x86_cc_signed_map[D.36992];
    *code.2733 = D.36993;
    goto <D.36994>;
    <D.36989>:
    code.2734 = code;
    code = code.2734 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.36996 = mono_opcode_to_cond (D.31502);
    D.36997 = cc_table[D.36996];
    D.36998 = x86_cc_unsigned_map[D.36997];
    *code.2734 = D.36998;
    <D.36994>:
    *code = 0;
    code = code + 1;
    goto <D.36979>;
    <D.36978>:
    code.2735 = code;
    code = code.2735 + 1;
    *code.2735 = 15;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37000 = mono_opcode_to_cond (D.31502);
    D.37001 = cc_signed_table[D.37000];
    if (D.37001 != 0) goto <D.37002>; else goto <D.37003>;
    <D.37002>:
    code.2736 = code;
    code = code.2736 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37005 = mono_opcode_to_cond (D.31502);
    D.37006 = cc_table[D.37005];
    D.37007 = x86_cc_signed_map[D.37006];
    D.37008 = D.37007 + 16;
    *code.2736 = D.37008;
    goto <D.37009>;
    <D.37003>:
    code.2737 = code;
    code = code.2737 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37011 = mono_opcode_to_cond (D.31502);
    D.37012 = cc_table[D.37011];
    D.37013 = x86_cc_unsigned_map[D.37012];
    D.37014 = D.37013 + 16;
    *code.2737 = D.37014;
    <D.37009>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2738 = code;
          code = code.2738 + 1;
          D.37016 = imb.b[0];
          *code.2738 = D.37016;
          code.2739 = code;
          code = code.2739 + 1;
          D.37018 = imb.b[1];
          *code.2739 = D.37018;
          code.2740 = code;
          code = code.2740 + 1;
          D.37020 = imb.b[2];
          *code.2740 = D.37020;
          code.2741 = code;
          code = code.2741 + 1;
          D.37022 = imb.b[3];
          *code.2741 = D.37022;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.36979>:
    <D.36977>:
    <D.36898>:
  }
  goto <D.24796>;
  <D.25721>:
  <D.25722>:
  <D.25723>:
  <D.25724>:
  {
    struct MonoInst * tins;

    D.36871 = ins->data.op[1].p;
    tins = mono_branch_optimize_exception_target (cfg, bb, D.36871);
    if (tins == 0B) goto <D.37023>; else goto <D.37024>;
    <D.37023>:
    D.36871 = ins->data.op[1].p;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 9, D.36871);
    code.2742 = code;
    code = code.2742 + 1;
    *code.2742 = 15;
    D.31501 = ins->opcode;
    if (D.31501 <= 459) goto <D.37026>; else goto <D.37027>;
    <D.37026>:
    code.2743 = code;
    code = code.2743 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37029 = D.31502 + -455;
    D.37030 = branch_cc_table[D.37029];
    D.37031 = x86_cc_signed_map[D.37030];
    D.37032 = D.37031 + 16;
    *code.2743 = D.37032;
    goto <D.37033>;
    <D.37027>:
    code.2744 = code;
    code = code.2744 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37029 = D.31502 + -455;
    D.37030 = branch_cc_table[D.37029];
    D.37035 = x86_cc_unsigned_map[D.37030];
    D.37036 = D.37035 + 16;
    *code.2744 = D.37036;
    <D.37033>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2745 = code;
          code = code.2745 + 1;
          D.37038 = imb.b[0];
          *code.2745 = D.37038;
          code.2746 = code;
          code = code.2746 + 1;
          D.37040 = imb.b[1];
          *code.2746 = D.37040;
          code.2747 = code;
          code = code.2747 + 1;
          D.37042 = imb.b[2];
          *code.2747 = D.37042;
          code.2748 = code;
          code = code.2748 + 1;
          D.37044 = imb.b[3];
          *code.2748 = D.37044;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37045>;
    <D.37024>:
    D.37046 = tins->data.op[1].many_blocks;
    D.37047 = *D.37046;
    D.37048 = D.37047->native_offset;
    if (D.37048 != 0) goto <D.37049>; else goto <D.37050>;
    <D.37049>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.37046 = tins->data.op[1].many_blocks;
      D.37047 = *D.37046;
      D.37048 = D.37047->native_offset;
      D.37051 = (sizetype) D.37048;
      D.37052 = D.31409 + D.37051;
      D.37053 = (int) D.37052;
      code.422 = (int) code;
      D.37054 = D.37053 - code.422;
      offset = D.37054 + -2;
      branch_start = code;
      offset.2749 = (unsigned int) offset;
      D.37056 = offset.2749 + 128;
      if (D.37056 <= 255) goto <D.37057>; else goto <D.37058>;
      <D.37057>:
      D.31501 = ins->opcode;
      if (D.31501 <= 459) goto <D.37059>; else goto <D.37060>;
      <D.37059>:
      code.2750 = code;
      code = code.2750 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37029 = D.31502 + -455;
      D.37030 = branch_cc_table[D.37029];
      D.37031 = x86_cc_signed_map[D.37030];
      *code.2750 = D.37031;
      goto <D.37062>;
      <D.37060>:
      code.2751 = code;
      code = code.2751 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37029 = D.31502 + -455;
      D.37030 = branch_cc_table[D.37029];
      D.37035 = x86_cc_unsigned_map[D.37030];
      *code.2751 = D.37035;
      <D.37062>:
      D.37064 = (unsigned char) offset;
      *code = D.37064;
      code = code + 1;
      goto <D.37065>;
      <D.37058>:
      D.31409 = cfg->native_code;
      D.37046 = tins->data.op[1].many_blocks;
      D.37047 = *D.37046;
      D.37048 = D.37047->native_offset;
      D.37051 = (sizetype) D.37048;
      D.37052 = D.31409 + D.37051;
      D.37053 = (int) D.37052;
      code.422 = (int) code;
      D.37054 = D.37053 - code.422;
      offset = D.37054 + -6;
      code.2752 = code;
      code = code.2752 + 1;
      *code.2752 = 15;
      D.31501 = ins->opcode;
      if (D.31501 <= 459) goto <D.37067>; else goto <D.37068>;
      <D.37067>:
      code.2753 = code;
      code = code.2753 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37029 = D.31502 + -455;
      D.37030 = branch_cc_table[D.37029];
      D.37031 = x86_cc_signed_map[D.37030];
      D.37032 = D.37031 + 16;
      *code.2753 = D.37032;
      goto <D.37070>;
      <D.37068>:
      code.2754 = code;
      code = code.2754 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37029 = D.31502 + -455;
      D.37030 = branch_cc_table[D.37029];
      D.37035 = x86_cc_unsigned_map[D.37030];
      D.37036 = D.37035 + 16;
      *code.2754 = D.37036;
      <D.37070>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.2755 = code;
            code = code.2755 + 1;
            D.37073 = imb.b[0];
            *code.2755 = D.37073;
            code.2756 = code;
            code = code.2756 + 1;
            D.37075 = imb.b[1];
            *code.2756 = D.37075;
            code.2757 = code;
            code = code.2757 + 1;
            D.37077 = imb.b[2];
            *code.2757 = D.37077;
            code.2758 = code;
            code = code.2758 + 1;
            D.37079 = imb.b[3];
            *code.2758 = D.37079;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37065>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.37080 = MEM[(unsigned char *)branch_start];
        D.37081 = (int) D.37080;
        switch (D.37081) <default: <D.25757>, case 15: <D.25736>, case 112: <D.25741>, case 113: <D.25742>, case 114: <D.25743>, case 115: <D.25744>, case 116: <D.25745>, case 117: <D.25746>, case 118: <D.25747>, case 119: <D.25748>, case 120: <D.25749>, case 121: <D.25750>, case 122: <D.25751>, case 123: <D.25752>, case 124: <D.25753>, case 125: <D.25754>, case 126: <D.25755>, case 127: <D.25756>, case 224: <D.25737>, case 225: <D.25738>, case 226: <D.25739>, case 232: <D.25733>, case 233: <D.25734>, case 235: <D.25740>>
        <D.25733>:
        <D.25734>:
        size = size + 1;
        goto <D.25735>;
        <D.25736>:
        D.37082 = *pos;
        D.37083 = D.37082 + 144;
        if (D.37083 > 31) goto <D.37084>; else goto <D.37085>;
        <D.37084>:
        __assert_fail ("0", "mini-x86.c", 3573, &__PRETTY_FUNCTION__);
        <D.37085>:
        size = size + 1;
        pos = pos + 1;
        goto <D.25735>;
        <D.25737>:
        <D.25738>:
        <D.25739>:
        <D.25740>:
        <D.25741>:
        <D.25742>:
        <D.25743>:
        <D.25744>:
        <D.25745>:
        <D.25746>:
        <D.25747>:
        <D.25748>:
        <D.25749>:
        <D.25750>:
        <D.25751>:
        <D.25752>:
        <D.25753>:
        <D.25754>:
        <D.25755>:
        <D.25756>:
        goto <D.25735>;
        <D.25757>:
        __assert_fail ("0", "mini-x86.c", 3573, &__PRETTY_FUNCTION__);
        <D.25735>:
        D.31409 = cfg->native_code;
        D.37046 = tins->data.op[1].many_blocks;
        D.37047 = *D.37046;
        D.37048 = D.37047->native_offset;
        D.37051 = (sizetype) D.37048;
        D.37052 = D.31409 + D.37051;
        D.37053 = (int) D.37052;
        pos.2759 = (int) pos;
        disp = D.37053 - pos.2759;
        if (size != 0) goto <D.37087>; else goto <D.37088>;
        <D.37087>:
        {
          union x86_imm_buf imb;

          try
            {
              D.37089 = disp + -4;
              imb.val = D.37089;
              pos.2760 = pos;
              pos = pos.2760 + 1;
              D.37091 = imb.b[0];
              *pos.2760 = D.37091;
              pos.2761 = pos;
              pos = pos.2761 + 1;
              D.37093 = imb.b[1];
              *pos.2761 = D.37093;
              pos.2762 = pos;
              pos = pos.2762 + 1;
              D.37095 = imb.b[2];
              *pos.2762 = D.37095;
              pos.2763 = pos;
              pos = pos.2763 + 1;
              D.37097 = imb.b[3];
              *pos.2763 = D.37097;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.37098>;
        <D.37088>:
        disp.2764 = (unsigned int) disp;
        D.37100 = disp.2764 + 127;
        if (D.37100 <= 255) goto <D.37101>; else goto <D.37102>;
        <D.37101>:
        D.37103 = (unsigned char) disp;
        D.37104 = D.37103 + 255;
        *pos = D.37104;
        pos = pos + 1;
        goto <D.37105>;
        <D.37102>:
        __assert_fail ("0", "mini-x86.c", 3573, &__PRETTY_FUNCTION__);
        <D.37105>:
        <D.37098>:
      }
    }
    goto <D.37106>;
    <D.37050>:
    D.37046 = tins->data.op[1].many_blocks;
    D.37047 = *D.37046;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.37047);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.37109>; else goto <D.37107>;
    <D.37109>:
    D.37046 = tins->data.op[1].many_blocks;
    D.37047 = *D.37046;
    D.37110 = D.37047->max_offset;
    D.37111 = D.37110 - cpos;
    D.37112 = (unsigned int) D.37111;
    D.37113 = D.37112 + 128;
    if (D.37113 <= 255) goto <D.37114>; else goto <D.37107>;
    <D.37114>:
    D.31501 = ins->opcode;
    if (D.31501 <= 459) goto <D.37115>; else goto <D.37116>;
    <D.37115>:
    code.2765 = code;
    code = code.2765 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37029 = D.31502 + -455;
    D.37030 = branch_cc_table[D.37029];
    D.37031 = x86_cc_signed_map[D.37030];
    *code.2765 = D.37031;
    goto <D.37118>;
    <D.37116>:
    code.2766 = code;
    code = code.2766 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37029 = D.31502 + -455;
    D.37030 = branch_cc_table[D.37029];
    D.37035 = x86_cc_unsigned_map[D.37030];
    *code.2766 = D.37035;
    <D.37118>:
    *code = 0;
    code = code + 1;
    goto <D.37108>;
    <D.37107>:
    code.2767 = code;
    code = code.2767 + 1;
    *code.2767 = 15;
    D.31501 = ins->opcode;
    if (D.31501 <= 459) goto <D.37121>; else goto <D.37122>;
    <D.37121>:
    code.2768 = code;
    code = code.2768 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37029 = D.31502 + -455;
    D.37030 = branch_cc_table[D.37029];
    D.37031 = x86_cc_signed_map[D.37030];
    D.37032 = D.37031 + 16;
    *code.2768 = D.37032;
    goto <D.37124>;
    <D.37122>:
    code.2769 = code;
    code = code.2769 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37029 = D.31502 + -455;
    D.37030 = branch_cc_table[D.37029];
    D.37035 = x86_cc_unsigned_map[D.37030];
    D.37036 = D.37035 + 16;
    *code.2769 = D.37036;
    <D.37124>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2770 = code;
          code = code.2770 + 1;
          D.37127 = imb.b[0];
          *code.2770 = D.37127;
          code.2771 = code;
          code = code.2771 + 1;
          D.37129 = imb.b[1];
          *code.2771 = D.37129;
          code.2772 = code;
          code = code.2772 + 1;
          D.37131 = imb.b[2];
          *code.2772 = D.37131;
          code.2773 = code;
          code = code.2773 + 1;
          D.37133 = imb.b[3];
          *code.2773 = D.37133;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37108>:
    <D.37106>:
    <D.37045>:
  }
  goto <D.24796>;
  <D.25760>:
  <D.25761>:
  <D.25762>:
  <D.25763>:
  {
    struct MonoInst * tins;

    D.36871 = ins->data.op[1].p;
    tins = mono_branch_optimize_exception_target (cfg, bb, D.36871);
    if (tins == 0B) goto <D.37134>; else goto <D.37135>;
    <D.37134>:
    D.36871 = ins->data.op[1].p;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 9, D.36871);
    code.2774 = code;
    code = code.2774 + 1;
    *code.2774 = 15;
    D.31501 = ins->opcode;
    if (D.31501 <= 473) goto <D.37137>; else goto <D.37138>;
    <D.37137>:
    code.2775 = code;
    code = code.2775 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37140 = D.31502 + -469;
    D.37141 = branch_cc_table[D.37140];
    D.37142 = x86_cc_signed_map[D.37141];
    D.37143 = D.37142 + 16;
    *code.2775 = D.37143;
    goto <D.37144>;
    <D.37138>:
    code.2776 = code;
    code = code.2776 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37140 = D.31502 + -469;
    D.37141 = branch_cc_table[D.37140];
    D.37146 = x86_cc_unsigned_map[D.37141];
    D.37147 = D.37146 + 16;
    *code.2776 = D.37147;
    <D.37144>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2777 = code;
          code = code.2777 + 1;
          D.37149 = imb.b[0];
          *code.2777 = D.37149;
          code.2778 = code;
          code = code.2778 + 1;
          D.37151 = imb.b[1];
          *code.2778 = D.37151;
          code.2779 = code;
          code = code.2779 + 1;
          D.37153 = imb.b[2];
          *code.2779 = D.37153;
          code.2780 = code;
          code = code.2780 + 1;
          D.37155 = imb.b[3];
          *code.2780 = D.37155;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37156>;
    <D.37135>:
    D.37157 = tins->data.op[1].many_blocks;
    D.37158 = *D.37157;
    D.37159 = D.37158->native_offset;
    if (D.37159 != 0) goto <D.37160>; else goto <D.37161>;
    <D.37160>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.37157 = tins->data.op[1].many_blocks;
      D.37158 = *D.37157;
      D.37159 = D.37158->native_offset;
      D.37162 = (sizetype) D.37159;
      D.37163 = D.31409 + D.37162;
      D.37164 = (int) D.37163;
      code.422 = (int) code;
      D.37165 = D.37164 - code.422;
      offset = D.37165 + -2;
      branch_start = code;
      offset.2781 = (unsigned int) offset;
      D.37167 = offset.2781 + 128;
      if (D.37167 <= 255) goto <D.37168>; else goto <D.37169>;
      <D.37168>:
      D.31501 = ins->opcode;
      if (D.31501 <= 473) goto <D.37170>; else goto <D.37171>;
      <D.37170>:
      code.2782 = code;
      code = code.2782 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37140 = D.31502 + -469;
      D.37141 = branch_cc_table[D.37140];
      D.37142 = x86_cc_signed_map[D.37141];
      *code.2782 = D.37142;
      goto <D.37173>;
      <D.37171>:
      code.2783 = code;
      code = code.2783 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37140 = D.31502 + -469;
      D.37141 = branch_cc_table[D.37140];
      D.37146 = x86_cc_unsigned_map[D.37141];
      *code.2783 = D.37146;
      <D.37173>:
      D.37175 = (unsigned char) offset;
      *code = D.37175;
      code = code + 1;
      goto <D.37176>;
      <D.37169>:
      D.31409 = cfg->native_code;
      D.37157 = tins->data.op[1].many_blocks;
      D.37158 = *D.37157;
      D.37159 = D.37158->native_offset;
      D.37162 = (sizetype) D.37159;
      D.37163 = D.31409 + D.37162;
      D.37164 = (int) D.37163;
      code.422 = (int) code;
      D.37165 = D.37164 - code.422;
      offset = D.37165 + -6;
      code.2784 = code;
      code = code.2784 + 1;
      *code.2784 = 15;
      D.31501 = ins->opcode;
      if (D.31501 <= 473) goto <D.37178>; else goto <D.37179>;
      <D.37178>:
      code.2785 = code;
      code = code.2785 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37140 = D.31502 + -469;
      D.37141 = branch_cc_table[D.37140];
      D.37142 = x86_cc_signed_map[D.37141];
      D.37143 = D.37142 + 16;
      *code.2785 = D.37143;
      goto <D.37181>;
      <D.37179>:
      code.2786 = code;
      code = code.2786 + 1;
      D.31501 = ins->opcode;
      D.31502 = (int) D.31501;
      D.37140 = D.31502 + -469;
      D.37141 = branch_cc_table[D.37140];
      D.37146 = x86_cc_unsigned_map[D.37141];
      D.37147 = D.37146 + 16;
      *code.2786 = D.37147;
      <D.37181>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.2787 = code;
            code = code.2787 + 1;
            D.37184 = imb.b[0];
            *code.2787 = D.37184;
            code.2788 = code;
            code = code.2788 + 1;
            D.37186 = imb.b[1];
            *code.2788 = D.37186;
            code.2789 = code;
            code = code.2789 + 1;
            D.37188 = imb.b[2];
            *code.2789 = D.37188;
            code.2790 = code;
            code = code.2790 + 1;
            D.37190 = imb.b[3];
            *code.2790 = D.37190;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37176>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.37191 = MEM[(unsigned char *)branch_start];
        D.37192 = (int) D.37191;
        switch (D.37192) <default: <D.25796>, case 15: <D.25775>, case 112: <D.25780>, case 113: <D.25781>, case 114: <D.25782>, case 115: <D.25783>, case 116: <D.25784>, case 117: <D.25785>, case 118: <D.25786>, case 119: <D.25787>, case 120: <D.25788>, case 121: <D.25789>, case 122: <D.25790>, case 123: <D.25791>, case 124: <D.25792>, case 125: <D.25793>, case 126: <D.25794>, case 127: <D.25795>, case 224: <D.25776>, case 225: <D.25777>, case 226: <D.25778>, case 232: <D.25772>, case 233: <D.25773>, case 235: <D.25779>>
        <D.25772>:
        <D.25773>:
        size = size + 1;
        goto <D.25774>;
        <D.25775>:
        D.37193 = *pos;
        D.37194 = D.37193 + 144;
        if (D.37194 > 31) goto <D.37195>; else goto <D.37196>;
        <D.37195>:
        __assert_fail ("0", "mini-x86.c", 3579, &__PRETTY_FUNCTION__);
        <D.37196>:
        size = size + 1;
        pos = pos + 1;
        goto <D.25774>;
        <D.25776>:
        <D.25777>:
        <D.25778>:
        <D.25779>:
        <D.25780>:
        <D.25781>:
        <D.25782>:
        <D.25783>:
        <D.25784>:
        <D.25785>:
        <D.25786>:
        <D.25787>:
        <D.25788>:
        <D.25789>:
        <D.25790>:
        <D.25791>:
        <D.25792>:
        <D.25793>:
        <D.25794>:
        <D.25795>:
        goto <D.25774>;
        <D.25796>:
        __assert_fail ("0", "mini-x86.c", 3579, &__PRETTY_FUNCTION__);
        <D.25774>:
        D.31409 = cfg->native_code;
        D.37157 = tins->data.op[1].many_blocks;
        D.37158 = *D.37157;
        D.37159 = D.37158->native_offset;
        D.37162 = (sizetype) D.37159;
        D.37163 = D.31409 + D.37162;
        D.37164 = (int) D.37163;
        pos.2791 = (int) pos;
        disp = D.37164 - pos.2791;
        if (size != 0) goto <D.37198>; else goto <D.37199>;
        <D.37198>:
        {
          union x86_imm_buf imb;

          try
            {
              D.37200 = disp + -4;
              imb.val = D.37200;
              pos.2792 = pos;
              pos = pos.2792 + 1;
              D.37202 = imb.b[0];
              *pos.2792 = D.37202;
              pos.2793 = pos;
              pos = pos.2793 + 1;
              D.37204 = imb.b[1];
              *pos.2793 = D.37204;
              pos.2794 = pos;
              pos = pos.2794 + 1;
              D.37206 = imb.b[2];
              *pos.2794 = D.37206;
              pos.2795 = pos;
              pos = pos.2795 + 1;
              D.37208 = imb.b[3];
              *pos.2795 = D.37208;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.37209>;
        <D.37199>:
        disp.2796 = (unsigned int) disp;
        D.37211 = disp.2796 + 127;
        if (D.37211 <= 255) goto <D.37212>; else goto <D.37213>;
        <D.37212>:
        D.37214 = (unsigned char) disp;
        D.37215 = D.37214 + 255;
        *pos = D.37215;
        pos = pos + 1;
        goto <D.37216>;
        <D.37213>:
        __assert_fail ("0", "mini-x86.c", 3579, &__PRETTY_FUNCTION__);
        <D.37216>:
        <D.37209>:
      }
    }
    goto <D.37217>;
    <D.37161>:
    D.37157 = tins->data.op[1].many_blocks;
    D.37158 = *D.37157;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.37158);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.37220>; else goto <D.37218>;
    <D.37220>:
    D.37157 = tins->data.op[1].many_blocks;
    D.37158 = *D.37157;
    D.37221 = D.37158->max_offset;
    D.37222 = D.37221 - cpos;
    D.37223 = (unsigned int) D.37222;
    D.37224 = D.37223 + 128;
    if (D.37224 <= 255) goto <D.37225>; else goto <D.37218>;
    <D.37225>:
    D.31501 = ins->opcode;
    if (D.31501 <= 473) goto <D.37226>; else goto <D.37227>;
    <D.37226>:
    code.2797 = code;
    code = code.2797 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37140 = D.31502 + -469;
    D.37141 = branch_cc_table[D.37140];
    D.37142 = x86_cc_signed_map[D.37141];
    *code.2797 = D.37142;
    goto <D.37229>;
    <D.37227>:
    code.2798 = code;
    code = code.2798 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37140 = D.31502 + -469;
    D.37141 = branch_cc_table[D.37140];
    D.37146 = x86_cc_unsigned_map[D.37141];
    *code.2798 = D.37146;
    <D.37229>:
    *code = 0;
    code = code + 1;
    goto <D.37219>;
    <D.37218>:
    code.2799 = code;
    code = code.2799 + 1;
    *code.2799 = 15;
    D.31501 = ins->opcode;
    if (D.31501 <= 473) goto <D.37232>; else goto <D.37233>;
    <D.37232>:
    code.2800 = code;
    code = code.2800 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37140 = D.31502 + -469;
    D.37141 = branch_cc_table[D.37140];
    D.37142 = x86_cc_signed_map[D.37141];
    D.37143 = D.37142 + 16;
    *code.2800 = D.37143;
    goto <D.37235>;
    <D.37233>:
    code.2801 = code;
    code = code.2801 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37140 = D.31502 + -469;
    D.37141 = branch_cc_table[D.37140];
    D.37146 = x86_cc_unsigned_map[D.37141];
    D.37147 = D.37146 + 16;
    *code.2801 = D.37147;
    <D.37235>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2802 = code;
          code = code.2802 + 1;
          D.37238 = imb.b[0];
          *code.2802 = D.37238;
          code.2803 = code;
          code = code.2803 + 1;
          D.37240 = imb.b[1];
          *code.2803 = D.37240;
          code.2804 = code;
          code = code.2804 + 1;
          D.37242 = imb.b[2];
          *code.2804 = D.37242;
          code.2805 = code;
          code = code.2805 + 1;
          D.37244 = imb.b[3];
          *code.2805 = D.37244;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37219>:
    <D.37217>:
    <D.37156>:
  }
  goto <D.24796>;
  <D.25799>:
  <D.25800>:
  <D.25801>:
  <D.25802>:
  <D.25803>:
  <D.25804>:
  <D.25805>:
  <D.25806>:
  <D.25807>:
  <D.25808>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.37248>; else goto <D.37249>;
  <D.37248>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.2806 = (unsigned int) offset;
    D.37255 = offset.2806 + 128;
    if (D.37255 <= 255) goto <D.37256>; else goto <D.37257>;
    <D.37256>:
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37258 = mono_opcode_to_cond (D.31502);
    D.37259 = cc_signed_table[D.37258];
    if (D.37259 != 0) goto <D.37260>; else goto <D.37261>;
    <D.37260>:
    code.2807 = code;
    code = code.2807 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37263 = mono_opcode_to_cond (D.31502);
    D.37264 = cc_table[D.37263];
    D.37265 = x86_cc_signed_map[D.37264];
    *code.2807 = D.37265;
    goto <D.37266>;
    <D.37261>:
    code.2808 = code;
    code = code.2808 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37268 = mono_opcode_to_cond (D.31502);
    D.37269 = cc_table[D.37268];
    D.37270 = x86_cc_unsigned_map[D.37269];
    *code.2808 = D.37270;
    <D.37266>:
    D.37271 = (unsigned char) offset;
    *code = D.37271;
    code = code + 1;
    goto <D.37272>;
    <D.37257>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.2809 = code;
    code = code.2809 + 1;
    *code.2809 = 15;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37274 = mono_opcode_to_cond (D.31502);
    D.37275 = cc_signed_table[D.37274];
    if (D.37275 != 0) goto <D.37276>; else goto <D.37277>;
    <D.37276>:
    code.2810 = code;
    code = code.2810 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37279 = mono_opcode_to_cond (D.31502);
    D.37280 = cc_table[D.37279];
    D.37281 = x86_cc_signed_map[D.37280];
    D.37282 = D.37281 + 16;
    *code.2810 = D.37282;
    goto <D.37283>;
    <D.37277>:
    code.2811 = code;
    code = code.2811 + 1;
    D.31501 = ins->opcode;
    D.31502 = (int) D.31501;
    D.37285 = mono_opcode_to_cond (D.31502);
    D.37286 = cc_table[D.37285];
    D.37287 = x86_cc_unsigned_map[D.37286];
    D.37288 = D.37287 + 16;
    *code.2811 = D.37288;
    <D.37283>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.2812 = code;
          code = code.2812 + 1;
          D.37290 = imb.b[0];
          *code.2812 = D.37290;
          code.2813 = code;
          code = code.2813 + 1;
          D.37292 = imb.b[1];
          *code.2813 = D.37292;
          code.2814 = code;
          code = code.2814 + 1;
          D.37294 = imb.b[2];
          *code.2814 = D.37294;
          code.2815 = code;
          code = code.2815 + 1;
          D.37296 = imb.b[3];
          *code.2815 = D.37296;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37272>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.37297 = MEM[(unsigned char *)branch_start];
      D.37298 = (int) D.37297;
      switch (D.37298) <default: <D.25839>, case 15: <D.25818>, case 112: <D.25823>, case 113: <D.25824>, case 114: <D.25825>, case 115: <D.25826>, case 116: <D.25827>, case 117: <D.25828>, case 118: <D.25829>, case 119: <D.25830>, case 120: <D.25831>, case 121: <D.25832>, case 122: <D.25833>, case 123: <D.25834>, case 124: <D.25835>, case 125: <D.25836>, case 126: <D.25837>, case 127: <D.25838>, case 224: <D.25819>, case 225: <D.25820>, case 226: <D.25821>, case 232: <D.25815>, case 233: <D.25816>, case 235: <D.25822>>
      <D.25815>:
      <D.25816>:
      size = size + 1;
      goto <D.25817>;
      <D.25818>:
      D.37299 = *pos;
      D.37300 = D.37299 + 144;
      if (D.37300 > 31) goto <D.37301>; else goto <D.37302>;
      <D.37301>:
      __assert_fail ("0", "mini-x86.c", 3591, &__PRETTY_FUNCTION__);
      <D.37302>:
      size = size + 1;
      pos = pos + 1;
      goto <D.25817>;
      <D.25819>:
      <D.25820>:
      <D.25821>:
      <D.25822>:
      <D.25823>:
      <D.25824>:
      <D.25825>:
      <D.25826>:
      <D.25827>:
      <D.25828>:
      <D.25829>:
      <D.25830>:
      <D.25831>:
      <D.25832>:
      <D.25833>:
      <D.25834>:
      <D.25835>:
      <D.25836>:
      <D.25837>:
      <D.25838>:
      goto <D.25817>;
      <D.25839>:
      __assert_fail ("0", "mini-x86.c", 3591, &__PRETTY_FUNCTION__);
      <D.25817>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.2816 = (int) pos;
      disp = D.37252 - pos.2816;
      if (size != 0) goto <D.37304>; else goto <D.37305>;
      <D.37304>:
      {
        union x86_imm_buf imb;

        try
          {
            D.37306 = disp + -4;
            imb.val = D.37306;
            pos.2817 = pos;
            pos = pos.2817 + 1;
            D.37308 = imb.b[0];
            *pos.2817 = D.37308;
            pos.2818 = pos;
            pos = pos.2818 + 1;
            D.37310 = imb.b[1];
            *pos.2818 = D.37310;
            pos.2819 = pos;
            pos = pos.2819 + 1;
            D.37312 = imb.b[2];
            *pos.2819 = D.37312;
            pos.2820 = pos;
            pos = pos.2820 + 1;
            D.37314 = imb.b[3];
            *pos.2820 = D.37314;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.37315>;
      <D.37305>:
      disp.2821 = (unsigned int) disp;
      D.37317 = disp.2821 + 127;
      if (D.37317 <= 255) goto <D.37318>; else goto <D.37319>;
      <D.37318>:
      D.37320 = (unsigned char) disp;
      D.37321 = D.37320 + 255;
      *pos = D.37321;
      pos = pos + 1;
      goto <D.37322>;
      <D.37319>:
      __assert_fail ("0", "mini-x86.c", 3591, &__PRETTY_FUNCTION__);
      <D.37322>:
      <D.37315>:
    }
  }
  goto <D.37323>;
  <D.37249>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.37326>; else goto <D.37324>;
  <D.37326>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.37331>; else goto <D.37324>;
  <D.37331>:
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37332 = mono_opcode_to_cond (D.31502);
  D.37333 = cc_signed_table[D.37332];
  if (D.37333 != 0) goto <D.37334>; else goto <D.37335>;
  <D.37334>:
  code.2822 = code;
  code = code.2822 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37337 = mono_opcode_to_cond (D.31502);
  D.37338 = cc_table[D.37337];
  D.37339 = x86_cc_signed_map[D.37338];
  *code.2822 = D.37339;
  goto <D.37340>;
  <D.37335>:
  code.2823 = code;
  code = code.2823 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37342 = mono_opcode_to_cond (D.31502);
  D.37343 = cc_table[D.37342];
  D.37344 = x86_cc_unsigned_map[D.37343];
  *code.2823 = D.37344;
  <D.37340>:
  *code = 0;
  code = code + 1;
  goto <D.37325>;
  <D.37324>:
  code.2824 = code;
  code = code.2824 + 1;
  *code.2824 = 15;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37346 = mono_opcode_to_cond (D.31502);
  D.37347 = cc_signed_table[D.37346];
  if (D.37347 != 0) goto <D.37348>; else goto <D.37349>;
  <D.37348>:
  code.2825 = code;
  code = code.2825 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37351 = mono_opcode_to_cond (D.31502);
  D.37352 = cc_table[D.37351];
  D.37353 = x86_cc_signed_map[D.37352];
  D.37354 = D.37353 + 16;
  *code.2825 = D.37354;
  goto <D.37355>;
  <D.37349>:
  code.2826 = code;
  code = code.2826 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37357 = mono_opcode_to_cond (D.31502);
  D.37358 = cc_table[D.37357];
  D.37359 = x86_cc_unsigned_map[D.37358];
  D.37360 = D.37359 + 16;
  *code.2826 = D.37360;
  <D.37355>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.2827 = code;
        code = code.2827 + 1;
        D.37362 = imb.b[0];
        *code.2827 = D.37362;
        code.2828 = code;
        code = code.2828 + 1;
        D.37364 = imb.b[1];
        *code.2828 = D.37364;
        code.2829 = code;
        code = code.2829 + 1;
        D.37366 = imb.b[2];
        *code.2829 = D.37366;
        code.2830 = code;
        code = code.2830 + 1;
        D.37368 = imb.b[3];
        *code.2830 = D.37368;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37325>:
  <D.37323>:
  goto <D.24796>;
  <D.25842>:
  <D.25843>:
  <D.25844>:
  <D.25845>:
  <D.25846>:
  <D.25847>:
  <D.25848>:
  <D.25849>:
  <D.25850>:
  <D.25851>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  D.37369 = D.31604 != D.31548;
  D.37370 = (long int) D.37369;
  D.37371 = __builtin_expect (D.37370, 0);
  if (D.37371 != 0) goto <D.37372>; else goto <D.37373>;
  <D.37372>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3604, "ins->dreg == ins->sreg1");
  <D.37373>:
  code.2831 = code;
  code = code.2831 + 1;
  *code.2831 = 15;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37375 = mono_opcode_to_cond (D.31502);
  D.37376 = cc_signed_table[D.37375];
  if (D.37376 != 0) goto <D.37377>; else goto <D.37378>;
  <D.37377>:
  code.2832 = code;
  code = code.2832 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37380 = mono_opcode_to_cond (D.31502);
  D.37381 = cc_table[D.37380];
  D.37382 = x86_cc_signed_map[D.37381];
  D.37383 = D.37382 + 208;
  *code.2832 = D.37383;
  goto <D.37384>;
  <D.37378>:
  code.2833 = code;
  code = code.2833 + 1;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.37386 = mono_opcode_to_cond (D.31502);
  D.37387 = cc_table[D.37386];
  D.37388 = x86_cc_unsigned_map[D.37387];
  D.37389 = D.37388 + 208;
  *code.2833 = D.37389;
  <D.37384>:
  code.2834 = code;
  code = code.2834 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.2834 = D.37392;
  goto <D.24796>;
  <D.25852>:
  {
    double d;

    try
      {
        D.32177 = ins->data.op[0].p;
        d.2835 = MEM[(double *)D.32177];
        d = d.2835;
        d.2836 = d;
        if (d.2836 == 0.0) goto <D.37397>; else goto <D.37394>;
        <D.37397>:
        d.2836 = d;
        D.37398 = __signbit (d.2836);
        if (D.37398 == 0) goto <D.37399>; else goto <D.37394>;
        <D.37399>:
        code.2837 = code;
        code = code.2837 + 1;
        *code.2837 = 217;
        code.2838 = code;
        code = code.2838 + 1;
        *code.2838 = 238;
        goto <D.37395>;
        <D.37394>:
        d.2836 = d;
        if (d.2836 == 1.0e+0) goto <D.37402>; else goto <D.37403>;
        <D.37402>:
        code.2839 = code;
        code = code.2839 + 1;
        *code.2839 = 217;
        code.2840 = code;
        code = code.2840 + 1;
        *code.2840 = 232;
        goto <D.37406>;
        <D.37403>:
        D.31466 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.31467 = D.31466 & 64;
        if (D.31467 != 0) goto <D.37407>; else goto <D.37408>;
        <D.37407>:
        {
          guint32 * val;

          val = &d;
          {
            int _imm;

            D.37409 = val + 4;
            D.37410 = *D.37409;
            _imm = (int) D.37410;
            _imm.2841 = (unsigned int) _imm;
            D.37412 = _imm.2841 + 128;
            if (D.37412 <= 255) goto <D.37413>; else goto <D.37414>;
            <D.37413>:
            code.2842 = code;
            code = code.2842 + 1;
            *code.2842 = 106;
            D.37416 = (unsigned char) _imm;
            *code = D.37416;
            code = code + 1;
            goto <D.37417>;
            <D.37414>:
            code.2843 = code;
            code = code.2843 + 1;
            *code.2843 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  code.2844 = code;
                  code = code.2844 + 1;
                  D.37420 = imb.b[0];
                  *code.2844 = D.37420;
                  code.2845 = code;
                  code = code.2845 + 1;
                  D.37422 = imb.b[1];
                  *code.2845 = D.37422;
                  code.2846 = code;
                  code = code.2846 + 1;
                  D.37424 = imb.b[2];
                  *code.2846 = D.37424;
                  code.2847 = code;
                  code = code.2847 + 1;
                  D.37426 = imb.b[3];
                  *code.2847 = D.37426;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.37417>:
          }
          {
            int _imm;

            D.37427 = *val;
            _imm = (int) D.37427;
            _imm.2848 = (unsigned int) _imm;
            D.37429 = _imm.2848 + 128;
            if (D.37429 <= 255) goto <D.37430>; else goto <D.37431>;
            <D.37430>:
            code.2849 = code;
            code = code.2849 + 1;
            *code.2849 = 106;
            D.37433 = (unsigned char) _imm;
            *code = D.37433;
            code = code + 1;
            goto <D.37434>;
            <D.37431>:
            code.2850 = code;
            code = code.2850 + 1;
            *code.2850 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  code.2851 = code;
                  code = code.2851 + 1;
                  D.37437 = imb.b[0];
                  *code.2851 = D.37437;
                  code.2852 = code;
                  code = code.2852 + 1;
                  D.37439 = imb.b[1];
                  *code.2852 = D.37439;
                  code.2853 = code;
                  code = code.2853 + 1;
                  D.37441 = imb.b[2];
                  *code.2853 = D.37441;
                  code.2854 = code;
                  code = code.2854 + 1;
                  D.37443 = imb.b[3];
                  *code.2854 = D.37443;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.37434>:
          }
          code.2855 = code;
          code = code.2855 + 1;
          *code.2855 = 221;
          if (1 != 0) goto <D.37445>; else goto <D.37446>;
          <D.37445>:
          if (1 != 0) goto <D.37447>; else goto <D.37448>;
          <D.37447>:
          code.2856 = code;
          code = code.2856 + 1;
          *code.2856 = 4;
          code.2857 = code;
          code = code.2857 + 1;
          *code.2857 = 36;
          goto <D.37451>;
          <D.37448>:
          if (1 != 0) goto <D.37452>; else goto <D.37453>;
          <D.37452>:
          code.2858 = code;
          code = code.2858 + 1;
          *code.2858 = 68;
          code.2859 = code;
          code = code.2859 + 1;
          *code.2859 = 36;
          *code = 0;
          code = code + 1;
          goto <D.37456>;
          <D.37453>:
          code.2860 = code;
          code = code.2860 + 1;
          *code.2860 = 132;
          code.2861 = code;
          code = code.2861 + 1;
          *code.2861 = 36;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.2862 = code;
                code = code.2862 + 1;
                D.37460 = imb.b[0];
                *code.2862 = D.37460;
                code.2863 = code;
                code = code.2863 + 1;
                D.37462 = imb.b[1];
                *code.2863 = D.37462;
                code.2864 = code;
                code = code.2864 + 1;
                D.37464 = imb.b[2];
                *code.2864 = D.37464;
                code.2865 = code;
                code = code.2865 + 1;
                D.37466 = imb.b[3];
                *code.2865 = D.37466;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.37456>:
          <D.37451>:
          goto <D.25860>;
          <D.37446>:
          if (1 != 0) goto <D.37467>; else goto <D.37468>;
          <D.37467>:
          code.2866 = code;
          code = code.2866 + 1;
          *code.2866 = 4;
          goto <D.25860>;
          <D.37468>:
          if (1 != 0) goto <D.37470>; else goto <D.37471>;
          <D.37470>:
          code.2867 = code;
          code = code.2867 + 1;
          *code.2867 = 68;
          *code = 0;
          code = code + 1;
          goto <D.37473>;
          <D.37471>:
          code.2868 = code;
          code = code.2868 + 1;
          *code.2868 = 132;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.2869 = code;
                code = code.2869 + 1;
                D.37476 = imb.b[0];
                *code.2869 = D.37476;
                code.2870 = code;
                code = code.2870 + 1;
                D.37478 = imb.b[1];
                *code.2870 = D.37478;
                code.2871 = code;
                code = code.2871 + 1;
                D.37480 = imb.b[2];
                *code.2871 = D.37480;
                code.2872 = code;
                code = code.2872 + 1;
                D.37482 = imb.b[3];
                *code.2872 = D.37482;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.37473>:
          <D.25860>:
          if (0 != 0) goto <D.37483>; else goto <D.37484>;
          <D.37483>:
          code.2873 = code;
          code = code.2873 + 1;
          *code.2873 = 5;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 8;
                code.2874 = code;
                code = code.2874 + 1;
                D.37487 = imb.b[0];
                *code.2874 = D.37487;
                code.2875 = code;
                code = code.2875 + 1;
                D.37489 = imb.b[1];
                *code.2875 = D.37489;
                code.2876 = code;
                code = code.2876 + 1;
                D.37491 = imb.b[2];
                *code.2876 = D.37491;
                code.2877 = code;
                code = code.2877 + 1;
                D.37493 = imb.b[3];
                *code.2877 = D.37493;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.25863>;
          <D.37484>:
          if (1 != 0) goto <D.37494>; else goto <D.37495>;
          <D.37494>:
          code.2878 = code;
          code = code.2878 + 1;
          *code.2878 = 131;
          code.2879 = code;
          code = code.2879 + 1;
          *code.2879 = 196;
          *code = 8;
          code = code + 1;
          goto <D.37498>;
          <D.37495>:
          code.2880 = code;
          code = code.2880 + 1;
          *code.2880 = 129;
          code.2881 = code;
          code = code.2881 + 1;
          *code.2881 = 196;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 8;
                code.2882 = code;
                code = code.2882 + 1;
                D.37502 = imb.b[0];
                *code.2882 = D.37502;
                code.2883 = code;
                code = code.2883 + 1;
                D.37504 = imb.b[1];
                *code.2883 = D.37504;
                code.2884 = code;
                code = code.2884 + 1;
                D.37506 = imb.b[2];
                *code.2884 = D.37506;
                code.2885 = code;
                code = code.2885 + 1;
                D.37508 = imb.b[3];
                *code.2885 = D.37508;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.37498>:
          <D.25863>:
        }
        goto <D.37509>;
        <D.37408>:
        D.32177 = ins->data.op[0].p;
        code.422 = (int) code;
        D.31409 = cfg->native_code;
        D.31488 = (int) D.31409;
        D.31489 = code.422 - D.31488;
        mono_add_patch_info (cfg, D.31489, 21, D.32177);
        code.2886 = code;
        code = code.2886 + 1;
        *code.2886 = 221;
        code.2887 = code;
        code = code.2887 + 1;
        *code.2887 = 5;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.2888 = code;
              code = code.2888 + 1;
              D.37513 = imb.b[0];
              *code.2888 = D.37513;
              code.2889 = code;
              code = code.2889 + 1;
              D.37515 = imb.b[1];
              *code.2889 = D.37515;
              code.2890 = code;
              code = code.2890 + 1;
              D.37517 = imb.b[2];
              *code.2890 = D.37517;
              code.2891 = code;
              code = code.2891 + 1;
              D.37519 = imb.b[3];
              *code.2891 = D.37519;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.37509>:
        <D.37406>:
        <D.37395>:
        goto <D.24796>;
      }
    finally
      {
        d = {CLOBBER};
      }
  }
  <D.25866>:
  {
    float f;

    try
      {
        D.32177 = ins->data.op[0].p;
        f.2892 = MEM[(float *)D.32177];
        f = f.2892;
        f.2893 = f;
        if (f.2893 == 0.0) goto <D.37524>; else goto <D.37521>;
        <D.37524>:
        f.2893 = f;
        D.37525 = __signbitf (f.2893);
        if (D.37525 == 0) goto <D.37526>; else goto <D.37521>;
        <D.37526>:
        code.2894 = code;
        code = code.2894 + 1;
        *code.2894 = 217;
        code.2895 = code;
        code = code.2895 + 1;
        *code.2895 = 238;
        goto <D.37522>;
        <D.37521>:
        f.2893 = f;
        if (f.2893 == 1.0e+0) goto <D.37529>; else goto <D.37530>;
        <D.37529>:
        code.2896 = code;
        code = code.2896 + 1;
        *code.2896 = 217;
        code.2897 = code;
        code = code.2897 + 1;
        *code.2897 = 232;
        goto <D.37533>;
        <D.37530>:
        D.31466 = BIT_FIELD_REF <*cfg, 8, 3392>;
        D.31467 = D.31466 & 64;
        if (D.31467 != 0) goto <D.37534>; else goto <D.37535>;
        <D.37534>:
        {
          guint32 val;

          f.2898 = &f;
          val = MEM[(guint32 *)f.2898];
          {
            int _imm;

            _imm = (int) val;
            _imm.2899 = (unsigned int) _imm;
            D.37538 = _imm.2899 + 128;
            if (D.37538 <= 255) goto <D.37539>; else goto <D.37540>;
            <D.37539>:
            code.2900 = code;
            code = code.2900 + 1;
            *code.2900 = 106;
            D.37542 = (unsigned char) _imm;
            *code = D.37542;
            code = code + 1;
            goto <D.37543>;
            <D.37540>:
            code.2901 = code;
            code = code.2901 + 1;
            *code.2901 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  code.2902 = code;
                  code = code.2902 + 1;
                  D.37546 = imb.b[0];
                  *code.2902 = D.37546;
                  code.2903 = code;
                  code = code.2903 + 1;
                  D.37548 = imb.b[1];
                  *code.2903 = D.37548;
                  code.2904 = code;
                  code = code.2904 + 1;
                  D.37550 = imb.b[2];
                  *code.2904 = D.37550;
                  code.2905 = code;
                  code = code.2905 + 1;
                  D.37552 = imb.b[3];
                  *code.2905 = D.37552;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.37543>:
          }
          code.2906 = code;
          code = code.2906 + 1;
          *code.2906 = 217;
          if (1 != 0) goto <D.37554>; else goto <D.37555>;
          <D.37554>:
          if (1 != 0) goto <D.37556>; else goto <D.37557>;
          <D.37556>:
          code.2907 = code;
          code = code.2907 + 1;
          *code.2907 = 4;
          code.2908 = code;
          code = code.2908 + 1;
          *code.2908 = 36;
          goto <D.37560>;
          <D.37557>:
          if (1 != 0) goto <D.37561>; else goto <D.37562>;
          <D.37561>:
          code.2909 = code;
          code = code.2909 + 1;
          *code.2909 = 68;
          code.2910 = code;
          code = code.2910 + 1;
          *code.2910 = 36;
          *code = 0;
          code = code + 1;
          goto <D.37565>;
          <D.37562>:
          code.2911 = code;
          code = code.2911 + 1;
          *code.2911 = 132;
          code.2912 = code;
          code = code.2912 + 1;
          *code.2912 = 36;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.2913 = code;
                code = code.2913 + 1;
                D.37569 = imb.b[0];
                *code.2913 = D.37569;
                code.2914 = code;
                code = code.2914 + 1;
                D.37571 = imb.b[1];
                *code.2914 = D.37571;
                code.2915 = code;
                code = code.2915 + 1;
                D.37573 = imb.b[2];
                *code.2915 = D.37573;
                code.2916 = code;
                code = code.2916 + 1;
                D.37575 = imb.b[3];
                *code.2916 = D.37575;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.37565>:
          <D.37560>:
          goto <D.25872>;
          <D.37555>:
          if (1 != 0) goto <D.37576>; else goto <D.37577>;
          <D.37576>:
          code.2917 = code;
          code = code.2917 + 1;
          *code.2917 = 4;
          goto <D.25872>;
          <D.37577>:
          if (1 != 0) goto <D.37579>; else goto <D.37580>;
          <D.37579>:
          code.2918 = code;
          code = code.2918 + 1;
          *code.2918 = 68;
          *code = 0;
          code = code + 1;
          goto <D.37582>;
          <D.37580>:
          code.2919 = code;
          code = code.2919 + 1;
          *code.2919 = 132;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.2920 = code;
                code = code.2920 + 1;
                D.37585 = imb.b[0];
                *code.2920 = D.37585;
                code.2921 = code;
                code = code.2921 + 1;
                D.37587 = imb.b[1];
                *code.2921 = D.37587;
                code.2922 = code;
                code = code.2922 + 1;
                D.37589 = imb.b[2];
                *code.2922 = D.37589;
                code.2923 = code;
                code = code.2923 + 1;
                D.37591 = imb.b[3];
                *code.2923 = D.37591;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.37582>:
          <D.25872>:
          if (0 != 0) goto <D.37592>; else goto <D.37593>;
          <D.37592>:
          code.2924 = code;
          code = code.2924 + 1;
          *code.2924 = 5;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 4;
                code.2925 = code;
                code = code.2925 + 1;
                D.37596 = imb.b[0];
                *code.2925 = D.37596;
                code.2926 = code;
                code = code.2926 + 1;
                D.37598 = imb.b[1];
                *code.2926 = D.37598;
                code.2927 = code;
                code = code.2927 + 1;
                D.37600 = imb.b[2];
                *code.2927 = D.37600;
                code.2928 = code;
                code = code.2928 + 1;
                D.37602 = imb.b[3];
                *code.2928 = D.37602;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.25875>;
          <D.37593>:
          if (1 != 0) goto <D.37603>; else goto <D.37604>;
          <D.37603>:
          code.2929 = code;
          code = code.2929 + 1;
          *code.2929 = 131;
          code.2930 = code;
          code = code.2930 + 1;
          *code.2930 = 196;
          *code = 4;
          code = code + 1;
          goto <D.37607>;
          <D.37604>:
          code.2931 = code;
          code = code.2931 + 1;
          *code.2931 = 129;
          code.2932 = code;
          code = code.2932 + 1;
          *code.2932 = 196;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 4;
                code.2933 = code;
                code = code.2933 + 1;
                D.37611 = imb.b[0];
                *code.2933 = D.37611;
                code.2934 = code;
                code = code.2934 + 1;
                D.37613 = imb.b[1];
                *code.2934 = D.37613;
                code.2935 = code;
                code = code.2935 + 1;
                D.37615 = imb.b[2];
                *code.2935 = D.37615;
                code.2936 = code;
                code = code.2936 + 1;
                D.37617 = imb.b[3];
                *code.2936 = D.37617;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.37607>:
          <D.25875>:
        }
        goto <D.37618>;
        <D.37535>:
        D.32177 = ins->data.op[0].p;
        code.422 = (int) code;
        D.31409 = cfg->native_code;
        D.31488 = (int) D.31409;
        D.31489 = code.422 - D.31488;
        mono_add_patch_info (cfg, D.31489, 20, D.32177);
        code.2937 = code;
        code = code.2937 + 1;
        *code.2937 = 217;
        code.2938 = code;
        code = code.2938 + 1;
        *code.2938 = 5;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.2939 = code;
              code = code.2939 + 1;
              D.37622 = imb.b[0];
              *code.2939 = D.37622;
              code.2940 = code;
              code = code.2940 + 1;
              D.37624 = imb.b[1];
              *code.2940 = D.37624;
              code.2941 = code;
              code = code.2941 + 1;
              D.37626 = imb.b[2];
              *code.2941 = D.37626;
              code.2942 = code;
              code = code.2942 + 1;
              D.37628 = imb.b[3];
              *code.2942 = D.37628;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.37618>:
        <D.37533>:
        <D.37522>:
        goto <D.24796>;
      }
    finally
      {
        f = {CLOBBER};
      }
  }
  <D.25878>:
  code.2943 = code;
  code = code.2943 + 1;
  *code.2943 = 221;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.37630>; else goto <D.37631>;
  <D.37630>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37632>; else goto <D.37633>;
  <D.37632>:
  code.2944 = code;
  code = code.2944 + 1;
  *code.2944 = 28;
  code.2945 = code;
  code = code.2945 + 1;
  *code.2945 = 36;
  goto <D.37636>;
  <D.37633>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37637>; else goto <D.37638>;
  <D.37637>:
  code.2946 = code;
  code = code.2946 + 1;
  *code.2946 = 92;
  code.2947 = code;
  code = code.2947 + 1;
  *code.2947 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37641>;
  <D.37638>:
  code.2948 = code;
  code = code.2948 + 1;
  *code.2948 = 156;
  code.2949 = code;
  code = code.2949 + 1;
  *code.2949 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2950 = code;
        code = code.2950 + 1;
        D.37645 = imb.b[0];
        *code.2950 = D.37645;
        code.2951 = code;
        code = code.2951 + 1;
        D.37647 = imb.b[1];
        *code.2951 = D.37647;
        code.2952 = code;
        code = code.2952 + 1;
        D.37649 = imb.b[2];
        *code.2952 = D.37649;
        code.2953 = code;
        code = code.2953 + 1;
        D.37651 = imb.b[3];
        *code.2953 = D.37651;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37641>:
  <D.37636>:
  goto <D.25880>;
  <D.37631>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37652>; else goto <D.37653>;
  <D.37652>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.37654>; else goto <D.37655>;
  <D.37654>:
  code.2954 = code;
  code = code.2954 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.37657 = D.31638 | 24;
  D.37658 = (unsigned char) D.37657;
  *code.2954 = D.37658;
  goto <D.25880>;
  <D.37655>:
  <D.37653>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37659>; else goto <D.37660>;
  <D.37659>:
  code.2955 = code;
  code = code.2955 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.37662 = D.31638 | 88;
  D.37663 = (unsigned char) D.37662;
  *code.2955 = D.37663;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37664>;
  <D.37660>:
  code.2956 = code;
  code = code.2956 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.37666 = D.31638 | -104;
  D.37667 = (unsigned char) D.37666;
  *code.2956 = D.37667;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2957 = code;
        code = code.2957 + 1;
        D.37669 = imb.b[0];
        *code.2957 = D.37669;
        code.2958 = code;
        code = code.2958 + 1;
        D.37671 = imb.b[1];
        *code.2958 = D.37671;
        code.2959 = code;
        code = code.2959 + 1;
        D.37673 = imb.b[2];
        *code.2959 = D.37673;
        code.2960 = code;
        code = code.2960 + 1;
        D.37675 = imb.b[3];
        *code.2960 = D.37675;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37664>:
  <D.25880>:
  goto <D.24796>;
  <D.25882>:
  code.2961 = code;
  code = code.2961 + 1;
  *code.2961 = 221;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.37677>; else goto <D.37678>;
  <D.37677>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37679>; else goto <D.37680>;
  <D.37679>:
  code.2962 = code;
  code = code.2962 + 1;
  *code.2962 = 4;
  code.2963 = code;
  code = code.2963 + 1;
  *code.2963 = 36;
  goto <D.37683>;
  <D.37680>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37684>; else goto <D.37685>;
  <D.37684>:
  code.2964 = code;
  code = code.2964 + 1;
  *code.2964 = 68;
  code.2965 = code;
  code = code.2965 + 1;
  *code.2965 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37688>;
  <D.37685>:
  code.2966 = code;
  code = code.2966 + 1;
  *code.2966 = 132;
  code.2967 = code;
  code = code.2967 + 1;
  *code.2967 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2968 = code;
        code = code.2968 + 1;
        D.37692 = imb.b[0];
        *code.2968 = D.37692;
        code.2969 = code;
        code = code.2969 + 1;
        D.37694 = imb.b[1];
        *code.2969 = D.37694;
        code.2970 = code;
        code = code.2970 + 1;
        D.37696 = imb.b[2];
        *code.2970 = D.37696;
        code.2971 = code;
        code = code.2971 + 1;
        D.37698 = imb.b[3];
        *code.2971 = D.37698;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37688>:
  <D.37683>:
  goto <D.25884>;
  <D.37678>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37699>; else goto <D.37700>;
  <D.37699>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.37701>; else goto <D.37702>;
  <D.37701>:
  code.2972 = code;
  code = code.2972 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.2972 = D.31581;
  goto <D.25884>;
  <D.37702>:
  <D.37700>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37704>; else goto <D.37705>;
  <D.37704>:
  code.2973 = code;
  code = code.2973 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.2973 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37707>;
  <D.37705>:
  code.2974 = code;
  code = code.2974 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.2974 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2975 = code;
        code = code.2975 + 1;
        D.37710 = imb.b[0];
        *code.2975 = D.37710;
        code.2976 = code;
        code = code.2976 + 1;
        D.37712 = imb.b[1];
        *code.2976 = D.37712;
        code.2977 = code;
        code = code.2977 + 1;
        D.37714 = imb.b[2];
        *code.2977 = D.37714;
        code.2978 = code;
        code = code.2978 + 1;
        D.37716 = imb.b[3];
        *code.2978 = D.37716;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37707>:
  <D.25884>:
  goto <D.24796>;
  <D.25886>:
  code.2979 = code;
  code = code.2979 + 1;
  *code.2979 = 217;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.37718>; else goto <D.37719>;
  <D.37718>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37720>; else goto <D.37721>;
  <D.37720>:
  code.2980 = code;
  code = code.2980 + 1;
  *code.2980 = 28;
  code.2981 = code;
  code = code.2981 + 1;
  *code.2981 = 36;
  goto <D.37724>;
  <D.37721>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37725>; else goto <D.37726>;
  <D.37725>:
  code.2982 = code;
  code = code.2982 + 1;
  *code.2982 = 92;
  code.2983 = code;
  code = code.2983 + 1;
  *code.2983 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37729>;
  <D.37726>:
  code.2984 = code;
  code = code.2984 + 1;
  *code.2984 = 156;
  code.2985 = code;
  code = code.2985 + 1;
  *code.2985 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2986 = code;
        code = code.2986 + 1;
        D.37733 = imb.b[0];
        *code.2986 = D.37733;
        code.2987 = code;
        code = code.2987 + 1;
        D.37735 = imb.b[1];
        *code.2987 = D.37735;
        code.2988 = code;
        code = code.2988 + 1;
        D.37737 = imb.b[2];
        *code.2988 = D.37737;
        code.2989 = code;
        code = code.2989 + 1;
        D.37739 = imb.b[3];
        *code.2989 = D.37739;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37729>:
  <D.37724>:
  goto <D.25888>;
  <D.37719>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37740>; else goto <D.37741>;
  <D.37740>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.37742>; else goto <D.37743>;
  <D.37742>:
  code.2990 = code;
  code = code.2990 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.37657 = D.31638 | 24;
  D.37658 = (unsigned char) D.37657;
  *code.2990 = D.37658;
  goto <D.25888>;
  <D.37743>:
  <D.37741>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37745>; else goto <D.37746>;
  <D.37745>:
  code.2991 = code;
  code = code.2991 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.37662 = D.31638 | 88;
  D.37663 = (unsigned char) D.37662;
  *code.2991 = D.37663;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37748>;
  <D.37746>:
  code.2992 = code;
  code = code.2992 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.37666 = D.31638 | -104;
  D.37667 = (unsigned char) D.37666;
  *code.2992 = D.37667;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.2993 = code;
        code = code.2993 + 1;
        D.37751 = imb.b[0];
        *code.2993 = D.37751;
        code.2994 = code;
        code = code.2994 + 1;
        D.37753 = imb.b[1];
        *code.2994 = D.37753;
        code.2995 = code;
        code = code.2995 + 1;
        D.37755 = imb.b[2];
        *code.2995 = D.37755;
        code.2996 = code;
        code = code.2996 + 1;
        D.37757 = imb.b[3];
        *code.2996 = D.37757;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37748>:
  <D.25888>:
  goto <D.24796>;
  <D.25890>:
  code.2997 = code;
  code = code.2997 + 1;
  *code.2997 = 217;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.37759>; else goto <D.37760>;
  <D.37759>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37761>; else goto <D.37762>;
  <D.37761>:
  code.2998 = code;
  code = code.2998 + 1;
  *code.2998 = 4;
  code.2999 = code;
  code = code.2999 + 1;
  *code.2999 = 36;
  goto <D.37765>;
  <D.37762>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37766>; else goto <D.37767>;
  <D.37766>:
  code.3000 = code;
  code = code.3000 + 1;
  *code.3000 = 68;
  code.3001 = code;
  code = code.3001 + 1;
  *code.3001 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37770>;
  <D.37767>:
  code.3002 = code;
  code = code.3002 + 1;
  *code.3002 = 132;
  code.3003 = code;
  code = code.3003 + 1;
  *code.3003 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3004 = code;
        code = code.3004 + 1;
        D.37774 = imb.b[0];
        *code.3004 = D.37774;
        code.3005 = code;
        code = code.3005 + 1;
        D.37776 = imb.b[1];
        *code.3005 = D.37776;
        code.3006 = code;
        code = code.3006 + 1;
        D.37778 = imb.b[2];
        *code.3006 = D.37778;
        code.3007 = code;
        code = code.3007 + 1;
        D.37780 = imb.b[3];
        *code.3007 = D.37780;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37770>:
  <D.37765>:
  goto <D.25892>;
  <D.37760>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.37781>; else goto <D.37782>;
  <D.37781>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.37783>; else goto <D.37784>;
  <D.37783>:
  code.3008 = code;
  code = code.3008 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.3008 = D.31581;
  goto <D.25892>;
  <D.37784>:
  <D.37782>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.37786>; else goto <D.37787>;
  <D.37786>:
  code.3009 = code;
  code = code.3009 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.3009 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.37789>;
  <D.37787>:
  code.3010 = code;
  code = code.3010 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.3010 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3011 = code;
        code = code.3011 + 1;
        D.37792 = imb.b[0];
        *code.3011 = D.37792;
        code.3012 = code;
        code = code.3012 + 1;
        D.37794 = imb.b[1];
        *code.3012 = D.37794;
        code.3013 = code;
        code = code.3013 + 1;
        D.37796 = imb.b[2];
        *code.3013 = D.37796;
        code.3014 = code;
        code = code.3014 + 1;
        D.37798 = imb.b[3];
        *code.3014 = D.37798;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37789>:
  <D.25892>:
  goto <D.24796>;
  <D.25894>:
  code.3015 = code;
  code = code.3015 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.3015 = D.36114;
  if (0 != 0) goto <D.37800>; else goto <D.37801>;
  <D.37800>:
  code.3016 = code;
  code = code.3016 + 1;
  *code.3016 = 223;
  if (1 != 0) goto <D.37803>; else goto <D.37804>;
  <D.37803>:
  if (1 != 0) goto <D.37805>; else goto <D.37806>;
  <D.37805>:
  code.3017 = code;
  code = code.3017 + 1;
  *code.3017 = 44;
  code.3018 = code;
  code = code.3018 + 1;
  *code.3018 = 36;
  goto <D.37809>;
  <D.37806>:
  if (1 != 0) goto <D.37810>; else goto <D.37811>;
  <D.37810>:
  code.3019 = code;
  code = code.3019 + 1;
  *code.3019 = 108;
  code.3020 = code;
  code = code.3020 + 1;
  *code.3020 = 36;
  *code = 0;
  code = code + 1;
  goto <D.37814>;
  <D.37811>:
  code.3021 = code;
  code = code.3021 + 1;
  *code.3021 = 172;
  code.3022 = code;
  code = code.3022 + 1;
  *code.3022 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3023 = code;
        code = code.3023 + 1;
        D.37818 = imb.b[0];
        *code.3023 = D.37818;
        code.3024 = code;
        code = code.3024 + 1;
        D.37820 = imb.b[1];
        *code.3024 = D.37820;
        code.3025 = code;
        code = code.3025 + 1;
        D.37822 = imb.b[2];
        *code.3025 = D.37822;
        code.3026 = code;
        code = code.3026 + 1;
        D.37824 = imb.b[3];
        *code.3026 = D.37824;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37814>:
  <D.37809>:
  goto <D.25896>;
  <D.37804>:
  if (1 != 0) goto <D.37825>; else goto <D.37826>;
  <D.37825>:
  code.3027 = code;
  code = code.3027 + 1;
  *code.3027 = 44;
  goto <D.25896>;
  <D.37826>:
  if (1 != 0) goto <D.37828>; else goto <D.37829>;
  <D.37828>:
  code.3028 = code;
  code = code.3028 + 1;
  *code.3028 = 108;
  *code = 0;
  code = code + 1;
  goto <D.37831>;
  <D.37829>:
  code.3029 = code;
  code = code.3029 + 1;
  *code.3029 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3030 = code;
        code = code.3030 + 1;
        D.37834 = imb.b[0];
        *code.3030 = D.37834;
        code.3031 = code;
        code = code.3031 + 1;
        D.37836 = imb.b[1];
        *code.3031 = D.37836;
        code.3032 = code;
        code = code.3032 + 1;
        D.37838 = imb.b[2];
        *code.3032 = D.37838;
        code.3033 = code;
        code = code.3033 + 1;
        D.37840 = imb.b[3];
        *code.3033 = D.37840;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37831>:
  <D.25896>:
  goto <D.37841>;
  <D.37801>:
  code.3034 = code;
  code = code.3034 + 1;
  *code.3034 = 219;
  if (1 != 0) goto <D.37843>; else goto <D.37844>;
  <D.37843>:
  if (1 != 0) goto <D.37845>; else goto <D.37846>;
  <D.37845>:
  code.3035 = code;
  code = code.3035 + 1;
  *code.3035 = 4;
  code.3036 = code;
  code = code.3036 + 1;
  *code.3036 = 36;
  goto <D.37849>;
  <D.37846>:
  if (1 != 0) goto <D.37850>; else goto <D.37851>;
  <D.37850>:
  code.3037 = code;
  code = code.3037 + 1;
  *code.3037 = 68;
  code.3038 = code;
  code = code.3038 + 1;
  *code.3038 = 36;
  *code = 0;
  code = code + 1;
  goto <D.37854>;
  <D.37851>:
  code.3039 = code;
  code = code.3039 + 1;
  *code.3039 = 132;
  code.3040 = code;
  code = code.3040 + 1;
  *code.3040 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3041 = code;
        code = code.3041 + 1;
        D.37858 = imb.b[0];
        *code.3041 = D.37858;
        code.3042 = code;
        code = code.3042 + 1;
        D.37860 = imb.b[1];
        *code.3042 = D.37860;
        code.3043 = code;
        code = code.3043 + 1;
        D.37862 = imb.b[2];
        *code.3043 = D.37862;
        code.3044 = code;
        code = code.3044 + 1;
        D.37864 = imb.b[3];
        *code.3044 = D.37864;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37854>:
  <D.37849>:
  goto <D.25899>;
  <D.37844>:
  if (1 != 0) goto <D.37865>; else goto <D.37866>;
  <D.37865>:
  code.3045 = code;
  code = code.3045 + 1;
  *code.3045 = 4;
  goto <D.25899>;
  <D.37866>:
  if (1 != 0) goto <D.37868>; else goto <D.37869>;
  <D.37868>:
  code.3046 = code;
  code = code.3046 + 1;
  *code.3046 = 68;
  *code = 0;
  code = code + 1;
  goto <D.37871>;
  <D.37869>:
  code.3047 = code;
  code = code.3047 + 1;
  *code.3047 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3048 = code;
        code = code.3048 + 1;
        D.37874 = imb.b[0];
        *code.3048 = D.37874;
        code.3049 = code;
        code = code.3049 + 1;
        D.37876 = imb.b[1];
        *code.3049 = D.37876;
        code.3050 = code;
        code = code.3050 + 1;
        D.37878 = imb.b[2];
        *code.3050 = D.37878;
        code.3051 = code;
        code = code.3051 + 1;
        D.37880 = imb.b[3];
        *code.3051 = D.37880;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37871>:
  <D.25899>:
  <D.37841>:
  code.3052 = code;
  code = code.3052 + 1;
  *code.3052 = 217;
  if (1 != 0) goto <D.37882>; else goto <D.37883>;
  <D.37882>:
  if (1 != 0) goto <D.37884>; else goto <D.37885>;
  <D.37884>:
  code.3053 = code;
  code = code.3053 + 1;
  *code.3053 = 28;
  code.3054 = code;
  code = code.3054 + 1;
  *code.3054 = 36;
  goto <D.37888>;
  <D.37885>:
  if (1 != 0) goto <D.37889>; else goto <D.37890>;
  <D.37889>:
  code.3055 = code;
  code = code.3055 + 1;
  *code.3055 = 92;
  code.3056 = code;
  code = code.3056 + 1;
  *code.3056 = 36;
  *code = 0;
  code = code + 1;
  goto <D.37893>;
  <D.37890>:
  code.3057 = code;
  code = code.3057 + 1;
  *code.3057 = 156;
  code.3058 = code;
  code = code.3058 + 1;
  *code.3058 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3059 = code;
        code = code.3059 + 1;
        D.37897 = imb.b[0];
        *code.3059 = D.37897;
        code.3060 = code;
        code = code.3060 + 1;
        D.37899 = imb.b[1];
        *code.3060 = D.37899;
        code.3061 = code;
        code = code.3061 + 1;
        D.37901 = imb.b[2];
        *code.3061 = D.37901;
        code.3062 = code;
        code = code.3062 + 1;
        D.37903 = imb.b[3];
        *code.3062 = D.37903;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37893>:
  <D.37888>:
  goto <D.25902>;
  <D.37883>:
  if (1 != 0) goto <D.37904>; else goto <D.37905>;
  <D.37904>:
  code.3063 = code;
  code = code.3063 + 1;
  *code.3063 = 28;
  goto <D.25902>;
  <D.37905>:
  if (1 != 0) goto <D.37907>; else goto <D.37908>;
  <D.37907>:
  code.3064 = code;
  code = code.3064 + 1;
  *code.3064 = 92;
  *code = 0;
  code = code + 1;
  goto <D.37910>;
  <D.37908>:
  code.3065 = code;
  code = code.3065 + 1;
  *code.3065 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3066 = code;
        code = code.3066 + 1;
        D.37913 = imb.b[0];
        *code.3066 = D.37913;
        code.3067 = code;
        code = code.3067 + 1;
        D.37915 = imb.b[1];
        *code.3067 = D.37915;
        code.3068 = code;
        code = code.3068 + 1;
        D.37917 = imb.b[2];
        *code.3068 = D.37917;
        code.3069 = code;
        code = code.3069 + 1;
        D.37919 = imb.b[3];
        *code.3069 = D.37919;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37910>:
  <D.25902>:
  code.3070 = code;
  code = code.3070 + 1;
  *code.3070 = 217;
  if (1 != 0) goto <D.37921>; else goto <D.37922>;
  <D.37921>:
  if (1 != 0) goto <D.37923>; else goto <D.37924>;
  <D.37923>:
  code.3071 = code;
  code = code.3071 + 1;
  *code.3071 = 4;
  code.3072 = code;
  code = code.3072 + 1;
  *code.3072 = 36;
  goto <D.37927>;
  <D.37924>:
  if (1 != 0) goto <D.37928>; else goto <D.37929>;
  <D.37928>:
  code.3073 = code;
  code = code.3073 + 1;
  *code.3073 = 68;
  code.3074 = code;
  code = code.3074 + 1;
  *code.3074 = 36;
  *code = 0;
  code = code + 1;
  goto <D.37932>;
  <D.37929>:
  code.3075 = code;
  code = code.3075 + 1;
  *code.3075 = 132;
  code.3076 = code;
  code = code.3076 + 1;
  *code.3076 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3077 = code;
        code = code.3077 + 1;
        D.37936 = imb.b[0];
        *code.3077 = D.37936;
        code.3078 = code;
        code = code.3078 + 1;
        D.37938 = imb.b[1];
        *code.3078 = D.37938;
        code.3079 = code;
        code = code.3079 + 1;
        D.37940 = imb.b[2];
        *code.3079 = D.37940;
        code.3080 = code;
        code = code.3080 + 1;
        D.37942 = imb.b[3];
        *code.3080 = D.37942;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37932>:
  <D.37927>:
  goto <D.25905>;
  <D.37922>:
  if (1 != 0) goto <D.37943>; else goto <D.37944>;
  <D.37943>:
  code.3081 = code;
  code = code.3081 + 1;
  *code.3081 = 4;
  goto <D.25905>;
  <D.37944>:
  if (1 != 0) goto <D.37946>; else goto <D.37947>;
  <D.37946>:
  code.3082 = code;
  code = code.3082 + 1;
  *code.3082 = 68;
  *code = 0;
  code = code + 1;
  goto <D.37949>;
  <D.37947>:
  code.3083 = code;
  code = code.3083 + 1;
  *code.3083 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3084 = code;
        code = code.3084 + 1;
        D.37952 = imb.b[0];
        *code.3084 = D.37952;
        code.3085 = code;
        code = code.3085 + 1;
        D.37954 = imb.b[1];
        *code.3085 = D.37954;
        code.3086 = code;
        code = code.3086 + 1;
        D.37956 = imb.b[2];
        *code.3086 = D.37956;
        code.3087 = code;
        code = code.3087 + 1;
        D.37958 = imb.b[3];
        *code.3087 = D.37958;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37949>:
  <D.25905>:
  if (0 != 0) goto <D.37959>; else goto <D.37960>;
  <D.37959>:
  code.3088 = code;
  code = code.3088 + 1;
  *code.3088 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3089 = code;
        code = code.3089 + 1;
        D.37963 = imb.b[0];
        *code.3089 = D.37963;
        code.3090 = code;
        code = code.3090 + 1;
        D.37965 = imb.b[1];
        *code.3090 = D.37965;
        code.3091 = code;
        code = code.3091 + 1;
        D.37967 = imb.b[2];
        *code.3091 = D.37967;
        code.3092 = code;
        code = code.3092 + 1;
        D.37969 = imb.b[3];
        *code.3092 = D.37969;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25908>;
  <D.37960>:
  if (1 != 0) goto <D.37970>; else goto <D.37971>;
  <D.37970>:
  code.3093 = code;
  code = code.3093 + 1;
  *code.3093 = 131;
  code.3094 = code;
  code = code.3094 + 1;
  *code.3094 = 196;
  *code = 4;
  code = code + 1;
  goto <D.37974>;
  <D.37971>:
  code.3095 = code;
  code = code.3095 + 1;
  *code.3095 = 129;
  code.3096 = code;
  code = code.3096 + 1;
  *code.3096 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3097 = code;
        code = code.3097 + 1;
        D.37978 = imb.b[0];
        *code.3097 = D.37978;
        code.3098 = code;
        code = code.3098 + 1;
        D.37980 = imb.b[1];
        *code.3098 = D.37980;
        code.3099 = code;
        code = code.3099 + 1;
        D.37982 = imb.b[2];
        *code.3099 = D.37982;
        code.3100 = code;
        code = code.3100 + 1;
        D.37984 = imb.b[3];
        *code.3100 = D.37984;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37974>:
  <D.25908>:
  goto <D.24796>;
  <D.25910>:
  code.3101 = code;
  code = code.3101 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.3101 = D.36114;
  if (0 != 0) goto <D.37986>; else goto <D.37987>;
  <D.37986>:
  code.3102 = code;
  code = code.3102 + 1;
  *code.3102 = 223;
  if (1 != 0) goto <D.37989>; else goto <D.37990>;
  <D.37989>:
  if (1 != 0) goto <D.37991>; else goto <D.37992>;
  <D.37991>:
  code.3103 = code;
  code = code.3103 + 1;
  *code.3103 = 44;
  code.3104 = code;
  code = code.3104 + 1;
  *code.3104 = 36;
  goto <D.37995>;
  <D.37992>:
  if (1 != 0) goto <D.37996>; else goto <D.37997>;
  <D.37996>:
  code.3105 = code;
  code = code.3105 + 1;
  *code.3105 = 108;
  code.3106 = code;
  code = code.3106 + 1;
  *code.3106 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38000>;
  <D.37997>:
  code.3107 = code;
  code = code.3107 + 1;
  *code.3107 = 172;
  code.3108 = code;
  code = code.3108 + 1;
  *code.3108 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3109 = code;
        code = code.3109 + 1;
        D.38004 = imb.b[0];
        *code.3109 = D.38004;
        code.3110 = code;
        code = code.3110 + 1;
        D.38006 = imb.b[1];
        *code.3110 = D.38006;
        code.3111 = code;
        code = code.3111 + 1;
        D.38008 = imb.b[2];
        *code.3111 = D.38008;
        code.3112 = code;
        code = code.3112 + 1;
        D.38010 = imb.b[3];
        *code.3112 = D.38010;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38000>:
  <D.37995>:
  goto <D.25912>;
  <D.37990>:
  if (1 != 0) goto <D.38011>; else goto <D.38012>;
  <D.38011>:
  code.3113 = code;
  code = code.3113 + 1;
  *code.3113 = 44;
  goto <D.25912>;
  <D.38012>:
  if (1 != 0) goto <D.38014>; else goto <D.38015>;
  <D.38014>:
  code.3114 = code;
  code = code.3114 + 1;
  *code.3114 = 108;
  *code = 0;
  code = code + 1;
  goto <D.38017>;
  <D.38015>:
  code.3115 = code;
  code = code.3115 + 1;
  *code.3115 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3116 = code;
        code = code.3116 + 1;
        D.38020 = imb.b[0];
        *code.3116 = D.38020;
        code.3117 = code;
        code = code.3117 + 1;
        D.38022 = imb.b[1];
        *code.3117 = D.38022;
        code.3118 = code;
        code = code.3118 + 1;
        D.38024 = imb.b[2];
        *code.3118 = D.38024;
        code.3119 = code;
        code = code.3119 + 1;
        D.38026 = imb.b[3];
        *code.3119 = D.38026;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38017>:
  <D.25912>:
  goto <D.38027>;
  <D.37987>:
  code.3120 = code;
  code = code.3120 + 1;
  *code.3120 = 219;
  if (1 != 0) goto <D.38029>; else goto <D.38030>;
  <D.38029>:
  if (1 != 0) goto <D.38031>; else goto <D.38032>;
  <D.38031>:
  code.3121 = code;
  code = code.3121 + 1;
  *code.3121 = 4;
  code.3122 = code;
  code = code.3122 + 1;
  *code.3122 = 36;
  goto <D.38035>;
  <D.38032>:
  if (1 != 0) goto <D.38036>; else goto <D.38037>;
  <D.38036>:
  code.3123 = code;
  code = code.3123 + 1;
  *code.3123 = 68;
  code.3124 = code;
  code = code.3124 + 1;
  *code.3124 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38040>;
  <D.38037>:
  code.3125 = code;
  code = code.3125 + 1;
  *code.3125 = 132;
  code.3126 = code;
  code = code.3126 + 1;
  *code.3126 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3127 = code;
        code = code.3127 + 1;
        D.38044 = imb.b[0];
        *code.3127 = D.38044;
        code.3128 = code;
        code = code.3128 + 1;
        D.38046 = imb.b[1];
        *code.3128 = D.38046;
        code.3129 = code;
        code = code.3129 + 1;
        D.38048 = imb.b[2];
        *code.3129 = D.38048;
        code.3130 = code;
        code = code.3130 + 1;
        D.38050 = imb.b[3];
        *code.3130 = D.38050;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38040>:
  <D.38035>:
  goto <D.25915>;
  <D.38030>:
  if (1 != 0) goto <D.38051>; else goto <D.38052>;
  <D.38051>:
  code.3131 = code;
  code = code.3131 + 1;
  *code.3131 = 4;
  goto <D.25915>;
  <D.38052>:
  if (1 != 0) goto <D.38054>; else goto <D.38055>;
  <D.38054>:
  code.3132 = code;
  code = code.3132 + 1;
  *code.3132 = 68;
  *code = 0;
  code = code + 1;
  goto <D.38057>;
  <D.38055>:
  code.3133 = code;
  code = code.3133 + 1;
  *code.3133 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3134 = code;
        code = code.3134 + 1;
        D.38060 = imb.b[0];
        *code.3134 = D.38060;
        code.3135 = code;
        code = code.3135 + 1;
        D.38062 = imb.b[1];
        *code.3135 = D.38062;
        code.3136 = code;
        code = code.3136 + 1;
        D.38064 = imb.b[2];
        *code.3136 = D.38064;
        code.3137 = code;
        code = code.3137 + 1;
        D.38066 = imb.b[3];
        *code.3137 = D.38066;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38057>:
  <D.25915>:
  <D.38027>:
  if (0 != 0) goto <D.38067>; else goto <D.38068>;
  <D.38067>:
  code.3138 = code;
  code = code.3138 + 1;
  *code.3138 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3139 = code;
        code = code.3139 + 1;
        D.38071 = imb.b[0];
        *code.3139 = D.38071;
        code.3140 = code;
        code = code.3140 + 1;
        D.38073 = imb.b[1];
        *code.3140 = D.38073;
        code.3141 = code;
        code = code.3141 + 1;
        D.38075 = imb.b[2];
        *code.3141 = D.38075;
        code.3142 = code;
        code = code.3142 + 1;
        D.38077 = imb.b[3];
        *code.3142 = D.38077;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25918>;
  <D.38068>:
  if (1 != 0) goto <D.38078>; else goto <D.38079>;
  <D.38078>:
  code.3143 = code;
  code = code.3143 + 1;
  *code.3143 = 131;
  code.3144 = code;
  code = code.3144 + 1;
  *code.3144 = 196;
  *code = 4;
  code = code + 1;
  goto <D.38082>;
  <D.38079>:
  code.3145 = code;
  code = code.3145 + 1;
  *code.3145 = 129;
  code.3146 = code;
  code = code.3146 + 1;
  *code.3146 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3147 = code;
        code = code.3147 + 1;
        D.38086 = imb.b[0];
        *code.3147 = D.38086;
        code.3148 = code;
        code = code.3148 + 1;
        D.38088 = imb.b[1];
        *code.3148 = D.38088;
        code.3149 = code;
        code = code.3149 + 1;
        D.38090 = imb.b[2];
        *code.3149 = D.38090;
        code.3150 = code;
        code = code.3150 + 1;
        D.38092 = imb.b[3];
        *code.3150 = D.38092;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38082>:
  <D.25918>:
  goto <D.24796>;
  <D.25920>:
  {
    int _imm;

    _imm = 0;
    _imm.3151 = (unsigned int) _imm;
    D.38094 = _imm.3151 + 128;
    if (D.38094 <= 255) goto <D.38095>; else goto <D.38096>;
    <D.38095>:
    code.3152 = code;
    code = code.3152 + 1;
    *code.3152 = 106;
    D.38098 = (unsigned char) _imm;
    *code = D.38098;
    code = code + 1;
    goto <D.38099>;
    <D.38096>:
    code.3153 = code;
    code = code.3153 + 1;
    *code.3153 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.3154 = code;
          code = code.3154 + 1;
          D.38102 = imb.b[0];
          *code.3154 = D.38102;
          code.3155 = code;
          code = code.3155 + 1;
          D.38104 = imb.b[1];
          *code.3155 = D.38104;
          code.3156 = code;
          code = code.3156 + 1;
          D.38106 = imb.b[2];
          *code.3156 = D.38106;
          code.3157 = code;
          code = code.3157 + 1;
          D.38108 = imb.b[3];
          *code.3157 = D.38108;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.38099>:
  }
  code.3158 = code;
  code = code.3158 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.3158 = D.36114;
  if (1 != 0) goto <D.38110>; else goto <D.38111>;
  <D.38110>:
  code.3159 = code;
  code = code.3159 + 1;
  *code.3159 = 223;
  if (1 != 0) goto <D.38113>; else goto <D.38114>;
  <D.38113>:
  if (1 != 0) goto <D.38115>; else goto <D.38116>;
  <D.38115>:
  code.3160 = code;
  code = code.3160 + 1;
  *code.3160 = 44;
  code.3161 = code;
  code = code.3161 + 1;
  *code.3161 = 36;
  goto <D.38119>;
  <D.38116>:
  if (1 != 0) goto <D.38120>; else goto <D.38121>;
  <D.38120>:
  code.3162 = code;
  code = code.3162 + 1;
  *code.3162 = 108;
  code.3163 = code;
  code = code.3163 + 1;
  *code.3163 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38124>;
  <D.38121>:
  code.3164 = code;
  code = code.3164 + 1;
  *code.3164 = 172;
  code.3165 = code;
  code = code.3165 + 1;
  *code.3165 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3166 = code;
        code = code.3166 + 1;
        D.38128 = imb.b[0];
        *code.3166 = D.38128;
        code.3167 = code;
        code = code.3167 + 1;
        D.38130 = imb.b[1];
        *code.3167 = D.38130;
        code.3168 = code;
        code = code.3168 + 1;
        D.38132 = imb.b[2];
        *code.3168 = D.38132;
        code.3169 = code;
        code = code.3169 + 1;
        D.38134 = imb.b[3];
        *code.3169 = D.38134;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38124>:
  <D.38119>:
  goto <D.25924>;
  <D.38114>:
  if (1 != 0) goto <D.38135>; else goto <D.38136>;
  <D.38135>:
  code.3170 = code;
  code = code.3170 + 1;
  *code.3170 = 44;
  goto <D.25924>;
  <D.38136>:
  if (1 != 0) goto <D.38138>; else goto <D.38139>;
  <D.38138>:
  code.3171 = code;
  code = code.3171 + 1;
  *code.3171 = 108;
  *code = 0;
  code = code + 1;
  goto <D.38141>;
  <D.38139>:
  code.3172 = code;
  code = code.3172 + 1;
  *code.3172 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3173 = code;
        code = code.3173 + 1;
        D.38144 = imb.b[0];
        *code.3173 = D.38144;
        code.3174 = code;
        code = code.3174 + 1;
        D.38146 = imb.b[1];
        *code.3174 = D.38146;
        code.3175 = code;
        code = code.3175 + 1;
        D.38148 = imb.b[2];
        *code.3175 = D.38148;
        code.3176 = code;
        code = code.3176 + 1;
        D.38150 = imb.b[3];
        *code.3176 = D.38150;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38141>:
  <D.25924>:
  goto <D.38151>;
  <D.38111>:
  code.3177 = code;
  code = code.3177 + 1;
  *code.3177 = 219;
  if (1 != 0) goto <D.38153>; else goto <D.38154>;
  <D.38153>:
  if (1 != 0) goto <D.38155>; else goto <D.38156>;
  <D.38155>:
  code.3178 = code;
  code = code.3178 + 1;
  *code.3178 = 4;
  code.3179 = code;
  code = code.3179 + 1;
  *code.3179 = 36;
  goto <D.38159>;
  <D.38156>:
  if (1 != 0) goto <D.38160>; else goto <D.38161>;
  <D.38160>:
  code.3180 = code;
  code = code.3180 + 1;
  *code.3180 = 68;
  code.3181 = code;
  code = code.3181 + 1;
  *code.3181 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38164>;
  <D.38161>:
  code.3182 = code;
  code = code.3182 + 1;
  *code.3182 = 132;
  code.3183 = code;
  code = code.3183 + 1;
  *code.3183 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3184 = code;
        code = code.3184 + 1;
        D.38168 = imb.b[0];
        *code.3184 = D.38168;
        code.3185 = code;
        code = code.3185 + 1;
        D.38170 = imb.b[1];
        *code.3185 = D.38170;
        code.3186 = code;
        code = code.3186 + 1;
        D.38172 = imb.b[2];
        *code.3186 = D.38172;
        code.3187 = code;
        code = code.3187 + 1;
        D.38174 = imb.b[3];
        *code.3187 = D.38174;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38164>:
  <D.38159>:
  goto <D.25927>;
  <D.38154>:
  if (1 != 0) goto <D.38175>; else goto <D.38176>;
  <D.38175>:
  code.3188 = code;
  code = code.3188 + 1;
  *code.3188 = 4;
  goto <D.25927>;
  <D.38176>:
  if (1 != 0) goto <D.38178>; else goto <D.38179>;
  <D.38178>:
  code.3189 = code;
  code = code.3189 + 1;
  *code.3189 = 68;
  *code = 0;
  code = code + 1;
  goto <D.38181>;
  <D.38179>:
  code.3190 = code;
  code = code.3190 + 1;
  *code.3190 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3191 = code;
        code = code.3191 + 1;
        D.38184 = imb.b[0];
        *code.3191 = D.38184;
        code.3192 = code;
        code = code.3192 + 1;
        D.38186 = imb.b[1];
        *code.3192 = D.38186;
        code.3193 = code;
        code = code.3193 + 1;
        D.38188 = imb.b[2];
        *code.3193 = D.38188;
        code.3194 = code;
        code = code.3194 + 1;
        D.38190 = imb.b[3];
        *code.3194 = D.38190;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38181>:
  <D.25927>:
  <D.38151>:
  if (0 != 0) goto <D.38191>; else goto <D.38192>;
  <D.38191>:
  code.3195 = code;
  code = code.3195 + 1;
  *code.3195 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3196 = code;
        code = code.3196 + 1;
        D.38195 = imb.b[0];
        *code.3196 = D.38195;
        code.3197 = code;
        code = code.3197 + 1;
        D.38197 = imb.b[1];
        *code.3197 = D.38197;
        code.3198 = code;
        code = code.3198 + 1;
        D.38199 = imb.b[2];
        *code.3198 = D.38199;
        code.3199 = code;
        code = code.3199 + 1;
        D.38201 = imb.b[3];
        *code.3199 = D.38201;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25930>;
  <D.38192>:
  if (1 != 0) goto <D.38202>; else goto <D.38203>;
  <D.38202>:
  code.3200 = code;
  code = code.3200 + 1;
  *code.3200 = 131;
  code.3201 = code;
  code = code.3201 + 1;
  *code.3201 = 196;
  *code = 8;
  code = code + 1;
  goto <D.38206>;
  <D.38203>:
  code.3202 = code;
  code = code.3202 + 1;
  *code.3202 = 129;
  code.3203 = code;
  code = code.3203 + 1;
  *code.3203 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3204 = code;
        code = code.3204 + 1;
        D.38210 = imb.b[0];
        *code.3204 = D.38210;
        code.3205 = code;
        code = code.3205 + 1;
        D.38212 = imb.b[1];
        *code.3205 = D.38212;
        code.3206 = code;
        code = code.3206 + 1;
        D.38214 = imb.b[2];
        *code.3206 = D.38214;
        code.3207 = code;
        code = code.3207 + 1;
        D.38216 = imb.b[3];
        *code.3207 = D.38216;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38206>:
  <D.25930>:
  goto <D.24796>;
  <D.25932>:
  if (1 != 0) goto <D.38217>; else goto <D.38218>;
  <D.38217>:
  code.3208 = code;
  code = code.3208 + 1;
  *code.3208 = 223;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.38220>; else goto <D.38221>;
  <D.38220>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38222>; else goto <D.38223>;
  <D.38222>:
  code.3209 = code;
  code = code.3209 + 1;
  *code.3209 = 44;
  code.3210 = code;
  code = code.3210 + 1;
  *code.3210 = 36;
  goto <D.38226>;
  <D.38223>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38227>; else goto <D.38228>;
  <D.38227>:
  code.3211 = code;
  code = code.3211 + 1;
  *code.3211 = 108;
  code.3212 = code;
  code = code.3212 + 1;
  *code.3212 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38231>;
  <D.38228>:
  code.3213 = code;
  code = code.3213 + 1;
  *code.3213 = 172;
  code.3214 = code;
  code = code.3214 + 1;
  *code.3214 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3215 = code;
        code = code.3215 + 1;
        D.38235 = imb.b[0];
        *code.3215 = D.38235;
        code.3216 = code;
        code = code.3216 + 1;
        D.38237 = imb.b[1];
        *code.3216 = D.38237;
        code.3217 = code;
        code = code.3217 + 1;
        D.38239 = imb.b[2];
        *code.3217 = D.38239;
        code.3218 = code;
        code = code.3218 + 1;
        D.38241 = imb.b[3];
        *code.3218 = D.38241;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38231>:
  <D.38226>:
  goto <D.25934>;
  <D.38221>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38242>; else goto <D.38243>;
  <D.38242>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.38244>; else goto <D.38245>;
  <D.38244>:
  code.3219 = code;
  code = code.3219 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33042 = D.31586 | 40;
  D.33043 = (unsigned char) D.33042;
  *code.3219 = D.33043;
  goto <D.25934>;
  <D.38245>:
  <D.38243>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38247>; else goto <D.38248>;
  <D.38247>:
  code.3220 = code;
  code = code.3220 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33047 = D.31586 | 104;
  D.33048 = (unsigned char) D.33047;
  *code.3220 = D.33048;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38250>;
  <D.38248>:
  code.3221 = code;
  code = code.3221 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33051 = D.31586 | -88;
  D.33052 = (unsigned char) D.33051;
  *code.3221 = D.33052;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3222 = code;
        code = code.3222 + 1;
        D.38253 = imb.b[0];
        *code.3222 = D.38253;
        code.3223 = code;
        code = code.3223 + 1;
        D.38255 = imb.b[1];
        *code.3223 = D.38255;
        code.3224 = code;
        code = code.3224 + 1;
        D.38257 = imb.b[2];
        *code.3224 = D.38257;
        code.3225 = code;
        code = code.3225 + 1;
        D.38259 = imb.b[3];
        *code.3225 = D.38259;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38250>:
  <D.25934>:
  goto <D.38260>;
  <D.38218>:
  code.3226 = code;
  code = code.3226 + 1;
  *code.3226 = 219;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.38262>; else goto <D.38263>;
  <D.38262>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38264>; else goto <D.38265>;
  <D.38264>:
  code.3227 = code;
  code = code.3227 + 1;
  *code.3227 = 4;
  code.3228 = code;
  code = code.3228 + 1;
  *code.3228 = 36;
  goto <D.38268>;
  <D.38265>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38269>; else goto <D.38270>;
  <D.38269>:
  code.3229 = code;
  code = code.3229 + 1;
  *code.3229 = 68;
  code.3230 = code;
  code = code.3230 + 1;
  *code.3230 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38273>;
  <D.38270>:
  code.3231 = code;
  code = code.3231 + 1;
  *code.3231 = 132;
  code.3232 = code;
  code = code.3232 + 1;
  *code.3232 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3233 = code;
        code = code.3233 + 1;
        D.38277 = imb.b[0];
        *code.3233 = D.38277;
        code.3234 = code;
        code = code.3234 + 1;
        D.38279 = imb.b[1];
        *code.3234 = D.38279;
        code.3235 = code;
        code = code.3235 + 1;
        D.38281 = imb.b[2];
        *code.3235 = D.38281;
        code.3236 = code;
        code = code.3236 + 1;
        D.38283 = imb.b[3];
        *code.3236 = D.38283;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38273>:
  <D.38268>:
  goto <D.25937>;
  <D.38263>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38284>; else goto <D.38285>;
  <D.38284>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.38286>; else goto <D.38287>;
  <D.38286>:
  code.3237 = code;
  code = code.3237 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.3237 = D.31581;
  goto <D.25937>;
  <D.38287>:
  <D.38285>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38289>; else goto <D.38290>;
  <D.38289>:
  code.3238 = code;
  code = code.3238 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.3238 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38292>;
  <D.38290>:
  code.3239 = code;
  code = code.3239 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.3239 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3240 = code;
        code = code.3240 + 1;
        D.38295 = imb.b[0];
        *code.3240 = D.38295;
        code.3241 = code;
        code = code.3241 + 1;
        D.38297 = imb.b[1];
        *code.3241 = D.38297;
        code.3242 = code;
        code = code.3242 + 1;
        D.38299 = imb.b[2];
        *code.3242 = D.38299;
        code.3243 = code;
        code = code.3243 + 1;
        D.38301 = imb.b[3];
        *code.3243 = D.38301;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38292>:
  <D.25937>:
  <D.38260>:
  goto <D.24796>;
  <D.25939>:
  if (0 != 0) goto <D.38302>; else goto <D.38303>;
  <D.38302>:
  code.3244 = code;
  code = code.3244 + 1;
  *code.3244 = 223;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.38305>; else goto <D.38306>;
  <D.38305>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38307>; else goto <D.38308>;
  <D.38307>:
  code.3245 = code;
  code = code.3245 + 1;
  *code.3245 = 44;
  code.3246 = code;
  code = code.3246 + 1;
  *code.3246 = 36;
  goto <D.38311>;
  <D.38308>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38312>; else goto <D.38313>;
  <D.38312>:
  code.3247 = code;
  code = code.3247 + 1;
  *code.3247 = 108;
  code.3248 = code;
  code = code.3248 + 1;
  *code.3248 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38316>;
  <D.38313>:
  code.3249 = code;
  code = code.3249 + 1;
  *code.3249 = 172;
  code.3250 = code;
  code = code.3250 + 1;
  *code.3250 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3251 = code;
        code = code.3251 + 1;
        D.38320 = imb.b[0];
        *code.3251 = D.38320;
        code.3252 = code;
        code = code.3252 + 1;
        D.38322 = imb.b[1];
        *code.3252 = D.38322;
        code.3253 = code;
        code = code.3253 + 1;
        D.38324 = imb.b[2];
        *code.3253 = D.38324;
        code.3254 = code;
        code = code.3254 + 1;
        D.38326 = imb.b[3];
        *code.3254 = D.38326;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38316>:
  <D.38311>:
  goto <D.25941>;
  <D.38306>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38327>; else goto <D.38328>;
  <D.38327>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.38329>; else goto <D.38330>;
  <D.38329>:
  code.3255 = code;
  code = code.3255 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33042 = D.31586 | 40;
  D.33043 = (unsigned char) D.33042;
  *code.3255 = D.33043;
  goto <D.25941>;
  <D.38330>:
  <D.38328>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38332>; else goto <D.38333>;
  <D.38332>:
  code.3256 = code;
  code = code.3256 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33047 = D.31586 | 104;
  D.33048 = (unsigned char) D.33047;
  *code.3256 = D.33048;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38335>;
  <D.38333>:
  code.3257 = code;
  code = code.3257 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.33051 = D.31586 | -88;
  D.33052 = (unsigned char) D.33051;
  *code.3257 = D.33052;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3258 = code;
        code = code.3258 + 1;
        D.38338 = imb.b[0];
        *code.3258 = D.38338;
        code.3259 = code;
        code = code.3259 + 1;
        D.38340 = imb.b[1];
        *code.3259 = D.38340;
        code.3260 = code;
        code = code.3260 + 1;
        D.38342 = imb.b[2];
        *code.3260 = D.38342;
        code.3261 = code;
        code = code.3261 + 1;
        D.38344 = imb.b[3];
        *code.3261 = D.38344;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38335>:
  <D.25941>:
  goto <D.38345>;
  <D.38303>:
  code.3262 = code;
  code = code.3262 + 1;
  *code.3262 = 219;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.38347>; else goto <D.38348>;
  <D.38347>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38349>; else goto <D.38350>;
  <D.38349>:
  code.3263 = code;
  code = code.3263 + 1;
  *code.3263 = 4;
  code.3264 = code;
  code = code.3264 + 1;
  *code.3264 = 36;
  goto <D.38353>;
  <D.38350>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38354>; else goto <D.38355>;
  <D.38354>:
  code.3265 = code;
  code = code.3265 + 1;
  *code.3265 = 68;
  code.3266 = code;
  code = code.3266 + 1;
  *code.3266 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38358>;
  <D.38355>:
  code.3267 = code;
  code = code.3267 + 1;
  *code.3267 = 132;
  code.3268 = code;
  code = code.3268 + 1;
  *code.3268 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3269 = code;
        code = code.3269 + 1;
        D.38362 = imb.b[0];
        *code.3269 = D.38362;
        code.3270 = code;
        code = code.3270 + 1;
        D.38364 = imb.b[1];
        *code.3270 = D.38364;
        code.3271 = code;
        code = code.3271 + 1;
        D.38366 = imb.b[2];
        *code.3271 = D.38366;
        code.3272 = code;
        code = code.3272 + 1;
        D.38368 = imb.b[3];
        *code.3272 = D.38368;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38358>:
  <D.38353>:
  goto <D.25944>;
  <D.38348>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.38369>; else goto <D.38370>;
  <D.38369>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.38371>; else goto <D.38372>;
  <D.38371>:
  code.3273 = code;
  code = code.3273 + 1;
  D.31548 = ins->sreg1;
  D.31580 = (unsigned char) D.31548;
  D.31581 = D.31580 & 7;
  *code.3273 = D.31581;
  goto <D.25944>;
  <D.38372>:
  <D.38370>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.38374>; else goto <D.38375>;
  <D.38374>:
  code.3274 = code;
  code = code.3274 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31587 = D.31586 | 64;
  D.31588 = (unsigned char) D.31587;
  *code.3274 = D.31588;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.38377>;
  <D.38375>:
  code.3275 = code;
  code = code.3275 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.31591 = D.31586 | -128;
  D.31592 = (unsigned char) D.31591;
  *code.3275 = D.31592;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.3276 = code;
        code = code.3276 + 1;
        D.38380 = imb.b[0];
        *code.3276 = D.38380;
        code.3277 = code;
        code = code.3277 + 1;
        D.38382 = imb.b[1];
        *code.3277 = D.38382;
        code.3278 = code;
        code = code.3278 + 1;
        D.38384 = imb.b[2];
        *code.3278 = D.38384;
        code.3279 = code;
        code = code.3279 + 1;
        D.38386 = imb.b[3];
        *code.3279 = D.38386;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38377>:
  <D.25944>:
  <D.38345>:
  goto <D.24796>;
  <D.25946>:
  if (0 != 0) goto <D.38387>; else goto <D.38388>;
  <D.38387>:
  code.3280 = code;
  code = code.3280 + 1;
  *code.3280 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3281 = code;
        code = code.3281 + 1;
        D.38391 = imb.b[0];
        *code.3281 = D.38391;
        code.3282 = code;
        code = code.3282 + 1;
        D.38393 = imb.b[1];
        *code.3282 = D.38393;
        code.3283 = code;
        code = code.3283 + 1;
        D.38395 = imb.b[2];
        *code.3283 = D.38395;
        code.3284 = code;
        code = code.3284 + 1;
        D.38397 = imb.b[3];
        *code.3284 = D.38397;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25948>;
  <D.38388>:
  if (1 != 0) goto <D.38398>; else goto <D.38399>;
  <D.38398>:
  code.3285 = code;
  code = code.3285 + 1;
  *code.3285 = 131;
  code.3286 = code;
  code = code.3286 + 1;
  *code.3286 = 236;
  *code = 4;
  code = code + 1;
  goto <D.38402>;
  <D.38399>:
  code.3287 = code;
  code = code.3287 + 1;
  *code.3287 = 129;
  code.3288 = code;
  code = code.3288 + 1;
  *code.3288 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3289 = code;
        code = code.3289 + 1;
        D.38406 = imb.b[0];
        *code.3289 = D.38406;
        code.3290 = code;
        code = code.3290 + 1;
        D.38408 = imb.b[1];
        *code.3290 = D.38408;
        code.3291 = code;
        code = code.3291 + 1;
        D.38410 = imb.b[2];
        *code.3291 = D.38410;
        code.3292 = code;
        code = code.3292 + 1;
        D.38412 = imb.b[3];
        *code.3292 = D.38412;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38402>:
  <D.25948>:
  code.3293 = code;
  code = code.3293 + 1;
  *code.3293 = 217;
  if (1 != 0) goto <D.38414>; else goto <D.38415>;
  <D.38414>:
  if (1 != 0) goto <D.38416>; else goto <D.38417>;
  <D.38416>:
  code.3294 = code;
  code = code.3294 + 1;
  *code.3294 = 28;
  code.3295 = code;
  code = code.3295 + 1;
  *code.3295 = 36;
  goto <D.38420>;
  <D.38417>:
  if (1 != 0) goto <D.38421>; else goto <D.38422>;
  <D.38421>:
  code.3296 = code;
  code = code.3296 + 1;
  *code.3296 = 92;
  code.3297 = code;
  code = code.3297 + 1;
  *code.3297 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38425>;
  <D.38422>:
  code.3298 = code;
  code = code.3298 + 1;
  *code.3298 = 156;
  code.3299 = code;
  code = code.3299 + 1;
  *code.3299 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3300 = code;
        code = code.3300 + 1;
        D.38429 = imb.b[0];
        *code.3300 = D.38429;
        code.3301 = code;
        code = code.3301 + 1;
        D.38431 = imb.b[1];
        *code.3301 = D.38431;
        code.3302 = code;
        code = code.3302 + 1;
        D.38433 = imb.b[2];
        *code.3302 = D.38433;
        code.3303 = code;
        code = code.3303 + 1;
        D.38435 = imb.b[3];
        *code.3303 = D.38435;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38425>:
  <D.38420>:
  goto <D.25951>;
  <D.38415>:
  if (1 != 0) goto <D.38436>; else goto <D.38437>;
  <D.38436>:
  code.3304 = code;
  code = code.3304 + 1;
  *code.3304 = 28;
  goto <D.25951>;
  <D.38437>:
  if (1 != 0) goto <D.38439>; else goto <D.38440>;
  <D.38439>:
  code.3305 = code;
  code = code.3305 + 1;
  *code.3305 = 92;
  *code = 0;
  code = code + 1;
  goto <D.38442>;
  <D.38440>:
  code.3306 = code;
  code = code.3306 + 1;
  *code.3306 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3307 = code;
        code = code.3307 + 1;
        D.38445 = imb.b[0];
        *code.3307 = D.38445;
        code.3308 = code;
        code = code.3308 + 1;
        D.38447 = imb.b[1];
        *code.3308 = D.38447;
        code.3309 = code;
        code = code.3309 + 1;
        D.38449 = imb.b[2];
        *code.3309 = D.38449;
        code.3310 = code;
        code = code.3310 + 1;
        D.38451 = imb.b[3];
        *code.3310 = D.38451;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38442>:
  <D.25951>:
  code.3311 = code;
  code = code.3311 + 1;
  *code.3311 = 217;
  if (1 != 0) goto <D.38453>; else goto <D.38454>;
  <D.38453>:
  if (1 != 0) goto <D.38455>; else goto <D.38456>;
  <D.38455>:
  code.3312 = code;
  code = code.3312 + 1;
  *code.3312 = 4;
  code.3313 = code;
  code = code.3313 + 1;
  *code.3313 = 36;
  goto <D.38459>;
  <D.38456>:
  if (1 != 0) goto <D.38460>; else goto <D.38461>;
  <D.38460>:
  code.3314 = code;
  code = code.3314 + 1;
  *code.3314 = 68;
  code.3315 = code;
  code = code.3315 + 1;
  *code.3315 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38464>;
  <D.38461>:
  code.3316 = code;
  code = code.3316 + 1;
  *code.3316 = 132;
  code.3317 = code;
  code = code.3317 + 1;
  *code.3317 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3318 = code;
        code = code.3318 + 1;
        D.38468 = imb.b[0];
        *code.3318 = D.38468;
        code.3319 = code;
        code = code.3319 + 1;
        D.38470 = imb.b[1];
        *code.3319 = D.38470;
        code.3320 = code;
        code = code.3320 + 1;
        D.38472 = imb.b[2];
        *code.3320 = D.38472;
        code.3321 = code;
        code = code.3321 + 1;
        D.38474 = imb.b[3];
        *code.3321 = D.38474;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38464>:
  <D.38459>:
  goto <D.25954>;
  <D.38454>:
  if (1 != 0) goto <D.38475>; else goto <D.38476>;
  <D.38475>:
  code.3322 = code;
  code = code.3322 + 1;
  *code.3322 = 4;
  goto <D.25954>;
  <D.38476>:
  if (1 != 0) goto <D.38478>; else goto <D.38479>;
  <D.38478>:
  code.3323 = code;
  code = code.3323 + 1;
  *code.3323 = 68;
  *code = 0;
  code = code + 1;
  goto <D.38481>;
  <D.38479>:
  code.3324 = code;
  code = code.3324 + 1;
  *code.3324 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3325 = code;
        code = code.3325 + 1;
        D.38484 = imb.b[0];
        *code.3325 = D.38484;
        code.3326 = code;
        code = code.3326 + 1;
        D.38486 = imb.b[1];
        *code.3326 = D.38486;
        code.3327 = code;
        code = code.3327 + 1;
        D.38488 = imb.b[2];
        *code.3327 = D.38488;
        code.3328 = code;
        code = code.3328 + 1;
        D.38490 = imb.b[3];
        *code.3328 = D.38490;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38481>:
  <D.25954>:
  if (0 != 0) goto <D.38491>; else goto <D.38492>;
  <D.38491>:
  code.3329 = code;
  code = code.3329 + 1;
  *code.3329 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3330 = code;
        code = code.3330 + 1;
        D.38495 = imb.b[0];
        *code.3330 = D.38495;
        code.3331 = code;
        code = code.3331 + 1;
        D.38497 = imb.b[1];
        *code.3331 = D.38497;
        code.3332 = code;
        code = code.3332 + 1;
        D.38499 = imb.b[2];
        *code.3332 = D.38499;
        code.3333 = code;
        code = code.3333 + 1;
        D.38501 = imb.b[3];
        *code.3333 = D.38501;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25957>;
  <D.38492>:
  if (1 != 0) goto <D.38502>; else goto <D.38503>;
  <D.38502>:
  code.3334 = code;
  code = code.3334 + 1;
  *code.3334 = 131;
  code.3335 = code;
  code = code.3335 + 1;
  *code.3335 = 196;
  *code = 4;
  code = code + 1;
  goto <D.38506>;
  <D.38503>:
  code.3336 = code;
  code = code.3336 + 1;
  *code.3336 = 129;
  code.3337 = code;
  code = code.3337 + 1;
  *code.3337 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3338 = code;
        code = code.3338 + 1;
        D.38510 = imb.b[0];
        *code.3338 = D.38510;
        code.3339 = code;
        code = code.3339 + 1;
        D.38512 = imb.b[1];
        *code.3339 = D.38512;
        code.3340 = code;
        code = code.3340 + 1;
        D.38514 = imb.b[2];
        *code.3340 = D.38514;
        code.3341 = code;
        code = code.3341 + 1;
        D.38516 = imb.b[3];
        *code.3341 = D.38516;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38506>:
  <D.25957>:
  goto <D.24796>;
  <D.25959>:
  D.31604 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31604, 1, 1);
  goto <D.24796>;
  <D.25960>:
  D.31604 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31604, 1, 0);
  goto <D.24796>;
  <D.25961>:
  D.31604 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31604, 2, 1);
  goto <D.24796>;
  <D.25962>:
  D.31604 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31604, 2, 0);
  goto <D.24796>;
  <D.25963>:
  <D.25964>:
  D.31604 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31604, 4, 1);
  goto <D.24796>;
  <D.25965>:
  if (0 != 0) goto <D.38517>; else goto <D.38518>;
  <D.38517>:
  code.3342 = code;
  code = code.3342 + 1;
  *code.3342 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3343 = code;
        code = code.3343 + 1;
        D.38521 = imb.b[0];
        *code.3343 = D.38521;
        code.3344 = code;
        code = code.3344 + 1;
        D.38523 = imb.b[1];
        *code.3344 = D.38523;
        code.3345 = code;
        code = code.3345 + 1;
        D.38525 = imb.b[2];
        *code.3345 = D.38525;
        code.3346 = code;
        code = code.3346 + 1;
        D.38527 = imb.b[3];
        *code.3346 = D.38527;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25967>;
  <D.38518>:
  if (1 != 0) goto <D.38528>; else goto <D.38529>;
  <D.38528>:
  code.3347 = code;
  code = code.3347 + 1;
  *code.3347 = 131;
  code.3348 = code;
  code = code.3348 + 1;
  *code.3348 = 236;
  *code = 4;
  code = code + 1;
  goto <D.38532>;
  <D.38529>:
  code.3349 = code;
  code = code.3349 + 1;
  *code.3349 = 129;
  code.3350 = code;
  code = code.3350 + 1;
  *code.3350 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3351 = code;
        code = code.3351 + 1;
        D.38536 = imb.b[0];
        *code.3351 = D.38536;
        code.3352 = code;
        code = code.3352 + 1;
        D.38538 = imb.b[1];
        *code.3352 = D.38538;
        code.3353 = code;
        code = code.3353 + 1;
        D.38540 = imb.b[2];
        *code.3353 = D.38540;
        code.3354 = code;
        code = code.3354 + 1;
        D.38542 = imb.b[3];
        *code.3354 = D.38542;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38532>:
  <D.25967>:
  code.3355 = code;
  code = code.3355 + 1;
  *code.3355 = 217;
  if (1 != 0) goto <D.38544>; else goto <D.38545>;
  <D.38544>:
  if (1 != 0) goto <D.38546>; else goto <D.38547>;
  <D.38546>:
  code.3356 = code;
  code = code.3356 + 1;
  *code.3356 = 60;
  code.3357 = code;
  code = code.3357 + 1;
  *code.3357 = 36;
  goto <D.38550>;
  <D.38547>:
  if (1 != 0) goto <D.38551>; else goto <D.38552>;
  <D.38551>:
  code.3358 = code;
  code = code.3358 + 1;
  *code.3358 = 124;
  code.3359 = code;
  code = code.3359 + 1;
  *code.3359 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38555>;
  <D.38552>:
  code.3360 = code;
  code = code.3360 + 1;
  *code.3360 = 188;
  code.3361 = code;
  code = code.3361 + 1;
  *code.3361 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3362 = code;
        code = code.3362 + 1;
        D.38559 = imb.b[0];
        *code.3362 = D.38559;
        code.3363 = code;
        code = code.3363 + 1;
        D.38561 = imb.b[1];
        *code.3363 = D.38561;
        code.3364 = code;
        code = code.3364 + 1;
        D.38563 = imb.b[2];
        *code.3364 = D.38563;
        code.3365 = code;
        code = code.3365 + 1;
        D.38565 = imb.b[3];
        *code.3365 = D.38565;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38555>:
  <D.38550>:
  goto <D.25970>;
  <D.38545>:
  if (1 != 0) goto <D.38566>; else goto <D.38567>;
  <D.38566>:
  code.3366 = code;
  code = code.3366 + 1;
  *code.3366 = 60;
  goto <D.25970>;
  <D.38567>:
  if (1 != 0) goto <D.38569>; else goto <D.38570>;
  <D.38569>:
  code.3367 = code;
  code = code.3367 + 1;
  *code.3367 = 124;
  *code = 0;
  code = code + 1;
  goto <D.38572>;
  <D.38570>:
  code.3368 = code;
  code = code.3368 + 1;
  *code.3368 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3369 = code;
        code = code.3369 + 1;
        D.38575 = imb.b[0];
        *code.3369 = D.38575;
        code.3370 = code;
        code = code.3370 + 1;
        D.38577 = imb.b[1];
        *code.3370 = D.38577;
        code.3371 = code;
        code = code.3371 + 1;
        D.38579 = imb.b[2];
        *code.3371 = D.38579;
        code.3372 = code;
        code = code.3372 + 1;
        D.38581 = imb.b[3];
        *code.3372 = D.38581;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38572>:
  <D.25970>:
  switch (2) <default: <D.25976>, case 1: <D.25972>, case 2: <D.25974>, case 4: <D.25975>>
  <D.25972>:
  code.3373 = code;
  code = code.3373 + 1;
  *code.3373 = 138;
  goto <D.25973>;
  <D.25974>:
  code.3374 = code;
  code = code.3374 + 1;
  *code.3374 = 102;
  <D.25975>:
  code.3375 = code;
  code = code.3375 + 1;
  *code.3375 = 139;
  goto <D.25973>;
  <D.25976>:
  __assert_fail ("0", "mini-x86.c", 3715, &__PRETTY_FUNCTION__);
  <D.25973>:
  if (1 != 0) goto <D.38585>; else goto <D.38586>;
  <D.38585>:
  if (1 != 0) goto <D.38587>; else goto <D.38588>;
  <D.38587>:
  code.3376 = code;
  code = code.3376 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.3376 = D.32289;
  code.3377 = code;
  code = code.3377 + 1;
  *code.3377 = 36;
  goto <D.38591>;
  <D.38588>:
  if (1 != 0) goto <D.38592>; else goto <D.38593>;
  <D.38592>:
  code.3378 = code;
  code = code.3378 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.3378 = D.32296;
  code.3379 = code;
  code = code.3379 + 1;
  *code.3379 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38596>;
  <D.38593>:
  code.3380 = code;
  code = code.3380 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.3380 = D.32301;
  code.3381 = code;
  code = code.3381 + 1;
  *code.3381 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3382 = code;
        code = code.3382 + 1;
        D.38600 = imb.b[0];
        *code.3382 = D.38600;
        code.3383 = code;
        code = code.3383 + 1;
        D.38602 = imb.b[1];
        *code.3383 = D.38602;
        code.3384 = code;
        code = code.3384 + 1;
        D.38604 = imb.b[2];
        *code.3384 = D.38604;
        code.3385 = code;
        code = code.3385 + 1;
        D.38606 = imb.b[3];
        *code.3385 = D.38606;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38596>:
  <D.38591>:
  goto <D.25978>;
  <D.38586>:
  if (1 != 0) goto <D.38607>; else goto <D.38608>;
  <D.38607>:
  code.3386 = code;
  code = code.3386 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.3386 = D.32289;
  goto <D.25978>;
  <D.38608>:
  if (1 != 0) goto <D.38610>; else goto <D.38611>;
  <D.38610>:
  code.3387 = code;
  code = code.3387 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.3387 = D.32296;
  *code = 0;
  code = code + 1;
  goto <D.38613>;
  <D.38611>:
  code.3388 = code;
  code = code.3388 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.3388 = D.32301;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3389 = code;
        code = code.3389 + 1;
        D.38616 = imb.b[0];
        *code.3389 = D.38616;
        code.3390 = code;
        code = code.3390 + 1;
        D.38618 = imb.b[1];
        *code.3390 = D.38618;
        code.3391 = code;
        code = code.3391 + 1;
        D.38620 = imb.b[2];
        *code.3391 = D.38620;
        code.3392 = code;
        code = code.3392 + 1;
        D.38622 = imb.b[3];
        *code.3392 = D.38622;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38613>:
  <D.25978>:
  D.31604 = ins->dreg;
  if (D.31604 == 0) goto <D.38623>; else goto <D.38624>;
  <D.38623>:
  code.3393 = code;
  code = code.3393 + 1;
  *code.3393 = 13;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 3072;
        code.3394 = code;
        code = code.3394 + 1;
        D.38627 = imb.b[0];
        *code.3394 = D.38627;
        code.3395 = code;
        code = code.3395 + 1;
        D.38629 = imb.b[1];
        *code.3395 = D.38629;
        code.3396 = code;
        code = code.3396 + 1;
        D.38631 = imb.b[2];
        *code.3396 = D.38631;
        code.3397 = code;
        code = code.3397 + 1;
        D.38633 = imb.b[3];
        *code.3397 = D.38633;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25981>;
  <D.38624>:
  if (0 != 0) goto <D.38634>; else goto <D.38635>;
  <D.38634>:
  code.3398 = code;
  code = code.3398 + 1;
  *code.3398 = 131;
  code.3399 = code;
  code = code.3399 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.38638 = D.31638 | -56;
  D.38639 = (unsigned char) D.38638;
  *code.3399 = D.38639;
  *code = 0;
  code = code + 1;
  goto <D.38640>;
  <D.38635>:
  code.3400 = code;
  code = code.3400 + 1;
  *code.3400 = 129;
  code.3401 = code;
  code = code.3401 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.38638 = D.31638 | -56;
  D.38639 = (unsigned char) D.38638;
  *code.3401 = D.38639;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 3072;
        code.3402 = code;
        code = code.3402 + 1;
        D.38644 = imb.b[0];
        *code.3402 = D.38644;
        code.3403 = code;
        code = code.3403 + 1;
        D.38646 = imb.b[1];
        *code.3403 = D.38646;
        code.3404 = code;
        code = code.3404 + 1;
        D.38648 = imb.b[2];
        *code.3404 = D.38648;
        code.3405 = code;
        code = code.3405 + 1;
        D.38650 = imb.b[3];
        *code.3405 = D.38650;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38640>:
  <D.25981>:
  switch (2) <default: <D.25987>, case 1: <D.25983>, case 2: <D.25985>, case 4: <D.25986>>
  <D.25983>:
  code.3406 = code;
  code = code.3406 + 1;
  *code.3406 = 136;
  goto <D.25984>;
  <D.25985>:
  code.3407 = code;
  code = code.3407 + 1;
  *code.3407 = 102;
  <D.25986>:
  code.3408 = code;
  code = code.3408 + 1;
  *code.3408 = 137;
  goto <D.25984>;
  <D.25987>:
  __assert_fail ("0", "mini-x86.c", 3717, &__PRETTY_FUNCTION__);
  <D.25984>:
  if (1 != 0) goto <D.38654>; else goto <D.38655>;
  <D.38654>:
  if (0 != 0) goto <D.38656>; else goto <D.38657>;
  <D.38656>:
  code.3409 = code;
  code = code.3409 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.3409 = D.32289;
  code.3410 = code;
  code = code.3410 + 1;
  *code.3410 = 36;
  goto <D.38660>;
  <D.38657>:
  if (1 != 0) goto <D.38661>; else goto <D.38662>;
  <D.38661>:
  code.3411 = code;
  code = code.3411 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.3411 = D.32296;
  code.3412 = code;
  code = code.3412 + 1;
  *code.3412 = 36;
  *code = 2;
  code = code + 1;
  goto <D.38665>;
  <D.38662>:
  code.3413 = code;
  code = code.3413 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.3413 = D.32301;
  code.3414 = code;
  code = code.3414 + 1;
  *code.3414 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.3415 = code;
        code = code.3415 + 1;
        D.38669 = imb.b[0];
        *code.3415 = D.38669;
        code.3416 = code;
        code = code.3416 + 1;
        D.38671 = imb.b[1];
        *code.3416 = D.38671;
        code.3417 = code;
        code = code.3417 + 1;
        D.38673 = imb.b[2];
        *code.3417 = D.38673;
        code.3418 = code;
        code = code.3418 + 1;
        D.38675 = imb.b[3];
        *code.3418 = D.38675;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38665>:
  <D.38660>:
  goto <D.25989>;
  <D.38655>:
  if (0 != 0) goto <D.38676>; else goto <D.38677>;
  <D.38676>:
  code.3419 = code;
  code = code.3419 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.3419 = D.32289;
  goto <D.25989>;
  <D.38677>:
  if (1 != 0) goto <D.38679>; else goto <D.38680>;
  <D.38679>:
  code.3420 = code;
  code = code.3420 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.3420 = D.32296;
  *code = 2;
  code = code + 1;
  goto <D.38682>;
  <D.38680>:
  code.3421 = code;
  code = code.3421 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.3421 = D.32301;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.3422 = code;
        code = code.3422 + 1;
        D.38685 = imb.b[0];
        *code.3422 = D.38685;
        code.3423 = code;
        code = code.3423 + 1;
        D.38687 = imb.b[1];
        *code.3423 = D.38687;
        code.3424 = code;
        code = code.3424 + 1;
        D.38689 = imb.b[2];
        *code.3424 = D.38689;
        code.3425 = code;
        code = code.3425 + 1;
        D.38691 = imb.b[3];
        *code.3425 = D.38691;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38682>:
  <D.25989>:
  code.3426 = code;
  code = code.3426 + 1;
  *code.3426 = 217;
  if (1 != 0) goto <D.38693>; else goto <D.38694>;
  <D.38693>:
  if (0 != 0) goto <D.38695>; else goto <D.38696>;
  <D.38695>:
  code.3427 = code;
  code = code.3427 + 1;
  *code.3427 = 44;
  code.3428 = code;
  code = code.3428 + 1;
  *code.3428 = 36;
  goto <D.38699>;
  <D.38696>:
  if (1 != 0) goto <D.38700>; else goto <D.38701>;
  <D.38700>:
  code.3429 = code;
  code = code.3429 + 1;
  *code.3429 = 108;
  code.3430 = code;
  code = code.3430 + 1;
  *code.3430 = 36;
  *code = 2;
  code = code + 1;
  goto <D.38704>;
  <D.38701>:
  code.3431 = code;
  code = code.3431 + 1;
  *code.3431 = 172;
  code.3432 = code;
  code = code.3432 + 1;
  *code.3432 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.3433 = code;
        code = code.3433 + 1;
        D.38708 = imb.b[0];
        *code.3433 = D.38708;
        code.3434 = code;
        code = code.3434 + 1;
        D.38710 = imb.b[1];
        *code.3434 = D.38710;
        code.3435 = code;
        code = code.3435 + 1;
        D.38712 = imb.b[2];
        *code.3435 = D.38712;
        code.3436 = code;
        code = code.3436 + 1;
        D.38714 = imb.b[3];
        *code.3436 = D.38714;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38704>:
  <D.38699>:
  goto <D.25992>;
  <D.38694>:
  if (0 != 0) goto <D.38715>; else goto <D.38716>;
  <D.38715>:
  code.3437 = code;
  code = code.3437 + 1;
  *code.3437 = 44;
  goto <D.25992>;
  <D.38716>:
  if (1 != 0) goto <D.38718>; else goto <D.38719>;
  <D.38718>:
  code.3438 = code;
  code = code.3438 + 1;
  *code.3438 = 108;
  *code = 2;
  code = code + 1;
  goto <D.38721>;
  <D.38719>:
  code.3439 = code;
  code = code.3439 + 1;
  *code.3439 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.3440 = code;
        code = code.3440 + 1;
        D.38724 = imb.b[0];
        *code.3440 = D.38724;
        code.3441 = code;
        code = code.3441 + 1;
        D.38726 = imb.b[1];
        *code.3441 = D.38726;
        code.3442 = code;
        code = code.3442 + 1;
        D.38728 = imb.b[2];
        *code.3442 = D.38728;
        code.3443 = code;
        code = code.3443 + 1;
        D.38730 = imb.b[3];
        *code.3443 = D.38730;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38721>:
  <D.25992>:
  if (0 != 0) goto <D.38731>; else goto <D.38732>;
  <D.38731>:
  code.3444 = code;
  code = code.3444 + 1;
  *code.3444 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3445 = code;
        code = code.3445 + 1;
        D.38735 = imb.b[0];
        *code.3445 = D.38735;
        code.3446 = code;
        code = code.3446 + 1;
        D.38737 = imb.b[1];
        *code.3446 = D.38737;
        code.3447 = code;
        code = code.3447 + 1;
        D.38739 = imb.b[2];
        *code.3447 = D.38739;
        code.3448 = code;
        code = code.3448 + 1;
        D.38741 = imb.b[3];
        *code.3448 = D.38741;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.25995>;
  <D.38732>:
  if (1 != 0) goto <D.38742>; else goto <D.38743>;
  <D.38742>:
  code.3449 = code;
  code = code.3449 + 1;
  *code.3449 = 131;
  code.3450 = code;
  code = code.3450 + 1;
  *code.3450 = 236;
  *code = 8;
  code = code + 1;
  goto <D.38746>;
  <D.38743>:
  code.3451 = code;
  code = code.3451 + 1;
  *code.3451 = 129;
  code.3452 = code;
  code = code.3452 + 1;
  *code.3452 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3453 = code;
        code = code.3453 + 1;
        D.38750 = imb.b[0];
        *code.3453 = D.38750;
        code.3454 = code;
        code = code.3454 + 1;
        D.38752 = imb.b[1];
        *code.3454 = D.38752;
        code.3455 = code;
        code = code.3455 + 1;
        D.38754 = imb.b[2];
        *code.3455 = D.38754;
        code.3456 = code;
        code = code.3456 + 1;
        D.38756 = imb.b[3];
        *code.3456 = D.38756;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38746>:
  <D.25995>:
  if (1 != 0) goto <D.38757>; else goto <D.38758>;
  <D.38757>:
  code.3457 = code;
  code = code.3457 + 1;
  *code.3457 = 223;
  if (1 != 0) goto <D.38760>; else goto <D.38761>;
  <D.38760>:
  if (1 != 0) goto <D.38762>; else goto <D.38763>;
  <D.38762>:
  code.3458 = code;
  code = code.3458 + 1;
  *code.3458 = 60;
  code.3459 = code;
  code = code.3459 + 1;
  *code.3459 = 36;
  goto <D.38766>;
  <D.38763>:
  if (1 != 0) goto <D.38767>; else goto <D.38768>;
  <D.38767>:
  code.3460 = code;
  code = code.3460 + 1;
  *code.3460 = 124;
  code.3461 = code;
  code = code.3461 + 1;
  *code.3461 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38771>;
  <D.38768>:
  code.3462 = code;
  code = code.3462 + 1;
  *code.3462 = 188;
  code.3463 = code;
  code = code.3463 + 1;
  *code.3463 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3464 = code;
        code = code.3464 + 1;
        D.38775 = imb.b[0];
        *code.3464 = D.38775;
        code.3465 = code;
        code = code.3465 + 1;
        D.38777 = imb.b[1];
        *code.3465 = D.38777;
        code.3466 = code;
        code = code.3466 + 1;
        D.38779 = imb.b[2];
        *code.3466 = D.38779;
        code.3467 = code;
        code = code.3467 + 1;
        D.38781 = imb.b[3];
        *code.3467 = D.38781;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38771>:
  <D.38766>:
  goto <D.25998>;
  <D.38761>:
  if (1 != 0) goto <D.38782>; else goto <D.38783>;
  <D.38782>:
  code.3468 = code;
  code = code.3468 + 1;
  *code.3468 = 60;
  goto <D.25998>;
  <D.38783>:
  if (1 != 0) goto <D.38785>; else goto <D.38786>;
  <D.38785>:
  code.3469 = code;
  code = code.3469 + 1;
  *code.3469 = 124;
  *code = 0;
  code = code + 1;
  goto <D.38788>;
  <D.38786>:
  code.3470 = code;
  code = code.3470 + 1;
  *code.3470 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3471 = code;
        code = code.3471 + 1;
        D.38791 = imb.b[0];
        *code.3471 = D.38791;
        code.3472 = code;
        code = code.3472 + 1;
        D.38793 = imb.b[1];
        *code.3472 = D.38793;
        code.3473 = code;
        code = code.3473 + 1;
        D.38795 = imb.b[2];
        *code.3473 = D.38795;
        code.3474 = code;
        code = code.3474 + 1;
        D.38797 = imb.b[3];
        *code.3474 = D.38797;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38788>:
  <D.25998>:
  goto <D.38798>;
  <D.38758>:
  code.3475 = code;
  code = code.3475 + 1;
  *code.3475 = 219;
  if (1 != 0) goto <D.38800>; else goto <D.38801>;
  <D.38800>:
  if (1 != 0) goto <D.38802>; else goto <D.38803>;
  <D.38802>:
  code.3476 = code;
  code = code.3476 + 1;
  *code.3476 = 28;
  code.3477 = code;
  code = code.3477 + 1;
  *code.3477 = 36;
  goto <D.38806>;
  <D.38803>:
  if (1 != 0) goto <D.38807>; else goto <D.38808>;
  <D.38807>:
  code.3478 = code;
  code = code.3478 + 1;
  *code.3478 = 92;
  code.3479 = code;
  code = code.3479 + 1;
  *code.3479 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38811>;
  <D.38808>:
  code.3480 = code;
  code = code.3480 + 1;
  *code.3480 = 156;
  code.3481 = code;
  code = code.3481 + 1;
  *code.3481 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3482 = code;
        code = code.3482 + 1;
        D.38815 = imb.b[0];
        *code.3482 = D.38815;
        code.3483 = code;
        code = code.3483 + 1;
        D.38817 = imb.b[1];
        *code.3483 = D.38817;
        code.3484 = code;
        code = code.3484 + 1;
        D.38819 = imb.b[2];
        *code.3484 = D.38819;
        code.3485 = code;
        code = code.3485 + 1;
        D.38821 = imb.b[3];
        *code.3485 = D.38821;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38811>:
  <D.38806>:
  goto <D.26001>;
  <D.38801>:
  if (1 != 0) goto <D.38822>; else goto <D.38823>;
  <D.38822>:
  code.3486 = code;
  code = code.3486 + 1;
  *code.3486 = 28;
  goto <D.26001>;
  <D.38823>:
  if (1 != 0) goto <D.38825>; else goto <D.38826>;
  <D.38825>:
  code.3487 = code;
  code = code.3487 + 1;
  *code.3487 = 92;
  *code = 0;
  code = code + 1;
  goto <D.38828>;
  <D.38826>:
  code.3488 = code;
  code = code.3488 + 1;
  *code.3488 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3489 = code;
        code = code.3489 + 1;
        D.38831 = imb.b[0];
        *code.3489 = D.38831;
        code.3490 = code;
        code = code.3490 + 1;
        D.38833 = imb.b[1];
        *code.3490 = D.38833;
        code.3491 = code;
        code = code.3491 + 1;
        D.38835 = imb.b[2];
        *code.3491 = D.38835;
        code.3492 = code;
        code = code.3492 + 1;
        D.38837 = imb.b[3];
        *code.3492 = D.38837;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38828>:
  <D.26001>:
  <D.38798>:
  code.3493 = code;
  code = code.3493 + 1;
  D.31604 = ins->dreg;
  D.33696 = (unsigned char) D.31604;
  D.38839 = D.33696 + 88;
  *code.3493 = D.38839;
  code.3494 = code;
  code = code.3494 + 1;
  D.34455 = ins->backend.reg3;
  D.38841 = (unsigned char) D.34455;
  D.38842 = D.38841 + 88;
  *code.3494 = D.38842;
  code.3495 = code;
  code = code.3495 + 1;
  *code.3495 = 217;
  if (1 != 0) goto <D.38844>; else goto <D.38845>;
  <D.38844>:
  if (1 != 0) goto <D.38846>; else goto <D.38847>;
  <D.38846>:
  code.3496 = code;
  code = code.3496 + 1;
  *code.3496 = 44;
  code.3497 = code;
  code = code.3497 + 1;
  *code.3497 = 36;
  goto <D.38850>;
  <D.38847>:
  if (1 != 0) goto <D.38851>; else goto <D.38852>;
  <D.38851>:
  code.3498 = code;
  code = code.3498 + 1;
  *code.3498 = 108;
  code.3499 = code;
  code = code.3499 + 1;
  *code.3499 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38855>;
  <D.38852>:
  code.3500 = code;
  code = code.3500 + 1;
  *code.3500 = 172;
  code.3501 = code;
  code = code.3501 + 1;
  *code.3501 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3502 = code;
        code = code.3502 + 1;
        D.38859 = imb.b[0];
        *code.3502 = D.38859;
        code.3503 = code;
        code = code.3503 + 1;
        D.38861 = imb.b[1];
        *code.3503 = D.38861;
        code.3504 = code;
        code = code.3504 + 1;
        D.38863 = imb.b[2];
        *code.3504 = D.38863;
        code.3505 = code;
        code = code.3505 + 1;
        D.38865 = imb.b[3];
        *code.3505 = D.38865;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38855>:
  <D.38850>:
  goto <D.26004>;
  <D.38845>:
  if (1 != 0) goto <D.38866>; else goto <D.38867>;
  <D.38866>:
  code.3506 = code;
  code = code.3506 + 1;
  *code.3506 = 44;
  goto <D.26004>;
  <D.38867>:
  if (1 != 0) goto <D.38869>; else goto <D.38870>;
  <D.38869>:
  code.3507 = code;
  code = code.3507 + 1;
  *code.3507 = 108;
  *code = 0;
  code = code + 1;
  goto <D.38872>;
  <D.38870>:
  code.3508 = code;
  code = code.3508 + 1;
  *code.3508 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3509 = code;
        code = code.3509 + 1;
        D.38875 = imb.b[0];
        *code.3509 = D.38875;
        code.3510 = code;
        code = code.3510 + 1;
        D.38877 = imb.b[1];
        *code.3510 = D.38877;
        code.3511 = code;
        code = code.3511 + 1;
        D.38879 = imb.b[2];
        *code.3511 = D.38879;
        code.3512 = code;
        code = code.3512 + 1;
        D.38881 = imb.b[3];
        *code.3512 = D.38881;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38872>:
  <D.26004>:
  if (0 != 0) goto <D.38882>; else goto <D.38883>;
  <D.38882>:
  code.3513 = code;
  code = code.3513 + 1;
  *code.3513 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3514 = code;
        code = code.3514 + 1;
        D.38886 = imb.b[0];
        *code.3514 = D.38886;
        code.3515 = code;
        code = code.3515 + 1;
        D.38888 = imb.b[1];
        *code.3515 = D.38888;
        code.3516 = code;
        code = code.3516 + 1;
        D.38890 = imb.b[2];
        *code.3516 = D.38890;
        code.3517 = code;
        code = code.3517 + 1;
        D.38892 = imb.b[3];
        *code.3517 = D.38892;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26007>;
  <D.38883>:
  if (1 != 0) goto <D.38893>; else goto <D.38894>;
  <D.38893>:
  code.3518 = code;
  code = code.3518 + 1;
  *code.3518 = 131;
  code.3519 = code;
  code = code.3519 + 1;
  *code.3519 = 196;
  *code = 4;
  code = code + 1;
  goto <D.38897>;
  <D.38894>:
  code.3520 = code;
  code = code.3520 + 1;
  *code.3520 = 129;
  code.3521 = code;
  code = code.3521 + 1;
  *code.3521 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.3522 = code;
        code = code.3522 + 1;
        D.38901 = imb.b[0];
        *code.3522 = D.38901;
        code.3523 = code;
        code = code.3523 + 1;
        D.38903 = imb.b[1];
        *code.3523 = D.38903;
        code.3524 = code;
        code = code.3524 + 1;
        D.38905 = imb.b[2];
        *code.3524 = D.38905;
        code.3525 = code;
        code = code.3525 + 1;
        D.38907 = imb.b[3];
        *code.3525 = D.38907;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38897>:
  <D.26007>:
  goto <D.24796>;
  <D.26009>:
  code.3526 = code;
  code = code.3526 + 1;
  D.31527 = ins->sreg2;
  D.34084 = (unsigned char) D.31527;
  D.34085 = D.34084 + 80;
  *code.3526 = D.34085;
  code.3527 = code;
  code = code.3527 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.3527 = D.36114;
  if (1 != 0) goto <D.38910>; else goto <D.38911>;
  <D.38910>:
  code.3528 = code;
  code = code.3528 + 1;
  *code.3528 = 223;
  if (1 != 0) goto <D.38913>; else goto <D.38914>;
  <D.38913>:
  if (1 != 0) goto <D.38915>; else goto <D.38916>;
  <D.38915>:
  code.3529 = code;
  code = code.3529 + 1;
  *code.3529 = 44;
  code.3530 = code;
  code = code.3530 + 1;
  *code.3530 = 36;
  goto <D.38919>;
  <D.38916>:
  if (1 != 0) goto <D.38920>; else goto <D.38921>;
  <D.38920>:
  code.3531 = code;
  code = code.3531 + 1;
  *code.3531 = 108;
  code.3532 = code;
  code = code.3532 + 1;
  *code.3532 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38924>;
  <D.38921>:
  code.3533 = code;
  code = code.3533 + 1;
  *code.3533 = 172;
  code.3534 = code;
  code = code.3534 + 1;
  *code.3534 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3535 = code;
        code = code.3535 + 1;
        D.38928 = imb.b[0];
        *code.3535 = D.38928;
        code.3536 = code;
        code = code.3536 + 1;
        D.38930 = imb.b[1];
        *code.3536 = D.38930;
        code.3537 = code;
        code = code.3537 + 1;
        D.38932 = imb.b[2];
        *code.3537 = D.38932;
        code.3538 = code;
        code = code.3538 + 1;
        D.38934 = imb.b[3];
        *code.3538 = D.38934;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38924>:
  <D.38919>:
  goto <D.26011>;
  <D.38914>:
  if (1 != 0) goto <D.38935>; else goto <D.38936>;
  <D.38935>:
  code.3539 = code;
  code = code.3539 + 1;
  *code.3539 = 44;
  goto <D.26011>;
  <D.38936>:
  if (1 != 0) goto <D.38938>; else goto <D.38939>;
  <D.38938>:
  code.3540 = code;
  code = code.3540 + 1;
  *code.3540 = 108;
  *code = 0;
  code = code + 1;
  goto <D.38941>;
  <D.38939>:
  code.3541 = code;
  code = code.3541 + 1;
  *code.3541 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3542 = code;
        code = code.3542 + 1;
        D.38944 = imb.b[0];
        *code.3542 = D.38944;
        code.3543 = code;
        code = code.3543 + 1;
        D.38946 = imb.b[1];
        *code.3543 = D.38946;
        code.3544 = code;
        code = code.3544 + 1;
        D.38948 = imb.b[2];
        *code.3544 = D.38948;
        code.3545 = code;
        code = code.3545 + 1;
        D.38950 = imb.b[3];
        *code.3545 = D.38950;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38941>:
  <D.26011>:
  goto <D.38951>;
  <D.38911>:
  code.3546 = code;
  code = code.3546 + 1;
  *code.3546 = 219;
  if (1 != 0) goto <D.38953>; else goto <D.38954>;
  <D.38953>:
  if (1 != 0) goto <D.38955>; else goto <D.38956>;
  <D.38955>:
  code.3547 = code;
  code = code.3547 + 1;
  *code.3547 = 4;
  code.3548 = code;
  code = code.3548 + 1;
  *code.3548 = 36;
  goto <D.38959>;
  <D.38956>:
  if (1 != 0) goto <D.38960>; else goto <D.38961>;
  <D.38960>:
  code.3549 = code;
  code = code.3549 + 1;
  *code.3549 = 68;
  code.3550 = code;
  code = code.3550 + 1;
  *code.3550 = 36;
  *code = 0;
  code = code + 1;
  goto <D.38964>;
  <D.38961>:
  code.3551 = code;
  code = code.3551 + 1;
  *code.3551 = 132;
  code.3552 = code;
  code = code.3552 + 1;
  *code.3552 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3553 = code;
        code = code.3553 + 1;
        D.38968 = imb.b[0];
        *code.3553 = D.38968;
        code.3554 = code;
        code = code.3554 + 1;
        D.38970 = imb.b[1];
        *code.3554 = D.38970;
        code.3555 = code;
        code = code.3555 + 1;
        D.38972 = imb.b[2];
        *code.3555 = D.38972;
        code.3556 = code;
        code = code.3556 + 1;
        D.38974 = imb.b[3];
        *code.3556 = D.38974;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38964>:
  <D.38959>:
  goto <D.26014>;
  <D.38954>:
  if (1 != 0) goto <D.38975>; else goto <D.38976>;
  <D.38975>:
  code.3557 = code;
  code = code.3557 + 1;
  *code.3557 = 4;
  goto <D.26014>;
  <D.38976>:
  if (1 != 0) goto <D.38978>; else goto <D.38979>;
  <D.38978>:
  code.3558 = code;
  code = code.3558 + 1;
  *code.3558 = 68;
  *code = 0;
  code = code + 1;
  goto <D.38981>;
  <D.38979>:
  code.3559 = code;
  code = code.3559 + 1;
  *code.3559 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3560 = code;
        code = code.3560 + 1;
        D.38984 = imb.b[0];
        *code.3560 = D.38984;
        code.3561 = code;
        code = code.3561 + 1;
        D.38986 = imb.b[1];
        *code.3561 = D.38986;
        code.3562 = code;
        code = code.3562 + 1;
        D.38988 = imb.b[2];
        *code.3562 = D.38988;
        code.3563 = code;
        code = code.3563 + 1;
        D.38990 = imb.b[3];
        *code.3563 = D.38990;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38981>:
  <D.26014>:
  <D.38951>:
  code.3564 = code;
  code = code.3564 + 1;
  *code.3564 = 221;
  if (1 != 0) goto <D.38992>; else goto <D.38993>;
  <D.38992>:
  if (1 != 0) goto <D.38994>; else goto <D.38995>;
  <D.38994>:
  code.3565 = code;
  code = code.3565 + 1;
  *code.3565 = 28;
  code.3566 = code;
  code = code.3566 + 1;
  *code.3566 = 36;
  goto <D.38998>;
  <D.38995>:
  if (1 != 0) goto <D.38999>; else goto <D.39000>;
  <D.38999>:
  code.3567 = code;
  code = code.3567 + 1;
  *code.3567 = 92;
  code.3568 = code;
  code = code.3568 + 1;
  *code.3568 = 36;
  *code = 0;
  code = code + 1;
  goto <D.39003>;
  <D.39000>:
  code.3569 = code;
  code = code.3569 + 1;
  *code.3569 = 156;
  code.3570 = code;
  code = code.3570 + 1;
  *code.3570 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3571 = code;
        code = code.3571 + 1;
        D.39007 = imb.b[0];
        *code.3571 = D.39007;
        code.3572 = code;
        code = code.3572 + 1;
        D.39009 = imb.b[1];
        *code.3572 = D.39009;
        code.3573 = code;
        code = code.3573 + 1;
        D.39011 = imb.b[2];
        *code.3573 = D.39011;
        code.3574 = code;
        code = code.3574 + 1;
        D.39013 = imb.b[3];
        *code.3574 = D.39013;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39003>:
  <D.38998>:
  goto <D.26017>;
  <D.38993>:
  if (1 != 0) goto <D.39014>; else goto <D.39015>;
  <D.39014>:
  code.3575 = code;
  code = code.3575 + 1;
  *code.3575 = 28;
  goto <D.26017>;
  <D.39015>:
  if (1 != 0) goto <D.39017>; else goto <D.39018>;
  <D.39017>:
  code.3576 = code;
  code = code.3576 + 1;
  *code.3576 = 92;
  *code = 0;
  code = code + 1;
  goto <D.39020>;
  <D.39018>:
  code.3577 = code;
  code = code.3577 + 1;
  *code.3577 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3578 = code;
        code = code.3578 + 1;
        D.39023 = imb.b[0];
        *code.3578 = D.39023;
        code.3579 = code;
        code = code.3579 + 1;
        D.39025 = imb.b[1];
        *code.3579 = D.39025;
        code.3580 = code;
        code = code.3580 + 1;
        D.39027 = imb.b[2];
        *code.3580 = D.39027;
        code.3581 = code;
        code = code.3581 + 1;
        D.39029 = imb.b[3];
        *code.3581 = D.39029;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39020>:
  <D.26017>:
  code.3582 = code;
  code = code.3582 + 1;
  *code.3582 = 221;
  if (1 != 0) goto <D.39031>; else goto <D.39032>;
  <D.39031>:
  if (1 != 0) goto <D.39033>; else goto <D.39034>;
  <D.39033>:
  code.3583 = code;
  code = code.3583 + 1;
  *code.3583 = 4;
  code.3584 = code;
  code = code.3584 + 1;
  *code.3584 = 36;
  goto <D.39037>;
  <D.39034>:
  if (1 != 0) goto <D.39038>; else goto <D.39039>;
  <D.39038>:
  code.3585 = code;
  code = code.3585 + 1;
  *code.3585 = 68;
  code.3586 = code;
  code = code.3586 + 1;
  *code.3586 = 36;
  *code = 0;
  code = code + 1;
  goto <D.39042>;
  <D.39039>:
  code.3587 = code;
  code = code.3587 + 1;
  *code.3587 = 132;
  code.3588 = code;
  code = code.3588 + 1;
  *code.3588 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3589 = code;
        code = code.3589 + 1;
        D.39046 = imb.b[0];
        *code.3589 = D.39046;
        code.3590 = code;
        code = code.3590 + 1;
        D.39048 = imb.b[1];
        *code.3590 = D.39048;
        code.3591 = code;
        code = code.3591 + 1;
        D.39050 = imb.b[2];
        *code.3591 = D.39050;
        code.3592 = code;
        code = code.3592 + 1;
        D.39052 = imb.b[3];
        *code.3592 = D.39052;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39042>:
  <D.39037>:
  goto <D.26020>;
  <D.39032>:
  if (1 != 0) goto <D.39053>; else goto <D.39054>;
  <D.39053>:
  code.3593 = code;
  code = code.3593 + 1;
  *code.3593 = 4;
  goto <D.26020>;
  <D.39054>:
  if (1 != 0) goto <D.39056>; else goto <D.39057>;
  <D.39056>:
  code.3594 = code;
  code = code.3594 + 1;
  *code.3594 = 68;
  *code = 0;
  code = code + 1;
  goto <D.39059>;
  <D.39057>:
  code.3595 = code;
  code = code.3595 + 1;
  *code.3595 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3596 = code;
        code = code.3596 + 1;
        D.39062 = imb.b[0];
        *code.3596 = D.39062;
        code.3597 = code;
        code = code.3597 + 1;
        D.39064 = imb.b[1];
        *code.3597 = D.39064;
        code.3598 = code;
        code = code.3598 + 1;
        D.39066 = imb.b[2];
        *code.3598 = D.39066;
        code.3599 = code;
        code = code.3599 + 1;
        D.39068 = imb.b[3];
        *code.3599 = D.39068;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39059>:
  <D.26020>:
  if (0 != 0) goto <D.39069>; else goto <D.39070>;
  <D.39069>:
  code.3600 = code;
  code = code.3600 + 1;
  *code.3600 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3601 = code;
        code = code.3601 + 1;
        D.39073 = imb.b[0];
        *code.3601 = D.39073;
        code.3602 = code;
        code = code.3602 + 1;
        D.39075 = imb.b[1];
        *code.3602 = D.39075;
        code.3603 = code;
        code = code.3603 + 1;
        D.39077 = imb.b[2];
        *code.3603 = D.39077;
        code.3604 = code;
        code = code.3604 + 1;
        D.39079 = imb.b[3];
        *code.3604 = D.39079;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26023>;
  <D.39070>:
  if (1 != 0) goto <D.39080>; else goto <D.39081>;
  <D.39080>:
  code.3605 = code;
  code = code.3605 + 1;
  *code.3605 = 131;
  code.3606 = code;
  code = code.3606 + 1;
  *code.3606 = 196;
  *code = 8;
  code = code + 1;
  goto <D.39084>;
  <D.39081>:
  code.3607 = code;
  code = code.3607 + 1;
  *code.3607 = 129;
  code.3608 = code;
  code = code.3608 + 1;
  *code.3608 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3609 = code;
        code = code.3609 + 1;
        D.39088 = imb.b[0];
        *code.3609 = D.39088;
        code.3610 = code;
        code = code.3610 + 1;
        D.39090 = imb.b[1];
        *code.3610 = D.39090;
        code.3611 = code;
        code = code.3611 + 1;
        D.39092 = imb.b[2];
        *code.3611 = D.39092;
        code.3612 = code;
        code = code.3612 + 1;
        D.39094 = imb.b[3];
        *code.3612 = D.39094;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39084>:
  <D.26023>:
  goto <D.24796>;
  <D.26025>:
  code.3613 = code;
  code = code.3613 + 1;
  D.31527 = ins->sreg2;
  D.34084 = (unsigned char) D.31527;
  D.34085 = D.34084 + 80;
  *code.3613 = D.34085;
  code.3614 = code;
  code = code.3614 + 1;
  D.31548 = ins->sreg1;
  D.36113 = (unsigned char) D.31548;
  D.36114 = D.36113 + 80;
  *code.3614 = D.36114;
  if (1 != 0) goto <D.39097>; else goto <D.39098>;
  <D.39097>:
  code.3615 = code;
  code = code.3615 + 1;
  *code.3615 = 223;
  if (1 != 0) goto <D.39100>; else goto <D.39101>;
  <D.39100>:
  if (1 != 0) goto <D.39102>; else goto <D.39103>;
  <D.39102>:
  code.3616 = code;
  code = code.3616 + 1;
  *code.3616 = 44;
  code.3617 = code;
  code = code.3617 + 1;
  *code.3617 = 36;
  goto <D.39106>;
  <D.39103>:
  if (1 != 0) goto <D.39107>; else goto <D.39108>;
  <D.39107>:
  code.3618 = code;
  code = code.3618 + 1;
  *code.3618 = 108;
  code.3619 = code;
  code = code.3619 + 1;
  *code.3619 = 36;
  *code = 0;
  code = code + 1;
  goto <D.39111>;
  <D.39108>:
  code.3620 = code;
  code = code.3620 + 1;
  *code.3620 = 172;
  code.3621 = code;
  code = code.3621 + 1;
  *code.3621 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3622 = code;
        code = code.3622 + 1;
        D.39115 = imb.b[0];
        *code.3622 = D.39115;
        code.3623 = code;
        code = code.3623 + 1;
        D.39117 = imb.b[1];
        *code.3623 = D.39117;
        code.3624 = code;
        code = code.3624 + 1;
        D.39119 = imb.b[2];
        *code.3624 = D.39119;
        code.3625 = code;
        code = code.3625 + 1;
        D.39121 = imb.b[3];
        *code.3625 = D.39121;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39111>:
  <D.39106>:
  goto <D.26027>;
  <D.39101>:
  if (1 != 0) goto <D.39122>; else goto <D.39123>;
  <D.39122>:
  code.3626 = code;
  code = code.3626 + 1;
  *code.3626 = 44;
  goto <D.26027>;
  <D.39123>:
  if (1 != 0) goto <D.39125>; else goto <D.39126>;
  <D.39125>:
  code.3627 = code;
  code = code.3627 + 1;
  *code.3627 = 108;
  *code = 0;
  code = code + 1;
  goto <D.39128>;
  <D.39126>:
  code.3628 = code;
  code = code.3628 + 1;
  *code.3628 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3629 = code;
        code = code.3629 + 1;
        D.39131 = imb.b[0];
        *code.3629 = D.39131;
        code.3630 = code;
        code = code.3630 + 1;
        D.39133 = imb.b[1];
        *code.3630 = D.39133;
        code.3631 = code;
        code = code.3631 + 1;
        D.39135 = imb.b[2];
        *code.3631 = D.39135;
        code.3632 = code;
        code = code.3632 + 1;
        D.39137 = imb.b[3];
        *code.3632 = D.39137;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39128>:
  <D.26027>:
  goto <D.39138>;
  <D.39098>:
  code.3633 = code;
  code = code.3633 + 1;
  *code.3633 = 219;
  if (1 != 0) goto <D.39140>; else goto <D.39141>;
  <D.39140>:
  if (1 != 0) goto <D.39142>; else goto <D.39143>;
  <D.39142>:
  code.3634 = code;
  code = code.3634 + 1;
  *code.3634 = 4;
  code.3635 = code;
  code = code.3635 + 1;
  *code.3635 = 36;
  goto <D.39146>;
  <D.39143>:
  if (1 != 0) goto <D.39147>; else goto <D.39148>;
  <D.39147>:
  code.3636 = code;
  code = code.3636 + 1;
  *code.3636 = 68;
  code.3637 = code;
  code = code.3637 + 1;
  *code.3637 = 36;
  *code = 0;
  code = code + 1;
  goto <D.39151>;
  <D.39148>:
  code.3638 = code;
  code = code.3638 + 1;
  *code.3638 = 132;
  code.3639 = code;
  code = code.3639 + 1;
  *code.3639 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3640 = code;
        code = code.3640 + 1;
        D.39155 = imb.b[0];
        *code.3640 = D.39155;
        code.3641 = code;
        code = code.3641 + 1;
        D.39157 = imb.b[1];
        *code.3641 = D.39157;
        code.3642 = code;
        code = code.3642 + 1;
        D.39159 = imb.b[2];
        *code.3642 = D.39159;
        code.3643 = code;
        code = code.3643 + 1;
        D.39161 = imb.b[3];
        *code.3643 = D.39161;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39151>:
  <D.39146>:
  goto <D.26030>;
  <D.39141>:
  if (1 != 0) goto <D.39162>; else goto <D.39163>;
  <D.39162>:
  code.3644 = code;
  code = code.3644 + 1;
  *code.3644 = 4;
  goto <D.26030>;
  <D.39163>:
  if (1 != 0) goto <D.39165>; else goto <D.39166>;
  <D.39165>:
  code.3645 = code;
  code = code.3645 + 1;
  *code.3645 = 68;
  *code = 0;
  code = code + 1;
  goto <D.39168>;
  <D.39166>:
  code.3646 = code;
  code = code.3646 + 1;
  *code.3646 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3647 = code;
        code = code.3647 + 1;
        D.39171 = imb.b[0];
        *code.3647 = D.39171;
        code.3648 = code;
        code = code.3648 + 1;
        D.39173 = imb.b[1];
        *code.3648 = D.39173;
        code.3649 = code;
        code = code.3649 + 1;
        D.39175 = imb.b[2];
        *code.3649 = D.39175;
        code.3650 = code;
        code = code.3650 + 1;
        D.39177 = imb.b[3];
        *code.3650 = D.39177;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39168>:
  <D.26030>:
  <D.39138>:
  code.3651 = code;
  code = code.3651 + 1;
  *code.3651 = 217;
  if (1 != 0) goto <D.39179>; else goto <D.39180>;
  <D.39179>:
  if (1 != 0) goto <D.39181>; else goto <D.39182>;
  <D.39181>:
  code.3652 = code;
  code = code.3652 + 1;
  *code.3652 = 28;
  code.3653 = code;
  code = code.3653 + 1;
  *code.3653 = 36;
  goto <D.39185>;
  <D.39182>:
  if (1 != 0) goto <D.39186>; else goto <D.39187>;
  <D.39186>:
  code.3654 = code;
  code = code.3654 + 1;
  *code.3654 = 92;
  code.3655 = code;
  code = code.3655 + 1;
  *code.3655 = 36;
  *code = 0;
  code = code + 1;
  goto <D.39190>;
  <D.39187>:
  code.3656 = code;
  code = code.3656 + 1;
  *code.3656 = 156;
  code.3657 = code;
  code = code.3657 + 1;
  *code.3657 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3658 = code;
        code = code.3658 + 1;
        D.39194 = imb.b[0];
        *code.3658 = D.39194;
        code.3659 = code;
        code = code.3659 + 1;
        D.39196 = imb.b[1];
        *code.3659 = D.39196;
        code.3660 = code;
        code = code.3660 + 1;
        D.39198 = imb.b[2];
        *code.3660 = D.39198;
        code.3661 = code;
        code = code.3661 + 1;
        D.39200 = imb.b[3];
        *code.3661 = D.39200;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39190>:
  <D.39185>:
  goto <D.26033>;
  <D.39180>:
  if (1 != 0) goto <D.39201>; else goto <D.39202>;
  <D.39201>:
  code.3662 = code;
  code = code.3662 + 1;
  *code.3662 = 28;
  goto <D.26033>;
  <D.39202>:
  if (1 != 0) goto <D.39204>; else goto <D.39205>;
  <D.39204>:
  code.3663 = code;
  code = code.3663 + 1;
  *code.3663 = 92;
  *code = 0;
  code = code + 1;
  goto <D.39207>;
  <D.39205>:
  code.3664 = code;
  code = code.3664 + 1;
  *code.3664 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3665 = code;
        code = code.3665 + 1;
        D.39210 = imb.b[0];
        *code.3665 = D.39210;
        code.3666 = code;
        code = code.3666 + 1;
        D.39212 = imb.b[1];
        *code.3666 = D.39212;
        code.3667 = code;
        code = code.3667 + 1;
        D.39214 = imb.b[2];
        *code.3667 = D.39214;
        code.3668 = code;
        code = code.3668 + 1;
        D.39216 = imb.b[3];
        *code.3668 = D.39216;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39207>:
  <D.26033>:
  code.3669 = code;
  code = code.3669 + 1;
  *code.3669 = 217;
  if (1 != 0) goto <D.39218>; else goto <D.39219>;
  <D.39218>:
  if (1 != 0) goto <D.39220>; else goto <D.39221>;
  <D.39220>:
  code.3670 = code;
  code = code.3670 + 1;
  *code.3670 = 4;
  code.3671 = code;
  code = code.3671 + 1;
  *code.3671 = 36;
  goto <D.39224>;
  <D.39221>:
  if (1 != 0) goto <D.39225>; else goto <D.39226>;
  <D.39225>:
  code.3672 = code;
  code = code.3672 + 1;
  *code.3672 = 68;
  code.3673 = code;
  code = code.3673 + 1;
  *code.3673 = 36;
  *code = 0;
  code = code + 1;
  goto <D.39229>;
  <D.39226>:
  code.3674 = code;
  code = code.3674 + 1;
  *code.3674 = 132;
  code.3675 = code;
  code = code.3675 + 1;
  *code.3675 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3676 = code;
        code = code.3676 + 1;
        D.39233 = imb.b[0];
        *code.3676 = D.39233;
        code.3677 = code;
        code = code.3677 + 1;
        D.39235 = imb.b[1];
        *code.3677 = D.39235;
        code.3678 = code;
        code = code.3678 + 1;
        D.39237 = imb.b[2];
        *code.3678 = D.39237;
        code.3679 = code;
        code = code.3679 + 1;
        D.39239 = imb.b[3];
        *code.3679 = D.39239;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39229>:
  <D.39224>:
  goto <D.26036>;
  <D.39219>:
  if (1 != 0) goto <D.39240>; else goto <D.39241>;
  <D.39240>:
  code.3680 = code;
  code = code.3680 + 1;
  *code.3680 = 4;
  goto <D.26036>;
  <D.39241>:
  if (1 != 0) goto <D.39243>; else goto <D.39244>;
  <D.39243>:
  code.3681 = code;
  code = code.3681 + 1;
  *code.3681 = 68;
  *code = 0;
  code = code + 1;
  goto <D.39246>;
  <D.39244>:
  code.3682 = code;
  code = code.3682 + 1;
  *code.3682 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3683 = code;
        code = code.3683 + 1;
        D.39249 = imb.b[0];
        *code.3683 = D.39249;
        code.3684 = code;
        code = code.3684 + 1;
        D.39251 = imb.b[1];
        *code.3684 = D.39251;
        code.3685 = code;
        code = code.3685 + 1;
        D.39253 = imb.b[2];
        *code.3685 = D.39253;
        code.3686 = code;
        code = code.3686 + 1;
        D.39255 = imb.b[3];
        *code.3686 = D.39255;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39246>:
  <D.26036>:
  if (0 != 0) goto <D.39256>; else goto <D.39257>;
  <D.39256>:
  code.3687 = code;
  code = code.3687 + 1;
  *code.3687 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3688 = code;
        code = code.3688 + 1;
        D.39260 = imb.b[0];
        *code.3688 = D.39260;
        code.3689 = code;
        code = code.3689 + 1;
        D.39262 = imb.b[1];
        *code.3689 = D.39262;
        code.3690 = code;
        code = code.3690 + 1;
        D.39264 = imb.b[2];
        *code.3690 = D.39264;
        code.3691 = code;
        code = code.3691 + 1;
        D.39266 = imb.b[3];
        *code.3691 = D.39266;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26039>;
  <D.39257>:
  if (1 != 0) goto <D.39267>; else goto <D.39268>;
  <D.39267>:
  code.3692 = code;
  code = code.3692 + 1;
  *code.3692 = 131;
  code.3693 = code;
  code = code.3693 + 1;
  *code.3693 = 196;
  *code = 8;
  code = code + 1;
  goto <D.39271>;
  <D.39268>:
  code.3694 = code;
  code = code.3694 + 1;
  *code.3694 = 129;
  code.3695 = code;
  code = code.3695 + 1;
  *code.3695 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.3696 = code;
        code = code.3696 + 1;
        D.39275 = imb.b[0];
        *code.3696 = D.39275;
        code.3697 = code;
        code = code.3697 + 1;
        D.39277 = imb.b[1];
        *code.3697 = D.39277;
        code.3698 = code;
        code = code.3698 + 1;
        D.39279 = imb.b[2];
        *code.3698 = D.39279;
        code.3699 = code;
        code = code.3699 + 1;
        D.39281 = imb.b[3];
        *code.3699 = D.39281;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39271>:
  <D.26039>:
  goto <D.24796>;
  <D.26041>:
  {
    static guint8 mn[10] = {0, 0, 0, 0, 0, 0, 0, 128, 63, 64};
    guint8 * br;

    code.3700 = code;
    code = code.3700 + 1;
    D.31527 = ins->sreg2;
    D.34084 = (unsigned char) D.31527;
    D.34085 = D.34084 + 80;
    *code.3700 = D.34085;
    code.3701 = code;
    code = code.3701 + 1;
    D.31548 = ins->sreg1;
    D.36113 = (unsigned char) D.31548;
    D.36114 = D.36113 + 80;
    *code.3701 = D.36114;
    if (1 != 0) goto <D.39284>; else goto <D.39285>;
    <D.39284>:
    code.3702 = code;
    code = code.3702 + 1;
    *code.3702 = 223;
    if (1 != 0) goto <D.39287>; else goto <D.39288>;
    <D.39287>:
    if (1 != 0) goto <D.39289>; else goto <D.39290>;
    <D.39289>:
    code.3703 = code;
    code = code.3703 + 1;
    *code.3703 = 44;
    code.3704 = code;
    code = code.3704 + 1;
    *code.3704 = 36;
    goto <D.39293>;
    <D.39290>:
    if (1 != 0) goto <D.39294>; else goto <D.39295>;
    <D.39294>:
    code.3705 = code;
    code = code.3705 + 1;
    *code.3705 = 108;
    code.3706 = code;
    code = code.3706 + 1;
    *code.3706 = 36;
    *code = 0;
    code = code + 1;
    goto <D.39298>;
    <D.39295>:
    code.3707 = code;
    code = code.3707 + 1;
    *code.3707 = 172;
    code.3708 = code;
    code = code.3708 + 1;
    *code.3708 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3709 = code;
          code = code.3709 + 1;
          D.39302 = imb.b[0];
          *code.3709 = D.39302;
          code.3710 = code;
          code = code.3710 + 1;
          D.39304 = imb.b[1];
          *code.3710 = D.39304;
          code.3711 = code;
          code = code.3711 + 1;
          D.39306 = imb.b[2];
          *code.3711 = D.39306;
          code.3712 = code;
          code = code.3712 + 1;
          D.39308 = imb.b[3];
          *code.3712 = D.39308;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39298>:
    <D.39293>:
    goto <D.26045>;
    <D.39288>:
    if (1 != 0) goto <D.39309>; else goto <D.39310>;
    <D.39309>:
    code.3713 = code;
    code = code.3713 + 1;
    *code.3713 = 44;
    goto <D.26045>;
    <D.39310>:
    if (1 != 0) goto <D.39312>; else goto <D.39313>;
    <D.39312>:
    code.3714 = code;
    code = code.3714 + 1;
    *code.3714 = 108;
    *code = 0;
    code = code + 1;
    goto <D.39315>;
    <D.39313>:
    code.3715 = code;
    code = code.3715 + 1;
    *code.3715 = 172;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3716 = code;
          code = code.3716 + 1;
          D.39318 = imb.b[0];
          *code.3716 = D.39318;
          code.3717 = code;
          code = code.3717 + 1;
          D.39320 = imb.b[1];
          *code.3717 = D.39320;
          code.3718 = code;
          code = code.3718 + 1;
          D.39322 = imb.b[2];
          *code.3718 = D.39322;
          code.3719 = code;
          code = code.3719 + 1;
          D.39324 = imb.b[3];
          *code.3719 = D.39324;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39315>:
    <D.26045>:
    goto <D.39325>;
    <D.39285>:
    code.3720 = code;
    code = code.3720 + 1;
    *code.3720 = 219;
    if (1 != 0) goto <D.39327>; else goto <D.39328>;
    <D.39327>:
    if (1 != 0) goto <D.39329>; else goto <D.39330>;
    <D.39329>:
    code.3721 = code;
    code = code.3721 + 1;
    *code.3721 = 4;
    code.3722 = code;
    code = code.3722 + 1;
    *code.3722 = 36;
    goto <D.39333>;
    <D.39330>:
    if (1 != 0) goto <D.39334>; else goto <D.39335>;
    <D.39334>:
    code.3723 = code;
    code = code.3723 + 1;
    *code.3723 = 68;
    code.3724 = code;
    code = code.3724 + 1;
    *code.3724 = 36;
    *code = 0;
    code = code + 1;
    goto <D.39338>;
    <D.39335>:
    code.3725 = code;
    code = code.3725 + 1;
    *code.3725 = 132;
    code.3726 = code;
    code = code.3726 + 1;
    *code.3726 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3727 = code;
          code = code.3727 + 1;
          D.39342 = imb.b[0];
          *code.3727 = D.39342;
          code.3728 = code;
          code = code.3728 + 1;
          D.39344 = imb.b[1];
          *code.3728 = D.39344;
          code.3729 = code;
          code = code.3729 + 1;
          D.39346 = imb.b[2];
          *code.3729 = D.39346;
          code.3730 = code;
          code = code.3730 + 1;
          D.39348 = imb.b[3];
          *code.3730 = D.39348;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39338>:
    <D.39333>:
    goto <D.26048>;
    <D.39328>:
    if (1 != 0) goto <D.39349>; else goto <D.39350>;
    <D.39349>:
    code.3731 = code;
    code = code.3731 + 1;
    *code.3731 = 4;
    goto <D.26048>;
    <D.39350>:
    if (1 != 0) goto <D.39352>; else goto <D.39353>;
    <D.39352>:
    code.3732 = code;
    code = code.3732 + 1;
    *code.3732 = 68;
    *code = 0;
    code = code + 1;
    goto <D.39355>;
    <D.39353>:
    code.3733 = code;
    code = code.3733 + 1;
    *code.3733 = 132;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3734 = code;
          code = code.3734 + 1;
          D.39358 = imb.b[0];
          *code.3734 = D.39358;
          code.3735 = code;
          code = code.3735 + 1;
          D.39360 = imb.b[1];
          *code.3735 = D.39360;
          code.3736 = code;
          code = code.3736 + 1;
          D.39362 = imb.b[2];
          *code.3736 = D.39362;
          code.3737 = code;
          code = code.3737 + 1;
          D.39364 = imb.b[3];
          *code.3737 = D.39364;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39355>:
    <D.26048>:
    <D.39325>:
    code.3738 = code;
    code = code.3738 + 1;
    *code.3738 = 133;
    code.3739 = code;
    code = code.3739 + 1;
    D.31527 = ins->sreg2;
    D.32604 = D.31527 & 7;
    D.32605 = D.32604 << 3;
    D.32606 = (signed char) D.32605;
    D.36394 = D.32606 | -64;
    D.31527 = ins->sreg2;
    D.31528 = (signed char) D.31527;
    D.31529 = D.31528 & 7;
    D.39367 = D.36394 | D.31529;
    D.39368 = (unsigned char) D.39367;
    *code.3739 = D.39368;
    br = code;
    if (1 != 0) goto <D.39369>; else goto <D.39370>;
    <D.39369>:
    code.3740 = code;
    code = code.3740 + 1;
    D.39372 = 121;
    *code.3740 = D.39372;
    goto <D.39373>;
    <D.39370>:
    code.3741 = code;
    code = code.3741 + 1;
    D.39375 = 121;
    *code.3741 = D.39375;
    <D.39373>:
    *code = 0;
    code = code + 1;
    D.31466 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.31467 = D.31466 & 64;
    if (D.31467 != 0) goto <D.39376>; else goto <D.39377>;
    <D.39376>:
    {
      int _imm;

      D.39378 = mn[9];
      D.39379 = (unsigned int) D.39378;
      D.39380 = D.39379 << 24;
      D.39381 = mn[8];
      D.39382 = (unsigned int) D.39381;
      D.39383 = D.39382 << 16;
      D.39384 = D.39380 | D.39383;
      D.39385 = mn[7];
      D.39386 = (unsigned int) D.39385;
      D.39387 = D.39386 << 8;
      D.39388 = D.39384 | D.39387;
      D.39389 = mn[6];
      D.39390 = (unsigned int) D.39389;
      D.39391 = D.39388 | D.39390;
      _imm = (int) D.39391;
      _imm.3742 = (unsigned int) _imm;
      D.39393 = _imm.3742 + 128;
      if (D.39393 <= 255) goto <D.39394>; else goto <D.39395>;
      <D.39394>:
      code.3743 = code;
      code = code.3743 + 1;
      *code.3743 = 106;
      D.39397 = (unsigned char) _imm;
      *code = D.39397;
      code = code + 1;
      goto <D.39398>;
      <D.39395>:
      code.3744 = code;
      code = code.3744 + 1;
      *code.3744 = 104;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = _imm;
            code.3745 = code;
            code = code.3745 + 1;
            D.39401 = imb.b[0];
            *code.3745 = D.39401;
            code.3746 = code;
            code = code.3746 + 1;
            D.39403 = imb.b[1];
            *code.3746 = D.39403;
            code.3747 = code;
            code = code.3747 + 1;
            D.39405 = imb.b[2];
            *code.3747 = D.39405;
            code.3748 = code;
            code = code.3748 + 1;
            D.39407 = imb.b[3];
            *code.3748 = D.39407;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.39398>:
    }
    {
      int _imm;

      D.39408 = mn[5];
      D.39409 = (unsigned int) D.39408;
      D.39410 = D.39409 << 24;
      D.39411 = mn[4];
      D.39412 = (unsigned int) D.39411;
      D.39413 = D.39412 << 16;
      D.39414 = D.39410 | D.39413;
      D.39415 = mn[3];
      D.39416 = (unsigned int) D.39415;
      D.39417 = D.39416 << 8;
      D.39418 = D.39414 | D.39417;
      D.39419 = mn[2];
      D.39420 = (unsigned int) D.39419;
      D.39421 = D.39418 | D.39420;
      _imm = (int) D.39421;
      _imm.3749 = (unsigned int) _imm;
      D.39423 = _imm.3749 + 128;
      if (D.39423 <= 255) goto <D.39424>; else goto <D.39425>;
      <D.39424>:
      code.3750 = code;
      code = code.3750 + 1;
      *code.3750 = 106;
      D.39427 = (unsigned char) _imm;
      *code = D.39427;
      code = code + 1;
      goto <D.39428>;
      <D.39425>:
      code.3751 = code;
      code = code.3751 + 1;
      *code.3751 = 104;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = _imm;
            code.3752 = code;
            code = code.3752 + 1;
            D.39431 = imb.b[0];
            *code.3752 = D.39431;
            code.3753 = code;
            code = code.3753 + 1;
            D.39433 = imb.b[1];
            *code.3753 = D.39433;
            code.3754 = code;
            code = code.3754 + 1;
            D.39435 = imb.b[2];
            *code.3754 = D.39435;
            code.3755 = code;
            code = code.3755 + 1;
            D.39437 = imb.b[3];
            *code.3755 = D.39437;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.39428>:
    }
    {
      int _imm;

      D.39438 = mn[1];
      D.39439 = (unsigned int) D.39438;
      D.39440 = D.39439 << 24;
      D.39441 = mn[0];
      D.39442 = (unsigned int) D.39441;
      D.39443 = D.39442 << 16;
      D.39444 = D.39440 | D.39443;
      _imm = (int) D.39444;
      _imm.3756 = (unsigned int) _imm;
      D.39446 = _imm.3756 + 128;
      if (D.39446 <= 255) goto <D.39447>; else goto <D.39448>;
      <D.39447>:
      code.3757 = code;
      code = code.3757 + 1;
      *code.3757 = 106;
      D.39450 = (unsigned char) _imm;
      *code = D.39450;
      code = code + 1;
      goto <D.39451>;
      <D.39448>:
      code.3758 = code;
      code = code.3758 + 1;
      *code.3758 = 104;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = _imm;
            code.3759 = code;
            code = code.3759 + 1;
            D.39454 = imb.b[0];
            *code.3759 = D.39454;
            code.3760 = code;
            code = code.3760 + 1;
            D.39456 = imb.b[1];
            *code.3760 = D.39456;
            code.3761 = code;
            code = code.3761 + 1;
            D.39458 = imb.b[2];
            *code.3761 = D.39458;
            code.3762 = code;
            code = code.3762 + 1;
            D.39460 = imb.b[3];
            *code.3762 = D.39460;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.39451>:
    }
    code.3763 = code;
    code = code.3763 + 1;
    *code.3763 = 219;
    if (1 != 0) goto <D.39462>; else goto <D.39463>;
    <D.39462>:
    if (0 != 0) goto <D.39464>; else goto <D.39465>;
    <D.39464>:
    code.3764 = code;
    code = code.3764 + 1;
    *code.3764 = 44;
    code.3765 = code;
    code = code.3765 + 1;
    *code.3765 = 36;
    goto <D.39468>;
    <D.39465>:
    if (1 != 0) goto <D.39469>; else goto <D.39470>;
    <D.39469>:
    code.3766 = code;
    code = code.3766 + 1;
    *code.3766 = 108;
    code.3767 = code;
    code = code.3767 + 1;
    *code.3767 = 36;
    *code = 2;
    code = code + 1;
    goto <D.39473>;
    <D.39470>:
    code.3768 = code;
    code = code.3768 + 1;
    *code.3768 = 172;
    code.3769 = code;
    code = code.3769 + 1;
    *code.3769 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 2;
          code.3770 = code;
          code = code.3770 + 1;
          D.39477 = imb.b[0];
          *code.3770 = D.39477;
          code.3771 = code;
          code = code.3771 + 1;
          D.39479 = imb.b[1];
          *code.3771 = D.39479;
          code.3772 = code;
          code = code.3772 + 1;
          D.39481 = imb.b[2];
          *code.3772 = D.39481;
          code.3773 = code;
          code = code.3773 + 1;
          D.39483 = imb.b[3];
          *code.3773 = D.39483;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39473>:
    <D.39468>:
    goto <D.26057>;
    <D.39463>:
    if (0 != 0) goto <D.39484>; else goto <D.39485>;
    <D.39484>:
    code.3774 = code;
    code = code.3774 + 1;
    *code.3774 = 44;
    goto <D.26057>;
    <D.39485>:
    if (1 != 0) goto <D.39487>; else goto <D.39488>;
    <D.39487>:
    code.3775 = code;
    code = code.3775 + 1;
    *code.3775 = 108;
    *code = 2;
    code = code + 1;
    goto <D.39490>;
    <D.39488>:
    code.3776 = code;
    code = code.3776 + 1;
    *code.3776 = 172;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 2;
          code.3777 = code;
          code = code.3777 + 1;
          D.39493 = imb.b[0];
          *code.3777 = D.39493;
          code.3778 = code;
          code = code.3778 + 1;
          D.39495 = imb.b[1];
          *code.3778 = D.39495;
          code.3779 = code;
          code = code.3779 + 1;
          D.39497 = imb.b[2];
          *code.3779 = D.39497;
          code.3780 = code;
          code = code.3780 + 1;
          D.39499 = imb.b[3];
          *code.3780 = D.39499;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39490>:
    <D.26057>:
    if (0 != 0) goto <D.39500>; else goto <D.39501>;
    <D.39500>:
    code.3781 = code;
    code = code.3781 + 1;
    *code.3781 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 12;
          code.3782 = code;
          code = code.3782 + 1;
          D.39504 = imb.b[0];
          *code.3782 = D.39504;
          code.3783 = code;
          code = code.3783 + 1;
          D.39506 = imb.b[1];
          *code.3783 = D.39506;
          code.3784 = code;
          code = code.3784 + 1;
          D.39508 = imb.b[2];
          *code.3784 = D.39508;
          code.3785 = code;
          code = code.3785 + 1;
          D.39510 = imb.b[3];
          *code.3785 = D.39510;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26060>;
    <D.39501>:
    if (1 != 0) goto <D.39511>; else goto <D.39512>;
    <D.39511>:
    code.3786 = code;
    code = code.3786 + 1;
    *code.3786 = 131;
    code.3787 = code;
    code = code.3787 + 1;
    *code.3787 = 196;
    *code = 12;
    code = code + 1;
    goto <D.39515>;
    <D.39512>:
    code.3788 = code;
    code = code.3788 + 1;
    *code.3788 = 129;
    code.3789 = code;
    code = code.3789 + 1;
    *code.3789 = 196;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 12;
          code.3790 = code;
          code = code.3790 + 1;
          D.39519 = imb.b[0];
          *code.3790 = D.39519;
          code.3791 = code;
          code = code.3791 + 1;
          D.39521 = imb.b[1];
          *code.3791 = D.39521;
          code.3792 = code;
          code = code.3792 + 1;
          D.39523 = imb.b[2];
          *code.3792 = D.39523;
          code.3793 = code;
          code = code.3793 + 1;
          D.39525 = imb.b[3];
          *code.3793 = D.39525;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39515>:
    <D.26060>:
    goto <D.39526>;
    <D.39377>:
    code.3794 = code;
    code = code.3794 + 1;
    *code.3794 = 219;
    code.3795 = code;
    code = code.3795 + 1;
    *code.3795 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          mn.3796 = (int) &mn;
          imb.val = mn.3796;
          code.3797 = code;
          code = code.3797 + 1;
          D.39531 = imb.b[0];
          *code.3797 = D.39531;
          code.3798 = code;
          code = code.3798 + 1;
          D.39533 = imb.b[1];
          *code.3798 = D.39533;
          code.3799 = code;
          code = code.3799 + 1;
          D.39535 = imb.b[2];
          *code.3799 = D.39535;
          code.3800 = code;
          code = code.3800 + 1;
          D.39537 = imb.b[3];
          *code.3800 = D.39537;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39526>:
    {
      static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

      code.3801 = code;
      code = code.3801 + 1;
      *code.3801 = 222;
      code.3802 = code;
      code = code.3802 + 1;
      D.39540 = 0;
      D.39541 = D.39540 << 3;
      D.39542 = D.39541 + 193;
      *code.3802 = D.39542;
    }
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = br + 1;
      size = 0;
      D.39543 = MEM[(unsigned char *)br];
      D.39544 = (int) D.39543;
      switch (D.39544) <default: <D.26091>, case 15: <D.26070>, case 112: <D.26075>, case 113: <D.26076>, case 114: <D.26077>, case 115: <D.26078>, case 116: <D.26079>, case 117: <D.26080>, case 118: <D.26081>, case 119: <D.26082>, case 120: <D.26083>, case 121: <D.26084>, case 122: <D.26085>, case 123: <D.26086>, case 124: <D.26087>, case 125: <D.26088>, case 126: <D.26089>, case 127: <D.26090>, case 224: <D.26071>, case 225: <D.26072>, case 226: <D.26073>, case 232: <D.26067>, case 233: <D.26068>, case 235: <D.26074>>
      <D.26067>:
      <D.26068>:
      size = size + 1;
      goto <D.26069>;
      <D.26070>:
      D.39545 = *pos;
      D.39546 = D.39545 + 144;
      if (D.39546 > 31) goto <D.39547>; else goto <D.39548>;
      <D.39547>:
      __assert_fail ("0", "mini-x86.c", 3769, &__PRETTY_FUNCTION__);
      <D.39548>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26069>;
      <D.26071>:
      <D.26072>:
      <D.26073>:
      <D.26074>:
      <D.26075>:
      <D.26076>:
      <D.26077>:
      <D.26078>:
      <D.26079>:
      <D.26080>:
      <D.26081>:
      <D.26082>:
      <D.26083>:
      <D.26084>:
      <D.26085>:
      <D.26086>:
      <D.26087>:
      <D.26088>:
      <D.26089>:
      <D.26090>:
      goto <D.26069>;
      <D.26091>:
      __assert_fail ("0", "mini-x86.c", 3769, &__PRETTY_FUNCTION__);
      <D.26069>:
      code.422 = (int) code;
      pos.3803 = (int) pos;
      disp = code.422 - pos.3803;
      if (size != 0) goto <D.39550>; else goto <D.39551>;
      <D.39550>:
      {
        union x86_imm_buf imb;

        try
          {
            D.39552 = disp + -4;
            imb.val = D.39552;
            pos.3804 = pos;
            pos = pos.3804 + 1;
            D.39554 = imb.b[0];
            *pos.3804 = D.39554;
            pos.3805 = pos;
            pos = pos.3805 + 1;
            D.39556 = imb.b[1];
            *pos.3805 = D.39556;
            pos.3806 = pos;
            pos = pos.3806 + 1;
            D.39558 = imb.b[2];
            *pos.3806 = D.39558;
            pos.3807 = pos;
            pos = pos.3807 + 1;
            D.39560 = imb.b[3];
            *pos.3807 = D.39560;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.39561>;
      <D.39551>:
      disp.3808 = (unsigned int) disp;
      D.39563 = disp.3808 + 127;
      if (D.39563 <= 255) goto <D.39564>; else goto <D.39565>;
      <D.39564>:
      D.39566 = (unsigned char) disp;
      D.39567 = D.39566 + 255;
      *pos = D.39567;
      pos = pos + 1;
      goto <D.39568>;
      <D.39565>:
      __assert_fail ("0", "mini-x86.c", 3769, &__PRETTY_FUNCTION__);
      <D.39568>:
      <D.39561>:
    }
    code.3809 = code;
    code = code.3809 + 1;
    *code.3809 = 221;
    if (1 != 0) goto <D.39570>; else goto <D.39571>;
    <D.39570>:
    if (1 != 0) goto <D.39572>; else goto <D.39573>;
    <D.39572>:
    code.3810 = code;
    code = code.3810 + 1;
    *code.3810 = 28;
    code.3811 = code;
    code = code.3811 + 1;
    *code.3811 = 36;
    goto <D.39576>;
    <D.39573>:
    if (1 != 0) goto <D.39577>; else goto <D.39578>;
    <D.39577>:
    code.3812 = code;
    code = code.3812 + 1;
    *code.3812 = 92;
    code.3813 = code;
    code = code.3813 + 1;
    *code.3813 = 36;
    *code = 0;
    code = code + 1;
    goto <D.39581>;
    <D.39578>:
    code.3814 = code;
    code = code.3814 + 1;
    *code.3814 = 156;
    code.3815 = code;
    code = code.3815 + 1;
    *code.3815 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3816 = code;
          code = code.3816 + 1;
          D.39585 = imb.b[0];
          *code.3816 = D.39585;
          code.3817 = code;
          code = code.3817 + 1;
          D.39587 = imb.b[1];
          *code.3817 = D.39587;
          code.3818 = code;
          code = code.3818 + 1;
          D.39589 = imb.b[2];
          *code.3818 = D.39589;
          code.3819 = code;
          code = code.3819 + 1;
          D.39591 = imb.b[3];
          *code.3819 = D.39591;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39581>:
    <D.39576>:
    goto <D.26094>;
    <D.39571>:
    if (1 != 0) goto <D.39592>; else goto <D.39593>;
    <D.39592>:
    code.3820 = code;
    code = code.3820 + 1;
    *code.3820 = 28;
    goto <D.26094>;
    <D.39593>:
    if (1 != 0) goto <D.39595>; else goto <D.39596>;
    <D.39595>:
    code.3821 = code;
    code = code.3821 + 1;
    *code.3821 = 92;
    *code = 0;
    code = code + 1;
    goto <D.39598>;
    <D.39596>:
    code.3822 = code;
    code = code.3822 + 1;
    *code.3822 = 156;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3823 = code;
          code = code.3823 + 1;
          D.39601 = imb.b[0];
          *code.3823 = D.39601;
          code.3824 = code;
          code = code.3824 + 1;
          D.39603 = imb.b[1];
          *code.3824 = D.39603;
          code.3825 = code;
          code = code.3825 + 1;
          D.39605 = imb.b[2];
          *code.3825 = D.39605;
          code.3826 = code;
          code = code.3826 + 1;
          D.39607 = imb.b[3];
          *code.3826 = D.39607;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39598>:
    <D.26094>:
    code.3827 = code;
    code = code.3827 + 1;
    *code.3827 = 221;
    if (1 != 0) goto <D.39609>; else goto <D.39610>;
    <D.39609>:
    if (1 != 0) goto <D.39611>; else goto <D.39612>;
    <D.39611>:
    code.3828 = code;
    code = code.3828 + 1;
    *code.3828 = 4;
    code.3829 = code;
    code = code.3829 + 1;
    *code.3829 = 36;
    goto <D.39615>;
    <D.39612>:
    if (1 != 0) goto <D.39616>; else goto <D.39617>;
    <D.39616>:
    code.3830 = code;
    code = code.3830 + 1;
    *code.3830 = 68;
    code.3831 = code;
    code = code.3831 + 1;
    *code.3831 = 36;
    *code = 0;
    code = code + 1;
    goto <D.39620>;
    <D.39617>:
    code.3832 = code;
    code = code.3832 + 1;
    *code.3832 = 132;
    code.3833 = code;
    code = code.3833 + 1;
    *code.3833 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3834 = code;
          code = code.3834 + 1;
          D.39624 = imb.b[0];
          *code.3834 = D.39624;
          code.3835 = code;
          code = code.3835 + 1;
          D.39626 = imb.b[1];
          *code.3835 = D.39626;
          code.3836 = code;
          code = code.3836 + 1;
          D.39628 = imb.b[2];
          *code.3836 = D.39628;
          code.3837 = code;
          code = code.3837 + 1;
          D.39630 = imb.b[3];
          *code.3837 = D.39630;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39620>:
    <D.39615>:
    goto <D.26097>;
    <D.39610>:
    if (1 != 0) goto <D.39631>; else goto <D.39632>;
    <D.39631>:
    code.3838 = code;
    code = code.3838 + 1;
    *code.3838 = 4;
    goto <D.26097>;
    <D.39632>:
    if (1 != 0) goto <D.39634>; else goto <D.39635>;
    <D.39634>:
    code.3839 = code;
    code = code.3839 + 1;
    *code.3839 = 68;
    *code = 0;
    code = code + 1;
    goto <D.39637>;
    <D.39635>:
    code.3840 = code;
    code = code.3840 + 1;
    *code.3840 = 132;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3841 = code;
          code = code.3841 + 1;
          D.39640 = imb.b[0];
          *code.3841 = D.39640;
          code.3842 = code;
          code = code.3842 + 1;
          D.39642 = imb.b[1];
          *code.3842 = D.39642;
          code.3843 = code;
          code = code.3843 + 1;
          D.39644 = imb.b[2];
          *code.3843 = D.39644;
          code.3844 = code;
          code = code.3844 + 1;
          D.39646 = imb.b[3];
          *code.3844 = D.39646;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39637>:
    <D.26097>:
    if (0 != 0) goto <D.39647>; else goto <D.39648>;
    <D.39647>:
    code.3845 = code;
    code = code.3845 + 1;
    *code.3845 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 8;
          code.3846 = code;
          code = code.3846 + 1;
          D.39651 = imb.b[0];
          *code.3846 = D.39651;
          code.3847 = code;
          code = code.3847 + 1;
          D.39653 = imb.b[1];
          *code.3847 = D.39653;
          code.3848 = code;
          code = code.3848 + 1;
          D.39655 = imb.b[2];
          *code.3848 = D.39655;
          code.3849 = code;
          code = code.3849 + 1;
          D.39657 = imb.b[3];
          *code.3849 = D.39657;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26100>;
    <D.39648>:
    if (1 != 0) goto <D.39658>; else goto <D.39659>;
    <D.39658>:
    code.3850 = code;
    code = code.3850 + 1;
    *code.3850 = 131;
    code.3851 = code;
    code = code.3851 + 1;
    *code.3851 = 196;
    *code = 8;
    code = code + 1;
    goto <D.39662>;
    <D.39659>:
    code.3852 = code;
    code = code.3852 + 1;
    *code.3852 = 129;
    code.3853 = code;
    code = code.3853 + 1;
    *code.3853 = 196;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 8;
          code.3854 = code;
          code = code.3854 + 1;
          D.39666 = imb.b[0];
          *code.3854 = D.39666;
          code.3855 = code;
          code = code.3855 + 1;
          D.39668 = imb.b[1];
          *code.3855 = D.39668;
          code.3856 = code;
          code = code.3856 + 1;
          D.39670 = imb.b[2];
          *code.3856 = D.39670;
          code.3857 = code;
          code = code.3857 + 1;
          D.39672 = imb.b[3];
          *code.3857 = D.39672;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39662>:
    <D.26100>:
    goto <D.24796>;
  }
  <D.26102>:
  <D.26103>:
  {
    guint8 * br[3];
    guint8 * label[1];
    struct MonoInst * tins;

    try
      {
        code.3858 = code;
        code = code.3858 + 1;
        *code.3858 = 133;
        code.3859 = code;
        code = code.3859 + 1;
        D.31548 = ins->sreg1;
        D.32035 = D.31548 & 7;
        D.32036 = D.32035 << 3;
        D.32037 = (signed char) D.32036;
        D.32565 = D.32037 | -64;
        D.31548 = ins->sreg1;
        D.31585 = (signed char) D.31548;
        D.31586 = D.31585 & 7;
        D.32876 = D.32565 | D.31586;
        D.32877 = (unsigned char) D.32876;
        *code.3859 = D.32877;
        br[0] = code;
        if (1 != 0) goto <D.39675>; else goto <D.39676>;
        <D.39675>:
        code.3860 = code;
        code = code.3860 + 1;
        D.39678 = 124;
        *code.3860 = D.39678;
        goto <D.39679>;
        <D.39676>:
        code.3861 = code;
        code = code.3861 + 1;
        D.39681 = 114;
        *code.3861 = D.39681;
        <D.39679>:
        *code = 0;
        code = code + 1;
        code.3862 = code;
        code = code.3862 + 1;
        *code.3862 = 133;
        code.3863 = code;
        code = code.3863 + 1;
        D.31527 = ins->sreg2;
        D.32604 = D.31527 & 7;
        D.32605 = D.32604 << 3;
        D.32606 = (signed char) D.32605;
        D.36394 = D.32606 | -64;
        D.31527 = ins->sreg2;
        D.31528 = (signed char) D.31527;
        D.31529 = D.31528 & 7;
        D.39367 = D.36394 | D.31529;
        D.39368 = (unsigned char) D.39367;
        *code.3863 = D.39368;
        br[1] = code;
        if (1 != 0) goto <D.39684>; else goto <D.39685>;
        <D.39684>:
        code.3864 = code;
        code = code.3864 + 1;
        D.34479 = 116;
        *code.3864 = D.34479;
        goto <D.39687>;
        <D.39685>:
        code.3865 = code;
        code = code.3865 + 1;
        D.34482 = 116;
        *code.3865 = D.34482;
        <D.39687>:
        *code = 0;
        code = code + 1;
        label[0] = code;
        tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
        if (tins != 0B) goto <D.39689>; else goto <D.39690>;
        <D.39689>:
        D.39691 = tins->data.op[1].many_blocks;
        D.39692 = *D.39691;
        code.422 = (int) code;
        D.31409 = cfg->native_code;
        D.31488 = (int) D.31409;
        D.31489 = code.422 - D.31488;
        mono_add_patch_info (cfg, D.31489, 0, D.39692);
        D.31411 = cfg->opt;
        D.35226 = D.31411 & 2;
        if (D.35226 != 0) goto <D.39695>; else goto <D.39693>;
        <D.39695>:
        D.39691 = tins->data.op[1].many_blocks;
        D.39692 = *D.39691;
        D.39696 = D.39692->max_offset;
        D.39697 = D.39696 - cpos;
        D.39698 = (unsigned int) D.39697;
        D.39699 = D.39698 + 128;
        if (D.39699 <= 255) goto <D.39700>; else goto <D.39693>;
        <D.39700>:
        code.3866 = code;
        code = code.3866 + 1;
        *code.3866 = 235;
        *code = 0;
        code = code + 1;
        goto <D.39694>;
        <D.39693>:
        code.3867 = code;
        code = code.3867 + 1;
        *code.3867 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.3868 = code;
              code = code.3868 + 1;
              D.39704 = imb.b[0];
              *code.3868 = D.39704;
              code.3869 = code;
              code = code.3869 + 1;
              D.39706 = imb.b[1];
              *code.3869 = D.39706;
              code.3870 = code;
              code = code.3870 + 1;
              D.39708 = imb.b[2];
              *code.3870 = D.39708;
              code.3871 = code;
              code = code.3871 + 1;
              D.39710 = imb.b[3];
              *code.3871 = D.39710;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.39694>:
        goto <D.39711>;
        <D.39690>:
        code.422 = (int) code;
        D.31409 = cfg->native_code;
        D.31488 = (int) D.31409;
        D.31489 = code.422 - D.31488;
        mono_add_patch_info (cfg, D.31489, 9, "OverflowException");
        code.3872 = code;
        code = code.3872 + 1;
        *code.3872 = 233;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.3873 = code;
              code = code.3873 + 1;
              D.39714 = imb.b[0];
              *code.3873 = D.39714;
              code.3874 = code;
              code = code.3874 + 1;
              D.39716 = imb.b[1];
              *code.3874 = D.39716;
              code.3875 = code;
              code = code.3875 + 1;
              D.39718 = imb.b[2];
              *code.3875 = D.39718;
              code.3876 = code;
              code = code.3876 + 1;
              D.39720 = imb.b[3];
              *code.3876 = D.39720;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.39711>:
        {
          unsigned char * pos;
          int disp;
          int size;

          D.39721 = br[0];
          pos = D.39721 + 1;
          size = 0;
          D.39721 = br[0];
          D.39722 = MEM[(unsigned char *)D.39721];
          D.39723 = (int) D.39722;
          switch (D.39723) <default: <D.26136>, case 15: <D.26115>, case 112: <D.26120>, case 113: <D.26121>, case 114: <D.26122>, case 115: <D.26123>, case 116: <D.26124>, case 117: <D.26125>, case 118: <D.26126>, case 119: <D.26127>, case 120: <D.26128>, case 121: <D.26129>, case 122: <D.26130>, case 123: <D.26131>, case 124: <D.26132>, case 125: <D.26133>, case 126: <D.26134>, case 127: <D.26135>, case 224: <D.26116>, case 225: <D.26117>, case 226: <D.26118>, case 232: <D.26112>, case 233: <D.26113>, case 235: <D.26119>>
          <D.26112>:
          <D.26113>:
          size = size + 1;
          goto <D.26114>;
          <D.26115>:
          D.39724 = *pos;
          D.39725 = D.39724 + 144;
          if (D.39725 > 31) goto <D.39726>; else goto <D.39727>;
          <D.39726>:
          __assert_fail ("0", "mini-x86.c", 3810, &__PRETTY_FUNCTION__);
          <D.39727>:
          size = size + 1;
          pos = pos + 1;
          goto <D.26114>;
          <D.26116>:
          <D.26117>:
          <D.26118>:
          <D.26119>:
          <D.26120>:
          <D.26121>:
          <D.26122>:
          <D.26123>:
          <D.26124>:
          <D.26125>:
          <D.26126>:
          <D.26127>:
          <D.26128>:
          <D.26129>:
          <D.26130>:
          <D.26131>:
          <D.26132>:
          <D.26133>:
          <D.26134>:
          <D.26135>:
          goto <D.26114>;
          <D.26136>:
          __assert_fail ("0", "mini-x86.c", 3810, &__PRETTY_FUNCTION__);
          <D.26114>:
          code.422 = (int) code;
          pos.3877 = (int) pos;
          disp = code.422 - pos.3877;
          if (size != 0) goto <D.39729>; else goto <D.39730>;
          <D.39729>:
          {
            union x86_imm_buf imb;

            try
              {
                D.39731 = disp + -4;
                imb.val = D.39731;
                pos.3878 = pos;
                pos = pos.3878 + 1;
                D.39733 = imb.b[0];
                *pos.3878 = D.39733;
                pos.3879 = pos;
                pos = pos.3879 + 1;
                D.39735 = imb.b[1];
                *pos.3879 = D.39735;
                pos.3880 = pos;
                pos = pos.3880 + 1;
                D.39737 = imb.b[2];
                *pos.3880 = D.39737;
                pos.3881 = pos;
                pos = pos.3881 + 1;
                D.39739 = imb.b[3];
                *pos.3881 = D.39739;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.39740>;
          <D.39730>:
          disp.3882 = (unsigned int) disp;
          D.39742 = disp.3882 + 127;
          if (D.39742 <= 255) goto <D.39743>; else goto <D.39744>;
          <D.39743>:
          D.39745 = (unsigned char) disp;
          D.39746 = D.39745 + 255;
          *pos = D.39746;
          pos = pos + 1;
          goto <D.39747>;
          <D.39744>:
          __assert_fail ("0", "mini-x86.c", 3810, &__PRETTY_FUNCTION__);
          <D.39747>:
          <D.39740>:
        }
        D.31527 = ins->sreg2;
        if (D.31527 == 0) goto <D.39748>; else goto <D.39749>;
        <D.39748>:
        code.3883 = code;
        code = code.3883 + 1;
        *code.3883 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -1;
              code.3884 = code;
              code = code.3884 + 1;
              D.39752 = imb.b[0];
              *code.3884 = D.39752;
              code.3885 = code;
              code = code.3885 + 1;
              D.39754 = imb.b[1];
              *code.3885 = D.39754;
              code.3886 = code;
              code = code.3886 + 1;
              D.39756 = imb.b[2];
              *code.3886 = D.39756;
              code.3887 = code;
              code = code.3887 + 1;
              D.39758 = imb.b[3];
              *code.3887 = D.39758;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.26139>;
        <D.39749>:
        if (1 != 0) goto <D.39759>; else goto <D.39760>;
        <D.39759>:
        code.3888 = code;
        code = code.3888 + 1;
        *code.3888 = 131;
        code.3889 = code;
        code = code.3889 + 1;
        D.31527 = ins->sreg2;
        D.31528 = (signed char) D.31527;
        D.34156 = D.31528 | -8;
        D.34157 = (unsigned char) D.34156;
        *code.3889 = D.34157;
        *code = 255;
        code = code + 1;
        goto <D.39763>;
        <D.39760>:
        code.3890 = code;
        code = code.3890 + 1;
        *code.3890 = 129;
        code.3891 = code;
        code = code.3891 + 1;
        D.31527 = ins->sreg2;
        D.31528 = (signed char) D.31527;
        D.34156 = D.31528 | -8;
        D.34157 = (unsigned char) D.34156;
        *code.3891 = D.34157;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -1;
              code.3892 = code;
              code = code.3892 + 1;
              D.39767 = imb.b[0];
              *code.3892 = D.39767;
              code.3893 = code;
              code = code.3893 + 1;
              D.39769 = imb.b[1];
              *code.3893 = D.39769;
              code.3894 = code;
              code = code.3894 + 1;
              D.39771 = imb.b[2];
              *code.3894 = D.39771;
              code.3895 = code;
              code = code.3895 + 1;
              D.39773 = imb.b[3];
              *code.3895 = D.39773;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.39763>:
        <D.26139>:
        {
          unsigned char * pos;
          int disp;
          int size;

          D.39774 = br[1];
          pos = D.39774 + 1;
          size = 0;
          D.39774 = br[1];
          D.39775 = MEM[(unsigned char *)D.39774];
          D.39776 = (int) D.39775;
          switch (D.39776) <default: <D.26168>, case 15: <D.26147>, case 112: <D.26152>, case 113: <D.26153>, case 114: <D.26154>, case 115: <D.26155>, case 116: <D.26156>, case 117: <D.26157>, case 118: <D.26158>, case 119: <D.26159>, case 120: <D.26160>, case 121: <D.26161>, case 122: <D.26162>, case 123: <D.26163>, case 124: <D.26164>, case 125: <D.26165>, case 126: <D.26166>, case 127: <D.26167>, case 224: <D.26148>, case 225: <D.26149>, case 226: <D.26150>, case 232: <D.26144>, case 233: <D.26145>, case 235: <D.26151>>
          <D.26144>:
          <D.26145>:
          size = size + 1;
          goto <D.26146>;
          <D.26147>:
          D.39777 = *pos;
          D.39778 = D.39777 + 144;
          if (D.39778 > 31) goto <D.39779>; else goto <D.39780>;
          <D.39779>:
          __assert_fail ("0", "mini-x86.c", 3814, &__PRETTY_FUNCTION__);
          <D.39780>:
          size = size + 1;
          pos = pos + 1;
          goto <D.26146>;
          <D.26148>:
          <D.26149>:
          <D.26150>:
          <D.26151>:
          <D.26152>:
          <D.26153>:
          <D.26154>:
          <D.26155>:
          <D.26156>:
          <D.26157>:
          <D.26158>:
          <D.26159>:
          <D.26160>:
          <D.26161>:
          <D.26162>:
          <D.26163>:
          <D.26164>:
          <D.26165>:
          <D.26166>:
          <D.26167>:
          goto <D.26146>;
          <D.26168>:
          __assert_fail ("0", "mini-x86.c", 3814, &__PRETTY_FUNCTION__);
          <D.26146>:
          code.422 = (int) code;
          pos.3896 = (int) pos;
          disp = code.422 - pos.3896;
          if (size != 0) goto <D.39782>; else goto <D.39783>;
          <D.39782>:
          {
            union x86_imm_buf imb;

            try
              {
                D.39784 = disp + -4;
                imb.val = D.39784;
                pos.3897 = pos;
                pos = pos.3897 + 1;
                D.39786 = imb.b[0];
                *pos.3897 = D.39786;
                pos.3898 = pos;
                pos = pos.3898 + 1;
                D.39788 = imb.b[1];
                *pos.3898 = D.39788;
                pos.3899 = pos;
                pos = pos.3899 + 1;
                D.39790 = imb.b[2];
                *pos.3899 = D.39790;
                pos.3900 = pos;
                pos = pos.3900 + 1;
                D.39792 = imb.b[3];
                *pos.3900 = D.39792;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.39793>;
          <D.39783>:
          disp.3901 = (unsigned int) disp;
          D.39795 = disp.3901 + 127;
          if (D.39795 <= 255) goto <D.39796>; else goto <D.39797>;
          <D.39796>:
          D.39798 = (unsigned char) disp;
          D.39799 = D.39798 + 255;
          *pos = D.39799;
          pos = pos + 1;
          goto <D.39800>;
          <D.39797>:
          __assert_fail ("0", "mini-x86.c", 3814, &__PRETTY_FUNCTION__);
          <D.39800>:
          <D.39793>:
        }
        br[2] = code;
        if (1 != 0) goto <D.39801>; else goto <D.39802>;
        <D.39801>:
        code.3902 = code;
        code = code.3902 + 1;
        D.39804 = 117;
        *code.3902 = D.39804;
        goto <D.39805>;
        <D.39802>:
        code.3903 = code;
        code = code.3903 + 1;
        D.39807 = 117;
        *code.3903 = D.39807;
        <D.39805>:
        *code = 0;
        code = code + 1;
        {
          unsigned char * pos;
          int disp;
          int size;

          D.39808 = br[2];
          pos = D.39808 + 1;
          size = 0;
          D.39808 = br[2];
          D.39809 = MEM[(unsigned char *)D.39808];
          D.39810 = (int) D.39809;
          switch (D.39810) <default: <D.26197>, case 15: <D.26176>, case 112: <D.26181>, case 113: <D.26182>, case 114: <D.26183>, case 115: <D.26184>, case 116: <D.26185>, case 117: <D.26186>, case 118: <D.26187>, case 119: <D.26188>, case 120: <D.26189>, case 121: <D.26190>, case 122: <D.26191>, case 123: <D.26192>, case 124: <D.26193>, case 125: <D.26194>, case 126: <D.26195>, case 127: <D.26196>, case 224: <D.26177>, case 225: <D.26178>, case 226: <D.26179>, case 232: <D.26173>, case 233: <D.26174>, case 235: <D.26180>>
          <D.26173>:
          <D.26174>:
          size = size + 1;
          goto <D.26175>;
          <D.26176>:
          D.39811 = *pos;
          D.39812 = D.39811 + 144;
          if (D.39812 > 31) goto <D.39813>; else goto <D.39814>;
          <D.39813>:
          __assert_fail ("0", "mini-x86.c", 3817, &__PRETTY_FUNCTION__);
          <D.39814>:
          size = size + 1;
          pos = pos + 1;
          goto <D.26175>;
          <D.26177>:
          <D.26178>:
          <D.26179>:
          <D.26180>:
          <D.26181>:
          <D.26182>:
          <D.26183>:
          <D.26184>:
          <D.26185>:
          <D.26186>:
          <D.26187>:
          <D.26188>:
          <D.26189>:
          <D.26190>:
          <D.26191>:
          <D.26192>:
          <D.26193>:
          <D.26194>:
          <D.26195>:
          <D.26196>:
          goto <D.26175>;
          <D.26197>:
          __assert_fail ("0", "mini-x86.c", 3817, &__PRETTY_FUNCTION__);
          <D.26175>:
          D.39815 = label[0];
          D.39816 = (int) D.39815;
          pos.3904 = (int) pos;
          disp = D.39816 - pos.3904;
          if (size != 0) goto <D.39818>; else goto <D.39819>;
          <D.39818>:
          {
            union x86_imm_buf imb;

            try
              {
                D.39820 = disp + -4;
                imb.val = D.39820;
                pos.3905 = pos;
                pos = pos.3905 + 1;
                D.39822 = imb.b[0];
                *pos.3905 = D.39822;
                pos.3906 = pos;
                pos = pos.3906 + 1;
                D.39824 = imb.b[1];
                *pos.3906 = D.39824;
                pos.3907 = pos;
                pos = pos.3907 + 1;
                D.39826 = imb.b[2];
                *pos.3907 = D.39826;
                pos.3908 = pos;
                pos = pos.3908 + 1;
                D.39828 = imb.b[3];
                *pos.3908 = D.39828;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.39829>;
          <D.39819>:
          disp.3909 = (unsigned int) disp;
          D.39831 = disp.3909 + 127;
          if (D.39831 <= 255) goto <D.39832>; else goto <D.39833>;
          <D.39832>:
          D.39834 = (unsigned char) disp;
          D.39835 = D.39834 + 255;
          *pos = D.39835;
          pos = pos + 1;
          goto <D.39836>;
          <D.39833>:
          __assert_fail ("0", "mini-x86.c", 3817, &__PRETTY_FUNCTION__);
          <D.39836>:
          <D.39829>:
        }
        D.31604 = ins->dreg;
        D.31548 = ins->sreg1;
        if (D.31604 != D.31548) goto <D.39837>; else goto <D.39838>;
        <D.39837>:
        switch (4) <default: <D.26203>, case 1: <D.26199>, case 2: <D.26201>, case 4: <D.26202>>
        <D.26199>:
        code.3910 = code;
        code = code.3910 + 1;
        *code.3910 = 138;
        goto <D.26200>;
        <D.26201>:
        code.3911 = code;
        code = code.3911 + 1;
        *code.3911 = 102;
        <D.26202>:
        code.3912 = code;
        code = code.3912 + 1;
        *code.3912 = 139;
        goto <D.26200>;
        <D.26203>:
        __assert_fail ("0", "mini-x86.c", 3820, &__PRETTY_FUNCTION__);
        <D.26200>:
        code.3913 = code;
        code = code.3913 + 1;
        D.31604 = ins->dreg;
        D.32225 = D.31604 & 7;
        D.32226 = D.32225 << 3;
        D.32227 = (signed char) D.32226;
        D.32533 = D.32227 | -64;
        D.31548 = ins->sreg1;
        D.31585 = (signed char) D.31548;
        D.31586 = D.31585 & 7;
        D.32534 = D.32533 | D.31586;
        D.32535 = (unsigned char) D.32534;
        *code.3913 = D.32535;
        <D.39838>:
        goto <D.24796>;
      }
    finally
      {
        br = {CLOBBER};
        label = {CLOBBER};
      }
  }
  <D.26204>:
  goto <D.24796>;
  <D.26205>:
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.3914 = code;
    code = code.3914 + 1;
    *code.3914 = 222;
    code.3915 = code;
    code = code.3915 + 1;
    D.39845 = 0;
    D.39846 = D.39845 << 3;
    D.39847 = D.39846 + 193;
    *code.3915 = D.39847;
  }
  goto <D.24796>;
  <D.26207>:
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.3916 = code;
    code = code.3916 + 1;
    *code.3916 = 222;
    code.3917 = code;
    code = code.3917 + 1;
    D.39850 = 5;
    D.39851 = D.39850 << 3;
    D.39852 = D.39851 + 193;
    *code.3917 = D.39852;
  }
  goto <D.24796>;
  <D.26209>:
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.3918 = code;
    code = code.3918 + 1;
    *code.3918 = 222;
    code.3919 = code;
    code = code.3919 + 1;
    D.39855 = 1;
    D.39856 = D.39855 << 3;
    D.39857 = D.39856 + 193;
    *code.3919 = D.39857;
  }
  goto <D.24796>;
  <D.26211>:
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.3920 = code;
    code = code.3920 + 1;
    *code.3920 = 222;
    code.3921 = code;
    code = code.3921 + 1;
    D.39860 = 7;
    D.39861 = D.39860 << 3;
    D.39862 = D.39861 + 193;
    *code.3921 = D.39862;
  }
  goto <D.24796>;
  <D.26213>:
  code.3922 = code;
  code = code.3922 + 1;
  *code.3922 = 217;
  code.3923 = code;
  code = code.3923 + 1;
  *code.3923 = 224;
  goto <D.24796>;
  <D.26214>:
  code.3924 = code;
  code = code.3924 + 1;
  *code.3924 = 217;
  code.3925 = code;
  code = code.3925 + 1;
  *code.3925 = 254;
  code.3926 = code;
  code = code.3926 + 1;
  *code.3926 = 217;
  code.3927 = code;
  code = code.3927 + 1;
  *code.3927 = 238;
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.3928 = code;
    code = code.3928 + 1;
    *code.3928 = 222;
    code.3929 = code;
    code = code.3929 + 1;
    D.39871 = 0;
    D.39872 = D.39871 << 3;
    D.39873 = D.39872 + 193;
    *code.3929 = D.39873;
  }
  goto <D.24796>;
  <D.26216>:
  code.3930 = code;
  code = code.3930 + 1;
  *code.3930 = 217;
  code.3931 = code;
  code = code.3931 + 1;
  *code.3931 = 255;
  code.3932 = code;
  code = code.3932 + 1;
  *code.3932 = 217;
  code.3933 = code;
  code = code.3933 + 1;
  *code.3933 = 238;
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.3934 = code;
    code = code.3934 + 1;
    *code.3934 = 222;
    code.3935 = code;
    code = code.3935 + 1;
    D.39880 = 0;
    D.39881 = D.39880 << 3;
    D.39882 = D.39881 + 193;
    *code.3935 = D.39882;
  }
  goto <D.24796>;
  <D.26218>:
  code.3936 = code;
  code = code.3936 + 1;
  *code.3936 = 217;
  code.3937 = code;
  code = code.3937 + 1;
  *code.3937 = 225;
  goto <D.24796>;
  <D.26219>:
  {
    guchar * check_pos;
    guchar * end_tan;
    guchar * pop_jump;

    code.3938 = code;
    code = code.3938 + 1;
    *code.3938 = 80;
    code.3939 = code;
    code = code.3939 + 1;
    *code.3939 = 217;
    code.3940 = code;
    code = code.3940 + 1;
    *code.3940 = 242;
    code.3941 = code;
    code = code.3941 + 1;
    *code.3941 = 223;
    code.3942 = code;
    code = code.3942 + 1;
    *code.3942 = 224;
    if (1 != 0) goto <D.39890>; else goto <D.39891>;
    <D.39890>:
    code.3943 = code;
    code = code.3943 + 1;
    *code.3943 = 169;
    goto <D.39893>;
    <D.39891>:
    code.3944 = code;
    code = code.3944 + 1;
    *code.3944 = 247;
    code.3945 = code;
    code = code.3945 + 1;
    *code.3945 = 192;
    <D.39893>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1024;
          code.3946 = code;
          code = code.3946 + 1;
          D.39897 = imb.b[0];
          *code.3946 = D.39897;
          code.3947 = code;
          code = code.3947 + 1;
          D.39899 = imb.b[1];
          *code.3947 = D.39899;
          code.3948 = code;
          code = code.3948 + 1;
          D.39901 = imb.b[2];
          *code.3948 = D.39901;
          code.3949 = code;
          code = code.3949 + 1;
          D.39903 = imb.b[3];
          *code.3949 = D.39903;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    check_pos = code;
    if (0 != 0) goto <D.39904>; else goto <D.39905>;
    <D.39904>:
    code.3950 = code;
    code = code.3950 + 1;
    D.39804 = 117;
    *code.3950 = D.39804;
    goto <D.39907>;
    <D.39905>:
    code.3951 = code;
    code = code.3951 + 1;
    D.39807 = 117;
    *code.3951 = D.39807;
    <D.39907>:
    *code = 0;
    code = code + 1;
    code.3952 = code;
    code = code.3952 + 1;
    *code.3952 = 221;
    code.3953 = code;
    code = code.3953 + 1;
    *code.3953 = 216;
    end_tan = code;
    code.3954 = code;
    code = code.3954 + 1;
    *code.3954 = 235;
    *code = 0;
    code = code + 1;
    code.3955 = code;
    code = code.3955 + 1;
    *code.3955 = 217;
    code.3956 = code;
    code = code.3956 + 1;
    *code.3956 = 235;
    code.3957 = code;
    code = code.3957 + 1;
    *code.3957 = 216;
    code.3958 = code;
    code = code.3958 + 1;
    *code.3958 = 192;
    code.3959 = code;
    code = code.3959 + 1;
    *code.3959 = 217;
    code.3960 = code;
    code = code.3960 + 1;
    *code.3960 = 201;
    code.3961 = code;
    code = code.3961 + 1;
    *code.3961 = 217;
    code.3962 = code;
    code = code.3962 + 1;
    *code.3962 = 245;
    code.3963 = code;
    code = code.3963 + 1;
    *code.3963 = 155;
    code.3964 = code;
    code = code.3964 + 1;
    *code.3964 = 223;
    code.3965 = code;
    code = code.3965 + 1;
    *code.3965 = 224;
    if (1 != 0) goto <D.39923>; else goto <D.39924>;
    <D.39923>:
    code.3966 = code;
    code = code.3966 + 1;
    *code.3966 = 169;
    goto <D.39926>;
    <D.39924>:
    code.3967 = code;
    code = code.3967 + 1;
    *code.3967 = 247;
    code.3968 = code;
    code = code.3968 + 1;
    *code.3968 = 192;
    <D.39926>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1024;
          code.3969 = code;
          code = code.3969 + 1;
          D.39930 = imb.b[0];
          *code.3969 = D.39930;
          code.3970 = code;
          code = code.3970 + 1;
          D.39932 = imb.b[1];
          *code.3970 = D.39932;
          code.3971 = code;
          code = code.3971 + 1;
          D.39934 = imb.b[2];
          *code.3971 = D.39934;
          code.3972 = code;
          code = code.3972 + 1;
          D.39936 = imb.b[3];
          *code.3972 = D.39936;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    pop_jump = code;
    if (0 != 0) goto <D.39937>; else goto <D.39938>;
    <D.39937>:
    code.3973 = code;
    code = code.3973 + 1;
    D.39804 = 117;
    *code.3973 = D.39804;
    goto <D.39940>;
    <D.39938>:
    code.3974 = code;
    code = code.3974 + 1;
    D.39807 = 117;
    *code.3974 = D.39807;
    <D.39940>:
    *code = 0;
    code = code + 1;
    code.3975 = code;
    code = code.3975 + 1;
    *code.3975 = 221;
    code.3976 = code;
    code = code.3976 + 1;
    *code.3976 = 217;
    code.3977 = code;
    code = code.3977 + 1;
    *code.3977 = 217;
    code.3978 = code;
    code = code.3978 + 1;
    *code.3978 = 242;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = pop_jump + 1;
      size = 0;
      D.39946 = MEM[(unsigned char *)pop_jump];
      D.39947 = (int) D.39946;
      switch (D.39947) <default: <D.26252>, case 15: <D.26231>, case 112: <D.26236>, case 113: <D.26237>, case 114: <D.26238>, case 115: <D.26239>, case 116: <D.26240>, case 117: <D.26241>, case 118: <D.26242>, case 119: <D.26243>, case 120: <D.26244>, case 121: <D.26245>, case 122: <D.26246>, case 123: <D.26247>, case 124: <D.26248>, case 125: <D.26249>, case 126: <D.26250>, case 127: <D.26251>, case 224: <D.26232>, case 225: <D.26233>, case 226: <D.26234>, case 232: <D.26228>, case 233: <D.26229>, case 235: <D.26235>>
      <D.26228>:
      <D.26229>:
      size = size + 1;
      goto <D.26230>;
      <D.26231>:
      D.39948 = *pos;
      D.39949 = D.39948 + 144;
      if (D.39949 > 31) goto <D.39950>; else goto <D.39951>;
      <D.39950>:
      __assert_fail ("0", "mini-x86.c", 3880, &__PRETTY_FUNCTION__);
      <D.39951>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26230>;
      <D.26232>:
      <D.26233>:
      <D.26234>:
      <D.26235>:
      <D.26236>:
      <D.26237>:
      <D.26238>:
      <D.26239>:
      <D.26240>:
      <D.26241>:
      <D.26242>:
      <D.26243>:
      <D.26244>:
      <D.26245>:
      <D.26246>:
      <D.26247>:
      <D.26248>:
      <D.26249>:
      <D.26250>:
      <D.26251>:
      goto <D.26230>;
      <D.26252>:
      __assert_fail ("0", "mini-x86.c", 3880, &__PRETTY_FUNCTION__);
      <D.26230>:
      code.422 = (int) code;
      pos.3979 = (int) pos;
      disp = code.422 - pos.3979;
      if (size != 0) goto <D.39953>; else goto <D.39954>;
      <D.39953>:
      {
        union x86_imm_buf imb;

        try
          {
            D.39955 = disp + -4;
            imb.val = D.39955;
            pos.3980 = pos;
            pos = pos.3980 + 1;
            D.39957 = imb.b[0];
            *pos.3980 = D.39957;
            pos.3981 = pos;
            pos = pos.3981 + 1;
            D.39959 = imb.b[1];
            *pos.3981 = D.39959;
            pos.3982 = pos;
            pos = pos.3982 + 1;
            D.39961 = imb.b[2];
            *pos.3982 = D.39961;
            pos.3983 = pos;
            pos = pos.3983 + 1;
            D.39963 = imb.b[3];
            *pos.3983 = D.39963;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.39964>;
      <D.39954>:
      disp.3984 = (unsigned int) disp;
      D.39966 = disp.3984 + 127;
      if (D.39966 <= 255) goto <D.39967>; else goto <D.39968>;
      <D.39967>:
      D.39969 = (unsigned char) disp;
      D.39970 = D.39969 + 255;
      *pos = D.39970;
      pos = pos + 1;
      goto <D.39971>;
      <D.39968>:
      __assert_fail ("0", "mini-x86.c", 3880, &__PRETTY_FUNCTION__);
      <D.39971>:
      <D.39964>:
    }
    code.3985 = code;
    code = code.3985 + 1;
    *code.3985 = 221;
    code.3986 = code;
    code = code.3986 + 1;
    *code.3986 = 216;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = check_pos + 1;
      size = 0;
      D.39974 = MEM[(unsigned char *)check_pos];
      D.39975 = (int) D.39974;
      switch (D.39975) <default: <D.26281>, case 15: <D.26260>, case 112: <D.26265>, case 113: <D.26266>, case 114: <D.26267>, case 115: <D.26268>, case 116: <D.26269>, case 117: <D.26270>, case 118: <D.26271>, case 119: <D.26272>, case 120: <D.26273>, case 121: <D.26274>, case 122: <D.26275>, case 123: <D.26276>, case 124: <D.26277>, case 125: <D.26278>, case 126: <D.26279>, case 127: <D.26280>, case 224: <D.26261>, case 225: <D.26262>, case 226: <D.26263>, case 232: <D.26257>, case 233: <D.26258>, case 235: <D.26264>>
      <D.26257>:
      <D.26258>:
      size = size + 1;
      goto <D.26259>;
      <D.26260>:
      D.39976 = *pos;
      D.39977 = D.39976 + 144;
      if (D.39977 > 31) goto <D.39978>; else goto <D.39979>;
      <D.39978>:
      __assert_fail ("0", "mini-x86.c", 3882, &__PRETTY_FUNCTION__);
      <D.39979>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26259>;
      <D.26261>:
      <D.26262>:
      <D.26263>:
      <D.26264>:
      <D.26265>:
      <D.26266>:
      <D.26267>:
      <D.26268>:
      <D.26269>:
      <D.26270>:
      <D.26271>:
      <D.26272>:
      <D.26273>:
      <D.26274>:
      <D.26275>:
      <D.26276>:
      <D.26277>:
      <D.26278>:
      <D.26279>:
      <D.26280>:
      goto <D.26259>;
      <D.26281>:
      __assert_fail ("0", "mini-x86.c", 3882, &__PRETTY_FUNCTION__);
      <D.26259>:
      code.422 = (int) code;
      pos.3987 = (int) pos;
      disp = code.422 - pos.3987;
      if (size != 0) goto <D.39981>; else goto <D.39982>;
      <D.39981>:
      {
        union x86_imm_buf imb;

        try
          {
            D.39983 = disp + -4;
            imb.val = D.39983;
            pos.3988 = pos;
            pos = pos.3988 + 1;
            D.39985 = imb.b[0];
            *pos.3988 = D.39985;
            pos.3989 = pos;
            pos = pos.3989 + 1;
            D.39987 = imb.b[1];
            *pos.3989 = D.39987;
            pos.3990 = pos;
            pos = pos.3990 + 1;
            D.39989 = imb.b[2];
            *pos.3990 = D.39989;
            pos.3991 = pos;
            pos = pos.3991 + 1;
            D.39991 = imb.b[3];
            *pos.3991 = D.39991;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.39992>;
      <D.39982>:
      disp.3992 = (unsigned int) disp;
      D.39994 = disp.3992 + 127;
      if (D.39994 <= 255) goto <D.39995>; else goto <D.39996>;
      <D.39995>:
      D.39997 = (unsigned char) disp;
      D.39998 = D.39997 + 255;
      *pos = D.39998;
      pos = pos + 1;
      goto <D.39999>;
      <D.39996>:
      __assert_fail ("0", "mini-x86.c", 3882, &__PRETTY_FUNCTION__);
      <D.39999>:
      <D.39992>:
    }
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = end_tan + 1;
      size = 0;
      D.40000 = MEM[(unsigned char *)end_tan];
      D.40001 = (int) D.40000;
      switch (D.40001) <default: <D.26310>, case 15: <D.26289>, case 112: <D.26294>, case 113: <D.26295>, case 114: <D.26296>, case 115: <D.26297>, case 116: <D.26298>, case 117: <D.26299>, case 118: <D.26300>, case 119: <D.26301>, case 120: <D.26302>, case 121: <D.26303>, case 122: <D.26304>, case 123: <D.26305>, case 124: <D.26306>, case 125: <D.26307>, case 126: <D.26308>, case 127: <D.26309>, case 224: <D.26290>, case 225: <D.26291>, case 226: <D.26292>, case 232: <D.26286>, case 233: <D.26287>, case 235: <D.26293>>
      <D.26286>:
      <D.26287>:
      size = size + 1;
      goto <D.26288>;
      <D.26289>:
      D.40002 = *pos;
      D.40003 = D.40002 + 144;
      if (D.40003 > 31) goto <D.40004>; else goto <D.40005>;
      <D.40004>:
      __assert_fail ("0", "mini-x86.c", 3883, &__PRETTY_FUNCTION__);
      <D.40005>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26288>;
      <D.26290>:
      <D.26291>:
      <D.26292>:
      <D.26293>:
      <D.26294>:
      <D.26295>:
      <D.26296>:
      <D.26297>:
      <D.26298>:
      <D.26299>:
      <D.26300>:
      <D.26301>:
      <D.26302>:
      <D.26303>:
      <D.26304>:
      <D.26305>:
      <D.26306>:
      <D.26307>:
      <D.26308>:
      <D.26309>:
      goto <D.26288>;
      <D.26310>:
      __assert_fail ("0", "mini-x86.c", 3883, &__PRETTY_FUNCTION__);
      <D.26288>:
      code.422 = (int) code;
      pos.3993 = (int) pos;
      disp = code.422 - pos.3993;
      if (size != 0) goto <D.40007>; else goto <D.40008>;
      <D.40007>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40009 = disp + -4;
            imb.val = D.40009;
            pos.3994 = pos;
            pos = pos.3994 + 1;
            D.40011 = imb.b[0];
            *pos.3994 = D.40011;
            pos.3995 = pos;
            pos = pos.3995 + 1;
            D.40013 = imb.b[1];
            *pos.3995 = D.40013;
            pos.3996 = pos;
            pos = pos.3996 + 1;
            D.40015 = imb.b[2];
            *pos.3996 = D.40015;
            pos.3997 = pos;
            pos = pos.3997 + 1;
            D.40017 = imb.b[3];
            *pos.3997 = D.40017;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40018>;
      <D.40008>:
      disp.3998 = (unsigned int) disp;
      D.40020 = disp.3998 + 127;
      if (D.40020 <= 255) goto <D.40021>; else goto <D.40022>;
      <D.40021>:
      D.40023 = (unsigned char) disp;
      D.40024 = D.40023 + 255;
      *pos = D.40024;
      pos = pos + 1;
      goto <D.40025>;
      <D.40022>:
      __assert_fail ("0", "mini-x86.c", 3883, &__PRETTY_FUNCTION__);
      <D.40025>:
      <D.40018>:
    }
    code.3999 = code;
    code = code.3999 + 1;
    *code.3999 = 217;
    code.4000 = code;
    code = code.4000 + 1;
    *code.4000 = 238;
    {
      static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

      code.4001 = code;
      code = code.4001 + 1;
      *code.4001 = 222;
      code.4002 = code;
      code = code.4002 + 1;
      D.40030 = 0;
      D.40031 = D.40030 << 3;
      D.40032 = D.40031 + 193;
      *code.4002 = D.40032;
    }
    code.4003 = code;
    code = code.4003 + 1;
    *code.4003 = 88;
    goto <D.24796>;
  }
  <D.26313>:
  code.4004 = code;
  code = code.4004 + 1;
  *code.4004 = 217;
  code.4005 = code;
  code = code.4005 + 1;
  *code.4005 = 232;
  code.4006 = code;
  code = code.4006 + 1;
  *code.4006 = 217;
  code.4007 = code;
  code = code.4007 + 1;
  *code.4007 = 243;
  code.4008 = code;
  code = code.4008 + 1;
  *code.4008 = 217;
  code.4009 = code;
  code = code.4009 + 1;
  *code.4009 = 238;
  {
    static const unsigned char map[9] = {0, 1, 2, 3, 5, 4, 7, 6, 8};

    code.4010 = code;
    code = code.4010 + 1;
    *code.4010 = 222;
    code.4011 = code;
    code = code.4011 + 1;
    D.40042 = 0;
    D.40043 = D.40042 << 3;
    D.40044 = D.40043 + 193;
    *code.4011 = D.40044;
  }
  goto <D.24796>;
  <D.26315>:
  code.4012 = code;
  code = code.4012 + 1;
  *code.4012 = 217;
  code.4013 = code;
  code = code.4013 + 1;
  *code.4013 = 250;
  goto <D.24796>;
  <D.26316>:
  code.4014 = code;
  code = code.4014 + 1;
  *code.4014 = 217;
  code.4015 = code;
  code = code.4015 + 1;
  *code.4015 = 252;
  goto <D.24796>;
  <D.26317>:
  D.31411 = cfg->opt;
  D.40049 = D.31411 & 256;
  D.40050 = D.40049 == 0;
  D.40051 = (long int) D.40050;
  D.40052 = __builtin_expect (D.40051, 0);
  if (D.40052 != 0) goto <D.40053>; else goto <D.40054>;
  <D.40053>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3902, "cfg->opt & MONO_OPT_CMOV");
  <D.40054>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  D.37369 = D.31604 != D.31548;
  D.37370 = (long int) D.37369;
  D.37371 = __builtin_expect (D.37370, 0);
  if (D.37371 != 0) goto <D.40055>; else goto <D.40056>;
  <D.40055>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3903, "ins->dreg == ins->sreg1");
  <D.40056>:
  code.4016 = code;
  code = code.4016 + 1;
  *code.4016 = 59;
  code.4017 = code;
  code = code.4017 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.4017 = D.32567;
  code.4018 = code;
  code = code.4018 + 1;
  *code.4018 = 15;
  if (1 != 0) goto <D.40060>; else goto <D.40061>;
  <D.40060>:
  code.4019 = code;
  code = code.4019 + 1;
  D.40063 = 127;
  D.40064 = D.40063 + 208;
  *code.4019 = D.40064;
  goto <D.40065>;
  <D.40061>:
  code.4020 = code;
  code = code.4020 + 1;
  D.40067 = 119;
  D.40068 = D.40067 + 208;
  *code.4020 = D.40068;
  <D.40065>:
  code.4021 = code;
  code = code.4021 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.4021 = D.37392;
  goto <D.24796>;
  <D.26318>:
  D.31411 = cfg->opt;
  D.40049 = D.31411 & 256;
  D.40050 = D.40049 == 0;
  D.40051 = (long int) D.40050;
  D.40052 = __builtin_expect (D.40051, 0);
  if (D.40052 != 0) goto <D.40070>; else goto <D.40071>;
  <D.40070>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3908, "cfg->opt & MONO_OPT_CMOV");
  <D.40071>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  D.37369 = D.31604 != D.31548;
  D.37370 = (long int) D.37369;
  D.37371 = __builtin_expect (D.37370, 0);
  if (D.37371 != 0) goto <D.40072>; else goto <D.40073>;
  <D.40072>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3909, "ins->dreg == ins->sreg1");
  <D.40073>:
  code.4022 = code;
  code = code.4022 + 1;
  *code.4022 = 59;
  code.4023 = code;
  code = code.4023 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.4023 = D.32567;
  code.4024 = code;
  code = code.4024 + 1;
  *code.4024 = 15;
  if (0 != 0) goto <D.40077>; else goto <D.40078>;
  <D.40077>:
  code.4025 = code;
  code = code.4025 + 1;
  D.40063 = 127;
  D.40064 = D.40063 + 208;
  *code.4025 = D.40064;
  goto <D.40080>;
  <D.40078>:
  code.4026 = code;
  code = code.4026 + 1;
  D.40067 = 119;
  D.40068 = D.40067 + 208;
  *code.4026 = D.40068;
  <D.40080>:
  code.4027 = code;
  code = code.4027 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.4027 = D.37392;
  goto <D.24796>;
  <D.26319>:
  D.31411 = cfg->opt;
  D.40049 = D.31411 & 256;
  D.40050 = D.40049 == 0;
  D.40051 = (long int) D.40050;
  D.40052 = __builtin_expect (D.40051, 0);
  if (D.40052 != 0) goto <D.40083>; else goto <D.40084>;
  <D.40083>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3914, "cfg->opt & MONO_OPT_CMOV");
  <D.40084>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  D.37369 = D.31604 != D.31548;
  D.37370 = (long int) D.37369;
  D.37371 = __builtin_expect (D.37370, 0);
  if (D.37371 != 0) goto <D.40085>; else goto <D.40086>;
  <D.40085>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3915, "ins->dreg == ins->sreg1");
  <D.40086>:
  code.4028 = code;
  code = code.4028 + 1;
  *code.4028 = 59;
  code.4029 = code;
  code = code.4029 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.4029 = D.32567;
  code.4030 = code;
  code = code.4030 + 1;
  *code.4030 = 15;
  if (1 != 0) goto <D.40090>; else goto <D.40091>;
  <D.40090>:
  code.4031 = code;
  code = code.4031 + 1;
  D.39678 = 124;
  D.40093 = D.39678 + 208;
  *code.4031 = D.40093;
  goto <D.40094>;
  <D.40091>:
  code.4032 = code;
  code = code.4032 + 1;
  D.39681 = 114;
  D.40096 = D.39681 + 208;
  *code.4032 = D.40096;
  <D.40094>:
  code.4033 = code;
  code = code.4033 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.4033 = D.37392;
  goto <D.24796>;
  <D.26320>:
  D.31411 = cfg->opt;
  D.40049 = D.31411 & 256;
  D.40050 = D.40049 == 0;
  D.40051 = (long int) D.40050;
  D.40052 = __builtin_expect (D.40051, 0);
  if (D.40052 != 0) goto <D.40098>; else goto <D.40099>;
  <D.40098>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3920, "cfg->opt & MONO_OPT_CMOV");
  <D.40099>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  D.37369 = D.31604 != D.31548;
  D.37370 = (long int) D.37369;
  D.37371 = __builtin_expect (D.37370, 0);
  if (D.37371 != 0) goto <D.40100>; else goto <D.40101>;
  <D.40100>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3921, "ins->dreg == ins->sreg1");
  <D.40101>:
  code.4034 = code;
  code = code.4034 + 1;
  *code.4034 = 59;
  code.4035 = code;
  code = code.4035 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.4035 = D.32567;
  code.4036 = code;
  code = code.4036 + 1;
  *code.4036 = 15;
  if (0 != 0) goto <D.40105>; else goto <D.40106>;
  <D.40105>:
  code.4037 = code;
  code = code.4037 + 1;
  D.39678 = 124;
  D.40093 = D.39678 + 208;
  *code.4037 = D.40093;
  goto <D.40108>;
  <D.40106>:
  code.4038 = code;
  code = code.4038 + 1;
  D.39681 = 114;
  D.40096 = D.39681 + 208;
  *code.4038 = D.40096;
  <D.40108>:
  code.4039 = code;
  code = code.4039 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.4039 = D.37392;
  goto <D.24796>;
  <D.26321>:
  code.4040 = code;
  code = code.4040 + 1;
  *code.4040 = 221;
  code.4041 = code;
  code = code.4041 + 1;
  *code.4041 = 216;
  goto <D.24796>;
  <D.26322>:
  code.4042 = code;
  code = code.4042 + 1;
  *code.4042 = 217;
  code.4043 = code;
  code = code.4043 + 1;
  D.31653 = ins->data.op[1].const_val;
  D.40115 = (unsigned char) D.31653;
  D.40116 = D.40115 & 7;
  D.40117 = D.40116 + 200;
  *code.4043 = D.40117;
  goto <D.24796>;
  <D.26323>:
  {
    guint8 * l1;
    guint8 * l2;

    code.4044 = code;
    code = code.4044 + 1;
    *code.4044 = 80;
    code.4045 = code;
    code = code.4045 + 1;
    *code.4045 = 217;
    code.4046 = code;
    code = code.4046 + 1;
    *code.4046 = 201;
    l1 = code;
    code.4047 = code;
    code = code.4047 + 1;
    *code.4047 = 217;
    code.4048 = code;
    code = code.4048 + 1;
    *code.4048 = 248;
    code.4049 = code;
    code = code.4049 + 1;
    *code.4049 = 223;
    code.4050 = code;
    code = code.4050 + 1;
    *code.4050 = 224;
    if (1 != 0) goto <D.40125>; else goto <D.40126>;
    <D.40125>:
    code.4051 = code;
    code = code.4051 + 1;
    *code.4051 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1024;
          code.4052 = code;
          code = code.4052 + 1;
          D.40129 = imb.b[0];
          *code.4052 = D.40129;
          code.4053 = code;
          code = code.4053 + 1;
          D.40131 = imb.b[1];
          *code.4053 = D.40131;
          code.4054 = code;
          code = code.4054 + 1;
          D.40133 = imb.b[2];
          *code.4054 = D.40133;
          code.4055 = code;
          code = code.4055 + 1;
          D.40135 = imb.b[3];
          *code.4055 = D.40135;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26327>;
    <D.40126>:
    if (0 != 0) goto <D.40136>; else goto <D.40137>;
    <D.40136>:
    code.4056 = code;
    code = code.4056 + 1;
    *code.4056 = 131;
    code.4057 = code;
    code = code.4057 + 1;
    *code.4057 = 224;
    *code = 0;
    code = code + 1;
    goto <D.40140>;
    <D.40137>:
    code.4058 = code;
    code = code.4058 + 1;
    *code.4058 = 129;
    code.4059 = code;
    code = code.4059 + 1;
    *code.4059 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1024;
          code.4060 = code;
          code = code.4060 + 1;
          D.40144 = imb.b[0];
          *code.4060 = D.40144;
          code.4061 = code;
          code = code.4061 + 1;
          D.40146 = imb.b[1];
          *code.4061 = D.40146;
          code.4062 = code;
          code = code.4062 + 1;
          D.40148 = imb.b[2];
          *code.4062 = D.40148;
          code.4063 = code;
          code = code.4063 + 1;
          D.40150 = imb.b[3];
          *code.4063 = D.40150;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40140>:
    <D.26327>:
    l2 = code;
    if (0 != 0) goto <D.40151>; else goto <D.40152>;
    <D.40151>:
    code.4064 = code;
    code = code.4064 + 1;
    D.39804 = 117;
    *code.4064 = D.39804;
    goto <D.40154>;
    <D.40152>:
    code.4065 = code;
    code = code.4065 + 1;
    D.39807 = 117;
    *code.4065 = D.39807;
    <D.40154>:
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = l2 + 1;
      size = 0;
      D.40156 = MEM[(unsigned char *)l2];
      D.40157 = (int) D.40156;
      switch (D.40157) <default: <D.26356>, case 15: <D.26335>, case 112: <D.26340>, case 113: <D.26341>, case 114: <D.26342>, case 115: <D.26343>, case 116: <D.26344>, case 117: <D.26345>, case 118: <D.26346>, case 119: <D.26347>, case 120: <D.26348>, case 121: <D.26349>, case 122: <D.26350>, case 123: <D.26351>, case 124: <D.26352>, case 125: <D.26353>, case 126: <D.26354>, case 127: <D.26355>, case 224: <D.26336>, case 225: <D.26337>, case 226: <D.26338>, case 232: <D.26332>, case 233: <D.26333>, case 235: <D.26339>>
      <D.26332>:
      <D.26333>:
      size = size + 1;
      goto <D.26334>;
      <D.26335>:
      D.40158 = *pos;
      D.40159 = D.40158 + 144;
      if (D.40159 > 31) goto <D.40160>; else goto <D.40161>;
      <D.40160>:
      __assert_fail ("0", "mini-x86.c", 3948, &__PRETTY_FUNCTION__);
      <D.40161>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26334>;
      <D.26336>:
      <D.26337>:
      <D.26338>:
      <D.26339>:
      <D.26340>:
      <D.26341>:
      <D.26342>:
      <D.26343>:
      <D.26344>:
      <D.26345>:
      <D.26346>:
      <D.26347>:
      <D.26348>:
      <D.26349>:
      <D.26350>:
      <D.26351>:
      <D.26352>:
      <D.26353>:
      <D.26354>:
      <D.26355>:
      goto <D.26334>;
      <D.26356>:
      __assert_fail ("0", "mini-x86.c", 3948, &__PRETTY_FUNCTION__);
      <D.26334>:
      l1.4066 = (int) l1;
      pos.4067 = (int) pos;
      disp = l1.4066 - pos.4067;
      if (size != 0) goto <D.40164>; else goto <D.40165>;
      <D.40164>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40166 = disp + -4;
            imb.val = D.40166;
            pos.4068 = pos;
            pos = pos.4068 + 1;
            D.40168 = imb.b[0];
            *pos.4068 = D.40168;
            pos.4069 = pos;
            pos = pos.4069 + 1;
            D.40170 = imb.b[1];
            *pos.4069 = D.40170;
            pos.4070 = pos;
            pos = pos.4070 + 1;
            D.40172 = imb.b[2];
            *pos.4070 = D.40172;
            pos.4071 = pos;
            pos = pos.4071 + 1;
            D.40174 = imb.b[3];
            *pos.4071 = D.40174;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40175>;
      <D.40165>:
      disp.4072 = (unsigned int) disp;
      D.40177 = disp.4072 + 127;
      if (D.40177 <= 255) goto <D.40178>; else goto <D.40179>;
      <D.40178>:
      D.40180 = (unsigned char) disp;
      D.40181 = D.40180 + 255;
      *pos = D.40181;
      pos = pos + 1;
      goto <D.40182>;
      <D.40179>:
      __assert_fail ("0", "mini-x86.c", 3948, &__PRETTY_FUNCTION__);
      <D.40182>:
      <D.40175>:
    }
    code.4073 = code;
    code = code.4073 + 1;
    *code.4073 = 221;
    code.4074 = code;
    code = code.4074 + 1;
    *code.4074 = 217;
    code.4075 = code;
    code = code.4075 + 1;
    *code.4075 = 88;
    goto <D.24796>;
  }
  <D.26358>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.40187>; else goto <D.40188>;
  <D.40187>:
  code.4076 = code;
  code = code.4076 + 1;
  *code.4076 = 223;
  code.4077 = code;
  code = code.4077 + 1;
  *code.4077 = 241;
  code.4078 = code;
  code = code.4078 + 1;
  *code.4078 = 221;
  code.4079 = code;
  code = code.4079 + 1;
  *code.4079 = 216;
  goto <D.24796>;
  <D.40188>:
  code.4080 = code;
  code = code.4080 + 1;
  *code.4080 = 222;
  code.4081 = code;
  code = code.4081 + 1;
  *code.4081 = 217;
  code.4082 = code;
  code = code.4082 + 1;
  *code.4082 = 223;
  code.4083 = code;
  code = code.4083 + 1;
  *code.4083 = 224;
  if (1 != 0) goto <D.40197>; else goto <D.40198>;
  <D.40197>:
  code.4084 = code;
  code = code.4084 + 1;
  *code.4084 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4085 = code;
        code = code.4085 + 1;
        D.40201 = imb.b[0];
        *code.4085 = D.40201;
        code.4086 = code;
        code = code.4086 + 1;
        D.40203 = imb.b[1];
        *code.4086 = D.40203;
        code.4087 = code;
        code = code.4087 + 1;
        D.40205 = imb.b[2];
        *code.4087 = D.40205;
        code.4088 = code;
        code = code.4088 + 1;
        D.40207 = imb.b[3];
        *code.4088 = D.40207;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26360>;
  <D.40198>:
  if (0 != 0) goto <D.40208>; else goto <D.40209>;
  <D.40208>:
  code.4089 = code;
  code = code.4089 + 1;
  *code.4089 = 131;
  code.4090 = code;
  code = code.4090 + 1;
  *code.4090 = 224;
  *code = 0;
  code = code + 1;
  goto <D.40212>;
  <D.40209>:
  code.4091 = code;
  code = code.4091 + 1;
  *code.4091 = 129;
  code.4092 = code;
  code = code.4092 + 1;
  *code.4092 = 224;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4093 = code;
        code = code.4093 + 1;
        D.40216 = imb.b[0];
        *code.4093 = D.40216;
        code.4094 = code;
        code = code.4094 + 1;
        D.40218 = imb.b[1];
        *code.4094 = D.40218;
        code.4095 = code;
        code = code.4095 + 1;
        D.40220 = imb.b[2];
        *code.4095 = D.40220;
        code.4096 = code;
        code = code.4096 + 1;
        D.40222 = imb.b[3];
        *code.4096 = D.40222;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40212>:
  <D.26360>:
  goto <D.24796>;
  <D.26362>:
  <D.26363>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.40223>; else goto <D.40224>;
  <D.40223>:
  {
    guchar * unordered_check;

    code.4097 = code;
    code = code.4097 + 1;
    *code.4097 = 51;
    code.4098 = code;
    code = code.4098 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4098 = D.34303;
    code.4099 = code;
    code = code.4099 + 1;
    *code.4099 = 223;
    code.4100 = code;
    code = code.4100 + 1;
    *code.4100 = 241;
    code.4101 = code;
    code = code.4101 + 1;
    *code.4101 = 221;
    code.4102 = code;
    code = code.4102 + 1;
    *code.4102 = 216;
    unordered_check = code;
    if (0 != 0) goto <D.40231>; else goto <D.40232>;
    <D.40231>:
    code.4103 = code;
    code = code.4103 + 1;
    D.40234 = 122;
    *code.4103 = D.40234;
    goto <D.40235>;
    <D.40232>:
    code.4104 = code;
    code = code.4104 + 1;
    D.40237 = 122;
    *code.4104 = D.40237;
    <D.40235>:
    *code = 0;
    code = code + 1;
    D.31501 = ins->opcode;
    if (D.31501 == 718) goto <D.40238>; else goto <D.40239>;
    <D.40238>:
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40240>; else goto <D.40241>;
    <D.40240>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3979, "X86_IS_BYTE_REG (ins->dreg)");
    <D.40241>:
    code.4105 = code;
    code = code.4105 + 1;
    *code.4105 = 15;
    if (0 != 0) goto <D.40243>; else goto <D.40244>;
    <D.40243>:
    code.4106 = code;
    code = code.4106 + 1;
    D.34479 = 116;
    D.40246 = D.34479 + 32;
    *code.4106 = D.40246;
    goto <D.40247>;
    <D.40244>:
    code.4107 = code;
    code = code.4107 + 1;
    D.34482 = 116;
    D.40249 = D.34482 + 32;
    *code.4107 = D.40249;
    <D.40247>:
    code.4108 = code;
    code = code.4108 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4108 = D.33951;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.40251 = MEM[(unsigned char *)unordered_check];
      D.40252 = (int) D.40251;
      switch (D.40252) <default: <D.26392>, case 15: <D.26371>, case 112: <D.26376>, case 113: <D.26377>, case 114: <D.26378>, case 115: <D.26379>, case 116: <D.26380>, case 117: <D.26381>, case 118: <D.26382>, case 119: <D.26383>, case 120: <D.26384>, case 121: <D.26385>, case 122: <D.26386>, case 123: <D.26387>, case 124: <D.26388>, case 125: <D.26389>, case 126: <D.26390>, case 127: <D.26391>, case 224: <D.26372>, case 225: <D.26373>, case 226: <D.26374>, case 232: <D.26368>, case 233: <D.26369>, case 235: <D.26375>>
      <D.26368>:
      <D.26369>:
      size = size + 1;
      goto <D.26370>;
      <D.26371>:
      D.40253 = *pos;
      D.40254 = D.40253 + 144;
      if (D.40254 > 31) goto <D.40255>; else goto <D.40256>;
      <D.40255>:
      __assert_fail ("0", "mini-x86.c", 3980, &__PRETTY_FUNCTION__);
      <D.40256>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26370>;
      <D.26372>:
      <D.26373>:
      <D.26374>:
      <D.26375>:
      <D.26376>:
      <D.26377>:
      <D.26378>:
      <D.26379>:
      <D.26380>:
      <D.26381>:
      <D.26382>:
      <D.26383>:
      <D.26384>:
      <D.26385>:
      <D.26386>:
      <D.26387>:
      <D.26388>:
      <D.26389>:
      <D.26390>:
      <D.26391>:
      goto <D.26370>;
      <D.26392>:
      __assert_fail ("0", "mini-x86.c", 3980, &__PRETTY_FUNCTION__);
      <D.26370>:
      code.422 = (int) code;
      pos.4109 = (int) pos;
      disp = code.422 - pos.4109;
      if (size != 0) goto <D.40258>; else goto <D.40259>;
      <D.40258>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40260 = disp + -4;
            imb.val = D.40260;
            pos.4110 = pos;
            pos = pos.4110 + 1;
            D.40262 = imb.b[0];
            *pos.4110 = D.40262;
            pos.4111 = pos;
            pos = pos.4111 + 1;
            D.40264 = imb.b[1];
            *pos.4111 = D.40264;
            pos.4112 = pos;
            pos = pos.4112 + 1;
            D.40266 = imb.b[2];
            *pos.4112 = D.40266;
            pos.4113 = pos;
            pos = pos.4113 + 1;
            D.40268 = imb.b[3];
            *pos.4113 = D.40268;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40269>;
      <D.40259>:
      disp.4114 = (unsigned int) disp;
      D.40271 = disp.4114 + 127;
      if (D.40271 <= 255) goto <D.40272>; else goto <D.40273>;
      <D.40272>:
      D.40274 = (unsigned char) disp;
      D.40275 = D.40274 + 255;
      *pos = D.40275;
      pos = pos + 1;
      goto <D.40276>;
      <D.40273>:
      __assert_fail ("0", "mini-x86.c", 3980, &__PRETTY_FUNCTION__);
      <D.40276>:
      <D.40269>:
    }
    goto <D.40277>;
    <D.40239>:
    {
      guchar * jump_to_end;

      D.31604 = ins->dreg;
      D.36840 = D.31604 > 3;
      D.36841 = (long int) D.36840;
      D.36842 = __builtin_expect (D.36841, 0);
      if (D.36842 != 0) goto <D.40278>; else goto <D.40279>;
      <D.40278>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3983, "X86_IS_BYTE_REG (ins->dreg)");
      <D.40279>:
      code.4115 = code;
      code = code.4115 + 1;
      *code.4115 = 15;
      if (0 != 0) goto <D.40281>; else goto <D.40282>;
      <D.40281>:
      code.4116 = code;
      code = code.4116 + 1;
      D.39804 = 117;
      D.40284 = D.39804 + 32;
      *code.4116 = D.40284;
      goto <D.40285>;
      <D.40282>:
      code.4117 = code;
      code = code.4117 + 1;
      D.39807 = 117;
      D.40287 = D.39807 + 32;
      *code.4117 = D.40287;
      <D.40285>:
      code.4118 = code;
      code = code.4118 + 1;
      D.31604 = ins->dreg;
      D.31637 = (signed char) D.31604;
      D.31638 = D.31637 & 7;
      D.33950 = D.31638 | -64;
      D.33951 = (unsigned char) D.33950;
      *code.4118 = D.33951;
      jump_to_end = code;
      code.4119 = code;
      code = code.4119 + 1;
      *code.4119 = 235;
      *code = 0;
      code = code + 1;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = unordered_check + 1;
        size = 0;
        D.40251 = MEM[(unsigned char *)unordered_check];
        D.40252 = (int) D.40251;
        switch (D.40252) <default: <D.26422>, case 15: <D.26401>, case 112: <D.26406>, case 113: <D.26407>, case 114: <D.26408>, case 115: <D.26409>, case 116: <D.26410>, case 117: <D.26411>, case 118: <D.26412>, case 119: <D.26413>, case 120: <D.26414>, case 121: <D.26415>, case 122: <D.26416>, case 123: <D.26417>, case 124: <D.26418>, case 125: <D.26419>, case 126: <D.26420>, case 127: <D.26421>, case 224: <D.26402>, case 225: <D.26403>, case 226: <D.26404>, case 232: <D.26398>, case 233: <D.26399>, case 235: <D.26405>>
        <D.26398>:
        <D.26399>:
        size = size + 1;
        goto <D.26400>;
        <D.26401>:
        D.40290 = *pos;
        D.40291 = D.40290 + 144;
        if (D.40291 > 31) goto <D.40292>; else goto <D.40293>;
        <D.40292>:
        __assert_fail ("0", "mini-x86.c", 3986, &__PRETTY_FUNCTION__);
        <D.40293>:
        size = size + 1;
        pos = pos + 1;
        goto <D.26400>;
        <D.26402>:
        <D.26403>:
        <D.26404>:
        <D.26405>:
        <D.26406>:
        <D.26407>:
        <D.26408>:
        <D.26409>:
        <D.26410>:
        <D.26411>:
        <D.26412>:
        <D.26413>:
        <D.26414>:
        <D.26415>:
        <D.26416>:
        <D.26417>:
        <D.26418>:
        <D.26419>:
        <D.26420>:
        <D.26421>:
        goto <D.26400>;
        <D.26422>:
        __assert_fail ("0", "mini-x86.c", 3986, &__PRETTY_FUNCTION__);
        <D.26400>:
        code.422 = (int) code;
        pos.4120 = (int) pos;
        disp = code.422 - pos.4120;
        if (size != 0) goto <D.40295>; else goto <D.40296>;
        <D.40295>:
        {
          union x86_imm_buf imb;

          try
            {
              D.40297 = disp + -4;
              imb.val = D.40297;
              pos.4121 = pos;
              pos = pos.4121 + 1;
              D.40299 = imb.b[0];
              *pos.4121 = D.40299;
              pos.4122 = pos;
              pos = pos.4122 + 1;
              D.40301 = imb.b[1];
              *pos.4122 = D.40301;
              pos.4123 = pos;
              pos = pos.4123 + 1;
              D.40303 = imb.b[2];
              *pos.4123 = D.40303;
              pos.4124 = pos;
              pos = pos.4124 + 1;
              D.40305 = imb.b[3];
              *pos.4124 = D.40305;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.40306>;
        <D.40296>:
        disp.4125 = (unsigned int) disp;
        D.40308 = disp.4125 + 127;
        if (D.40308 <= 255) goto <D.40309>; else goto <D.40310>;
        <D.40309>:
        D.40311 = (unsigned char) disp;
        D.40312 = D.40311 + 255;
        *pos = D.40312;
        pos = pos + 1;
        goto <D.40313>;
        <D.40310>:
        __assert_fail ("0", "mini-x86.c", 3986, &__PRETTY_FUNCTION__);
        <D.40313>:
        <D.40306>:
      }
      code.4126 = code;
      code = code.4126 + 1;
      D.31604 = ins->dreg;
      D.33696 = (unsigned char) D.31604;
      D.33697 = D.33696 + 64;
      *code.4126 = D.33697;
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = jump_to_end + 1;
        size = 0;
        D.40315 = MEM[(unsigned char *)jump_to_end];
        D.40316 = (int) D.40315;
        switch (D.40316) <default: <D.26451>, case 15: <D.26430>, case 112: <D.26435>, case 113: <D.26436>, case 114: <D.26437>, case 115: <D.26438>, case 116: <D.26439>, case 117: <D.26440>, case 118: <D.26441>, case 119: <D.26442>, case 120: <D.26443>, case 121: <D.26444>, case 122: <D.26445>, case 123: <D.26446>, case 124: <D.26447>, case 125: <D.26448>, case 126: <D.26449>, case 127: <D.26450>, case 224: <D.26431>, case 225: <D.26432>, case 226: <D.26433>, case 232: <D.26427>, case 233: <D.26428>, case 235: <D.26434>>
        <D.26427>:
        <D.26428>:
        size = size + 1;
        goto <D.26429>;
        <D.26430>:
        D.40317 = *pos;
        D.40318 = D.40317 + 144;
        if (D.40318 > 31) goto <D.40319>; else goto <D.40320>;
        <D.40319>:
        __assert_fail ("0", "mini-x86.c", 3988, &__PRETTY_FUNCTION__);
        <D.40320>:
        size = size + 1;
        pos = pos + 1;
        goto <D.26429>;
        <D.26431>:
        <D.26432>:
        <D.26433>:
        <D.26434>:
        <D.26435>:
        <D.26436>:
        <D.26437>:
        <D.26438>:
        <D.26439>:
        <D.26440>:
        <D.26441>:
        <D.26442>:
        <D.26443>:
        <D.26444>:
        <D.26445>:
        <D.26446>:
        <D.26447>:
        <D.26448>:
        <D.26449>:
        <D.26450>:
        goto <D.26429>;
        <D.26451>:
        __assert_fail ("0", "mini-x86.c", 3988, &__PRETTY_FUNCTION__);
        <D.26429>:
        code.422 = (int) code;
        pos.4127 = (int) pos;
        disp = code.422 - pos.4127;
        if (size != 0) goto <D.40322>; else goto <D.40323>;
        <D.40322>:
        {
          union x86_imm_buf imb;

          try
            {
              D.40324 = disp + -4;
              imb.val = D.40324;
              pos.4128 = pos;
              pos = pos.4128 + 1;
              D.40326 = imb.b[0];
              *pos.4128 = D.40326;
              pos.4129 = pos;
              pos = pos.4129 + 1;
              D.40328 = imb.b[1];
              *pos.4129 = D.40328;
              pos.4130 = pos;
              pos = pos.4130 + 1;
              D.40330 = imb.b[2];
              *pos.4130 = D.40330;
              pos.4131 = pos;
              pos = pos.4131 + 1;
              D.40332 = imb.b[3];
              *pos.4131 = D.40332;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.40333>;
        <D.40323>:
        disp.4132 = (unsigned int) disp;
        D.40335 = disp.4132 + 127;
        if (D.40335 <= 255) goto <D.40336>; else goto <D.40337>;
        <D.40336>:
        D.40338 = (unsigned char) disp;
        D.40339 = D.40338 + 255;
        *pos = D.40339;
        pos = pos + 1;
        goto <D.40340>;
        <D.40337>:
        __assert_fail ("0", "mini-x86.c", 3988, &__PRETTY_FUNCTION__);
        <D.40340>:
        <D.40333>:
      }
    }
    <D.40277>:
    goto <D.24796>;
  }
  <D.40224>:
  D.31604 = ins->dreg;
  if (D.31604 != 0) goto <D.40341>; else goto <D.40342>;
  <D.40341>:
  code.4133 = code;
  code = code.4133 + 1;
  *code.4133 = 80;
  <D.40342>:
  code.4134 = code;
  code = code.4134 + 1;
  *code.4134 = 222;
  code.4135 = code;
  code = code.4135 + 1;
  *code.4135 = 217;
  code.4136 = code;
  code = code.4136 + 1;
  *code.4136 = 223;
  code.4137 = code;
  code = code.4137 + 1;
  *code.4137 = 224;
  if (1 != 0) goto <D.40348>; else goto <D.40349>;
  <D.40348>:
  code.4138 = code;
  code = code.4138 + 1;
  *code.4138 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4139 = code;
        code = code.4139 + 1;
        D.40352 = imb.b[0];
        *code.4139 = D.40352;
        code.4140 = code;
        code = code.4140 + 1;
        D.40354 = imb.b[1];
        *code.4140 = D.40354;
        code.4141 = code;
        code = code.4141 + 1;
        D.40356 = imb.b[2];
        *code.4141 = D.40356;
        code.4142 = code;
        code = code.4142 + 1;
        D.40358 = imb.b[3];
        *code.4142 = D.40358;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26454>;
  <D.40349>:
  if (0 != 0) goto <D.40359>; else goto <D.40360>;
  <D.40359>:
  code.4143 = code;
  code = code.4143 + 1;
  *code.4143 = 131;
  code.4144 = code;
  code = code.4144 + 1;
  *code.4144 = 224;
  *code = 0;
  code = code + 1;
  goto <D.40363>;
  <D.40360>:
  code.4145 = code;
  code = code.4145 + 1;
  *code.4145 = 129;
  code.4146 = code;
  code = code.4146 + 1;
  *code.4146 = 224;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4147 = code;
        code = code.4147 + 1;
        D.40367 = imb.b[0];
        *code.4147 = D.40367;
        code.4148 = code;
        code = code.4148 + 1;
        D.40369 = imb.b[1];
        *code.4148 = D.40369;
        code.4149 = code;
        code = code.4149 + 1;
        D.40371 = imb.b[2];
        *code.4149 = D.40371;
        code.4150 = code;
        code = code.4150 + 1;
        D.40373 = imb.b[3];
        *code.4150 = D.40373;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40363>:
  <D.26454>:
  if (1 != 0) goto <D.40374>; else goto <D.40375>;
  <D.40374>:
  code.4151 = code;
  code = code.4151 + 1;
  *code.4151 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.4152 = code;
        code = code.4152 + 1;
        D.40378 = imb.b[0];
        *code.4152 = D.40378;
        code.4153 = code;
        code = code.4153 + 1;
        D.40380 = imb.b[1];
        *code.4153 = D.40380;
        code.4154 = code;
        code = code.4154 + 1;
        D.40382 = imb.b[2];
        *code.4154 = D.40382;
        code.4155 = code;
        code = code.4155 + 1;
        D.40384 = imb.b[3];
        *code.4155 = D.40384;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26457>;
  <D.40375>:
  if (0 != 0) goto <D.40385>; else goto <D.40386>;
  <D.40385>:
  code.4156 = code;
  code = code.4156 + 1;
  *code.4156 = 131;
  code.4157 = code;
  code = code.4157 + 1;
  *code.4157 = 248;
  *code = 0;
  code = code + 1;
  goto <D.40389>;
  <D.40386>:
  code.4158 = code;
  code = code.4158 + 1;
  *code.4158 = 129;
  code.4159 = code;
  code = code.4159 + 1;
  *code.4159 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.4160 = code;
        code = code.4160 + 1;
        D.40393 = imb.b[0];
        *code.4160 = D.40393;
        code.4161 = code;
        code = code.4161 + 1;
        D.40395 = imb.b[1];
        *code.4161 = D.40395;
        code.4162 = code;
        code = code.4162 + 1;
        D.40397 = imb.b[2];
        *code.4162 = D.40397;
        code.4163 = code;
        code = code.4163 + 1;
        D.40399 = imb.b[3];
        *code.4163 = D.40399;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40389>:
  <D.26457>:
  D.31604 = ins->dreg;
  D.36840 = D.31604 > 3;
  D.36841 = (long int) D.36840;
  D.36842 = __builtin_expect (D.36841, 0);
  if (D.36842 != 0) goto <D.40400>; else goto <D.40401>;
  <D.40400>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 3999, "X86_IS_BYTE_REG (ins->dreg)");
  <D.40401>:
  code.4164 = code;
  code = code.4164 + 1;
  *code.4164 = 15;
  if (1 != 0) goto <D.40403>; else goto <D.40404>;
  <D.40403>:
  code.4165 = code;
  code = code.4165 + 1;
  D.31501 = ins->opcode;
  D.40406 = D.31501 != 718;
  D.40407 = (int) D.40406;
  D.40408 = x86_cc_signed_map[D.40407];
  D.40409 = D.40408 + 32;
  *code.4165 = D.40409;
  goto <D.40410>;
  <D.40404>:
  code.4166 = code;
  code = code.4166 + 1;
  D.31501 = ins->opcode;
  D.40406 = D.31501 != 718;
  D.40407 = (int) D.40406;
  D.40412 = x86_cc_unsigned_map[D.40407];
  D.40413 = D.40412 + 32;
  *code.4166 = D.40413;
  <D.40410>:
  code.4167 = code;
  code = code.4167 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.4167 = D.33951;
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40415>; else goto <D.40416>;
    <D.40415>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4000, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.40416>:
    code.4168 = code;
    code = code.4168 + 1;
    *code.4168 = 15;
    if (0 != 0) goto <D.40418>; else goto <D.40419>;
    <D.40418>:
    op = op + 8;
    <D.40419>:
    if (0 != 0) goto <D.40420>; else goto <D.40421>;
    <D.40420>:
    op = op + 1;
    <D.40421>:
    code.4169 = code;
    code = code.4169 + 1;
    *code.4169 = op;
    code.4170 = code;
    code = code.4170 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4170 = D.34303;
  }
  D.31604 = ins->dreg;
  if (D.31604 != 0) goto <D.40424>; else goto <D.40425>;
  <D.40424>:
  code.4171 = code;
  code = code.4171 + 1;
  *code.4171 = 88;
  <D.40425>:
  goto <D.24796>;
  <D.26460>:
  <D.26461>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.40427>; else goto <D.40428>;
  <D.40427>:
  code.4172 = code;
  code = code.4172 + 1;
  *code.4172 = 51;
  code.4173 = code;
  code = code.4173 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.4173 = D.34303;
  code.4174 = code;
  code = code.4174 + 1;
  *code.4174 = 223;
  code.4175 = code;
  code = code.4175 + 1;
  *code.4175 = 241;
  code.4176 = code;
  code = code.4176 + 1;
  *code.4176 = 221;
  code.4177 = code;
  code = code.4177 + 1;
  *code.4177 = 216;
  D.31501 = ins->opcode;
  if (D.31501 == 722) goto <D.40435>; else goto <D.40436>;
  <D.40435>:
  {
    guchar * unordered_check;
    guchar * jump_to_end;

    unordered_check = code;
    if (0 != 0) goto <D.40437>; else goto <D.40438>;
    <D.40437>:
    code.4178 = code;
    code = code.4178 + 1;
    D.40234 = 122;
    *code.4178 = D.40234;
    goto <D.40440>;
    <D.40438>:
    code.4179 = code;
    code = code.4179 + 1;
    D.40237 = 122;
    *code.4179 = D.40237;
    <D.40440>:
    *code = 0;
    code = code + 1;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40442>; else goto <D.40443>;
    <D.40442>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4018, "X86_IS_BYTE_REG (ins->dreg)");
    <D.40443>:
    code.4180 = code;
    code = code.4180 + 1;
    *code.4180 = 15;
    if (0 != 0) goto <D.40445>; else goto <D.40446>;
    <D.40445>:
    code.4181 = code;
    code = code.4181 + 1;
    D.40063 = 127;
    D.40448 = D.40063 + 32;
    *code.4181 = D.40448;
    goto <D.40449>;
    <D.40446>:
    code.4182 = code;
    code = code.4182 + 1;
    D.40067 = 119;
    D.40451 = D.40067 + 32;
    *code.4182 = D.40451;
    <D.40449>:
    code.4183 = code;
    code = code.4183 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4183 = D.33951;
    jump_to_end = code;
    code.4184 = code;
    code = code.4184 + 1;
    *code.4184 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.40454 = MEM[(unsigned char *)unordered_check];
      D.40455 = (int) D.40454;
      switch (D.40455) <default: <D.26491>, case 15: <D.26470>, case 112: <D.26475>, case 113: <D.26476>, case 114: <D.26477>, case 115: <D.26478>, case 116: <D.26479>, case 117: <D.26480>, case 118: <D.26481>, case 119: <D.26482>, case 120: <D.26483>, case 121: <D.26484>, case 122: <D.26485>, case 123: <D.26486>, case 124: <D.26487>, case 125: <D.26488>, case 126: <D.26489>, case 127: <D.26490>, case 224: <D.26471>, case 225: <D.26472>, case 226: <D.26473>, case 232: <D.26467>, case 233: <D.26468>, case 235: <D.26474>>
      <D.26467>:
      <D.26468>:
      size = size + 1;
      goto <D.26469>;
      <D.26470>:
      D.40456 = *pos;
      D.40457 = D.40456 + 144;
      if (D.40457 > 31) goto <D.40458>; else goto <D.40459>;
      <D.40458>:
      __assert_fail ("0", "mini-x86.c", 4021, &__PRETTY_FUNCTION__);
      <D.40459>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26469>;
      <D.26471>:
      <D.26472>:
      <D.26473>:
      <D.26474>:
      <D.26475>:
      <D.26476>:
      <D.26477>:
      <D.26478>:
      <D.26479>:
      <D.26480>:
      <D.26481>:
      <D.26482>:
      <D.26483>:
      <D.26484>:
      <D.26485>:
      <D.26486>:
      <D.26487>:
      <D.26488>:
      <D.26489>:
      <D.26490>:
      goto <D.26469>;
      <D.26491>:
      __assert_fail ("0", "mini-x86.c", 4021, &__PRETTY_FUNCTION__);
      <D.26469>:
      code.422 = (int) code;
      pos.4185 = (int) pos;
      disp = code.422 - pos.4185;
      if (size != 0) goto <D.40461>; else goto <D.40462>;
      <D.40461>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40463 = disp + -4;
            imb.val = D.40463;
            pos.4186 = pos;
            pos = pos.4186 + 1;
            D.40465 = imb.b[0];
            *pos.4186 = D.40465;
            pos.4187 = pos;
            pos = pos.4187 + 1;
            D.40467 = imb.b[1];
            *pos.4187 = D.40467;
            pos.4188 = pos;
            pos = pos.4188 + 1;
            D.40469 = imb.b[2];
            *pos.4188 = D.40469;
            pos.4189 = pos;
            pos = pos.4189 + 1;
            D.40471 = imb.b[3];
            *pos.4189 = D.40471;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40472>;
      <D.40462>:
      disp.4190 = (unsigned int) disp;
      D.40474 = disp.4190 + 127;
      if (D.40474 <= 255) goto <D.40475>; else goto <D.40476>;
      <D.40475>:
      D.40477 = (unsigned char) disp;
      D.40478 = D.40477 + 255;
      *pos = D.40478;
      pos = pos + 1;
      goto <D.40479>;
      <D.40476>:
      __assert_fail ("0", "mini-x86.c", 4021, &__PRETTY_FUNCTION__);
      <D.40479>:
      <D.40472>:
    }
    code.4191 = code;
    code = code.4191 + 1;
    D.31604 = ins->dreg;
    D.33696 = (unsigned char) D.31604;
    D.33697 = D.33696 + 64;
    *code.4191 = D.33697;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump_to_end + 1;
      size = 0;
      D.40481 = MEM[(unsigned char *)jump_to_end];
      D.40482 = (int) D.40481;
      switch (D.40482) <default: <D.26520>, case 15: <D.26499>, case 112: <D.26504>, case 113: <D.26505>, case 114: <D.26506>, case 115: <D.26507>, case 116: <D.26508>, case 117: <D.26509>, case 118: <D.26510>, case 119: <D.26511>, case 120: <D.26512>, case 121: <D.26513>, case 122: <D.26514>, case 123: <D.26515>, case 124: <D.26516>, case 125: <D.26517>, case 126: <D.26518>, case 127: <D.26519>, case 224: <D.26500>, case 225: <D.26501>, case 226: <D.26502>, case 232: <D.26496>, case 233: <D.26497>, case 235: <D.26503>>
      <D.26496>:
      <D.26497>:
      size = size + 1;
      goto <D.26498>;
      <D.26499>:
      D.40483 = *pos;
      D.40484 = D.40483 + 144;
      if (D.40484 > 31) goto <D.40485>; else goto <D.40486>;
      <D.40485>:
      __assert_fail ("0", "mini-x86.c", 4023, &__PRETTY_FUNCTION__);
      <D.40486>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26498>;
      <D.26500>:
      <D.26501>:
      <D.26502>:
      <D.26503>:
      <D.26504>:
      <D.26505>:
      <D.26506>:
      <D.26507>:
      <D.26508>:
      <D.26509>:
      <D.26510>:
      <D.26511>:
      <D.26512>:
      <D.26513>:
      <D.26514>:
      <D.26515>:
      <D.26516>:
      <D.26517>:
      <D.26518>:
      <D.26519>:
      goto <D.26498>;
      <D.26520>:
      __assert_fail ("0", "mini-x86.c", 4023, &__PRETTY_FUNCTION__);
      <D.26498>:
      code.422 = (int) code;
      pos.4192 = (int) pos;
      disp = code.422 - pos.4192;
      if (size != 0) goto <D.40488>; else goto <D.40489>;
      <D.40488>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40490 = disp + -4;
            imb.val = D.40490;
            pos.4193 = pos;
            pos = pos.4193 + 1;
            D.40492 = imb.b[0];
            *pos.4193 = D.40492;
            pos.4194 = pos;
            pos = pos.4194 + 1;
            D.40494 = imb.b[1];
            *pos.4194 = D.40494;
            pos.4195 = pos;
            pos = pos.4195 + 1;
            D.40496 = imb.b[2];
            *pos.4195 = D.40496;
            pos.4196 = pos;
            pos = pos.4196 + 1;
            D.40498 = imb.b[3];
            *pos.4196 = D.40498;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40499>;
      <D.40489>:
      disp.4197 = (unsigned int) disp;
      D.40501 = disp.4197 + 127;
      if (D.40501 <= 255) goto <D.40502>; else goto <D.40503>;
      <D.40502>:
      D.40504 = (unsigned char) disp;
      D.40505 = D.40504 + 255;
      *pos = D.40505;
      pos = pos + 1;
      goto <D.40506>;
      <D.40503>:
      __assert_fail ("0", "mini-x86.c", 4023, &__PRETTY_FUNCTION__);
      <D.40506>:
      <D.40499>:
    }
  }
  goto <D.40507>;
  <D.40436>:
  D.31604 = ins->dreg;
  D.36840 = D.31604 > 3;
  D.36841 = (long int) D.36840;
  D.36842 = __builtin_expect (D.36841, 0);
  if (D.36842 != 0) goto <D.40508>; else goto <D.40509>;
  <D.40508>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4025, "X86_IS_BYTE_REG (ins->dreg)");
  <D.40509>:
  code.4198 = code;
  code = code.4198 + 1;
  *code.4198 = 15;
  if (0 != 0) goto <D.40511>; else goto <D.40512>;
  <D.40511>:
  code.4199 = code;
  code = code.4199 + 1;
  D.40063 = 127;
  D.40448 = D.40063 + 32;
  *code.4199 = D.40448;
  goto <D.40514>;
  <D.40512>:
  code.4200 = code;
  code = code.4200 + 1;
  D.40067 = 119;
  D.40451 = D.40067 + 32;
  *code.4200 = D.40451;
  <D.40514>:
  code.4201 = code;
  code = code.4201 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.4201 = D.33951;
  <D.40507>:
  goto <D.24796>;
  <D.40428>:
  D.31604 = ins->dreg;
  if (D.31604 != 0) goto <D.40517>; else goto <D.40518>;
  <D.40517>:
  code.4202 = code;
  code = code.4202 + 1;
  *code.4202 = 80;
  <D.40518>:
  code.4203 = code;
  code = code.4203 + 1;
  *code.4203 = 222;
  code.4204 = code;
  code = code.4204 + 1;
  *code.4204 = 217;
  code.4205 = code;
  code = code.4205 + 1;
  *code.4205 = 223;
  code.4206 = code;
  code = code.4206 + 1;
  *code.4206 = 224;
  if (1 != 0) goto <D.40524>; else goto <D.40525>;
  <D.40524>:
  code.4207 = code;
  code = code.4207 + 1;
  *code.4207 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4208 = code;
        code = code.4208 + 1;
        D.40528 = imb.b[0];
        *code.4208 = D.40528;
        code.4209 = code;
        code = code.4209 + 1;
        D.40530 = imb.b[1];
        *code.4209 = D.40530;
        code.4210 = code;
        code = code.4210 + 1;
        D.40532 = imb.b[2];
        *code.4210 = D.40532;
        code.4211 = code;
        code = code.4211 + 1;
        D.40534 = imb.b[3];
        *code.4211 = D.40534;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26523>;
  <D.40525>:
  if (0 != 0) goto <D.40535>; else goto <D.40536>;
  <D.40535>:
  code.4212 = code;
  code = code.4212 + 1;
  *code.4212 = 131;
  code.4213 = code;
  code = code.4213 + 1;
  *code.4213 = 224;
  *code = 0;
  code = code + 1;
  goto <D.40539>;
  <D.40536>:
  code.4214 = code;
  code = code.4214 + 1;
  *code.4214 = 129;
  code.4215 = code;
  code = code.4215 + 1;
  *code.4215 = 224;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4216 = code;
        code = code.4216 + 1;
        D.40543 = imb.b[0];
        *code.4216 = D.40543;
        code.4217 = code;
        code = code.4217 + 1;
        D.40545 = imb.b[1];
        *code.4217 = D.40545;
        code.4218 = code;
        code = code.4218 + 1;
        D.40547 = imb.b[2];
        *code.4218 = D.40547;
        code.4219 = code;
        code = code.4219 + 1;
        D.40549 = imb.b[3];
        *code.4219 = D.40549;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40539>:
  <D.26523>:
  D.31501 = ins->opcode;
  if (D.31501 == 722) goto <D.40550>; else goto <D.40551>;
  <D.40550>:
  {
    guchar * is_not_zero_check;
    guchar * end_jump;

    is_not_zero_check = code;
    if (1 != 0) goto <D.40552>; else goto <D.40553>;
    <D.40552>:
    code.4220 = code;
    code = code.4220 + 1;
    D.39804 = 117;
    *code.4220 = D.39804;
    goto <D.40555>;
    <D.40553>:
    code.4221 = code;
    code = code.4221 + 1;
    D.39807 = 117;
    *code.4221 = D.39807;
    <D.40555>:
    *code = 0;
    code = code + 1;
    end_jump = code;
    code.4222 = code;
    code = code.4222 + 1;
    *code.4222 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = is_not_zero_check + 1;
      size = 0;
      D.40558 = MEM[(unsigned char *)is_not_zero_check];
      D.40559 = (int) D.40558;
      switch (D.40559) <default: <D.26554>, case 15: <D.26533>, case 112: <D.26538>, case 113: <D.26539>, case 114: <D.26540>, case 115: <D.26541>, case 116: <D.26542>, case 117: <D.26543>, case 118: <D.26544>, case 119: <D.26545>, case 120: <D.26546>, case 121: <D.26547>, case 122: <D.26548>, case 123: <D.26549>, case 124: <D.26550>, case 125: <D.26551>, case 126: <D.26552>, case 127: <D.26553>, case 224: <D.26534>, case 225: <D.26535>, case 226: <D.26536>, case 232: <D.26530>, case 233: <D.26531>, case 235: <D.26537>>
      <D.26530>:
      <D.26531>:
      size = size + 1;
      goto <D.26532>;
      <D.26533>:
      D.40560 = *pos;
      D.40561 = D.40560 + 144;
      if (D.40561 > 31) goto <D.40562>; else goto <D.40563>;
      <D.40562>:
      __assert_fail ("0", "mini-x86.c", 4040, &__PRETTY_FUNCTION__);
      <D.40563>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26532>;
      <D.26534>:
      <D.26535>:
      <D.26536>:
      <D.26537>:
      <D.26538>:
      <D.26539>:
      <D.26540>:
      <D.26541>:
      <D.26542>:
      <D.26543>:
      <D.26544>:
      <D.26545>:
      <D.26546>:
      <D.26547>:
      <D.26548>:
      <D.26549>:
      <D.26550>:
      <D.26551>:
      <D.26552>:
      <D.26553>:
      goto <D.26532>;
      <D.26554>:
      __assert_fail ("0", "mini-x86.c", 4040, &__PRETTY_FUNCTION__);
      <D.26532>:
      code.422 = (int) code;
      pos.4223 = (int) pos;
      disp = code.422 - pos.4223;
      if (size != 0) goto <D.40565>; else goto <D.40566>;
      <D.40565>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40567 = disp + -4;
            imb.val = D.40567;
            pos.4224 = pos;
            pos = pos.4224 + 1;
            D.40569 = imb.b[0];
            *pos.4224 = D.40569;
            pos.4225 = pos;
            pos = pos.4225 + 1;
            D.40571 = imb.b[1];
            *pos.4225 = D.40571;
            pos.4226 = pos;
            pos = pos.4226 + 1;
            D.40573 = imb.b[2];
            *pos.4226 = D.40573;
            pos.4227 = pos;
            pos = pos.4227 + 1;
            D.40575 = imb.b[3];
            *pos.4227 = D.40575;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40576>;
      <D.40566>:
      disp.4228 = (unsigned int) disp;
      D.40578 = disp.4228 + 127;
      if (D.40578 <= 255) goto <D.40579>; else goto <D.40580>;
      <D.40579>:
      D.40581 = (unsigned char) disp;
      D.40582 = D.40581 + 255;
      *pos = D.40582;
      pos = pos + 1;
      goto <D.40583>;
      <D.40580>:
      __assert_fail ("0", "mini-x86.c", 4040, &__PRETTY_FUNCTION__);
      <D.40583>:
      <D.40576>:
    }
    if (1 != 0) goto <D.40584>; else goto <D.40585>;
    <D.40584>:
    code.4229 = code;
    code = code.4229 + 1;
    *code.4229 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4230 = code;
          code = code.4230 + 1;
          D.40588 = imb.b[0];
          *code.4230 = D.40588;
          code.4231 = code;
          code = code.4231 + 1;
          D.40590 = imb.b[1];
          *code.4231 = D.40590;
          code.4232 = code;
          code = code.4232 + 1;
          D.40592 = imb.b[2];
          *code.4232 = D.40592;
          code.4233 = code;
          code = code.4233 + 1;
          D.40594 = imb.b[3];
          *code.4233 = D.40594;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26557>;
    <D.40585>:
    if (0 != 0) goto <D.40595>; else goto <D.40596>;
    <D.40595>:
    code.4234 = code;
    code = code.4234 + 1;
    *code.4234 = 131;
    code.4235 = code;
    code = code.4235 + 1;
    *code.4235 = 248;
    *code = 0;
    code = code + 1;
    goto <D.40599>;
    <D.40596>:
    code.4236 = code;
    code = code.4236 + 1;
    *code.4236 = 129;
    code.4237 = code;
    code = code.4237 + 1;
    *code.4237 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4238 = code;
          code = code.4238 + 1;
          D.40603 = imb.b[0];
          *code.4238 = D.40603;
          code.4239 = code;
          code = code.4239 + 1;
          D.40605 = imb.b[1];
          *code.4239 = D.40605;
          code.4240 = code;
          code = code.4240 + 1;
          D.40607 = imb.b[2];
          *code.4240 = D.40607;
          code.4241 = code;
          code = code.4241 + 1;
          D.40609 = imb.b[3];
          *code.4241 = D.40609;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40599>:
    <D.26557>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = end_jump + 1;
      size = 0;
      D.40610 = MEM[(unsigned char *)end_jump];
      D.40611 = (int) D.40610;
      switch (D.40611) <default: <D.26586>, case 15: <D.26565>, case 112: <D.26570>, case 113: <D.26571>, case 114: <D.26572>, case 115: <D.26573>, case 116: <D.26574>, case 117: <D.26575>, case 118: <D.26576>, case 119: <D.26577>, case 120: <D.26578>, case 121: <D.26579>, case 122: <D.26580>, case 123: <D.26581>, case 124: <D.26582>, case 125: <D.26583>, case 126: <D.26584>, case 127: <D.26585>, case 224: <D.26566>, case 225: <D.26567>, case 226: <D.26568>, case 232: <D.26562>, case 233: <D.26563>, case 235: <D.26569>>
      <D.26562>:
      <D.26563>:
      size = size + 1;
      goto <D.26564>;
      <D.26565>:
      D.40612 = *pos;
      D.40613 = D.40612 + 144;
      if (D.40613 > 31) goto <D.40614>; else goto <D.40615>;
      <D.40614>:
      __assert_fail ("0", "mini-x86.c", 4043, &__PRETTY_FUNCTION__);
      <D.40615>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26564>;
      <D.26566>:
      <D.26567>:
      <D.26568>:
      <D.26569>:
      <D.26570>:
      <D.26571>:
      <D.26572>:
      <D.26573>:
      <D.26574>:
      <D.26575>:
      <D.26576>:
      <D.26577>:
      <D.26578>:
      <D.26579>:
      <D.26580>:
      <D.26581>:
      <D.26582>:
      <D.26583>:
      <D.26584>:
      <D.26585>:
      goto <D.26564>;
      <D.26586>:
      __assert_fail ("0", "mini-x86.c", 4043, &__PRETTY_FUNCTION__);
      <D.26564>:
      code.422 = (int) code;
      pos.4242 = (int) pos;
      disp = code.422 - pos.4242;
      if (size != 0) goto <D.40617>; else goto <D.40618>;
      <D.40617>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40619 = disp + -4;
            imb.val = D.40619;
            pos.4243 = pos;
            pos = pos.4243 + 1;
            D.40621 = imb.b[0];
            *pos.4243 = D.40621;
            pos.4244 = pos;
            pos = pos.4244 + 1;
            D.40623 = imb.b[1];
            *pos.4244 = D.40623;
            pos.4245 = pos;
            pos = pos.4245 + 1;
            D.40625 = imb.b[2];
            *pos.4245 = D.40625;
            pos.4246 = pos;
            pos = pos.4246 + 1;
            D.40627 = imb.b[3];
            *pos.4246 = D.40627;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40628>;
      <D.40618>:
      disp.4247 = (unsigned int) disp;
      D.40630 = disp.4247 + 127;
      if (D.40630 <= 255) goto <D.40631>; else goto <D.40632>;
      <D.40631>:
      D.40633 = (unsigned char) disp;
      D.40634 = D.40633 + 255;
      *pos = D.40634;
      pos = pos + 1;
      goto <D.40635>;
      <D.40632>:
      __assert_fail ("0", "mini-x86.c", 4043, &__PRETTY_FUNCTION__);
      <D.40635>:
      <D.40628>:
    }
  }
  <D.40551>:
  D.31604 = ins->dreg;
  D.36840 = D.31604 > 3;
  D.36841 = (long int) D.36840;
  D.36842 = __builtin_expect (D.36841, 0);
  if (D.36842 != 0) goto <D.40636>; else goto <D.40637>;
  <D.40636>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4045, "X86_IS_BYTE_REG (ins->dreg)");
  <D.40637>:
  code.4248 = code;
  code = code.4248 + 1;
  *code.4248 = 15;
  if (1 != 0) goto <D.40639>; else goto <D.40640>;
  <D.40639>:
  code.4249 = code;
  code = code.4249 + 1;
  D.34479 = 116;
  D.40246 = D.34479 + 32;
  *code.4249 = D.40246;
  goto <D.40642>;
  <D.40640>:
  code.4250 = code;
  code = code.4250 + 1;
  D.34482 = 116;
  D.40249 = D.34482 + 32;
  *code.4250 = D.40249;
  <D.40642>:
  code.4251 = code;
  code = code.4251 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.4251 = D.33951;
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40645>; else goto <D.40646>;
    <D.40645>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4046, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.40646>:
    code.4252 = code;
    code = code.4252 + 1;
    *code.4252 = 15;
    if (0 != 0) goto <D.40648>; else goto <D.40649>;
    <D.40648>:
    op = op + 8;
    <D.40649>:
    if (0 != 0) goto <D.40650>; else goto <D.40651>;
    <D.40650>:
    op = op + 1;
    <D.40651>:
    code.4253 = code;
    code = code.4253 + 1;
    *code.4253 = op;
    code.4254 = code;
    code = code.4254 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4254 = D.34303;
  }
  D.31604 = ins->dreg;
  if (D.31604 != 0) goto <D.40654>; else goto <D.40655>;
  <D.40654>:
  code.4255 = code;
  code = code.4255 + 1;
  *code.4255 = 88;
  <D.40655>:
  goto <D.24796>;
  <D.26589>:
  {
    guchar * unordered_check;
    guchar * jump_to_end;

    D.31411 = cfg->opt;
    D.40186 = D.31411 & 16384;
    if (D.40186 != 0) goto <D.40657>; else goto <D.40658>;
    <D.40657>:
    code.4256 = code;
    code = code.4256 + 1;
    *code.4256 = 51;
    code.4257 = code;
    code = code.4257 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4257 = D.34303;
    code.4258 = code;
    code = code.4258 + 1;
    *code.4258 = 223;
    code.4259 = code;
    code = code.4259 + 1;
    *code.4259 = 241;
    code.4260 = code;
    code = code.4260 + 1;
    *code.4260 = 221;
    code.4261 = code;
    code = code.4261 + 1;
    *code.4261 = 216;
    unordered_check = code;
    if (0 != 0) goto <D.40665>; else goto <D.40666>;
    <D.40665>:
    code.4262 = code;
    code = code.4262 + 1;
    D.40234 = 122;
    *code.4262 = D.40234;
    goto <D.40668>;
    <D.40666>:
    code.4263 = code;
    code = code.4263 + 1;
    D.40237 = 122;
    *code.4263 = D.40237;
    <D.40668>:
    *code = 0;
    code = code + 1;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40670>; else goto <D.40671>;
    <D.40670>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4063, "X86_IS_BYTE_REG (ins->dreg)");
    <D.40671>:
    code.4264 = code;
    code = code.4264 + 1;
    *code.4264 = 15;
    if (0 != 0) goto <D.40673>; else goto <D.40674>;
    <D.40673>:
    code.4265 = code;
    code = code.4265 + 1;
    D.40676 = 125;
    D.40677 = D.40676 + 32;
    *code.4265 = D.40677;
    goto <D.40678>;
    <D.40674>:
    code.4266 = code;
    code = code.4266 + 1;
    D.40680 = 115;
    D.40681 = D.40680 + 32;
    *code.4266 = D.40681;
    <D.40678>:
    code.4267 = code;
    code = code.4267 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4267 = D.33951;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.40683 = MEM[(unsigned char *)unordered_check];
      D.40684 = (int) D.40683;
      switch (D.40684) <default: <D.26619>, case 15: <D.26598>, case 112: <D.26603>, case 113: <D.26604>, case 114: <D.26605>, case 115: <D.26606>, case 116: <D.26607>, case 117: <D.26608>, case 118: <D.26609>, case 119: <D.26610>, case 120: <D.26611>, case 121: <D.26612>, case 122: <D.26613>, case 123: <D.26614>, case 124: <D.26615>, case 125: <D.26616>, case 126: <D.26617>, case 127: <D.26618>, case 224: <D.26599>, case 225: <D.26600>, case 226: <D.26601>, case 232: <D.26595>, case 233: <D.26596>, case 235: <D.26602>>
      <D.26595>:
      <D.26596>:
      size = size + 1;
      goto <D.26597>;
      <D.26598>:
      D.40685 = *pos;
      D.40686 = D.40685 + 144;
      if (D.40686 > 31) goto <D.40687>; else goto <D.40688>;
      <D.40687>:
      __assert_fail ("0", "mini-x86.c", 4064, &__PRETTY_FUNCTION__);
      <D.40688>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26597>;
      <D.26599>:
      <D.26600>:
      <D.26601>:
      <D.26602>:
      <D.26603>:
      <D.26604>:
      <D.26605>:
      <D.26606>:
      <D.26607>:
      <D.26608>:
      <D.26609>:
      <D.26610>:
      <D.26611>:
      <D.26612>:
      <D.26613>:
      <D.26614>:
      <D.26615>:
      <D.26616>:
      <D.26617>:
      <D.26618>:
      goto <D.26597>;
      <D.26619>:
      __assert_fail ("0", "mini-x86.c", 4064, &__PRETTY_FUNCTION__);
      <D.26597>:
      code.422 = (int) code;
      pos.4268 = (int) pos;
      disp = code.422 - pos.4268;
      if (size != 0) goto <D.40690>; else goto <D.40691>;
      <D.40690>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40692 = disp + -4;
            imb.val = D.40692;
            pos.4269 = pos;
            pos = pos.4269 + 1;
            D.40694 = imb.b[0];
            *pos.4269 = D.40694;
            pos.4270 = pos;
            pos = pos.4270 + 1;
            D.40696 = imb.b[1];
            *pos.4270 = D.40696;
            pos.4271 = pos;
            pos = pos.4271 + 1;
            D.40698 = imb.b[2];
            *pos.4271 = D.40698;
            pos.4272 = pos;
            pos = pos.4272 + 1;
            D.40700 = imb.b[3];
            *pos.4272 = D.40700;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40701>;
      <D.40691>:
      disp.4273 = (unsigned int) disp;
      D.40703 = disp.4273 + 127;
      if (D.40703 <= 255) goto <D.40704>; else goto <D.40705>;
      <D.40704>:
      D.40706 = (unsigned char) disp;
      D.40707 = D.40706 + 255;
      *pos = D.40707;
      pos = pos + 1;
      goto <D.40708>;
      <D.40705>:
      __assert_fail ("0", "mini-x86.c", 4064, &__PRETTY_FUNCTION__);
      <D.40708>:
      <D.40701>:
    }
    goto <D.24796>;
    <D.40658>:
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.40709>; else goto <D.40710>;
    <D.40709>:
    code.4274 = code;
    code = code.4274 + 1;
    *code.4274 = 80;
    <D.40710>:
    code.4275 = code;
    code = code.4275 + 1;
    *code.4275 = 222;
    code.4276 = code;
    code = code.4276 + 1;
    *code.4276 = 217;
    code.4277 = code;
    code = code.4277 + 1;
    *code.4277 = 223;
    code.4278 = code;
    code = code.4278 + 1;
    *code.4278 = 224;
    if (1 != 0) goto <D.40716>; else goto <D.40717>;
    <D.40716>:
    code.4279 = code;
    code = code.4279 + 1;
    *code.4279 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4280 = code;
          code = code.4280 + 1;
          D.40720 = imb.b[0];
          *code.4280 = D.40720;
          code.4281 = code;
          code = code.4281 + 1;
          D.40722 = imb.b[1];
          *code.4281 = D.40722;
          code.4282 = code;
          code = code.4282 + 1;
          D.40724 = imb.b[2];
          *code.4282 = D.40724;
          code.4283 = code;
          code = code.4283 + 1;
          D.40726 = imb.b[3];
          *code.4283 = D.40726;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26622>;
    <D.40717>:
    if (0 != 0) goto <D.40727>; else goto <D.40728>;
    <D.40727>:
    code.4284 = code;
    code = code.4284 + 1;
    *code.4284 = 131;
    code.4285 = code;
    code = code.4285 + 1;
    *code.4285 = 224;
    *code = 0;
    code = code + 1;
    goto <D.40731>;
    <D.40728>:
    code.4286 = code;
    code = code.4286 + 1;
    *code.4286 = 129;
    code.4287 = code;
    code = code.4287 + 1;
    *code.4287 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4288 = code;
          code = code.4288 + 1;
          D.40735 = imb.b[0];
          *code.4288 = D.40735;
          code.4289 = code;
          code = code.4289 + 1;
          D.40737 = imb.b[1];
          *code.4289 = D.40737;
          code.4290 = code;
          code = code.4290 + 1;
          D.40739 = imb.b[2];
          *code.4290 = D.40739;
          code.4291 = code;
          code = code.4291 + 1;
          D.40741 = imb.b[3];
          *code.4291 = D.40741;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40731>:
    <D.26622>:
    if (1 != 0) goto <D.40742>; else goto <D.40743>;
    <D.40742>:
    code.4292 = code;
    code = code.4292 + 1;
    *code.4292 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4293 = code;
          code = code.4293 + 1;
          D.40746 = imb.b[0];
          *code.4293 = D.40746;
          code.4294 = code;
          code = code.4294 + 1;
          D.40748 = imb.b[1];
          *code.4294 = D.40748;
          code.4295 = code;
          code = code.4295 + 1;
          D.40750 = imb.b[2];
          *code.4295 = D.40750;
          code.4296 = code;
          code = code.4296 + 1;
          D.40752 = imb.b[3];
          *code.4296 = D.40752;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26625>;
    <D.40743>:
    if (0 != 0) goto <D.40753>; else goto <D.40754>;
    <D.40753>:
    code.4297 = code;
    code = code.4297 + 1;
    *code.4297 = 131;
    code.4298 = code;
    code = code.4298 + 1;
    *code.4298 = 248;
    *code = 0;
    code = code + 1;
    goto <D.40757>;
    <D.40754>:
    code.4299 = code;
    code = code.4299 + 1;
    *code.4299 = 129;
    code.4300 = code;
    code = code.4300 + 1;
    *code.4300 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4301 = code;
          code = code.4301 + 1;
          D.40761 = imb.b[0];
          *code.4301 = D.40761;
          code.4302 = code;
          code = code.4302 + 1;
          D.40763 = imb.b[1];
          *code.4302 = D.40763;
          code.4303 = code;
          code = code.4303 + 1;
          D.40765 = imb.b[2];
          *code.4303 = D.40765;
          code.4304 = code;
          code = code.4304 + 1;
          D.40767 = imb.b[3];
          *code.4304 = D.40767;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40757>:
    <D.26625>:
    unordered_check = code;
    if (0 != 0) goto <D.40768>; else goto <D.40769>;
    <D.40768>:
    code.4305 = code;
    code = code.4305 + 1;
    D.34479 = 116;
    *code.4305 = D.34479;
    goto <D.40771>;
    <D.40769>:
    code.4306 = code;
    code = code.4306 + 1;
    D.34482 = 116;
    *code.4306 = D.34482;
    <D.40771>:
    *code = 0;
    code = code + 1;
    if (1 != 0) goto <D.40773>; else goto <D.40774>;
    <D.40773>:
    code.4307 = code;
    code = code.4307 + 1;
    *code.4307 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 256;
          code.4308 = code;
          code = code.4308 + 1;
          D.40777 = imb.b[0];
          *code.4308 = D.40777;
          code.4309 = code;
          code = code.4309 + 1;
          D.40779 = imb.b[1];
          *code.4309 = D.40779;
          code.4310 = code;
          code = code.4310 + 1;
          D.40781 = imb.b[2];
          *code.4310 = D.40781;
          code.4311 = code;
          code = code.4311 + 1;
          D.40783 = imb.b[3];
          *code.4311 = D.40783;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26628>;
    <D.40774>:
    if (0 != 0) goto <D.40784>; else goto <D.40785>;
    <D.40784>:
    code.4312 = code;
    code = code.4312 + 1;
    *code.4312 = 131;
    code.4313 = code;
    code = code.4313 + 1;
    *code.4313 = 248;
    *code = 0;
    code = code + 1;
    goto <D.40788>;
    <D.40785>:
    code.4314 = code;
    code = code.4314 + 1;
    *code.4314 = 129;
    code.4315 = code;
    code = code.4315 + 1;
    *code.4315 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 256;
          code.4316 = code;
          code = code.4316 + 1;
          D.40792 = imb.b[0];
          *code.4316 = D.40792;
          code.4317 = code;
          code = code.4317 + 1;
          D.40794 = imb.b[1];
          *code.4317 = D.40794;
          code.4318 = code;
          code = code.4318 + 1;
          D.40796 = imb.b[2];
          *code.4318 = D.40796;
          code.4319 = code;
          code = code.4319 + 1;
          D.40798 = imb.b[3];
          *code.4319 = D.40798;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40788>:
    <D.26628>:
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40799>; else goto <D.40800>;
    <D.40799>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4077, "X86_IS_BYTE_REG (ins->dreg)");
    <D.40800>:
    code.4320 = code;
    code = code.4320 + 1;
    *code.4320 = 15;
    if (1 != 0) goto <D.40802>; else goto <D.40803>;
    <D.40802>:
    code.4321 = code;
    code = code.4321 + 1;
    D.39804 = 117;
    D.40284 = D.39804 + 32;
    *code.4321 = D.40284;
    goto <D.40805>;
    <D.40803>:
    code.4322 = code;
    code = code.4322 + 1;
    D.39807 = 117;
    D.40287 = D.39807 + 32;
    *code.4322 = D.40287;
    <D.40805>:
    code.4323 = code;
    code = code.4323 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4323 = D.33951;
    {
      unsigned char op;

      op = 182;
      D.31604 = ins->dreg;
      D.36840 = D.31604 > 3;
      D.36841 = (long int) D.36840;
      D.36842 = __builtin_expect (D.36841, 0);
      if (D.36842 != 0) goto <D.40808>; else goto <D.40809>;
      <D.40808>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4078, "0 || X86_IS_BYTE_REG (ins->dreg)");
      <D.40809>:
      code.4324 = code;
      code = code.4324 + 1;
      *code.4324 = 15;
      if (0 != 0) goto <D.40811>; else goto <D.40812>;
      <D.40811>:
      op = op + 8;
      <D.40812>:
      if (0 != 0) goto <D.40813>; else goto <D.40814>;
      <D.40813>:
      op = op + 1;
      <D.40814>:
      code.4325 = code;
      code = code.4325 + 1;
      *code.4325 = op;
      code.4326 = code;
      code = code.4326 + 1;
      D.31604 = ins->dreg;
      D.32225 = D.31604 & 7;
      D.32226 = D.32225 << 3;
      D.32227 = (signed char) D.32226;
      D.32533 = D.32227 | -64;
      D.31604 = ins->dreg;
      D.31637 = (signed char) D.31604;
      D.31638 = D.31637 & 7;
      D.34302 = D.32533 | D.31638;
      D.34303 = (unsigned char) D.34302;
      *code.4326 = D.34303;
    }
    jump_to_end = code;
    code.4327 = code;
    code = code.4327 + 1;
    *code.4327 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.40683 = MEM[(unsigned char *)unordered_check];
      D.40684 = (int) D.40683;
      switch (D.40684) <default: <D.26658>, case 15: <D.26637>, case 112: <D.26642>, case 113: <D.26643>, case 114: <D.26644>, case 115: <D.26645>, case 116: <D.26646>, case 117: <D.26647>, case 118: <D.26648>, case 119: <D.26649>, case 120: <D.26650>, case 121: <D.26651>, case 122: <D.26652>, case 123: <D.26653>, case 124: <D.26654>, case 125: <D.26655>, case 126: <D.26656>, case 127: <D.26657>, case 224: <D.26638>, case 225: <D.26639>, case 226: <D.26640>, case 232: <D.26634>, case 233: <D.26635>, case 235: <D.26641>>
      <D.26634>:
      <D.26635>:
      size = size + 1;
      goto <D.26636>;
      <D.26637>:
      D.40818 = *pos;
      D.40819 = D.40818 + 144;
      if (D.40819 > 31) goto <D.40820>; else goto <D.40821>;
      <D.40820>:
      __assert_fail ("0", "mini-x86.c", 4081, &__PRETTY_FUNCTION__);
      <D.40821>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26636>;
      <D.26638>:
      <D.26639>:
      <D.26640>:
      <D.26641>:
      <D.26642>:
      <D.26643>:
      <D.26644>:
      <D.26645>:
      <D.26646>:
      <D.26647>:
      <D.26648>:
      <D.26649>:
      <D.26650>:
      <D.26651>:
      <D.26652>:
      <D.26653>:
      <D.26654>:
      <D.26655>:
      <D.26656>:
      <D.26657>:
      goto <D.26636>;
      <D.26658>:
      __assert_fail ("0", "mini-x86.c", 4081, &__PRETTY_FUNCTION__);
      <D.26636>:
      code.422 = (int) code;
      pos.4328 = (int) pos;
      disp = code.422 - pos.4328;
      if (size != 0) goto <D.40823>; else goto <D.40824>;
      <D.40823>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40825 = disp + -4;
            imb.val = D.40825;
            pos.4329 = pos;
            pos = pos.4329 + 1;
            D.40827 = imb.b[0];
            *pos.4329 = D.40827;
            pos.4330 = pos;
            pos = pos.4330 + 1;
            D.40829 = imb.b[1];
            *pos.4330 = D.40829;
            pos.4331 = pos;
            pos = pos.4331 + 1;
            D.40831 = imb.b[2];
            *pos.4331 = D.40831;
            pos.4332 = pos;
            pos = pos.4332 + 1;
            D.40833 = imb.b[3];
            *pos.4332 = D.40833;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40834>;
      <D.40824>:
      disp.4333 = (unsigned int) disp;
      D.40836 = disp.4333 + 127;
      if (D.40836 <= 255) goto <D.40837>; else goto <D.40838>;
      <D.40837>:
      D.40839 = (unsigned char) disp;
      D.40840 = D.40839 + 255;
      *pos = D.40840;
      pos = pos + 1;
      goto <D.40841>;
      <D.40838>:
      __assert_fail ("0", "mini-x86.c", 4081, &__PRETTY_FUNCTION__);
      <D.40841>:
      <D.40834>:
    }
    code.4334 = code;
    code = code.4334 + 1;
    *code.4334 = 51;
    code.4335 = code;
    code = code.4335 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4335 = D.34303;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump_to_end + 1;
      size = 0;
      D.40844 = MEM[(unsigned char *)jump_to_end];
      D.40845 = (int) D.40844;
      switch (D.40845) <default: <D.26687>, case 15: <D.26666>, case 112: <D.26671>, case 113: <D.26672>, case 114: <D.26673>, case 115: <D.26674>, case 116: <D.26675>, case 117: <D.26676>, case 118: <D.26677>, case 119: <D.26678>, case 120: <D.26679>, case 121: <D.26680>, case 122: <D.26681>, case 123: <D.26682>, case 124: <D.26683>, case 125: <D.26684>, case 126: <D.26685>, case 127: <D.26686>, case 224: <D.26667>, case 225: <D.26668>, case 226: <D.26669>, case 232: <D.26663>, case 233: <D.26664>, case 235: <D.26670>>
      <D.26663>:
      <D.26664>:
      size = size + 1;
      goto <D.26665>;
      <D.26666>:
      D.40846 = *pos;
      D.40847 = D.40846 + 144;
      if (D.40847 > 31) goto <D.40848>; else goto <D.40849>;
      <D.40848>:
      __assert_fail ("0", "mini-x86.c", 4083, &__PRETTY_FUNCTION__);
      <D.40849>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26665>;
      <D.26667>:
      <D.26668>:
      <D.26669>:
      <D.26670>:
      <D.26671>:
      <D.26672>:
      <D.26673>:
      <D.26674>:
      <D.26675>:
      <D.26676>:
      <D.26677>:
      <D.26678>:
      <D.26679>:
      <D.26680>:
      <D.26681>:
      <D.26682>:
      <D.26683>:
      <D.26684>:
      <D.26685>:
      <D.26686>:
      goto <D.26665>;
      <D.26687>:
      __assert_fail ("0", "mini-x86.c", 4083, &__PRETTY_FUNCTION__);
      <D.26665>:
      code.422 = (int) code;
      pos.4336 = (int) pos;
      disp = code.422 - pos.4336;
      if (size != 0) goto <D.40851>; else goto <D.40852>;
      <D.40851>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40853 = disp + -4;
            imb.val = D.40853;
            pos.4337 = pos;
            pos = pos.4337 + 1;
            D.40855 = imb.b[0];
            *pos.4337 = D.40855;
            pos.4338 = pos;
            pos = pos.4338 + 1;
            D.40857 = imb.b[1];
            *pos.4338 = D.40857;
            pos.4339 = pos;
            pos = pos.4339 + 1;
            D.40859 = imb.b[2];
            *pos.4339 = D.40859;
            pos.4340 = pos;
            pos = pos.4340 + 1;
            D.40861 = imb.b[3];
            *pos.4340 = D.40861;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40862>;
      <D.40852>:
      disp.4341 = (unsigned int) disp;
      D.40864 = disp.4341 + 127;
      if (D.40864 <= 255) goto <D.40865>; else goto <D.40866>;
      <D.40865>:
      D.40867 = (unsigned char) disp;
      D.40868 = D.40867 + 255;
      *pos = D.40868;
      pos = pos + 1;
      goto <D.40869>;
      <D.40866>:
      __assert_fail ("0", "mini-x86.c", 4083, &__PRETTY_FUNCTION__);
      <D.40869>:
      <D.40862>:
    }
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.40870>; else goto <D.40871>;
    <D.40870>:
    code.4342 = code;
    code = code.4342 + 1;
    *code.4342 = 88;
    <D.40871>:
    goto <D.24796>;
  }
  <D.26689>:
  <D.26690>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.40873>; else goto <D.40874>;
  <D.40873>:
  {
    guchar * unordered_check;

    code.4343 = code;
    code = code.4343 + 1;
    *code.4343 = 51;
    code.4344 = code;
    code = code.4344 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4344 = D.34303;
    code.4345 = code;
    code = code.4345 + 1;
    *code.4345 = 223;
    code.4346 = code;
    code = code.4346 + 1;
    *code.4346 = 241;
    code.4347 = code;
    code = code.4347 + 1;
    *code.4347 = 221;
    code.4348 = code;
    code = code.4348 + 1;
    *code.4348 = 216;
    D.31501 = ins->opcode;
    if (D.31501 == 719) goto <D.40881>; else goto <D.40882>;
    <D.40881>:
    unordered_check = code;
    if (0 != 0) goto <D.40883>; else goto <D.40884>;
    <D.40883>:
    code.4349 = code;
    code = code.4349 + 1;
    D.40234 = 122;
    *code.4349 = D.40234;
    goto <D.40886>;
    <D.40884>:
    code.4350 = code;
    code = code.4350 + 1;
    D.40237 = 122;
    *code.4350 = D.40237;
    <D.40886>:
    *code = 0;
    code = code + 1;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40888>; else goto <D.40889>;
    <D.40888>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4102, "X86_IS_BYTE_REG (ins->dreg)");
    <D.40889>:
    code.4351 = code;
    code = code.4351 + 1;
    *code.4351 = 15;
    if (0 != 0) goto <D.40891>; else goto <D.40892>;
    <D.40891>:
    code.4352 = code;
    code = code.4352 + 1;
    D.39678 = 124;
    D.40894 = D.39678 + 32;
    *code.4352 = D.40894;
    goto <D.40895>;
    <D.40892>:
    code.4353 = code;
    code = code.4353 + 1;
    D.39681 = 114;
    D.40897 = D.39681 + 32;
    *code.4353 = D.40897;
    <D.40895>:
    code.4354 = code;
    code = code.4354 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4354 = D.33951;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.40899 = MEM[(unsigned char *)unordered_check];
      D.40900 = (int) D.40899;
      switch (D.40900) <default: <D.26719>, case 15: <D.26698>, case 112: <D.26703>, case 113: <D.26704>, case 114: <D.26705>, case 115: <D.26706>, case 116: <D.26707>, case 117: <D.26708>, case 118: <D.26709>, case 119: <D.26710>, case 120: <D.26711>, case 121: <D.26712>, case 122: <D.26713>, case 123: <D.26714>, case 124: <D.26715>, case 125: <D.26716>, case 126: <D.26717>, case 127: <D.26718>, case 224: <D.26699>, case 225: <D.26700>, case 226: <D.26701>, case 232: <D.26695>, case 233: <D.26696>, case 235: <D.26702>>
      <D.26695>:
      <D.26696>:
      size = size + 1;
      goto <D.26697>;
      <D.26698>:
      D.40901 = *pos;
      D.40902 = D.40901 + 144;
      if (D.40902 > 31) goto <D.40903>; else goto <D.40904>;
      <D.40903>:
      __assert_fail ("0", "mini-x86.c", 4103, &__PRETTY_FUNCTION__);
      <D.40904>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26697>;
      <D.26699>:
      <D.26700>:
      <D.26701>:
      <D.26702>:
      <D.26703>:
      <D.26704>:
      <D.26705>:
      <D.26706>:
      <D.26707>:
      <D.26708>:
      <D.26709>:
      <D.26710>:
      <D.26711>:
      <D.26712>:
      <D.26713>:
      <D.26714>:
      <D.26715>:
      <D.26716>:
      <D.26717>:
      <D.26718>:
      goto <D.26697>;
      <D.26719>:
      __assert_fail ("0", "mini-x86.c", 4103, &__PRETTY_FUNCTION__);
      <D.26697>:
      code.422 = (int) code;
      pos.4355 = (int) pos;
      disp = code.422 - pos.4355;
      if (size != 0) goto <D.40906>; else goto <D.40907>;
      <D.40906>:
      {
        union x86_imm_buf imb;

        try
          {
            D.40908 = disp + -4;
            imb.val = D.40908;
            pos.4356 = pos;
            pos = pos.4356 + 1;
            D.40910 = imb.b[0];
            *pos.4356 = D.40910;
            pos.4357 = pos;
            pos = pos.4357 + 1;
            D.40912 = imb.b[1];
            *pos.4357 = D.40912;
            pos.4358 = pos;
            pos = pos.4358 + 1;
            D.40914 = imb.b[2];
            *pos.4358 = D.40914;
            pos.4359 = pos;
            pos = pos.4359 + 1;
            D.40916 = imb.b[3];
            *pos.4359 = D.40916;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40917>;
      <D.40907>:
      disp.4360 = (unsigned int) disp;
      D.40919 = disp.4360 + 127;
      if (D.40919 <= 255) goto <D.40920>; else goto <D.40921>;
      <D.40920>:
      D.40922 = (unsigned char) disp;
      D.40923 = D.40922 + 255;
      *pos = D.40923;
      pos = pos + 1;
      goto <D.40924>;
      <D.40921>:
      __assert_fail ("0", "mini-x86.c", 4103, &__PRETTY_FUNCTION__);
      <D.40924>:
      <D.40917>:
    }
    goto <D.40925>;
    <D.40882>:
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.40926>; else goto <D.40927>;
    <D.40926>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4105, "X86_IS_BYTE_REG (ins->dreg)");
    <D.40927>:
    code.4361 = code;
    code = code.4361 + 1;
    *code.4361 = 15;
    if (0 != 0) goto <D.40929>; else goto <D.40930>;
    <D.40929>:
    code.4362 = code;
    code = code.4362 + 1;
    D.39678 = 124;
    D.40894 = D.39678 + 32;
    *code.4362 = D.40894;
    goto <D.40932>;
    <D.40930>:
    code.4363 = code;
    code = code.4363 + 1;
    D.39681 = 114;
    D.40897 = D.39681 + 32;
    *code.4363 = D.40897;
    <D.40932>:
    code.4364 = code;
    code = code.4364 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4364 = D.33951;
    <D.40925>:
    goto <D.24796>;
  }
  <D.40874>:
  D.31604 = ins->dreg;
  if (D.31604 != 0) goto <D.40935>; else goto <D.40936>;
  <D.40935>:
  code.4365 = code;
  code = code.4365 + 1;
  *code.4365 = 80;
  <D.40936>:
  code.4366 = code;
  code = code.4366 + 1;
  *code.4366 = 222;
  code.4367 = code;
  code = code.4367 + 1;
  *code.4367 = 217;
  code.4368 = code;
  code = code.4368 + 1;
  *code.4368 = 223;
  code.4369 = code;
  code = code.4369 + 1;
  *code.4369 = 224;
  if (1 != 0) goto <D.40942>; else goto <D.40943>;
  <D.40942>:
  code.4370 = code;
  code = code.4370 + 1;
  *code.4370 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4371 = code;
        code = code.4371 + 1;
        D.40946 = imb.b[0];
        *code.4371 = D.40946;
        code.4372 = code;
        code = code.4372 + 1;
        D.40948 = imb.b[1];
        *code.4372 = D.40948;
        code.4373 = code;
        code = code.4373 + 1;
        D.40950 = imb.b[2];
        *code.4373 = D.40950;
        code.4374 = code;
        code = code.4374 + 1;
        D.40952 = imb.b[3];
        *code.4374 = D.40952;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26722>;
  <D.40943>:
  if (0 != 0) goto <D.40953>; else goto <D.40954>;
  <D.40953>:
  code.4375 = code;
  code = code.4375 + 1;
  *code.4375 = 131;
  code.4376 = code;
  code = code.4376 + 1;
  *code.4376 = 224;
  *code = 0;
  code = code + 1;
  goto <D.40957>;
  <D.40954>:
  code.4377 = code;
  code = code.4377 + 1;
  *code.4377 = 129;
  code.4378 = code;
  code = code.4378 + 1;
  *code.4378 = 224;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 17664;
        code.4379 = code;
        code = code.4379 + 1;
        D.40961 = imb.b[0];
        *code.4379 = D.40961;
        code.4380 = code;
        code = code.4380 + 1;
        D.40963 = imb.b[1];
        *code.4380 = D.40963;
        code.4381 = code;
        code = code.4381 + 1;
        D.40965 = imb.b[2];
        *code.4381 = D.40965;
        code.4382 = code;
        code = code.4382 + 1;
        D.40967 = imb.b[3];
        *code.4382 = D.40967;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40957>:
  <D.26722>:
  if (1 != 0) goto <D.40968>; else goto <D.40969>;
  <D.40968>:
  code.4383 = code;
  code = code.4383 + 1;
  *code.4383 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.4384 = code;
        code = code.4384 + 1;
        D.40972 = imb.b[0];
        *code.4384 = D.40972;
        code.4385 = code;
        code = code.4385 + 1;
        D.40974 = imb.b[1];
        *code.4385 = D.40974;
        code.4386 = code;
        code = code.4386 + 1;
        D.40976 = imb.b[2];
        *code.4386 = D.40976;
        code.4387 = code;
        code = code.4387 + 1;
        D.40978 = imb.b[3];
        *code.4387 = D.40978;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26725>;
  <D.40969>:
  if (0 != 0) goto <D.40979>; else goto <D.40980>;
  <D.40979>:
  code.4388 = code;
  code = code.4388 + 1;
  *code.4388 = 131;
  code.4389 = code;
  code = code.4389 + 1;
  *code.4389 = 248;
  *code = 0;
  code = code + 1;
  goto <D.40983>;
  <D.40980>:
  code.4390 = code;
  code = code.4390 + 1;
  *code.4390 = 129;
  code.4391 = code;
  code = code.4391 + 1;
  *code.4391 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.4392 = code;
        code = code.4392 + 1;
        D.40987 = imb.b[0];
        *code.4392 = D.40987;
        code.4393 = code;
        code = code.4393 + 1;
        D.40989 = imb.b[1];
        *code.4393 = D.40989;
        code.4394 = code;
        code = code.4394 + 1;
        D.40991 = imb.b[2];
        *code.4394 = D.40991;
        code.4395 = code;
        code = code.4395 + 1;
        D.40993 = imb.b[3];
        *code.4395 = D.40993;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40983>:
  <D.26725>:
  D.31501 = ins->opcode;
  if (D.31501 == 720) goto <D.40994>; else goto <D.40995>;
  <D.40994>:
  {
    guchar * is_not_zero_check;
    guchar * end_jump;

    is_not_zero_check = code;
    if (1 != 0) goto <D.40996>; else goto <D.40997>;
    <D.40996>:
    code.4396 = code;
    code = code.4396 + 1;
    D.39804 = 117;
    *code.4396 = D.39804;
    goto <D.40999>;
    <D.40997>:
    code.4397 = code;
    code = code.4397 + 1;
    D.39807 = 117;
    *code.4397 = D.39807;
    <D.40999>:
    *code = 0;
    code = code + 1;
    end_jump = code;
    code.4398 = code;
    code = code.4398 + 1;
    *code.4398 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = is_not_zero_check + 1;
      size = 0;
      D.41002 = MEM[(unsigned char *)is_not_zero_check];
      D.41003 = (int) D.41002;
      switch (D.41003) <default: <D.26756>, case 15: <D.26735>, case 112: <D.26740>, case 113: <D.26741>, case 114: <D.26742>, case 115: <D.26743>, case 116: <D.26744>, case 117: <D.26745>, case 118: <D.26746>, case 119: <D.26747>, case 120: <D.26748>, case 121: <D.26749>, case 122: <D.26750>, case 123: <D.26751>, case 124: <D.26752>, case 125: <D.26753>, case 126: <D.26754>, case 127: <D.26755>, case 224: <D.26736>, case 225: <D.26737>, case 226: <D.26738>, case 232: <D.26732>, case 233: <D.26733>, case 235: <D.26739>>
      <D.26732>:
      <D.26733>:
      size = size + 1;
      goto <D.26734>;
      <D.26735>:
      D.41004 = *pos;
      D.41005 = D.41004 + 144;
      if (D.41005 > 31) goto <D.41006>; else goto <D.41007>;
      <D.41006>:
      __assert_fail ("0", "mini-x86.c", 4121, &__PRETTY_FUNCTION__);
      <D.41007>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26734>;
      <D.26736>:
      <D.26737>:
      <D.26738>:
      <D.26739>:
      <D.26740>:
      <D.26741>:
      <D.26742>:
      <D.26743>:
      <D.26744>:
      <D.26745>:
      <D.26746>:
      <D.26747>:
      <D.26748>:
      <D.26749>:
      <D.26750>:
      <D.26751>:
      <D.26752>:
      <D.26753>:
      <D.26754>:
      <D.26755>:
      goto <D.26734>;
      <D.26756>:
      __assert_fail ("0", "mini-x86.c", 4121, &__PRETTY_FUNCTION__);
      <D.26734>:
      code.422 = (int) code;
      pos.4399 = (int) pos;
      disp = code.422 - pos.4399;
      if (size != 0) goto <D.41009>; else goto <D.41010>;
      <D.41009>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41011 = disp + -4;
            imb.val = D.41011;
            pos.4400 = pos;
            pos = pos.4400 + 1;
            D.41013 = imb.b[0];
            *pos.4400 = D.41013;
            pos.4401 = pos;
            pos = pos.4401 + 1;
            D.41015 = imb.b[1];
            *pos.4401 = D.41015;
            pos.4402 = pos;
            pos = pos.4402 + 1;
            D.41017 = imb.b[2];
            *pos.4402 = D.41017;
            pos.4403 = pos;
            pos = pos.4403 + 1;
            D.41019 = imb.b[3];
            *pos.4403 = D.41019;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41020>;
      <D.41010>:
      disp.4404 = (unsigned int) disp;
      D.41022 = disp.4404 + 127;
      if (D.41022 <= 255) goto <D.41023>; else goto <D.41024>;
      <D.41023>:
      D.41025 = (unsigned char) disp;
      D.41026 = D.41025 + 255;
      *pos = D.41026;
      pos = pos + 1;
      goto <D.41027>;
      <D.41024>:
      __assert_fail ("0", "mini-x86.c", 4121, &__PRETTY_FUNCTION__);
      <D.41027>:
      <D.41020>:
    }
    if (1 != 0) goto <D.41028>; else goto <D.41029>;
    <D.41028>:
    code.4405 = code;
    code = code.4405 + 1;
    *code.4405 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4406 = code;
          code = code.4406 + 1;
          D.41032 = imb.b[0];
          *code.4406 = D.41032;
          code.4407 = code;
          code = code.4407 + 1;
          D.41034 = imb.b[1];
          *code.4407 = D.41034;
          code.4408 = code;
          code = code.4408 + 1;
          D.41036 = imb.b[2];
          *code.4408 = D.41036;
          code.4409 = code;
          code = code.4409 + 1;
          D.41038 = imb.b[3];
          *code.4409 = D.41038;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26759>;
    <D.41029>:
    if (0 != 0) goto <D.41039>; else goto <D.41040>;
    <D.41039>:
    code.4410 = code;
    code = code.4410 + 1;
    *code.4410 = 131;
    code.4411 = code;
    code = code.4411 + 1;
    *code.4411 = 248;
    *code = 0;
    code = code + 1;
    goto <D.41043>;
    <D.41040>:
    code.4412 = code;
    code = code.4412 + 1;
    *code.4412 = 129;
    code.4413 = code;
    code = code.4413 + 1;
    *code.4413 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4414 = code;
          code = code.4414 + 1;
          D.41047 = imb.b[0];
          *code.4414 = D.41047;
          code.4415 = code;
          code = code.4415 + 1;
          D.41049 = imb.b[1];
          *code.4415 = D.41049;
          code.4416 = code;
          code = code.4416 + 1;
          D.41051 = imb.b[2];
          *code.4416 = D.41051;
          code.4417 = code;
          code = code.4417 + 1;
          D.41053 = imb.b[3];
          *code.4417 = D.41053;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41043>:
    <D.26759>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = end_jump + 1;
      size = 0;
      D.41054 = MEM[(unsigned char *)end_jump];
      D.41055 = (int) D.41054;
      switch (D.41055) <default: <D.26788>, case 15: <D.26767>, case 112: <D.26772>, case 113: <D.26773>, case 114: <D.26774>, case 115: <D.26775>, case 116: <D.26776>, case 117: <D.26777>, case 118: <D.26778>, case 119: <D.26779>, case 120: <D.26780>, case 121: <D.26781>, case 122: <D.26782>, case 123: <D.26783>, case 124: <D.26784>, case 125: <D.26785>, case 126: <D.26786>, case 127: <D.26787>, case 224: <D.26768>, case 225: <D.26769>, case 226: <D.26770>, case 232: <D.26764>, case 233: <D.26765>, case 235: <D.26771>>
      <D.26764>:
      <D.26765>:
      size = size + 1;
      goto <D.26766>;
      <D.26767>:
      D.41056 = *pos;
      D.41057 = D.41056 + 144;
      if (D.41057 > 31) goto <D.41058>; else goto <D.41059>;
      <D.41058>:
      __assert_fail ("0", "mini-x86.c", 4124, &__PRETTY_FUNCTION__);
      <D.41059>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26766>;
      <D.26768>:
      <D.26769>:
      <D.26770>:
      <D.26771>:
      <D.26772>:
      <D.26773>:
      <D.26774>:
      <D.26775>:
      <D.26776>:
      <D.26777>:
      <D.26778>:
      <D.26779>:
      <D.26780>:
      <D.26781>:
      <D.26782>:
      <D.26783>:
      <D.26784>:
      <D.26785>:
      <D.26786>:
      <D.26787>:
      goto <D.26766>;
      <D.26788>:
      __assert_fail ("0", "mini-x86.c", 4124, &__PRETTY_FUNCTION__);
      <D.26766>:
      code.422 = (int) code;
      pos.4418 = (int) pos;
      disp = code.422 - pos.4418;
      if (size != 0) goto <D.41061>; else goto <D.41062>;
      <D.41061>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41063 = disp + -4;
            imb.val = D.41063;
            pos.4419 = pos;
            pos = pos.4419 + 1;
            D.41065 = imb.b[0];
            *pos.4419 = D.41065;
            pos.4420 = pos;
            pos = pos.4420 + 1;
            D.41067 = imb.b[1];
            *pos.4420 = D.41067;
            pos.4421 = pos;
            pos = pos.4421 + 1;
            D.41069 = imb.b[2];
            *pos.4421 = D.41069;
            pos.4422 = pos;
            pos = pos.4422 + 1;
            D.41071 = imb.b[3];
            *pos.4422 = D.41071;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41072>;
      <D.41062>:
      disp.4423 = (unsigned int) disp;
      D.41074 = disp.4423 + 127;
      if (D.41074 <= 255) goto <D.41075>; else goto <D.41076>;
      <D.41075>:
      D.41077 = (unsigned char) disp;
      D.41078 = D.41077 + 255;
      *pos = D.41078;
      pos = pos + 1;
      goto <D.41079>;
      <D.41076>:
      __assert_fail ("0", "mini-x86.c", 4124, &__PRETTY_FUNCTION__);
      <D.41079>:
      <D.41072>:
    }
  }
  <D.40995>:
  D.31604 = ins->dreg;
  D.36840 = D.31604 > 3;
  D.36841 = (long int) D.36840;
  D.36842 = __builtin_expect (D.36841, 0);
  if (D.36842 != 0) goto <D.41080>; else goto <D.41081>;
  <D.41080>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4126, "X86_IS_BYTE_REG (ins->dreg)");
  <D.41081>:
  code.4424 = code;
  code = code.4424 + 1;
  *code.4424 = 15;
  if (1 != 0) goto <D.41083>; else goto <D.41084>;
  <D.41083>:
  code.4425 = code;
  code = code.4425 + 1;
  D.34479 = 116;
  D.40246 = D.34479 + 32;
  *code.4425 = D.40246;
  goto <D.41086>;
  <D.41084>:
  code.4426 = code;
  code = code.4426 + 1;
  D.34482 = 116;
  D.40249 = D.34482 + 32;
  *code.4426 = D.40249;
  <D.41086>:
  code.4427 = code;
  code = code.4427 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33950 = D.31638 | -64;
  D.33951 = (unsigned char) D.33950;
  *code.4427 = D.33951;
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.41089>; else goto <D.41090>;
    <D.41089>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4127, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.41090>:
    code.4428 = code;
    code = code.4428 + 1;
    *code.4428 = 15;
    if (0 != 0) goto <D.41092>; else goto <D.41093>;
    <D.41092>:
    op = op + 8;
    <D.41093>:
    if (0 != 0) goto <D.41094>; else goto <D.41095>;
    <D.41094>:
    op = op + 1;
    <D.41095>:
    code.4429 = code;
    code = code.4429 + 1;
    *code.4429 = op;
    code.4430 = code;
    code = code.4430 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4430 = D.34303;
  }
  D.31604 = ins->dreg;
  if (D.31604 != 0) goto <D.41098>; else goto <D.41099>;
  <D.41098>:
  code.4431 = code;
  code = code.4431 + 1;
  *code.4431 = 88;
  <D.41099>:
  goto <D.24796>;
  <D.26791>:
  {
    guchar * unordered_check;
    guchar * jump_to_end;

    D.31411 = cfg->opt;
    D.40186 = D.31411 & 16384;
    if (D.40186 != 0) goto <D.41101>; else goto <D.41102>;
    <D.41101>:
    code.4432 = code;
    code = code.4432 + 1;
    *code.4432 = 51;
    code.4433 = code;
    code = code.4433 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4433 = D.34303;
    code.4434 = code;
    code = code.4434 + 1;
    *code.4434 = 223;
    code.4435 = code;
    code = code.4435 + 1;
    *code.4435 = 241;
    code.4436 = code;
    code = code.4436 + 1;
    *code.4436 = 221;
    code.4437 = code;
    code = code.4437 + 1;
    *code.4437 = 216;
    unordered_check = code;
    if (0 != 0) goto <D.41109>; else goto <D.41110>;
    <D.41109>:
    code.4438 = code;
    code = code.4438 + 1;
    D.40234 = 122;
    *code.4438 = D.40234;
    goto <D.41112>;
    <D.41110>:
    code.4439 = code;
    code = code.4439 + 1;
    D.40237 = 122;
    *code.4439 = D.40237;
    <D.41112>:
    *code = 0;
    code = code + 1;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.41114>; else goto <D.41115>;
    <D.41114>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4144, "X86_IS_BYTE_REG (ins->dreg)");
    <D.41115>:
    code.4440 = code;
    code = code.4440 + 1;
    *code.4440 = 15;
    if (0 != 0) goto <D.41117>; else goto <D.41118>;
    <D.41117>:
    code.4441 = code;
    code = code.4441 + 1;
    D.41120 = 126;
    D.41121 = D.41120 + 32;
    *code.4441 = D.41121;
    goto <D.41122>;
    <D.41118>:
    code.4442 = code;
    code = code.4442 + 1;
    D.41124 = 118;
    D.41125 = D.41124 + 32;
    *code.4442 = D.41125;
    <D.41122>:
    code.4443 = code;
    code = code.4443 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4443 = D.33951;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.41127 = MEM[(unsigned char *)unordered_check];
      D.41128 = (int) D.41127;
      switch (D.41128) <default: <D.26821>, case 15: <D.26800>, case 112: <D.26805>, case 113: <D.26806>, case 114: <D.26807>, case 115: <D.26808>, case 116: <D.26809>, case 117: <D.26810>, case 118: <D.26811>, case 119: <D.26812>, case 120: <D.26813>, case 121: <D.26814>, case 122: <D.26815>, case 123: <D.26816>, case 124: <D.26817>, case 125: <D.26818>, case 126: <D.26819>, case 127: <D.26820>, case 224: <D.26801>, case 225: <D.26802>, case 226: <D.26803>, case 232: <D.26797>, case 233: <D.26798>, case 235: <D.26804>>
      <D.26797>:
      <D.26798>:
      size = size + 1;
      goto <D.26799>;
      <D.26800>:
      D.41129 = *pos;
      D.41130 = D.41129 + 144;
      if (D.41130 > 31) goto <D.41131>; else goto <D.41132>;
      <D.41131>:
      __assert_fail ("0", "mini-x86.c", 4145, &__PRETTY_FUNCTION__);
      <D.41132>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26799>;
      <D.26801>:
      <D.26802>:
      <D.26803>:
      <D.26804>:
      <D.26805>:
      <D.26806>:
      <D.26807>:
      <D.26808>:
      <D.26809>:
      <D.26810>:
      <D.26811>:
      <D.26812>:
      <D.26813>:
      <D.26814>:
      <D.26815>:
      <D.26816>:
      <D.26817>:
      <D.26818>:
      <D.26819>:
      <D.26820>:
      goto <D.26799>;
      <D.26821>:
      __assert_fail ("0", "mini-x86.c", 4145, &__PRETTY_FUNCTION__);
      <D.26799>:
      code.422 = (int) code;
      pos.4444 = (int) pos;
      disp = code.422 - pos.4444;
      if (size != 0) goto <D.41134>; else goto <D.41135>;
      <D.41134>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41136 = disp + -4;
            imb.val = D.41136;
            pos.4445 = pos;
            pos = pos.4445 + 1;
            D.41138 = imb.b[0];
            *pos.4445 = D.41138;
            pos.4446 = pos;
            pos = pos.4446 + 1;
            D.41140 = imb.b[1];
            *pos.4446 = D.41140;
            pos.4447 = pos;
            pos = pos.4447 + 1;
            D.41142 = imb.b[2];
            *pos.4447 = D.41142;
            pos.4448 = pos;
            pos = pos.4448 + 1;
            D.41144 = imb.b[3];
            *pos.4448 = D.41144;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41145>;
      <D.41135>:
      disp.4449 = (unsigned int) disp;
      D.41147 = disp.4449 + 127;
      if (D.41147 <= 255) goto <D.41148>; else goto <D.41149>;
      <D.41148>:
      D.41150 = (unsigned char) disp;
      D.41151 = D.41150 + 255;
      *pos = D.41151;
      pos = pos + 1;
      goto <D.41152>;
      <D.41149>:
      __assert_fail ("0", "mini-x86.c", 4145, &__PRETTY_FUNCTION__);
      <D.41152>:
      <D.41145>:
    }
    goto <D.24796>;
    <D.41102>:
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.41153>; else goto <D.41154>;
    <D.41153>:
    code.4450 = code;
    code = code.4450 + 1;
    *code.4450 = 80;
    <D.41154>:
    code.4451 = code;
    code = code.4451 + 1;
    *code.4451 = 222;
    code.4452 = code;
    code = code.4452 + 1;
    *code.4452 = 217;
    code.4453 = code;
    code = code.4453 + 1;
    *code.4453 = 223;
    code.4454 = code;
    code = code.4454 + 1;
    *code.4454 = 224;
    if (1 != 0) goto <D.41160>; else goto <D.41161>;
    <D.41160>:
    code.4455 = code;
    code = code.4455 + 1;
    *code.4455 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4456 = code;
          code = code.4456 + 1;
          D.41164 = imb.b[0];
          *code.4456 = D.41164;
          code.4457 = code;
          code = code.4457 + 1;
          D.41166 = imb.b[1];
          *code.4457 = D.41166;
          code.4458 = code;
          code = code.4458 + 1;
          D.41168 = imb.b[2];
          *code.4458 = D.41168;
          code.4459 = code;
          code = code.4459 + 1;
          D.41170 = imb.b[3];
          *code.4459 = D.41170;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26824>;
    <D.41161>:
    if (0 != 0) goto <D.41171>; else goto <D.41172>;
    <D.41171>:
    code.4460 = code;
    code = code.4460 + 1;
    *code.4460 = 131;
    code.4461 = code;
    code = code.4461 + 1;
    *code.4461 = 224;
    *code = 0;
    code = code + 1;
    goto <D.41175>;
    <D.41172>:
    code.4462 = code;
    code = code.4462 + 1;
    *code.4462 = 129;
    code.4463 = code;
    code = code.4463 + 1;
    *code.4463 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4464 = code;
          code = code.4464 + 1;
          D.41179 = imb.b[0];
          *code.4464 = D.41179;
          code.4465 = code;
          code = code.4465 + 1;
          D.41181 = imb.b[1];
          *code.4465 = D.41181;
          code.4466 = code;
          code = code.4466 + 1;
          D.41183 = imb.b[2];
          *code.4466 = D.41183;
          code.4467 = code;
          code = code.4467 + 1;
          D.41185 = imb.b[3];
          *code.4467 = D.41185;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41175>:
    <D.26824>:
    if (1 != 0) goto <D.41186>; else goto <D.41187>;
    <D.41186>:
    code.4468 = code;
    code = code.4468 + 1;
    *code.4468 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4469 = code;
          code = code.4469 + 1;
          D.41190 = imb.b[0];
          *code.4469 = D.41190;
          code.4470 = code;
          code = code.4470 + 1;
          D.41192 = imb.b[1];
          *code.4470 = D.41192;
          code.4471 = code;
          code = code.4471 + 1;
          D.41194 = imb.b[2];
          *code.4471 = D.41194;
          code.4472 = code;
          code = code.4472 + 1;
          D.41196 = imb.b[3];
          *code.4472 = D.41196;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26827>;
    <D.41187>:
    if (0 != 0) goto <D.41197>; else goto <D.41198>;
    <D.41197>:
    code.4473 = code;
    code = code.4473 + 1;
    *code.4473 = 131;
    code.4474 = code;
    code = code.4474 + 1;
    *code.4474 = 248;
    *code = 0;
    code = code + 1;
    goto <D.41201>;
    <D.41198>:
    code.4475 = code;
    code = code.4475 + 1;
    *code.4475 = 129;
    code.4476 = code;
    code = code.4476 + 1;
    *code.4476 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4477 = code;
          code = code.4477 + 1;
          D.41205 = imb.b[0];
          *code.4477 = D.41205;
          code.4478 = code;
          code = code.4478 + 1;
          D.41207 = imb.b[1];
          *code.4478 = D.41207;
          code.4479 = code;
          code = code.4479 + 1;
          D.41209 = imb.b[2];
          *code.4479 = D.41209;
          code.4480 = code;
          code = code.4480 + 1;
          D.41211 = imb.b[3];
          *code.4480 = D.41211;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41201>:
    <D.26827>:
    unordered_check = code;
    if (0 != 0) goto <D.41212>; else goto <D.41213>;
    <D.41212>:
    code.4481 = code;
    code = code.4481 + 1;
    D.34479 = 116;
    *code.4481 = D.34479;
    goto <D.41215>;
    <D.41213>:
    code.4482 = code;
    code = code.4482 + 1;
    D.34482 = 116;
    *code.4482 = D.34482;
    <D.41215>:
    *code = 0;
    code = code + 1;
    if (1 != 0) goto <D.41217>; else goto <D.41218>;
    <D.41217>:
    code.4483 = code;
    code = code.4483 + 1;
    *code.4483 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 256;
          code.4484 = code;
          code = code.4484 + 1;
          D.41221 = imb.b[0];
          *code.4484 = D.41221;
          code.4485 = code;
          code = code.4485 + 1;
          D.41223 = imb.b[1];
          *code.4485 = D.41223;
          code.4486 = code;
          code = code.4486 + 1;
          D.41225 = imb.b[2];
          *code.4486 = D.41225;
          code.4487 = code;
          code = code.4487 + 1;
          D.41227 = imb.b[3];
          *code.4487 = D.41227;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.26830>;
    <D.41218>:
    if (0 != 0) goto <D.41228>; else goto <D.41229>;
    <D.41228>:
    code.4488 = code;
    code = code.4488 + 1;
    *code.4488 = 131;
    code.4489 = code;
    code = code.4489 + 1;
    *code.4489 = 248;
    *code = 0;
    code = code + 1;
    goto <D.41232>;
    <D.41229>:
    code.4490 = code;
    code = code.4490 + 1;
    *code.4490 = 129;
    code.4491 = code;
    code = code.4491 + 1;
    *code.4491 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 256;
          code.4492 = code;
          code = code.4492 + 1;
          D.41236 = imb.b[0];
          *code.4492 = D.41236;
          code.4493 = code;
          code = code.4493 + 1;
          D.41238 = imb.b[1];
          *code.4493 = D.41238;
          code.4494 = code;
          code = code.4494 + 1;
          D.41240 = imb.b[2];
          *code.4494 = D.41240;
          code.4495 = code;
          code = code.4495 + 1;
          D.41242 = imb.b[3];
          *code.4495 = D.41242;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41232>:
    <D.26830>:
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.41243>; else goto <D.41244>;
    <D.41243>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4158, "X86_IS_BYTE_REG (ins->dreg)");
    <D.41244>:
    code.4496 = code;
    code = code.4496 + 1;
    *code.4496 = 15;
    if (1 != 0) goto <D.41246>; else goto <D.41247>;
    <D.41246>:
    code.4497 = code;
    code = code.4497 + 1;
    D.40676 = 125;
    D.40677 = D.40676 + 32;
    *code.4497 = D.40677;
    goto <D.41249>;
    <D.41247>:
    code.4498 = code;
    code = code.4498 + 1;
    D.40680 = 115;
    D.40681 = D.40680 + 32;
    *code.4498 = D.40681;
    <D.41249>:
    code.4499 = code;
    code = code.4499 + 1;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.33950 = D.31638 | -64;
    D.33951 = (unsigned char) D.33950;
    *code.4499 = D.33951;
    {
      unsigned char op;

      op = 182;
      D.31604 = ins->dreg;
      D.36840 = D.31604 > 3;
      D.36841 = (long int) D.36840;
      D.36842 = __builtin_expect (D.36841, 0);
      if (D.36842 != 0) goto <D.41252>; else goto <D.41253>;
      <D.41252>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4159, "0 || X86_IS_BYTE_REG (ins->dreg)");
      <D.41253>:
      code.4500 = code;
      code = code.4500 + 1;
      *code.4500 = 15;
      if (0 != 0) goto <D.41255>; else goto <D.41256>;
      <D.41255>:
      op = op + 8;
      <D.41256>:
      if (0 != 0) goto <D.41257>; else goto <D.41258>;
      <D.41257>:
      op = op + 1;
      <D.41258>:
      code.4501 = code;
      code = code.4501 + 1;
      *code.4501 = op;
      code.4502 = code;
      code = code.4502 + 1;
      D.31604 = ins->dreg;
      D.32225 = D.31604 & 7;
      D.32226 = D.32225 << 3;
      D.32227 = (signed char) D.32226;
      D.32533 = D.32227 | -64;
      D.31604 = ins->dreg;
      D.31637 = (signed char) D.31604;
      D.31638 = D.31637 & 7;
      D.34302 = D.32533 | D.31638;
      D.34303 = (unsigned char) D.34302;
      *code.4502 = D.34303;
    }
    jump_to_end = code;
    code.4503 = code;
    code = code.4503 + 1;
    *code.4503 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = unordered_check + 1;
      size = 0;
      D.41127 = MEM[(unsigned char *)unordered_check];
      D.41128 = (int) D.41127;
      switch (D.41128) <default: <D.26860>, case 15: <D.26839>, case 112: <D.26844>, case 113: <D.26845>, case 114: <D.26846>, case 115: <D.26847>, case 116: <D.26848>, case 117: <D.26849>, case 118: <D.26850>, case 119: <D.26851>, case 120: <D.26852>, case 121: <D.26853>, case 122: <D.26854>, case 123: <D.26855>, case 124: <D.26856>, case 125: <D.26857>, case 126: <D.26858>, case 127: <D.26859>, case 224: <D.26840>, case 225: <D.26841>, case 226: <D.26842>, case 232: <D.26836>, case 233: <D.26837>, case 235: <D.26843>>
      <D.26836>:
      <D.26837>:
      size = size + 1;
      goto <D.26838>;
      <D.26839>:
      D.41262 = *pos;
      D.41263 = D.41262 + 144;
      if (D.41263 > 31) goto <D.41264>; else goto <D.41265>;
      <D.41264>:
      __assert_fail ("0", "mini-x86.c", 4162, &__PRETTY_FUNCTION__);
      <D.41265>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26838>;
      <D.26840>:
      <D.26841>:
      <D.26842>:
      <D.26843>:
      <D.26844>:
      <D.26845>:
      <D.26846>:
      <D.26847>:
      <D.26848>:
      <D.26849>:
      <D.26850>:
      <D.26851>:
      <D.26852>:
      <D.26853>:
      <D.26854>:
      <D.26855>:
      <D.26856>:
      <D.26857>:
      <D.26858>:
      <D.26859>:
      goto <D.26838>;
      <D.26860>:
      __assert_fail ("0", "mini-x86.c", 4162, &__PRETTY_FUNCTION__);
      <D.26838>:
      code.422 = (int) code;
      pos.4504 = (int) pos;
      disp = code.422 - pos.4504;
      if (size != 0) goto <D.41267>; else goto <D.41268>;
      <D.41267>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41269 = disp + -4;
            imb.val = D.41269;
            pos.4505 = pos;
            pos = pos.4505 + 1;
            D.41271 = imb.b[0];
            *pos.4505 = D.41271;
            pos.4506 = pos;
            pos = pos.4506 + 1;
            D.41273 = imb.b[1];
            *pos.4506 = D.41273;
            pos.4507 = pos;
            pos = pos.4507 + 1;
            D.41275 = imb.b[2];
            *pos.4507 = D.41275;
            pos.4508 = pos;
            pos = pos.4508 + 1;
            D.41277 = imb.b[3];
            *pos.4508 = D.41277;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41278>;
      <D.41268>:
      disp.4509 = (unsigned int) disp;
      D.41280 = disp.4509 + 127;
      if (D.41280 <= 255) goto <D.41281>; else goto <D.41282>;
      <D.41281>:
      D.41283 = (unsigned char) disp;
      D.41284 = D.41283 + 255;
      *pos = D.41284;
      pos = pos + 1;
      goto <D.41285>;
      <D.41282>:
      __assert_fail ("0", "mini-x86.c", 4162, &__PRETTY_FUNCTION__);
      <D.41285>:
      <D.41278>:
    }
    code.4510 = code;
    code = code.4510 + 1;
    *code.4510 = 51;
    code.4511 = code;
    code = code.4511 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.4511 = D.34303;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump_to_end + 1;
      size = 0;
      D.41288 = MEM[(unsigned char *)jump_to_end];
      D.41289 = (int) D.41288;
      switch (D.41289) <default: <D.26889>, case 15: <D.26868>, case 112: <D.26873>, case 113: <D.26874>, case 114: <D.26875>, case 115: <D.26876>, case 116: <D.26877>, case 117: <D.26878>, case 118: <D.26879>, case 119: <D.26880>, case 120: <D.26881>, case 121: <D.26882>, case 122: <D.26883>, case 123: <D.26884>, case 124: <D.26885>, case 125: <D.26886>, case 126: <D.26887>, case 127: <D.26888>, case 224: <D.26869>, case 225: <D.26870>, case 226: <D.26871>, case 232: <D.26865>, case 233: <D.26866>, case 235: <D.26872>>
      <D.26865>:
      <D.26866>:
      size = size + 1;
      goto <D.26867>;
      <D.26868>:
      D.41290 = *pos;
      D.41291 = D.41290 + 144;
      if (D.41291 > 31) goto <D.41292>; else goto <D.41293>;
      <D.41292>:
      __assert_fail ("0", "mini-x86.c", 4164, &__PRETTY_FUNCTION__);
      <D.41293>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26867>;
      <D.26869>:
      <D.26870>:
      <D.26871>:
      <D.26872>:
      <D.26873>:
      <D.26874>:
      <D.26875>:
      <D.26876>:
      <D.26877>:
      <D.26878>:
      <D.26879>:
      <D.26880>:
      <D.26881>:
      <D.26882>:
      <D.26883>:
      <D.26884>:
      <D.26885>:
      <D.26886>:
      <D.26887>:
      <D.26888>:
      goto <D.26867>;
      <D.26889>:
      __assert_fail ("0", "mini-x86.c", 4164, &__PRETTY_FUNCTION__);
      <D.26867>:
      code.422 = (int) code;
      pos.4512 = (int) pos;
      disp = code.422 - pos.4512;
      if (size != 0) goto <D.41295>; else goto <D.41296>;
      <D.41295>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41297 = disp + -4;
            imb.val = D.41297;
            pos.4513 = pos;
            pos = pos.4513 + 1;
            D.41299 = imb.b[0];
            *pos.4513 = D.41299;
            pos.4514 = pos;
            pos = pos.4514 + 1;
            D.41301 = imb.b[1];
            *pos.4514 = D.41301;
            pos.4515 = pos;
            pos = pos.4515 + 1;
            D.41303 = imb.b[2];
            *pos.4515 = D.41303;
            pos.4516 = pos;
            pos = pos.4516 + 1;
            D.41305 = imb.b[3];
            *pos.4516 = D.41305;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41306>;
      <D.41296>:
      disp.4517 = (unsigned int) disp;
      D.41308 = disp.4517 + 127;
      if (D.41308 <= 255) goto <D.41309>; else goto <D.41310>;
      <D.41309>:
      D.41311 = (unsigned char) disp;
      D.41312 = D.41311 + 255;
      *pos = D.41312;
      pos = pos + 1;
      goto <D.41313>;
      <D.41310>:
      __assert_fail ("0", "mini-x86.c", 4164, &__PRETTY_FUNCTION__);
      <D.41313>:
      <D.41306>:
    }
    D.31604 = ins->dreg;
    if (D.31604 != 0) goto <D.41314>; else goto <D.41315>;
    <D.41314>:
    code.4518 = code;
    code = code.4518 + 1;
    *code.4518 = 88;
    <D.41315>:
    goto <D.24796>;
  }
  <D.26891>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.41317>; else goto <D.41318>;
  <D.41317>:
  {
    guchar * jump;

    jump = code;
    if (1 != 0) goto <D.41319>; else goto <D.41320>;
    <D.41319>:
    code.4519 = code;
    code = code.4519 + 1;
    D.40234 = 122;
    *code.4519 = D.40234;
    goto <D.41322>;
    <D.41320>:
    code.4520 = code;
    code = code.4520 + 1;
    D.40237 = 122;
    *code.4520 = D.40237;
    <D.41322>:
    *code = 0;
    code = code + 1;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    if (D.37247 != 0) goto <D.41324>; else goto <D.41325>;
    <D.41324>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -2;
      branch_start = code;
      offset.4521 = (unsigned int) offset;
      D.41327 = offset.4521 + 128;
      if (D.41327 <= 255) goto <D.41328>; else goto <D.41329>;
      <D.41328>:
      if (0 != 0) goto <D.41330>; else goto <D.41331>;
      <D.41330>:
      code.4522 = code;
      code = code.4522 + 1;
      D.34479 = 116;
      *code.4522 = D.34479;
      goto <D.41333>;
      <D.41331>:
      code.4523 = code;
      code = code.4523 + 1;
      D.34482 = 116;
      *code.4523 = D.34482;
      <D.41333>:
      D.41335 = (unsigned char) offset;
      *code = D.41335;
      code = code + 1;
      goto <D.41336>;
      <D.41329>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -6;
      code.4524 = code;
      code = code.4524 + 1;
      *code.4524 = 15;
      if (0 != 0) goto <D.41338>; else goto <D.41339>;
      <D.41338>:
      code.4525 = code;
      code = code.4525 + 1;
      D.34479 = 116;
      D.41341 = D.34479 + 16;
      *code.4525 = D.41341;
      goto <D.41342>;
      <D.41339>:
      code.4526 = code;
      code = code.4526 + 1;
      D.34482 = 116;
      D.41344 = D.34482 + 16;
      *code.4526 = D.41344;
      <D.41342>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.4527 = code;
            code = code.4527 + 1;
            D.41346 = imb.b[0];
            *code.4527 = D.41346;
            code.4528 = code;
            code = code.4528 + 1;
            D.41348 = imb.b[1];
            *code.4528 = D.41348;
            code.4529 = code;
            code = code.4529 + 1;
            D.41350 = imb.b[2];
            *code.4529 = D.41350;
            code.4530 = code;
            code = code.4530 + 1;
            D.41352 = imb.b[3];
            *code.4530 = D.41352;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.41336>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.41353 = MEM[(unsigned char *)branch_start];
        D.41354 = (int) D.41353;
        switch (D.41354) <default: <D.26923>, case 15: <D.26902>, case 112: <D.26907>, case 113: <D.26908>, case 114: <D.26909>, case 115: <D.26910>, case 116: <D.26911>, case 117: <D.26912>, case 118: <D.26913>, case 119: <D.26914>, case 120: <D.26915>, case 121: <D.26916>, case 122: <D.26917>, case 123: <D.26918>, case 124: <D.26919>, case 125: <D.26920>, case 126: <D.26921>, case 127: <D.26922>, case 224: <D.26903>, case 225: <D.26904>, case 226: <D.26905>, case 232: <D.26899>, case 233: <D.26900>, case 235: <D.26906>>
        <D.26899>:
        <D.26900>:
        size = size + 1;
        goto <D.26901>;
        <D.26902>:
        D.41355 = *pos;
        D.41356 = D.41355 + 144;
        if (D.41356 > 31) goto <D.41357>; else goto <D.41358>;
        <D.41357>:
        __assert_fail ("0", "mini-x86.c", 4174, &__PRETTY_FUNCTION__);
        <D.41358>:
        size = size + 1;
        pos = pos + 1;
        goto <D.26901>;
        <D.26903>:
        <D.26904>:
        <D.26905>:
        <D.26906>:
        <D.26907>:
        <D.26908>:
        <D.26909>:
        <D.26910>:
        <D.26911>:
        <D.26912>:
        <D.26913>:
        <D.26914>:
        <D.26915>:
        <D.26916>:
        <D.26917>:
        <D.26918>:
        <D.26919>:
        <D.26920>:
        <D.26921>:
        <D.26922>:
        goto <D.26901>;
        <D.26923>:
        __assert_fail ("0", "mini-x86.c", 4174, &__PRETTY_FUNCTION__);
        <D.26901>:
        D.31409 = cfg->native_code;
        D.37245 = ins->data.op[1].many_blocks;
        D.37246 = *D.37245;
        D.37247 = D.37246->native_offset;
        D.37250 = (sizetype) D.37247;
        D.37251 = D.31409 + D.37250;
        D.37252 = (int) D.37251;
        pos.4531 = (int) pos;
        disp = D.37252 - pos.4531;
        if (size != 0) goto <D.41360>; else goto <D.41361>;
        <D.41360>:
        {
          union x86_imm_buf imb;

          try
            {
              D.41362 = disp + -4;
              imb.val = D.41362;
              pos.4532 = pos;
              pos = pos.4532 + 1;
              D.41364 = imb.b[0];
              *pos.4532 = D.41364;
              pos.4533 = pos;
              pos = pos.4533 + 1;
              D.41366 = imb.b[1];
              *pos.4533 = D.41366;
              pos.4534 = pos;
              pos = pos.4534 + 1;
              D.41368 = imb.b[2];
              *pos.4534 = D.41368;
              pos.4535 = pos;
              pos = pos.4535 + 1;
              D.41370 = imb.b[3];
              *pos.4535 = D.41370;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.41371>;
        <D.41361>:
        disp.4536 = (unsigned int) disp;
        D.41373 = disp.4536 + 127;
        if (D.41373 <= 255) goto <D.41374>; else goto <D.41375>;
        <D.41374>:
        D.41376 = (unsigned char) disp;
        D.41377 = D.41376 + 255;
        *pos = D.41377;
        pos = pos + 1;
        goto <D.41378>;
        <D.41375>:
        __assert_fail ("0", "mini-x86.c", 4174, &__PRETTY_FUNCTION__);
        <D.41378>:
        <D.41371>:
      }
    }
    goto <D.41379>;
    <D.41325>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.37246);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.41382>; else goto <D.41380>;
    <D.41382>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37327 = D.37246->max_offset;
    D.37328 = D.37327 - cpos;
    D.37329 = (unsigned int) D.37328;
    D.37330 = D.37329 + 128;
    if (D.37330 <= 255) goto <D.41383>; else goto <D.41380>;
    <D.41383>:
    if (0 != 0) goto <D.41384>; else goto <D.41385>;
    <D.41384>:
    code.4537 = code;
    code = code.4537 + 1;
    D.34479 = 116;
    *code.4537 = D.34479;
    goto <D.41387>;
    <D.41385>:
    code.4538 = code;
    code = code.4538 + 1;
    D.34482 = 116;
    *code.4538 = D.34482;
    <D.41387>:
    *code = 0;
    code = code + 1;
    goto <D.41381>;
    <D.41380>:
    code.4539 = code;
    code = code.4539 + 1;
    *code.4539 = 15;
    if (0 != 0) goto <D.41390>; else goto <D.41391>;
    <D.41390>:
    code.4540 = code;
    code = code.4540 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.4540 = D.41341;
    goto <D.41393>;
    <D.41391>:
    code.4541 = code;
    code = code.4541 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.4541 = D.41344;
    <D.41393>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4542 = code;
          code = code.4542 + 1;
          D.41396 = imb.b[0];
          *code.4542 = D.41396;
          code.4543 = code;
          code = code.4543 + 1;
          D.41398 = imb.b[1];
          *code.4543 = D.41398;
          code.4544 = code;
          code = code.4544 + 1;
          D.41400 = imb.b[2];
          *code.4544 = D.41400;
          code.4545 = code;
          code = code.4545 + 1;
          D.41402 = imb.b[3];
          *code.4545 = D.41402;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41381>:
    <D.41379>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = jump + 1;
      size = 0;
      D.41403 = MEM[(unsigned char *)jump];
      D.41404 = (int) D.41403;
      switch (D.41404) <default: <D.26953>, case 15: <D.26932>, case 112: <D.26937>, case 113: <D.26938>, case 114: <D.26939>, case 115: <D.26940>, case 116: <D.26941>, case 117: <D.26942>, case 118: <D.26943>, case 119: <D.26944>, case 120: <D.26945>, case 121: <D.26946>, case 122: <D.26947>, case 123: <D.26948>, case 124: <D.26949>, case 125: <D.26950>, case 126: <D.26951>, case 127: <D.26952>, case 224: <D.26933>, case 225: <D.26934>, case 226: <D.26935>, case 232: <D.26929>, case 233: <D.26930>, case 235: <D.26936>>
      <D.26929>:
      <D.26930>:
      size = size + 1;
      goto <D.26931>;
      <D.26932>:
      D.41405 = *pos;
      D.41406 = D.41405 + 144;
      if (D.41406 > 31) goto <D.41407>; else goto <D.41408>;
      <D.41407>:
      __assert_fail ("0", "mini-x86.c", 4175, &__PRETTY_FUNCTION__);
      <D.41408>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26931>;
      <D.26933>:
      <D.26934>:
      <D.26935>:
      <D.26936>:
      <D.26937>:
      <D.26938>:
      <D.26939>:
      <D.26940>:
      <D.26941>:
      <D.26942>:
      <D.26943>:
      <D.26944>:
      <D.26945>:
      <D.26946>:
      <D.26947>:
      <D.26948>:
      <D.26949>:
      <D.26950>:
      <D.26951>:
      <D.26952>:
      goto <D.26931>;
      <D.26953>:
      __assert_fail ("0", "mini-x86.c", 4175, &__PRETTY_FUNCTION__);
      <D.26931>:
      code.422 = (int) code;
      pos.4546 = (int) pos;
      disp = code.422 - pos.4546;
      if (size != 0) goto <D.41410>; else goto <D.41411>;
      <D.41410>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41412 = disp + -4;
            imb.val = D.41412;
            pos.4547 = pos;
            pos = pos.4547 + 1;
            D.41414 = imb.b[0];
            *pos.4547 = D.41414;
            pos.4548 = pos;
            pos = pos.4548 + 1;
            D.41416 = imb.b[1];
            *pos.4548 = D.41416;
            pos.4549 = pos;
            pos = pos.4549 + 1;
            D.41418 = imb.b[2];
            *pos.4549 = D.41418;
            pos.4550 = pos;
            pos = pos.4550 + 1;
            D.41420 = imb.b[3];
            *pos.4550 = D.41420;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41421>;
      <D.41411>:
      disp.4551 = (unsigned int) disp;
      D.41423 = disp.4551 + 127;
      if (D.41423 <= 255) goto <D.41424>; else goto <D.41425>;
      <D.41424>:
      D.41426 = (unsigned char) disp;
      D.41427 = D.41426 + 255;
      *pos = D.41427;
      pos = pos + 1;
      goto <D.41428>;
      <D.41425>:
      __assert_fail ("0", "mini-x86.c", 4175, &__PRETTY_FUNCTION__);
      <D.41428>:
      <D.41421>:
    }
    goto <D.24796>;
  }
  <D.41318>:
  if (1 != 0) goto <D.41429>; else goto <D.41430>;
  <D.41429>:
  code.4552 = code;
  code = code.4552 + 1;
  *code.4552 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.4553 = code;
        code = code.4553 + 1;
        D.41433 = imb.b[0];
        *code.4553 = D.41433;
        code.4554 = code;
        code = code.4554 + 1;
        D.41435 = imb.b[1];
        *code.4554 = D.41435;
        code.4555 = code;
        code = code.4555 + 1;
        D.41437 = imb.b[2];
        *code.4555 = D.41437;
        code.4556 = code;
        code = code.4556 + 1;
        D.41439 = imb.b[3];
        *code.4556 = D.41439;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.26956>;
  <D.41430>:
  if (0 != 0) goto <D.41440>; else goto <D.41441>;
  <D.41440>:
  code.4557 = code;
  code = code.4557 + 1;
  *code.4557 = 131;
  code.4558 = code;
  code = code.4558 + 1;
  *code.4558 = 248;
  *code = 0;
  code = code + 1;
  goto <D.41444>;
  <D.41441>:
  code.4559 = code;
  code = code.4559 + 1;
  *code.4559 = 129;
  code.4560 = code;
  code = code.4560 + 1;
  *code.4560 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.4561 = code;
        code = code.4561 + 1;
        D.41448 = imb.b[0];
        *code.4561 = D.41448;
        code.4562 = code;
        code = code.4562 + 1;
        D.41450 = imb.b[1];
        *code.4562 = D.41450;
        code.4563 = code;
        code = code.4563 + 1;
        D.41452 = imb.b[2];
        *code.4563 = D.41452;
        code.4564 = code;
        code = code.4564 + 1;
        D.41454 = imb.b[3];
        *code.4564 = D.41454;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41444>:
  <D.26956>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41455>; else goto <D.41456>;
  <D.41455>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4565 = (unsigned int) offset;
    D.41458 = offset.4565 + 128;
    if (D.41458 <= 255) goto <D.41459>; else goto <D.41460>;
    <D.41459>:
    if (1 != 0) goto <D.41461>; else goto <D.41462>;
    <D.41461>:
    code.4566 = code;
    code = code.4566 + 1;
    D.34479 = 116;
    *code.4566 = D.34479;
    goto <D.41464>;
    <D.41462>:
    code.4567 = code;
    code = code.4567 + 1;
    D.34482 = 116;
    *code.4567 = D.34482;
    <D.41464>:
    D.41466 = (unsigned char) offset;
    *code = D.41466;
    code = code + 1;
    goto <D.41467>;
    <D.41460>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4568 = code;
    code = code.4568 + 1;
    *code.4568 = 15;
    if (1 != 0) goto <D.41469>; else goto <D.41470>;
    <D.41469>:
    code.4569 = code;
    code = code.4569 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.4569 = D.41341;
    goto <D.41472>;
    <D.41470>:
    code.4570 = code;
    code = code.4570 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.4570 = D.41344;
    <D.41472>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4571 = code;
          code = code.4571 + 1;
          D.41475 = imb.b[0];
          *code.4571 = D.41475;
          code.4572 = code;
          code = code.4572 + 1;
          D.41477 = imb.b[1];
          *code.4572 = D.41477;
          code.4573 = code;
          code = code.4573 + 1;
          D.41479 = imb.b[2];
          *code.4573 = D.41479;
          code.4574 = code;
          code = code.4574 + 1;
          D.41481 = imb.b[3];
          *code.4574 = D.41481;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41467>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41482 = MEM[(unsigned char *)branch_start];
      D.41483 = (int) D.41482;
      switch (D.41483) <default: <D.26988>, case 15: <D.26967>, case 112: <D.26972>, case 113: <D.26973>, case 114: <D.26974>, case 115: <D.26975>, case 116: <D.26976>, case 117: <D.26977>, case 118: <D.26978>, case 119: <D.26979>, case 120: <D.26980>, case 121: <D.26981>, case 122: <D.26982>, case 123: <D.26983>, case 124: <D.26984>, case 125: <D.26985>, case 126: <D.26986>, case 127: <D.26987>, case 224: <D.26968>, case 225: <D.26969>, case 226: <D.26970>, case 232: <D.26964>, case 233: <D.26965>, case 235: <D.26971>>
      <D.26964>:
      <D.26965>:
      size = size + 1;
      goto <D.26966>;
      <D.26967>:
      D.41484 = *pos;
      D.41485 = D.41484 + 144;
      if (D.41485 > 31) goto <D.41486>; else goto <D.41487>;
      <D.41486>:
      __assert_fail ("0", "mini-x86.c", 4179, &__PRETTY_FUNCTION__);
      <D.41487>:
      size = size + 1;
      pos = pos + 1;
      goto <D.26966>;
      <D.26968>:
      <D.26969>:
      <D.26970>:
      <D.26971>:
      <D.26972>:
      <D.26973>:
      <D.26974>:
      <D.26975>:
      <D.26976>:
      <D.26977>:
      <D.26978>:
      <D.26979>:
      <D.26980>:
      <D.26981>:
      <D.26982>:
      <D.26983>:
      <D.26984>:
      <D.26985>:
      <D.26986>:
      <D.26987>:
      goto <D.26966>;
      <D.26988>:
      __assert_fail ("0", "mini-x86.c", 4179, &__PRETTY_FUNCTION__);
      <D.26966>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4575 = (int) pos;
      disp = D.37252 - pos.4575;
      if (size != 0) goto <D.41489>; else goto <D.41490>;
      <D.41489>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41491 = disp + -4;
            imb.val = D.41491;
            pos.4576 = pos;
            pos = pos.4576 + 1;
            D.41493 = imb.b[0];
            *pos.4576 = D.41493;
            pos.4577 = pos;
            pos = pos.4577 + 1;
            D.41495 = imb.b[1];
            *pos.4577 = D.41495;
            pos.4578 = pos;
            pos = pos.4578 + 1;
            D.41497 = imb.b[2];
            *pos.4578 = D.41497;
            pos.4579 = pos;
            pos = pos.4579 + 1;
            D.41499 = imb.b[3];
            *pos.4579 = D.41499;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41500>;
      <D.41490>:
      disp.4580 = (unsigned int) disp;
      D.41502 = disp.4580 + 127;
      if (D.41502 <= 255) goto <D.41503>; else goto <D.41504>;
      <D.41503>:
      D.41505 = (unsigned char) disp;
      D.41506 = D.41505 + 255;
      *pos = D.41506;
      pos = pos + 1;
      goto <D.41507>;
      <D.41504>:
      __assert_fail ("0", "mini-x86.c", 4179, &__PRETTY_FUNCTION__);
      <D.41507>:
      <D.41500>:
    }
  }
  goto <D.41508>;
  <D.41456>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.41511>; else goto <D.41509>;
  <D.41511>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.41512>; else goto <D.41509>;
  <D.41512>:
  if (1 != 0) goto <D.41513>; else goto <D.41514>;
  <D.41513>:
  code.4581 = code;
  code = code.4581 + 1;
  D.34479 = 116;
  *code.4581 = D.34479;
  goto <D.41516>;
  <D.41514>:
  code.4582 = code;
  code = code.4582 + 1;
  D.34482 = 116;
  *code.4582 = D.34482;
  <D.41516>:
  *code = 0;
  code = code + 1;
  goto <D.41510>;
  <D.41509>:
  code.4583 = code;
  code = code.4583 + 1;
  *code.4583 = 15;
  if (1 != 0) goto <D.41519>; else goto <D.41520>;
  <D.41519>:
  code.4584 = code;
  code = code.4584 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.4584 = D.41341;
  goto <D.41522>;
  <D.41520>:
  code.4585 = code;
  code = code.4585 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.4585 = D.41344;
  <D.41522>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4586 = code;
        code = code.4586 + 1;
        D.41525 = imb.b[0];
        *code.4586 = D.41525;
        code.4587 = code;
        code = code.4587 + 1;
        D.41527 = imb.b[1];
        *code.4587 = D.41527;
        code.4588 = code;
        code = code.4588 + 1;
        D.41529 = imb.b[2];
        *code.4588 = D.41529;
        code.4589 = code;
        code = code.4589 + 1;
        D.41531 = imb.b[3];
        *code.4589 = D.41531;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41510>:
  <D.41508>:
  goto <D.24796>;
  <D.26991>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.41532>; else goto <D.41533>;
  <D.41532>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41534>; else goto <D.41535>;
  <D.41534>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4590 = (unsigned int) offset;
    D.41537 = offset.4590 + 128;
    if (D.41537 <= 255) goto <D.41538>; else goto <D.41539>;
    <D.41538>:
    if (0 != 0) goto <D.41540>; else goto <D.41541>;
    <D.41540>:
    code.4591 = code;
    code = code.4591 + 1;
    D.39804 = 117;
    *code.4591 = D.39804;
    goto <D.41543>;
    <D.41541>:
    code.4592 = code;
    code = code.4592 + 1;
    D.39807 = 117;
    *code.4592 = D.39807;
    <D.41543>:
    D.41545 = (unsigned char) offset;
    *code = D.41545;
    code = code + 1;
    goto <D.41546>;
    <D.41539>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4593 = code;
    code = code.4593 + 1;
    *code.4593 = 15;
    if (0 != 0) goto <D.41548>; else goto <D.41549>;
    <D.41548>:
    code.4594 = code;
    code = code.4594 + 1;
    D.39804 = 117;
    D.41551 = D.39804 + 16;
    *code.4594 = D.41551;
    goto <D.41552>;
    <D.41549>:
    code.4595 = code;
    code = code.4595 + 1;
    D.39807 = 117;
    D.41554 = D.39807 + 16;
    *code.4595 = D.41554;
    <D.41552>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4596 = code;
          code = code.4596 + 1;
          D.41556 = imb.b[0];
          *code.4596 = D.41556;
          code.4597 = code;
          code = code.4597 + 1;
          D.41558 = imb.b[1];
          *code.4597 = D.41558;
          code.4598 = code;
          code = code.4598 + 1;
          D.41560 = imb.b[2];
          *code.4598 = D.41560;
          code.4599 = code;
          code = code.4599 + 1;
          D.41562 = imb.b[3];
          *code.4599 = D.41562;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41546>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41563 = MEM[(unsigned char *)branch_start];
      D.41564 = (int) D.41563;
      switch (D.41564) <default: <D.27022>, case 15: <D.27001>, case 112: <D.27006>, case 113: <D.27007>, case 114: <D.27008>, case 115: <D.27009>, case 116: <D.27010>, case 117: <D.27011>, case 118: <D.27012>, case 119: <D.27013>, case 120: <D.27014>, case 121: <D.27015>, case 122: <D.27016>, case 123: <D.27017>, case 124: <D.27018>, case 125: <D.27019>, case 126: <D.27020>, case 127: <D.27021>, case 224: <D.27002>, case 225: <D.27003>, case 226: <D.27004>, case 232: <D.26998>, case 233: <D.26999>, case 235: <D.27005>>
      <D.26998>:
      <D.26999>:
      size = size + 1;
      goto <D.27000>;
      <D.27001>:
      D.41565 = *pos;
      D.41566 = D.41565 + 144;
      if (D.41566 > 31) goto <D.41567>; else goto <D.41568>;
      <D.41567>:
      __assert_fail ("0", "mini-x86.c", 4185, &__PRETTY_FUNCTION__);
      <D.41568>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27000>;
      <D.27002>:
      <D.27003>:
      <D.27004>:
      <D.27005>:
      <D.27006>:
      <D.27007>:
      <D.27008>:
      <D.27009>:
      <D.27010>:
      <D.27011>:
      <D.27012>:
      <D.27013>:
      <D.27014>:
      <D.27015>:
      <D.27016>:
      <D.27017>:
      <D.27018>:
      <D.27019>:
      <D.27020>:
      <D.27021>:
      goto <D.27000>;
      <D.27022>:
      __assert_fail ("0", "mini-x86.c", 4185, &__PRETTY_FUNCTION__);
      <D.27000>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4600 = (int) pos;
      disp = D.37252 - pos.4600;
      if (size != 0) goto <D.41570>; else goto <D.41571>;
      <D.41570>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41572 = disp + -4;
            imb.val = D.41572;
            pos.4601 = pos;
            pos = pos.4601 + 1;
            D.41574 = imb.b[0];
            *pos.4601 = D.41574;
            pos.4602 = pos;
            pos = pos.4602 + 1;
            D.41576 = imb.b[1];
            *pos.4602 = D.41576;
            pos.4603 = pos;
            pos = pos.4603 + 1;
            D.41578 = imb.b[2];
            *pos.4603 = D.41578;
            pos.4604 = pos;
            pos = pos.4604 + 1;
            D.41580 = imb.b[3];
            *pos.4604 = D.41580;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41581>;
      <D.41571>:
      disp.4605 = (unsigned int) disp;
      D.41583 = disp.4605 + 127;
      if (D.41583 <= 255) goto <D.41584>; else goto <D.41585>;
      <D.41584>:
      D.41586 = (unsigned char) disp;
      D.41587 = D.41586 + 255;
      *pos = D.41587;
      pos = pos + 1;
      goto <D.41588>;
      <D.41585>:
      __assert_fail ("0", "mini-x86.c", 4185, &__PRETTY_FUNCTION__);
      <D.41588>:
      <D.41581>:
    }
  }
  goto <D.41589>;
  <D.41535>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.41592>; else goto <D.41590>;
  <D.41592>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.41593>; else goto <D.41590>;
  <D.41593>:
  if (0 != 0) goto <D.41594>; else goto <D.41595>;
  <D.41594>:
  code.4606 = code;
  code = code.4606 + 1;
  D.39804 = 117;
  *code.4606 = D.39804;
  goto <D.41597>;
  <D.41595>:
  code.4607 = code;
  code = code.4607 + 1;
  D.39807 = 117;
  *code.4607 = D.39807;
  <D.41597>:
  *code = 0;
  code = code + 1;
  goto <D.41591>;
  <D.41590>:
  code.4608 = code;
  code = code.4608 + 1;
  *code.4608 = 15;
  if (0 != 0) goto <D.41600>; else goto <D.41601>;
  <D.41600>:
  code.4609 = code;
  code = code.4609 + 1;
  D.39804 = 117;
  D.41551 = D.39804 + 16;
  *code.4609 = D.41551;
  goto <D.41603>;
  <D.41601>:
  code.4610 = code;
  code = code.4610 + 1;
  D.39807 = 117;
  D.41554 = D.39807 + 16;
  *code.4610 = D.41554;
  <D.41603>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4611 = code;
        code = code.4611 + 1;
        D.41606 = imb.b[0];
        *code.4611 = D.41606;
        code.4612 = code;
        code = code.4612 + 1;
        D.41608 = imb.b[1];
        *code.4612 = D.41608;
        code.4613 = code;
        code = code.4613 + 1;
        D.41610 = imb.b[2];
        *code.4613 = D.41610;
        code.4614 = code;
        code = code.4614 + 1;
        D.41612 = imb.b[3];
        *code.4614 = D.41612;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41591>:
  <D.41589>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41613>; else goto <D.41614>;
  <D.41613>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4615 = (unsigned int) offset;
    D.41616 = offset.4615 + 128;
    if (D.41616 <= 255) goto <D.41617>; else goto <D.41618>;
    <D.41617>:
    if (0 != 0) goto <D.41619>; else goto <D.41620>;
    <D.41619>:
    code.4616 = code;
    code = code.4616 + 1;
    D.40234 = 122;
    *code.4616 = D.40234;
    goto <D.41622>;
    <D.41620>:
    code.4617 = code;
    code = code.4617 + 1;
    D.40237 = 122;
    *code.4617 = D.40237;
    <D.41622>:
    D.41624 = (unsigned char) offset;
    *code = D.41624;
    code = code + 1;
    goto <D.41625>;
    <D.41618>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4618 = code;
    code = code.4618 + 1;
    *code.4618 = 15;
    if (0 != 0) goto <D.41627>; else goto <D.41628>;
    <D.41627>:
    code.4619 = code;
    code = code.4619 + 1;
    D.40234 = 122;
    D.41630 = D.40234 + 16;
    *code.4619 = D.41630;
    goto <D.41631>;
    <D.41628>:
    code.4620 = code;
    code = code.4620 + 1;
    D.40237 = 122;
    D.41633 = D.40237 + 16;
    *code.4620 = D.41633;
    <D.41631>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4621 = code;
          code = code.4621 + 1;
          D.41635 = imb.b[0];
          *code.4621 = D.41635;
          code.4622 = code;
          code = code.4622 + 1;
          D.41637 = imb.b[1];
          *code.4622 = D.41637;
          code.4623 = code;
          code = code.4623 + 1;
          D.41639 = imb.b[2];
          *code.4623 = D.41639;
          code.4624 = code;
          code = code.4624 + 1;
          D.41641 = imb.b[3];
          *code.4624 = D.41641;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41625>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41642 = MEM[(unsigned char *)branch_start];
      D.41643 = (int) D.41642;
      switch (D.41643) <default: <D.27055>, case 15: <D.27034>, case 112: <D.27039>, case 113: <D.27040>, case 114: <D.27041>, case 115: <D.27042>, case 116: <D.27043>, case 117: <D.27044>, case 118: <D.27045>, case 119: <D.27046>, case 120: <D.27047>, case 121: <D.27048>, case 122: <D.27049>, case 123: <D.27050>, case 124: <D.27051>, case 125: <D.27052>, case 126: <D.27053>, case 127: <D.27054>, case 224: <D.27035>, case 225: <D.27036>, case 226: <D.27037>, case 232: <D.27031>, case 233: <D.27032>, case 235: <D.27038>>
      <D.27031>:
      <D.27032>:
      size = size + 1;
      goto <D.27033>;
      <D.27034>:
      D.41644 = *pos;
      D.41645 = D.41644 + 144;
      if (D.41645 > 31) goto <D.41646>; else goto <D.41647>;
      <D.41646>:
      __assert_fail ("0", "mini-x86.c", 4186, &__PRETTY_FUNCTION__);
      <D.41647>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27033>;
      <D.27035>:
      <D.27036>:
      <D.27037>:
      <D.27038>:
      <D.27039>:
      <D.27040>:
      <D.27041>:
      <D.27042>:
      <D.27043>:
      <D.27044>:
      <D.27045>:
      <D.27046>:
      <D.27047>:
      <D.27048>:
      <D.27049>:
      <D.27050>:
      <D.27051>:
      <D.27052>:
      <D.27053>:
      <D.27054>:
      goto <D.27033>;
      <D.27055>:
      __assert_fail ("0", "mini-x86.c", 4186, &__PRETTY_FUNCTION__);
      <D.27033>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4625 = (int) pos;
      disp = D.37252 - pos.4625;
      if (size != 0) goto <D.41649>; else goto <D.41650>;
      <D.41649>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41651 = disp + -4;
            imb.val = D.41651;
            pos.4626 = pos;
            pos = pos.4626 + 1;
            D.41653 = imb.b[0];
            *pos.4626 = D.41653;
            pos.4627 = pos;
            pos = pos.4627 + 1;
            D.41655 = imb.b[1];
            *pos.4627 = D.41655;
            pos.4628 = pos;
            pos = pos.4628 + 1;
            D.41657 = imb.b[2];
            *pos.4628 = D.41657;
            pos.4629 = pos;
            pos = pos.4629 + 1;
            D.41659 = imb.b[3];
            *pos.4629 = D.41659;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41660>;
      <D.41650>:
      disp.4630 = (unsigned int) disp;
      D.41662 = disp.4630 + 127;
      if (D.41662 <= 255) goto <D.41663>; else goto <D.41664>;
      <D.41663>:
      D.41665 = (unsigned char) disp;
      D.41666 = D.41665 + 255;
      *pos = D.41666;
      pos = pos + 1;
      goto <D.41667>;
      <D.41664>:
      __assert_fail ("0", "mini-x86.c", 4186, &__PRETTY_FUNCTION__);
      <D.41667>:
      <D.41660>:
    }
  }
  goto <D.41668>;
  <D.41614>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.41671>; else goto <D.41669>;
  <D.41671>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.41672>; else goto <D.41669>;
  <D.41672>:
  if (0 != 0) goto <D.41673>; else goto <D.41674>;
  <D.41673>:
  code.4631 = code;
  code = code.4631 + 1;
  D.40234 = 122;
  *code.4631 = D.40234;
  goto <D.41676>;
  <D.41674>:
  code.4632 = code;
  code = code.4632 + 1;
  D.40237 = 122;
  *code.4632 = D.40237;
  <D.41676>:
  *code = 0;
  code = code + 1;
  goto <D.41670>;
  <D.41669>:
  code.4633 = code;
  code = code.4633 + 1;
  *code.4633 = 15;
  if (0 != 0) goto <D.41679>; else goto <D.41680>;
  <D.41679>:
  code.4634 = code;
  code = code.4634 + 1;
  D.40234 = 122;
  D.41630 = D.40234 + 16;
  *code.4634 = D.41630;
  goto <D.41682>;
  <D.41680>:
  code.4635 = code;
  code = code.4635 + 1;
  D.40237 = 122;
  D.41633 = D.40237 + 16;
  *code.4635 = D.41633;
  <D.41682>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4636 = code;
        code = code.4636 + 1;
        D.41685 = imb.b[0];
        *code.4636 = D.41685;
        code.4637 = code;
        code = code.4637 + 1;
        D.41687 = imb.b[1];
        *code.4637 = D.41687;
        code.4638 = code;
        code = code.4638 + 1;
        D.41689 = imb.b[2];
        *code.4638 = D.41689;
        code.4639 = code;
        code = code.4639 + 1;
        D.41691 = imb.b[3];
        *code.4639 = D.41691;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41670>:
  <D.41668>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41692>; else goto <D.41693>;
  <D.41692>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4640 = (unsigned int) offset;
    D.41695 = offset.4640 + 128;
    if (D.41695 <= 255) goto <D.41696>; else goto <D.41697>;
    <D.41696>:
    if (0 != 0) goto <D.41698>; else goto <D.41699>;
    <D.41698>:
    code.4641 = code;
    code = code.4641 + 1;
    D.39678 = 124;
    *code.4641 = D.39678;
    goto <D.41701>;
    <D.41699>:
    code.4642 = code;
    code = code.4642 + 1;
    D.39681 = 114;
    *code.4642 = D.39681;
    <D.41701>:
    D.41703 = (unsigned char) offset;
    *code = D.41703;
    code = code + 1;
    goto <D.41704>;
    <D.41697>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4643 = code;
    code = code.4643 + 1;
    *code.4643 = 15;
    if (0 != 0) goto <D.41706>; else goto <D.41707>;
    <D.41706>:
    code.4644 = code;
    code = code.4644 + 1;
    D.39678 = 124;
    D.41709 = D.39678 + 16;
    *code.4644 = D.41709;
    goto <D.41710>;
    <D.41707>:
    code.4645 = code;
    code = code.4645 + 1;
    D.39681 = 114;
    D.41712 = D.39681 + 16;
    *code.4645 = D.41712;
    <D.41710>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4646 = code;
          code = code.4646 + 1;
          D.41714 = imb.b[0];
          *code.4646 = D.41714;
          code.4647 = code;
          code = code.4647 + 1;
          D.41716 = imb.b[1];
          *code.4647 = D.41716;
          code.4648 = code;
          code = code.4648 + 1;
          D.41718 = imb.b[2];
          *code.4648 = D.41718;
          code.4649 = code;
          code = code.4649 + 1;
          D.41720 = imb.b[3];
          *code.4649 = D.41720;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41704>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41721 = MEM[(unsigned char *)branch_start];
      D.41722 = (int) D.41721;
      switch (D.41722) <default: <D.27088>, case 15: <D.27067>, case 112: <D.27072>, case 113: <D.27073>, case 114: <D.27074>, case 115: <D.27075>, case 116: <D.27076>, case 117: <D.27077>, case 118: <D.27078>, case 119: <D.27079>, case 120: <D.27080>, case 121: <D.27081>, case 122: <D.27082>, case 123: <D.27083>, case 124: <D.27084>, case 125: <D.27085>, case 126: <D.27086>, case 127: <D.27087>, case 224: <D.27068>, case 225: <D.27069>, case 226: <D.27070>, case 232: <D.27064>, case 233: <D.27065>, case 235: <D.27071>>
      <D.27064>:
      <D.27065>:
      size = size + 1;
      goto <D.27066>;
      <D.27067>:
      D.41723 = *pos;
      D.41724 = D.41723 + 144;
      if (D.41724 > 31) goto <D.41725>; else goto <D.41726>;
      <D.41725>:
      __assert_fail ("0", "mini-x86.c", 4187, &__PRETTY_FUNCTION__);
      <D.41726>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27066>;
      <D.27068>:
      <D.27069>:
      <D.27070>:
      <D.27071>:
      <D.27072>:
      <D.27073>:
      <D.27074>:
      <D.27075>:
      <D.27076>:
      <D.27077>:
      <D.27078>:
      <D.27079>:
      <D.27080>:
      <D.27081>:
      <D.27082>:
      <D.27083>:
      <D.27084>:
      <D.27085>:
      <D.27086>:
      <D.27087>:
      goto <D.27066>;
      <D.27088>:
      __assert_fail ("0", "mini-x86.c", 4187, &__PRETTY_FUNCTION__);
      <D.27066>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4650 = (int) pos;
      disp = D.37252 - pos.4650;
      if (size != 0) goto <D.41728>; else goto <D.41729>;
      <D.41728>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41730 = disp + -4;
            imb.val = D.41730;
            pos.4651 = pos;
            pos = pos.4651 + 1;
            D.41732 = imb.b[0];
            *pos.4651 = D.41732;
            pos.4652 = pos;
            pos = pos.4652 + 1;
            D.41734 = imb.b[1];
            *pos.4652 = D.41734;
            pos.4653 = pos;
            pos = pos.4653 + 1;
            D.41736 = imb.b[2];
            *pos.4653 = D.41736;
            pos.4654 = pos;
            pos = pos.4654 + 1;
            D.41738 = imb.b[3];
            *pos.4654 = D.41738;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41739>;
      <D.41729>:
      disp.4655 = (unsigned int) disp;
      D.41741 = disp.4655 + 127;
      if (D.41741 <= 255) goto <D.41742>; else goto <D.41743>;
      <D.41742>:
      D.41744 = (unsigned char) disp;
      D.41745 = D.41744 + 255;
      *pos = D.41745;
      pos = pos + 1;
      goto <D.41746>;
      <D.41743>:
      __assert_fail ("0", "mini-x86.c", 4187, &__PRETTY_FUNCTION__);
      <D.41746>:
      <D.41739>:
    }
  }
  goto <D.41747>;
  <D.41693>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.41750>; else goto <D.41748>;
  <D.41750>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.41751>; else goto <D.41748>;
  <D.41751>:
  if (0 != 0) goto <D.41752>; else goto <D.41753>;
  <D.41752>:
  code.4656 = code;
  code = code.4656 + 1;
  D.39678 = 124;
  *code.4656 = D.39678;
  goto <D.41755>;
  <D.41753>:
  code.4657 = code;
  code = code.4657 + 1;
  D.39681 = 114;
  *code.4657 = D.39681;
  <D.41755>:
  *code = 0;
  code = code + 1;
  goto <D.41749>;
  <D.41748>:
  code.4658 = code;
  code = code.4658 + 1;
  *code.4658 = 15;
  if (0 != 0) goto <D.41758>; else goto <D.41759>;
  <D.41758>:
  code.4659 = code;
  code = code.4659 + 1;
  D.39678 = 124;
  D.41709 = D.39678 + 16;
  *code.4659 = D.41709;
  goto <D.41761>;
  <D.41759>:
  code.4660 = code;
  code = code.4660 + 1;
  D.39681 = 114;
  D.41712 = D.39681 + 16;
  *code.4660 = D.41712;
  <D.41761>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4661 = code;
        code = code.4661 + 1;
        D.41764 = imb.b[0];
        *code.4661 = D.41764;
        code.4662 = code;
        code = code.4662 + 1;
        D.41766 = imb.b[1];
        *code.4662 = D.41766;
        code.4663 = code;
        code = code.4663 + 1;
        D.41768 = imb.b[2];
        *code.4663 = D.41768;
        code.4664 = code;
        code = code.4664 + 1;
        D.41770 = imb.b[3];
        *code.4664 = D.41770;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41749>:
  <D.41747>:
  goto <D.24796>;
  <D.41533>:
  if (1 != 0) goto <D.41771>; else goto <D.41772>;
  <D.41771>:
  code.4665 = code;
  code = code.4665 + 1;
  *code.4665 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.4666 = code;
        code = code.4666 + 1;
        D.41775 = imb.b[0];
        *code.4666 = D.41775;
        code.4667 = code;
        code = code.4667 + 1;
        D.41777 = imb.b[1];
        *code.4667 = D.41777;
        code.4668 = code;
        code = code.4668 + 1;
        D.41779 = imb.b[2];
        *code.4668 = D.41779;
        code.4669 = code;
        code = code.4669 + 1;
        D.41781 = imb.b[3];
        *code.4669 = D.41781;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27092>;
  <D.41772>:
  if (0 != 0) goto <D.41782>; else goto <D.41783>;
  <D.41782>:
  code.4670 = code;
  code = code.4670 + 1;
  *code.4670 = 131;
  code.4671 = code;
  code = code.4671 + 1;
  *code.4671 = 248;
  *code = 0;
  code = code + 1;
  goto <D.41786>;
  <D.41783>:
  code.4672 = code;
  code = code.4672 + 1;
  *code.4672 = 129;
  code.4673 = code;
  code = code.4673 + 1;
  *code.4673 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.4674 = code;
        code = code.4674 + 1;
        D.41790 = imb.b[0];
        *code.4674 = D.41790;
        code.4675 = code;
        code = code.4675 + 1;
        D.41792 = imb.b[1];
        *code.4675 = D.41792;
        code.4676 = code;
        code = code.4676 + 1;
        D.41794 = imb.b[2];
        *code.4676 = D.41794;
        code.4677 = code;
        code = code.4677 + 1;
        D.41796 = imb.b[3];
        *code.4677 = D.41796;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41786>:
  <D.27092>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41797>; else goto <D.41798>;
  <D.41797>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4678 = (unsigned int) offset;
    D.41800 = offset.4678 + 128;
    if (D.41800 <= 255) goto <D.41801>; else goto <D.41802>;
    <D.41801>:
    if (0 != 0) goto <D.41803>; else goto <D.41804>;
    <D.41803>:
    code.4679 = code;
    code = code.4679 + 1;
    D.39804 = 117;
    *code.4679 = D.39804;
    goto <D.41806>;
    <D.41804>:
    code.4680 = code;
    code = code.4680 + 1;
    D.39807 = 117;
    *code.4680 = D.39807;
    <D.41806>:
    D.41808 = (unsigned char) offset;
    *code = D.41808;
    code = code + 1;
    goto <D.41809>;
    <D.41802>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4681 = code;
    code = code.4681 + 1;
    *code.4681 = 15;
    if (0 != 0) goto <D.41811>; else goto <D.41812>;
    <D.41811>:
    code.4682 = code;
    code = code.4682 + 1;
    D.39804 = 117;
    D.41551 = D.39804 + 16;
    *code.4682 = D.41551;
    goto <D.41814>;
    <D.41812>:
    code.4683 = code;
    code = code.4683 + 1;
    D.39807 = 117;
    D.41554 = D.39807 + 16;
    *code.4683 = D.41554;
    <D.41814>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4684 = code;
          code = code.4684 + 1;
          D.41817 = imb.b[0];
          *code.4684 = D.41817;
          code.4685 = code;
          code = code.4685 + 1;
          D.41819 = imb.b[1];
          *code.4685 = D.41819;
          code.4686 = code;
          code = code.4686 + 1;
          D.41821 = imb.b[2];
          *code.4686 = D.41821;
          code.4687 = code;
          code = code.4687 + 1;
          D.41823 = imb.b[3];
          *code.4687 = D.41823;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41809>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41824 = MEM[(unsigned char *)branch_start];
      D.41825 = (int) D.41824;
      switch (D.41825) <default: <D.27124>, case 15: <D.27103>, case 112: <D.27108>, case 113: <D.27109>, case 114: <D.27110>, case 115: <D.27111>, case 116: <D.27112>, case 117: <D.27113>, case 118: <D.27114>, case 119: <D.27115>, case 120: <D.27116>, case 121: <D.27117>, case 122: <D.27118>, case 123: <D.27119>, case 124: <D.27120>, case 125: <D.27121>, case 126: <D.27122>, case 127: <D.27123>, case 224: <D.27104>, case 225: <D.27105>, case 226: <D.27106>, case 232: <D.27100>, case 233: <D.27101>, case 235: <D.27107>>
      <D.27100>:
      <D.27101>:
      size = size + 1;
      goto <D.27102>;
      <D.27103>:
      D.41826 = *pos;
      D.41827 = D.41826 + 144;
      if (D.41827 > 31) goto <D.41828>; else goto <D.41829>;
      <D.41828>:
      __assert_fail ("0", "mini-x86.c", 4191, &__PRETTY_FUNCTION__);
      <D.41829>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27102>;
      <D.27104>:
      <D.27105>:
      <D.27106>:
      <D.27107>:
      <D.27108>:
      <D.27109>:
      <D.27110>:
      <D.27111>:
      <D.27112>:
      <D.27113>:
      <D.27114>:
      <D.27115>:
      <D.27116>:
      <D.27117>:
      <D.27118>:
      <D.27119>:
      <D.27120>:
      <D.27121>:
      <D.27122>:
      <D.27123>:
      goto <D.27102>;
      <D.27124>:
      __assert_fail ("0", "mini-x86.c", 4191, &__PRETTY_FUNCTION__);
      <D.27102>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4688 = (int) pos;
      disp = D.37252 - pos.4688;
      if (size != 0) goto <D.41831>; else goto <D.41832>;
      <D.41831>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41833 = disp + -4;
            imb.val = D.41833;
            pos.4689 = pos;
            pos = pos.4689 + 1;
            D.41835 = imb.b[0];
            *pos.4689 = D.41835;
            pos.4690 = pos;
            pos = pos.4690 + 1;
            D.41837 = imb.b[1];
            *pos.4690 = D.41837;
            pos.4691 = pos;
            pos = pos.4691 + 1;
            D.41839 = imb.b[2];
            *pos.4691 = D.41839;
            pos.4692 = pos;
            pos = pos.4692 + 1;
            D.41841 = imb.b[3];
            *pos.4692 = D.41841;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41842>;
      <D.41832>:
      disp.4693 = (unsigned int) disp;
      D.41844 = disp.4693 + 127;
      if (D.41844 <= 255) goto <D.41845>; else goto <D.41846>;
      <D.41845>:
      D.41847 = (unsigned char) disp;
      D.41848 = D.41847 + 255;
      *pos = D.41848;
      pos = pos + 1;
      goto <D.41849>;
      <D.41846>:
      __assert_fail ("0", "mini-x86.c", 4191, &__PRETTY_FUNCTION__);
      <D.41849>:
      <D.41842>:
    }
  }
  goto <D.41850>;
  <D.41798>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.41853>; else goto <D.41851>;
  <D.41853>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.41854>; else goto <D.41851>;
  <D.41854>:
  if (0 != 0) goto <D.41855>; else goto <D.41856>;
  <D.41855>:
  code.4694 = code;
  code = code.4694 + 1;
  D.39804 = 117;
  *code.4694 = D.39804;
  goto <D.41858>;
  <D.41856>:
  code.4695 = code;
  code = code.4695 + 1;
  D.39807 = 117;
  *code.4695 = D.39807;
  <D.41858>:
  *code = 0;
  code = code + 1;
  goto <D.41852>;
  <D.41851>:
  code.4696 = code;
  code = code.4696 + 1;
  *code.4696 = 15;
  if (0 != 0) goto <D.41861>; else goto <D.41862>;
  <D.41861>:
  code.4697 = code;
  code = code.4697 + 1;
  D.39804 = 117;
  D.41551 = D.39804 + 16;
  *code.4697 = D.41551;
  goto <D.41864>;
  <D.41862>:
  code.4698 = code;
  code = code.4698 + 1;
  D.39807 = 117;
  D.41554 = D.39807 + 16;
  *code.4698 = D.41554;
  <D.41864>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4699 = code;
        code = code.4699 + 1;
        D.41867 = imb.b[0];
        *code.4699 = D.41867;
        code.4700 = code;
        code = code.4700 + 1;
        D.41869 = imb.b[1];
        *code.4700 = D.41869;
        code.4701 = code;
        code = code.4701 + 1;
        D.41871 = imb.b[2];
        *code.4701 = D.41871;
        code.4702 = code;
        code = code.4702 + 1;
        D.41873 = imb.b[3];
        *code.4702 = D.41873;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41852>:
  <D.41850>:
  goto <D.24796>;
  <D.27127>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.41874>; else goto <D.41875>;
  <D.41874>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41876>; else goto <D.41877>;
  <D.41876>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4703 = (unsigned int) offset;
    D.41879 = offset.4703 + 128;
    if (D.41879 <= 255) goto <D.41880>; else goto <D.41881>;
    <D.41880>:
    if (0 != 0) goto <D.41882>; else goto <D.41883>;
    <D.41882>:
    code.4704 = code;
    code = code.4704 + 1;
    D.40063 = 127;
    *code.4704 = D.40063;
    goto <D.41885>;
    <D.41883>:
    code.4705 = code;
    code = code.4705 + 1;
    D.40067 = 119;
    *code.4705 = D.40067;
    <D.41885>:
    D.41887 = (unsigned char) offset;
    *code = D.41887;
    code = code + 1;
    goto <D.41888>;
    <D.41881>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4706 = code;
    code = code.4706 + 1;
    *code.4706 = 15;
    if (0 != 0) goto <D.41890>; else goto <D.41891>;
    <D.41890>:
    code.4707 = code;
    code = code.4707 + 1;
    D.40063 = 127;
    D.41893 = D.40063 + 16;
    *code.4707 = D.41893;
    goto <D.41894>;
    <D.41891>:
    code.4708 = code;
    code = code.4708 + 1;
    D.40067 = 119;
    D.41896 = D.40067 + 16;
    *code.4708 = D.41896;
    <D.41894>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4709 = code;
          code = code.4709 + 1;
          D.41898 = imb.b[0];
          *code.4709 = D.41898;
          code.4710 = code;
          code = code.4710 + 1;
          D.41900 = imb.b[1];
          *code.4710 = D.41900;
          code.4711 = code;
          code = code.4711 + 1;
          D.41902 = imb.b[2];
          *code.4711 = D.41902;
          code.4712 = code;
          code = code.4712 + 1;
          D.41904 = imb.b[3];
          *code.4712 = D.41904;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41888>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41905 = MEM[(unsigned char *)branch_start];
      D.41906 = (int) D.41905;
      switch (D.41906) <default: <D.27158>, case 15: <D.27137>, case 112: <D.27142>, case 113: <D.27143>, case 114: <D.27144>, case 115: <D.27145>, case 116: <D.27146>, case 117: <D.27147>, case 118: <D.27148>, case 119: <D.27149>, case 120: <D.27150>, case 121: <D.27151>, case 122: <D.27152>, case 123: <D.27153>, case 124: <D.27154>, case 125: <D.27155>, case 126: <D.27156>, case 127: <D.27157>, case 224: <D.27138>, case 225: <D.27139>, case 226: <D.27140>, case 232: <D.27134>, case 233: <D.27135>, case 235: <D.27141>>
      <D.27134>:
      <D.27135>:
      size = size + 1;
      goto <D.27136>;
      <D.27137>:
      D.41907 = *pos;
      D.41908 = D.41907 + 144;
      if (D.41908 > 31) goto <D.41909>; else goto <D.41910>;
      <D.41909>:
      __assert_fail ("0", "mini-x86.c", 4195, &__PRETTY_FUNCTION__);
      <D.41910>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27136>;
      <D.27138>:
      <D.27139>:
      <D.27140>:
      <D.27141>:
      <D.27142>:
      <D.27143>:
      <D.27144>:
      <D.27145>:
      <D.27146>:
      <D.27147>:
      <D.27148>:
      <D.27149>:
      <D.27150>:
      <D.27151>:
      <D.27152>:
      <D.27153>:
      <D.27154>:
      <D.27155>:
      <D.27156>:
      <D.27157>:
      goto <D.27136>;
      <D.27158>:
      __assert_fail ("0", "mini-x86.c", 4195, &__PRETTY_FUNCTION__);
      <D.27136>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4713 = (int) pos;
      disp = D.37252 - pos.4713;
      if (size != 0) goto <D.41912>; else goto <D.41913>;
      <D.41912>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41914 = disp + -4;
            imb.val = D.41914;
            pos.4714 = pos;
            pos = pos.4714 + 1;
            D.41916 = imb.b[0];
            *pos.4714 = D.41916;
            pos.4715 = pos;
            pos = pos.4715 + 1;
            D.41918 = imb.b[1];
            *pos.4715 = D.41918;
            pos.4716 = pos;
            pos = pos.4716 + 1;
            D.41920 = imb.b[2];
            *pos.4716 = D.41920;
            pos.4717 = pos;
            pos = pos.4717 + 1;
            D.41922 = imb.b[3];
            *pos.4717 = D.41922;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41923>;
      <D.41913>:
      disp.4718 = (unsigned int) disp;
      D.41925 = disp.4718 + 127;
      if (D.41925 <= 255) goto <D.41926>; else goto <D.41927>;
      <D.41926>:
      D.41928 = (unsigned char) disp;
      D.41929 = D.41928 + 255;
      *pos = D.41929;
      pos = pos + 1;
      goto <D.41930>;
      <D.41927>:
      __assert_fail ("0", "mini-x86.c", 4195, &__PRETTY_FUNCTION__);
      <D.41930>:
      <D.41923>:
    }
  }
  goto <D.41931>;
  <D.41877>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.41934>; else goto <D.41932>;
  <D.41934>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.41935>; else goto <D.41932>;
  <D.41935>:
  if (0 != 0) goto <D.41936>; else goto <D.41937>;
  <D.41936>:
  code.4719 = code;
  code = code.4719 + 1;
  D.40063 = 127;
  *code.4719 = D.40063;
  goto <D.41939>;
  <D.41937>:
  code.4720 = code;
  code = code.4720 + 1;
  D.40067 = 119;
  *code.4720 = D.40067;
  <D.41939>:
  *code = 0;
  code = code + 1;
  goto <D.41933>;
  <D.41932>:
  code.4721 = code;
  code = code.4721 + 1;
  *code.4721 = 15;
  if (0 != 0) goto <D.41942>; else goto <D.41943>;
  <D.41942>:
  code.4722 = code;
  code = code.4722 + 1;
  D.40063 = 127;
  D.41893 = D.40063 + 16;
  *code.4722 = D.41893;
  goto <D.41945>;
  <D.41943>:
  code.4723 = code;
  code = code.4723 + 1;
  D.40067 = 119;
  D.41896 = D.40067 + 16;
  *code.4723 = D.41896;
  <D.41945>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4724 = code;
        code = code.4724 + 1;
        D.41948 = imb.b[0];
        *code.4724 = D.41948;
        code.4725 = code;
        code = code.4725 + 1;
        D.41950 = imb.b[1];
        *code.4725 = D.41950;
        code.4726 = code;
        code = code.4726 + 1;
        D.41952 = imb.b[2];
        *code.4726 = D.41952;
        code.4727 = code;
        code = code.4727 + 1;
        D.41954 = imb.b[3];
        *code.4727 = D.41954;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41933>:
  <D.41931>:
  goto <D.24796>;
  <D.41875>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.41955>; else goto <D.41956>;
  <D.41955>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4728 = (unsigned int) offset;
    D.41958 = offset.4728 + 128;
    if (D.41958 <= 255) goto <D.41959>; else goto <D.41960>;
    <D.41959>:
    if (0 != 0) goto <D.41961>; else goto <D.41962>;
    <D.41961>:
    code.4729 = code;
    code = code.4729 + 1;
    D.34479 = 116;
    *code.4729 = D.34479;
    goto <D.41964>;
    <D.41962>:
    code.4730 = code;
    code = code.4730 + 1;
    D.34482 = 116;
    *code.4730 = D.34482;
    <D.41964>:
    D.41966 = (unsigned char) offset;
    *code = D.41966;
    code = code + 1;
    goto <D.41967>;
    <D.41960>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4731 = code;
    code = code.4731 + 1;
    *code.4731 = 15;
    if (0 != 0) goto <D.41969>; else goto <D.41970>;
    <D.41969>:
    code.4732 = code;
    code = code.4732 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.4732 = D.41341;
    goto <D.41972>;
    <D.41970>:
    code.4733 = code;
    code = code.4733 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.4733 = D.41344;
    <D.41972>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4734 = code;
          code = code.4734 + 1;
          D.41975 = imb.b[0];
          *code.4734 = D.41975;
          code.4735 = code;
          code = code.4735 + 1;
          D.41977 = imb.b[1];
          *code.4735 = D.41977;
          code.4736 = code;
          code = code.4736 + 1;
          D.41979 = imb.b[2];
          *code.4736 = D.41979;
          code.4737 = code;
          code = code.4737 + 1;
          D.41981 = imb.b[3];
          *code.4737 = D.41981;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41967>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.41982 = MEM[(unsigned char *)branch_start];
      D.41983 = (int) D.41982;
      switch (D.41983) <default: <D.27191>, case 15: <D.27170>, case 112: <D.27175>, case 113: <D.27176>, case 114: <D.27177>, case 115: <D.27178>, case 116: <D.27179>, case 117: <D.27180>, case 118: <D.27181>, case 119: <D.27182>, case 120: <D.27183>, case 121: <D.27184>, case 122: <D.27185>, case 123: <D.27186>, case 124: <D.27187>, case 125: <D.27188>, case 126: <D.27189>, case 127: <D.27190>, case 224: <D.27171>, case 225: <D.27172>, case 226: <D.27173>, case 232: <D.27167>, case 233: <D.27168>, case 235: <D.27174>>
      <D.27167>:
      <D.27168>:
      size = size + 1;
      goto <D.27169>;
      <D.27170>:
      D.41984 = *pos;
      D.41985 = D.41984 + 144;
      if (D.41985 > 31) goto <D.41986>; else goto <D.41987>;
      <D.41986>:
      __assert_fail ("0", "mini-x86.c", 4198, &__PRETTY_FUNCTION__);
      <D.41987>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27169>;
      <D.27171>:
      <D.27172>:
      <D.27173>:
      <D.27174>:
      <D.27175>:
      <D.27176>:
      <D.27177>:
      <D.27178>:
      <D.27179>:
      <D.27180>:
      <D.27181>:
      <D.27182>:
      <D.27183>:
      <D.27184>:
      <D.27185>:
      <D.27186>:
      <D.27187>:
      <D.27188>:
      <D.27189>:
      <D.27190>:
      goto <D.27169>;
      <D.27191>:
      __assert_fail ("0", "mini-x86.c", 4198, &__PRETTY_FUNCTION__);
      <D.27169>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4738 = (int) pos;
      disp = D.37252 - pos.4738;
      if (size != 0) goto <D.41989>; else goto <D.41990>;
      <D.41989>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41991 = disp + -4;
            imb.val = D.41991;
            pos.4739 = pos;
            pos = pos.4739 + 1;
            D.41993 = imb.b[0];
            *pos.4739 = D.41993;
            pos.4740 = pos;
            pos = pos.4740 + 1;
            D.41995 = imb.b[1];
            *pos.4740 = D.41995;
            pos.4741 = pos;
            pos = pos.4741 + 1;
            D.41997 = imb.b[2];
            *pos.4741 = D.41997;
            pos.4742 = pos;
            pos = pos.4742 + 1;
            D.41999 = imb.b[3];
            *pos.4742 = D.41999;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42000>;
      <D.41990>:
      disp.4743 = (unsigned int) disp;
      D.42002 = disp.4743 + 127;
      if (D.42002 <= 255) goto <D.42003>; else goto <D.42004>;
      <D.42003>:
      D.42005 = (unsigned char) disp;
      D.42006 = D.42005 + 255;
      *pos = D.42006;
      pos = pos + 1;
      goto <D.42007>;
      <D.42004>:
      __assert_fail ("0", "mini-x86.c", 4198, &__PRETTY_FUNCTION__);
      <D.42007>:
      <D.42000>:
    }
  }
  goto <D.42008>;
  <D.41956>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42011>; else goto <D.42009>;
  <D.42011>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42012>; else goto <D.42009>;
  <D.42012>:
  if (0 != 0) goto <D.42013>; else goto <D.42014>;
  <D.42013>:
  code.4744 = code;
  code = code.4744 + 1;
  D.34479 = 116;
  *code.4744 = D.34479;
  goto <D.42016>;
  <D.42014>:
  code.4745 = code;
  code = code.4745 + 1;
  D.34482 = 116;
  *code.4745 = D.34482;
  <D.42016>:
  *code = 0;
  code = code + 1;
  goto <D.42010>;
  <D.42009>:
  code.4746 = code;
  code = code.4746 + 1;
  *code.4746 = 15;
  if (0 != 0) goto <D.42019>; else goto <D.42020>;
  <D.42019>:
  code.4747 = code;
  code = code.4747 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.4747 = D.41341;
  goto <D.42022>;
  <D.42020>:
  code.4748 = code;
  code = code.4748 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.4748 = D.41344;
  <D.42022>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4749 = code;
        code = code.4749 + 1;
        D.42025 = imb.b[0];
        *code.4749 = D.42025;
        code.4750 = code;
        code = code.4750 + 1;
        D.42027 = imb.b[1];
        *code.4750 = D.42027;
        code.4751 = code;
        code = code.4751 + 1;
        D.42029 = imb.b[2];
        *code.4751 = D.42029;
        code.4752 = code;
        code = code.4752 + 1;
        D.42031 = imb.b[3];
        *code.4752 = D.42031;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42010>:
  <D.42008>:
  goto <D.24796>;
  <D.27194>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.42032>; else goto <D.42033>;
  <D.42032>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42034>; else goto <D.42035>;
  <D.42034>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4753 = (unsigned int) offset;
    D.42037 = offset.4753 + 128;
    if (D.42037 <= 255) goto <D.42038>; else goto <D.42039>;
    <D.42038>:
    if (0 != 0) goto <D.42040>; else goto <D.42041>;
    <D.42040>:
    code.4754 = code;
    code = code.4754 + 1;
    D.40234 = 122;
    *code.4754 = D.40234;
    goto <D.42043>;
    <D.42041>:
    code.4755 = code;
    code = code.4755 + 1;
    D.40237 = 122;
    *code.4755 = D.40237;
    <D.42043>:
    D.42045 = (unsigned char) offset;
    *code = D.42045;
    code = code + 1;
    goto <D.42046>;
    <D.42039>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4756 = code;
    code = code.4756 + 1;
    *code.4756 = 15;
    if (0 != 0) goto <D.42048>; else goto <D.42049>;
    <D.42048>:
    code.4757 = code;
    code = code.4757 + 1;
    D.40234 = 122;
    D.41630 = D.40234 + 16;
    *code.4757 = D.41630;
    goto <D.42051>;
    <D.42049>:
    code.4758 = code;
    code = code.4758 + 1;
    D.40237 = 122;
    D.41633 = D.40237 + 16;
    *code.4758 = D.41633;
    <D.42051>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4759 = code;
          code = code.4759 + 1;
          D.42054 = imb.b[0];
          *code.4759 = D.42054;
          code.4760 = code;
          code = code.4760 + 1;
          D.42056 = imb.b[1];
          *code.4760 = D.42056;
          code.4761 = code;
          code = code.4761 + 1;
          D.42058 = imb.b[2];
          *code.4761 = D.42058;
          code.4762 = code;
          code = code.4762 + 1;
          D.42060 = imb.b[3];
          *code.4762 = D.42060;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42046>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42061 = MEM[(unsigned char *)branch_start];
      D.42062 = (int) D.42061;
      switch (D.42062) <default: <D.27225>, case 15: <D.27204>, case 112: <D.27209>, case 113: <D.27210>, case 114: <D.27211>, case 115: <D.27212>, case 116: <D.27213>, case 117: <D.27214>, case 118: <D.27215>, case 119: <D.27216>, case 120: <D.27217>, case 121: <D.27218>, case 122: <D.27219>, case 123: <D.27220>, case 124: <D.27221>, case 125: <D.27222>, case 126: <D.27223>, case 127: <D.27224>, case 224: <D.27205>, case 225: <D.27206>, case 226: <D.27207>, case 232: <D.27201>, case 233: <D.27202>, case 235: <D.27208>>
      <D.27201>:
      <D.27202>:
      size = size + 1;
      goto <D.27203>;
      <D.27204>:
      D.42063 = *pos;
      D.42064 = D.42063 + 144;
      if (D.42064 > 31) goto <D.42065>; else goto <D.42066>;
      <D.42065>:
      __assert_fail ("0", "mini-x86.c", 4202, &__PRETTY_FUNCTION__);
      <D.42066>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27203>;
      <D.27205>:
      <D.27206>:
      <D.27207>:
      <D.27208>:
      <D.27209>:
      <D.27210>:
      <D.27211>:
      <D.27212>:
      <D.27213>:
      <D.27214>:
      <D.27215>:
      <D.27216>:
      <D.27217>:
      <D.27218>:
      <D.27219>:
      <D.27220>:
      <D.27221>:
      <D.27222>:
      <D.27223>:
      <D.27224>:
      goto <D.27203>;
      <D.27225>:
      __assert_fail ("0", "mini-x86.c", 4202, &__PRETTY_FUNCTION__);
      <D.27203>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4763 = (int) pos;
      disp = D.37252 - pos.4763;
      if (size != 0) goto <D.42068>; else goto <D.42069>;
      <D.42068>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42070 = disp + -4;
            imb.val = D.42070;
            pos.4764 = pos;
            pos = pos.4764 + 1;
            D.42072 = imb.b[0];
            *pos.4764 = D.42072;
            pos.4765 = pos;
            pos = pos.4765 + 1;
            D.42074 = imb.b[1];
            *pos.4765 = D.42074;
            pos.4766 = pos;
            pos = pos.4766 + 1;
            D.42076 = imb.b[2];
            *pos.4766 = D.42076;
            pos.4767 = pos;
            pos = pos.4767 + 1;
            D.42078 = imb.b[3];
            *pos.4767 = D.42078;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42079>;
      <D.42069>:
      disp.4768 = (unsigned int) disp;
      D.42081 = disp.4768 + 127;
      if (D.42081 <= 255) goto <D.42082>; else goto <D.42083>;
      <D.42082>:
      D.42084 = (unsigned char) disp;
      D.42085 = D.42084 + 255;
      *pos = D.42085;
      pos = pos + 1;
      goto <D.42086>;
      <D.42083>:
      __assert_fail ("0", "mini-x86.c", 4202, &__PRETTY_FUNCTION__);
      <D.42086>:
      <D.42079>:
    }
  }
  goto <D.42087>;
  <D.42035>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42090>; else goto <D.42088>;
  <D.42090>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42091>; else goto <D.42088>;
  <D.42091>:
  if (0 != 0) goto <D.42092>; else goto <D.42093>;
  <D.42092>:
  code.4769 = code;
  code = code.4769 + 1;
  D.40234 = 122;
  *code.4769 = D.40234;
  goto <D.42095>;
  <D.42093>:
  code.4770 = code;
  code = code.4770 + 1;
  D.40237 = 122;
  *code.4770 = D.40237;
  <D.42095>:
  *code = 0;
  code = code + 1;
  goto <D.42089>;
  <D.42088>:
  code.4771 = code;
  code = code.4771 + 1;
  *code.4771 = 15;
  if (0 != 0) goto <D.42098>; else goto <D.42099>;
  <D.42098>:
  code.4772 = code;
  code = code.4772 + 1;
  D.40234 = 122;
  D.41630 = D.40234 + 16;
  *code.4772 = D.41630;
  goto <D.42101>;
  <D.42099>:
  code.4773 = code;
  code = code.4773 + 1;
  D.40237 = 122;
  D.41633 = D.40237 + 16;
  *code.4773 = D.41633;
  <D.42101>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4774 = code;
        code = code.4774 + 1;
        D.42104 = imb.b[0];
        *code.4774 = D.42104;
        code.4775 = code;
        code = code.4775 + 1;
        D.42106 = imb.b[1];
        *code.4775 = D.42106;
        code.4776 = code;
        code = code.4776 + 1;
        D.42108 = imb.b[2];
        *code.4776 = D.42108;
        code.4777 = code;
        code = code.4777 + 1;
        D.42110 = imb.b[3];
        *code.4777 = D.42110;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42089>:
  <D.42087>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42111>; else goto <D.42112>;
  <D.42111>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4778 = (unsigned int) offset;
    D.42114 = offset.4778 + 128;
    if (D.42114 <= 255) goto <D.42115>; else goto <D.42116>;
    <D.42115>:
    if (0 != 0) goto <D.42117>; else goto <D.42118>;
    <D.42117>:
    code.4779 = code;
    code = code.4779 + 1;
    D.40063 = 127;
    *code.4779 = D.40063;
    goto <D.42120>;
    <D.42118>:
    code.4780 = code;
    code = code.4780 + 1;
    D.40067 = 119;
    *code.4780 = D.40067;
    <D.42120>:
    D.42122 = (unsigned char) offset;
    *code = D.42122;
    code = code + 1;
    goto <D.42123>;
    <D.42116>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4781 = code;
    code = code.4781 + 1;
    *code.4781 = 15;
    if (0 != 0) goto <D.42125>; else goto <D.42126>;
    <D.42125>:
    code.4782 = code;
    code = code.4782 + 1;
    D.40063 = 127;
    D.41893 = D.40063 + 16;
    *code.4782 = D.41893;
    goto <D.42128>;
    <D.42126>:
    code.4783 = code;
    code = code.4783 + 1;
    D.40067 = 119;
    D.41896 = D.40067 + 16;
    *code.4783 = D.41896;
    <D.42128>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4784 = code;
          code = code.4784 + 1;
          D.42131 = imb.b[0];
          *code.4784 = D.42131;
          code.4785 = code;
          code = code.4785 + 1;
          D.42133 = imb.b[1];
          *code.4785 = D.42133;
          code.4786 = code;
          code = code.4786 + 1;
          D.42135 = imb.b[2];
          *code.4786 = D.42135;
          code.4787 = code;
          code = code.4787 + 1;
          D.42137 = imb.b[3];
          *code.4787 = D.42137;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42123>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42138 = MEM[(unsigned char *)branch_start];
      D.42139 = (int) D.42138;
      switch (D.42139) <default: <D.27258>, case 15: <D.27237>, case 112: <D.27242>, case 113: <D.27243>, case 114: <D.27244>, case 115: <D.27245>, case 116: <D.27246>, case 117: <D.27247>, case 118: <D.27248>, case 119: <D.27249>, case 120: <D.27250>, case 121: <D.27251>, case 122: <D.27252>, case 123: <D.27253>, case 124: <D.27254>, case 125: <D.27255>, case 126: <D.27256>, case 127: <D.27257>, case 224: <D.27238>, case 225: <D.27239>, case 226: <D.27240>, case 232: <D.27234>, case 233: <D.27235>, case 235: <D.27241>>
      <D.27234>:
      <D.27235>:
      size = size + 1;
      goto <D.27236>;
      <D.27237>:
      D.42140 = *pos;
      D.42141 = D.42140 + 144;
      if (D.42141 > 31) goto <D.42142>; else goto <D.42143>;
      <D.42142>:
      __assert_fail ("0", "mini-x86.c", 4203, &__PRETTY_FUNCTION__);
      <D.42143>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27236>;
      <D.27238>:
      <D.27239>:
      <D.27240>:
      <D.27241>:
      <D.27242>:
      <D.27243>:
      <D.27244>:
      <D.27245>:
      <D.27246>:
      <D.27247>:
      <D.27248>:
      <D.27249>:
      <D.27250>:
      <D.27251>:
      <D.27252>:
      <D.27253>:
      <D.27254>:
      <D.27255>:
      <D.27256>:
      <D.27257>:
      goto <D.27236>;
      <D.27258>:
      __assert_fail ("0", "mini-x86.c", 4203, &__PRETTY_FUNCTION__);
      <D.27236>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4788 = (int) pos;
      disp = D.37252 - pos.4788;
      if (size != 0) goto <D.42145>; else goto <D.42146>;
      <D.42145>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42147 = disp + -4;
            imb.val = D.42147;
            pos.4789 = pos;
            pos = pos.4789 + 1;
            D.42149 = imb.b[0];
            *pos.4789 = D.42149;
            pos.4790 = pos;
            pos = pos.4790 + 1;
            D.42151 = imb.b[1];
            *pos.4790 = D.42151;
            pos.4791 = pos;
            pos = pos.4791 + 1;
            D.42153 = imb.b[2];
            *pos.4791 = D.42153;
            pos.4792 = pos;
            pos = pos.4792 + 1;
            D.42155 = imb.b[3];
            *pos.4792 = D.42155;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42156>;
      <D.42146>:
      disp.4793 = (unsigned int) disp;
      D.42158 = disp.4793 + 127;
      if (D.42158 <= 255) goto <D.42159>; else goto <D.42160>;
      <D.42159>:
      D.42161 = (unsigned char) disp;
      D.42162 = D.42161 + 255;
      *pos = D.42162;
      pos = pos + 1;
      goto <D.42163>;
      <D.42160>:
      __assert_fail ("0", "mini-x86.c", 4203, &__PRETTY_FUNCTION__);
      <D.42163>:
      <D.42156>:
    }
  }
  goto <D.42164>;
  <D.42112>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42167>; else goto <D.42165>;
  <D.42167>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42168>; else goto <D.42165>;
  <D.42168>:
  if (0 != 0) goto <D.42169>; else goto <D.42170>;
  <D.42169>:
  code.4794 = code;
  code = code.4794 + 1;
  D.40063 = 127;
  *code.4794 = D.40063;
  goto <D.42172>;
  <D.42170>:
  code.4795 = code;
  code = code.4795 + 1;
  D.40067 = 119;
  *code.4795 = D.40067;
  <D.42172>:
  *code = 0;
  code = code + 1;
  goto <D.42166>;
  <D.42165>:
  code.4796 = code;
  code = code.4796 + 1;
  *code.4796 = 15;
  if (0 != 0) goto <D.42175>; else goto <D.42176>;
  <D.42175>:
  code.4797 = code;
  code = code.4797 + 1;
  D.40063 = 127;
  D.41893 = D.40063 + 16;
  *code.4797 = D.41893;
  goto <D.42178>;
  <D.42176>:
  code.4798 = code;
  code = code.4798 + 1;
  D.40067 = 119;
  D.41896 = D.40067 + 16;
  *code.4798 = D.41896;
  <D.42178>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4799 = code;
        code = code.4799 + 1;
        D.42181 = imb.b[0];
        *code.4799 = D.42181;
        code.4800 = code;
        code = code.4800 + 1;
        D.42183 = imb.b[1];
        *code.4800 = D.42183;
        code.4801 = code;
        code = code.4801 + 1;
        D.42185 = imb.b[2];
        *code.4801 = D.42185;
        code.4802 = code;
        code = code.4802 + 1;
        D.42187 = imb.b[3];
        *code.4802 = D.42187;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42166>:
  <D.42164>:
  goto <D.24796>;
  <D.42033>:
  D.31501 = ins->opcode;
  if (D.31501 == 671) goto <D.42188>; else goto <D.42189>;
  <D.42188>:
  {
    guchar * is_not_zero_check;
    guchar * end_jump;

    is_not_zero_check = code;
    if (1 != 0) goto <D.42190>; else goto <D.42191>;
    <D.42190>:
    code.4803 = code;
    code = code.4803 + 1;
    D.39804 = 117;
    *code.4803 = D.39804;
    goto <D.42193>;
    <D.42191>:
    code.4804 = code;
    code = code.4804 + 1;
    D.39807 = 117;
    *code.4804 = D.39807;
    <D.42193>:
    *code = 0;
    code = code + 1;
    end_jump = code;
    code.4805 = code;
    code = code.4805 + 1;
    *code.4805 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = is_not_zero_check + 1;
      size = 0;
      D.42196 = MEM[(unsigned char *)is_not_zero_check];
      D.42197 = (int) D.42196;
      switch (D.42197) <default: <D.27290>, case 15: <D.27269>, case 112: <D.27274>, case 113: <D.27275>, case 114: <D.27276>, case 115: <D.27277>, case 116: <D.27278>, case 117: <D.27279>, case 118: <D.27280>, case 119: <D.27281>, case 120: <D.27282>, case 121: <D.27283>, case 122: <D.27284>, case 123: <D.27285>, case 124: <D.27286>, case 125: <D.27287>, case 126: <D.27288>, case 127: <D.27289>, case 224: <D.27270>, case 225: <D.27271>, case 226: <D.27272>, case 232: <D.27266>, case 233: <D.27267>, case 235: <D.27273>>
      <D.27266>:
      <D.27267>:
      size = size + 1;
      goto <D.27268>;
      <D.27269>:
      D.42198 = *pos;
      D.42199 = D.42198 + 144;
      if (D.42199 > 31) goto <D.42200>; else goto <D.42201>;
      <D.42200>:
      __assert_fail ("0", "mini-x86.c", 4212, &__PRETTY_FUNCTION__);
      <D.42201>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27268>;
      <D.27270>:
      <D.27271>:
      <D.27272>:
      <D.27273>:
      <D.27274>:
      <D.27275>:
      <D.27276>:
      <D.27277>:
      <D.27278>:
      <D.27279>:
      <D.27280>:
      <D.27281>:
      <D.27282>:
      <D.27283>:
      <D.27284>:
      <D.27285>:
      <D.27286>:
      <D.27287>:
      <D.27288>:
      <D.27289>:
      goto <D.27268>;
      <D.27290>:
      __assert_fail ("0", "mini-x86.c", 4212, &__PRETTY_FUNCTION__);
      <D.27268>:
      code.422 = (int) code;
      pos.4806 = (int) pos;
      disp = code.422 - pos.4806;
      if (size != 0) goto <D.42203>; else goto <D.42204>;
      <D.42203>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42205 = disp + -4;
            imb.val = D.42205;
            pos.4807 = pos;
            pos = pos.4807 + 1;
            D.42207 = imb.b[0];
            *pos.4807 = D.42207;
            pos.4808 = pos;
            pos = pos.4808 + 1;
            D.42209 = imb.b[1];
            *pos.4808 = D.42209;
            pos.4809 = pos;
            pos = pos.4809 + 1;
            D.42211 = imb.b[2];
            *pos.4809 = D.42211;
            pos.4810 = pos;
            pos = pos.4810 + 1;
            D.42213 = imb.b[3];
            *pos.4810 = D.42213;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42214>;
      <D.42204>:
      disp.4811 = (unsigned int) disp;
      D.42216 = disp.4811 + 127;
      if (D.42216 <= 255) goto <D.42217>; else goto <D.42218>;
      <D.42217>:
      D.42219 = (unsigned char) disp;
      D.42220 = D.42219 + 255;
      *pos = D.42220;
      pos = pos + 1;
      goto <D.42221>;
      <D.42218>:
      __assert_fail ("0", "mini-x86.c", 4212, &__PRETTY_FUNCTION__);
      <D.42221>:
      <D.42214>:
    }
    if (1 != 0) goto <D.42222>; else goto <D.42223>;
    <D.42222>:
    code.4812 = code;
    code = code.4812 + 1;
    *code.4812 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4813 = code;
          code = code.4813 + 1;
          D.42226 = imb.b[0];
          *code.4813 = D.42226;
          code.4814 = code;
          code = code.4814 + 1;
          D.42228 = imb.b[1];
          *code.4814 = D.42228;
          code.4815 = code;
          code = code.4815 + 1;
          D.42230 = imb.b[2];
          *code.4815 = D.42230;
          code.4816 = code;
          code = code.4816 + 1;
          D.42232 = imb.b[3];
          *code.4816 = D.42232;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.27293>;
    <D.42223>:
    if (0 != 0) goto <D.42233>; else goto <D.42234>;
    <D.42233>:
    code.4817 = code;
    code = code.4817 + 1;
    *code.4817 = 131;
    code.4818 = code;
    code = code.4818 + 1;
    *code.4818 = 248;
    *code = 0;
    code = code + 1;
    goto <D.42237>;
    <D.42234>:
    code.4819 = code;
    code = code.4819 + 1;
    *code.4819 = 129;
    code.4820 = code;
    code = code.4820 + 1;
    *code.4820 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4821 = code;
          code = code.4821 + 1;
          D.42241 = imb.b[0];
          *code.4821 = D.42241;
          code.4822 = code;
          code = code.4822 + 1;
          D.42243 = imb.b[1];
          *code.4822 = D.42243;
          code.4823 = code;
          code = code.4823 + 1;
          D.42245 = imb.b[2];
          *code.4823 = D.42245;
          code.4824 = code;
          code = code.4824 + 1;
          D.42247 = imb.b[3];
          *code.4824 = D.42247;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42237>:
    <D.27293>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = end_jump + 1;
      size = 0;
      D.42248 = MEM[(unsigned char *)end_jump];
      D.42249 = (int) D.42248;
      switch (D.42249) <default: <D.27322>, case 15: <D.27301>, case 112: <D.27306>, case 113: <D.27307>, case 114: <D.27308>, case 115: <D.27309>, case 116: <D.27310>, case 117: <D.27311>, case 118: <D.27312>, case 119: <D.27313>, case 120: <D.27314>, case 121: <D.27315>, case 122: <D.27316>, case 123: <D.27317>, case 124: <D.27318>, case 125: <D.27319>, case 126: <D.27320>, case 127: <D.27321>, case 224: <D.27302>, case 225: <D.27303>, case 226: <D.27304>, case 232: <D.27298>, case 233: <D.27299>, case 235: <D.27305>>
      <D.27298>:
      <D.27299>:
      size = size + 1;
      goto <D.27300>;
      <D.27301>:
      D.42250 = *pos;
      D.42251 = D.42250 + 144;
      if (D.42251 > 31) goto <D.42252>; else goto <D.42253>;
      <D.42252>:
      __assert_fail ("0", "mini-x86.c", 4215, &__PRETTY_FUNCTION__);
      <D.42253>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27300>;
      <D.27302>:
      <D.27303>:
      <D.27304>:
      <D.27305>:
      <D.27306>:
      <D.27307>:
      <D.27308>:
      <D.27309>:
      <D.27310>:
      <D.27311>:
      <D.27312>:
      <D.27313>:
      <D.27314>:
      <D.27315>:
      <D.27316>:
      <D.27317>:
      <D.27318>:
      <D.27319>:
      <D.27320>:
      <D.27321>:
      goto <D.27300>;
      <D.27322>:
      __assert_fail ("0", "mini-x86.c", 4215, &__PRETTY_FUNCTION__);
      <D.27300>:
      code.422 = (int) code;
      pos.4825 = (int) pos;
      disp = code.422 - pos.4825;
      if (size != 0) goto <D.42255>; else goto <D.42256>;
      <D.42255>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42257 = disp + -4;
            imb.val = D.42257;
            pos.4826 = pos;
            pos = pos.4826 + 1;
            D.42259 = imb.b[0];
            *pos.4826 = D.42259;
            pos.4827 = pos;
            pos = pos.4827 + 1;
            D.42261 = imb.b[1];
            *pos.4827 = D.42261;
            pos.4828 = pos;
            pos = pos.4828 + 1;
            D.42263 = imb.b[2];
            *pos.4828 = D.42263;
            pos.4829 = pos;
            pos = pos.4829 + 1;
            D.42265 = imb.b[3];
            *pos.4829 = D.42265;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42266>;
      <D.42256>:
      disp.4830 = (unsigned int) disp;
      D.42268 = disp.4830 + 127;
      if (D.42268 <= 255) goto <D.42269>; else goto <D.42270>;
      <D.42269>:
      D.42271 = (unsigned char) disp;
      D.42272 = D.42271 + 255;
      *pos = D.42272;
      pos = pos + 1;
      goto <D.42273>;
      <D.42270>:
      __assert_fail ("0", "mini-x86.c", 4215, &__PRETTY_FUNCTION__);
      <D.42273>:
      <D.42266>:
    }
  }
  <D.42189>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42274>; else goto <D.42275>;
  <D.42274>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4831 = (unsigned int) offset;
    D.42277 = offset.4831 + 128;
    if (D.42277 <= 255) goto <D.42278>; else goto <D.42279>;
    <D.42278>:
    if (0 != 0) goto <D.42280>; else goto <D.42281>;
    <D.42280>:
    code.4832 = code;
    code = code.4832 + 1;
    D.34479 = 116;
    *code.4832 = D.34479;
    goto <D.42283>;
    <D.42281>:
    code.4833 = code;
    code = code.4833 + 1;
    D.34482 = 116;
    *code.4833 = D.34482;
    <D.42283>:
    D.42285 = (unsigned char) offset;
    *code = D.42285;
    code = code + 1;
    goto <D.42286>;
    <D.42279>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4834 = code;
    code = code.4834 + 1;
    *code.4834 = 15;
    if (0 != 0) goto <D.42288>; else goto <D.42289>;
    <D.42288>:
    code.4835 = code;
    code = code.4835 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.4835 = D.41341;
    goto <D.42291>;
    <D.42289>:
    code.4836 = code;
    code = code.4836 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.4836 = D.41344;
    <D.42291>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4837 = code;
          code = code.4837 + 1;
          D.42294 = imb.b[0];
          *code.4837 = D.42294;
          code.4838 = code;
          code = code.4838 + 1;
          D.42296 = imb.b[1];
          *code.4838 = D.42296;
          code.4839 = code;
          code = code.4839 + 1;
          D.42298 = imb.b[2];
          *code.4839 = D.42298;
          code.4840 = code;
          code = code.4840 + 1;
          D.42300 = imb.b[3];
          *code.4840 = D.42300;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42286>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42301 = MEM[(unsigned char *)branch_start];
      D.42302 = (int) D.42301;
      switch (D.42302) <default: <D.27354>, case 15: <D.27333>, case 112: <D.27338>, case 113: <D.27339>, case 114: <D.27340>, case 115: <D.27341>, case 116: <D.27342>, case 117: <D.27343>, case 118: <D.27344>, case 119: <D.27345>, case 120: <D.27346>, case 121: <D.27347>, case 122: <D.27348>, case 123: <D.27349>, case 124: <D.27350>, case 125: <D.27351>, case 126: <D.27352>, case 127: <D.27353>, case 224: <D.27334>, case 225: <D.27335>, case 226: <D.27336>, case 232: <D.27330>, case 233: <D.27331>, case 235: <D.27337>>
      <D.27330>:
      <D.27331>:
      size = size + 1;
      goto <D.27332>;
      <D.27333>:
      D.42303 = *pos;
      D.42304 = D.42303 + 144;
      if (D.42304 > 31) goto <D.42305>; else goto <D.42306>;
      <D.42305>:
      __assert_fail ("0", "mini-x86.c", 4217, &__PRETTY_FUNCTION__);
      <D.42306>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27332>;
      <D.27334>:
      <D.27335>:
      <D.27336>:
      <D.27337>:
      <D.27338>:
      <D.27339>:
      <D.27340>:
      <D.27341>:
      <D.27342>:
      <D.27343>:
      <D.27344>:
      <D.27345>:
      <D.27346>:
      <D.27347>:
      <D.27348>:
      <D.27349>:
      <D.27350>:
      <D.27351>:
      <D.27352>:
      <D.27353>:
      goto <D.27332>;
      <D.27354>:
      __assert_fail ("0", "mini-x86.c", 4217, &__PRETTY_FUNCTION__);
      <D.27332>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4841 = (int) pos;
      disp = D.37252 - pos.4841;
      if (size != 0) goto <D.42308>; else goto <D.42309>;
      <D.42308>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42310 = disp + -4;
            imb.val = D.42310;
            pos.4842 = pos;
            pos = pos.4842 + 1;
            D.42312 = imb.b[0];
            *pos.4842 = D.42312;
            pos.4843 = pos;
            pos = pos.4843 + 1;
            D.42314 = imb.b[1];
            *pos.4843 = D.42314;
            pos.4844 = pos;
            pos = pos.4844 + 1;
            D.42316 = imb.b[2];
            *pos.4844 = D.42316;
            pos.4845 = pos;
            pos = pos.4845 + 1;
            D.42318 = imb.b[3];
            *pos.4845 = D.42318;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42319>;
      <D.42309>:
      disp.4846 = (unsigned int) disp;
      D.42321 = disp.4846 + 127;
      if (D.42321 <= 255) goto <D.42322>; else goto <D.42323>;
      <D.42322>:
      D.42324 = (unsigned char) disp;
      D.42325 = D.42324 + 255;
      *pos = D.42325;
      pos = pos + 1;
      goto <D.42326>;
      <D.42323>:
      __assert_fail ("0", "mini-x86.c", 4217, &__PRETTY_FUNCTION__);
      <D.42326>:
      <D.42319>:
    }
  }
  goto <D.42327>;
  <D.42275>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42330>; else goto <D.42328>;
  <D.42330>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42331>; else goto <D.42328>;
  <D.42331>:
  if (0 != 0) goto <D.42332>; else goto <D.42333>;
  <D.42332>:
  code.4847 = code;
  code = code.4847 + 1;
  D.34479 = 116;
  *code.4847 = D.34479;
  goto <D.42335>;
  <D.42333>:
  code.4848 = code;
  code = code.4848 + 1;
  D.34482 = 116;
  *code.4848 = D.34482;
  <D.42335>:
  *code = 0;
  code = code + 1;
  goto <D.42329>;
  <D.42328>:
  code.4849 = code;
  code = code.4849 + 1;
  *code.4849 = 15;
  if (0 != 0) goto <D.42338>; else goto <D.42339>;
  <D.42338>:
  code.4850 = code;
  code = code.4850 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.4850 = D.41341;
  goto <D.42341>;
  <D.42339>:
  code.4851 = code;
  code = code.4851 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.4851 = D.41344;
  <D.42341>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4852 = code;
        code = code.4852 + 1;
        D.42344 = imb.b[0];
        *code.4852 = D.42344;
        code.4853 = code;
        code = code.4853 + 1;
        D.42346 = imb.b[1];
        *code.4853 = D.42346;
        code.4854 = code;
        code = code.4854 + 1;
        D.42348 = imb.b[2];
        *code.4854 = D.42348;
        code.4855 = code;
        code = code.4855 + 1;
        D.42350 = imb.b[3];
        *code.4855 = D.42350;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42329>:
  <D.42327>:
  goto <D.24796>;
  <D.27357>:
  <D.27358>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.42351>; else goto <D.42352>;
  <D.42351>:
  D.31501 = ins->opcode;
  if (D.31501 == 664) goto <D.42353>; else goto <D.42354>;
  <D.42353>:
  {
    guchar * br1;

    br1 = code;
    if (0 != 0) goto <D.42355>; else goto <D.42356>;
    <D.42355>:
    code.4856 = code;
    code = code.4856 + 1;
    D.40234 = 122;
    *code.4856 = D.40234;
    goto <D.42358>;
    <D.42356>:
    code.4857 = code;
    code = code.4857 + 1;
    D.40237 = 122;
    *code.4857 = D.40237;
    <D.42358>:
    *code = 0;
    code = code + 1;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    if (D.37247 != 0) goto <D.42360>; else goto <D.42361>;
    <D.42360>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -2;
      branch_start = code;
      offset.4858 = (unsigned int) offset;
      D.42363 = offset.4858 + 128;
      if (D.42363 <= 255) goto <D.42364>; else goto <D.42365>;
      <D.42364>:
      if (0 != 0) goto <D.42366>; else goto <D.42367>;
      <D.42366>:
      code.4859 = code;
      code = code.4859 + 1;
      D.39678 = 124;
      *code.4859 = D.39678;
      goto <D.42369>;
      <D.42367>:
      code.4860 = code;
      code = code.4860 + 1;
      D.39681 = 114;
      *code.4860 = D.39681;
      <D.42369>:
      D.42371 = (unsigned char) offset;
      *code = D.42371;
      code = code + 1;
      goto <D.42372>;
      <D.42365>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -6;
      code.4861 = code;
      code = code.4861 + 1;
      *code.4861 = 15;
      if (0 != 0) goto <D.42374>; else goto <D.42375>;
      <D.42374>:
      code.4862 = code;
      code = code.4862 + 1;
      D.39678 = 124;
      D.41709 = D.39678 + 16;
      *code.4862 = D.41709;
      goto <D.42377>;
      <D.42375>:
      code.4863 = code;
      code = code.4863 + 1;
      D.39681 = 114;
      D.41712 = D.39681 + 16;
      *code.4863 = D.41712;
      <D.42377>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.4864 = code;
            code = code.4864 + 1;
            D.42380 = imb.b[0];
            *code.4864 = D.42380;
            code.4865 = code;
            code = code.4865 + 1;
            D.42382 = imb.b[1];
            *code.4865 = D.42382;
            code.4866 = code;
            code = code.4866 + 1;
            D.42384 = imb.b[2];
            *code.4866 = D.42384;
            code.4867 = code;
            code = code.4867 + 1;
            D.42386 = imb.b[3];
            *code.4867 = D.42386;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.42372>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.42387 = MEM[(unsigned char *)branch_start];
        D.42388 = (int) D.42387;
        switch (D.42388) <default: <D.27390>, case 15: <D.27369>, case 112: <D.27374>, case 113: <D.27375>, case 114: <D.27376>, case 115: <D.27377>, case 116: <D.27378>, case 117: <D.27379>, case 118: <D.27380>, case 119: <D.27381>, case 120: <D.27382>, case 121: <D.27383>, case 122: <D.27384>, case 123: <D.27385>, case 124: <D.27386>, case 125: <D.27387>, case 126: <D.27388>, case 127: <D.27389>, case 224: <D.27370>, case 225: <D.27371>, case 226: <D.27372>, case 232: <D.27366>, case 233: <D.27367>, case 235: <D.27373>>
        <D.27366>:
        <D.27367>:
        size = size + 1;
        goto <D.27368>;
        <D.27369>:
        D.42389 = *pos;
        D.42390 = D.42389 + 144;
        if (D.42390 > 31) goto <D.42391>; else goto <D.42392>;
        <D.42391>:
        __assert_fail ("0", "mini-x86.c", 4229, &__PRETTY_FUNCTION__);
        <D.42392>:
        size = size + 1;
        pos = pos + 1;
        goto <D.27368>;
        <D.27370>:
        <D.27371>:
        <D.27372>:
        <D.27373>:
        <D.27374>:
        <D.27375>:
        <D.27376>:
        <D.27377>:
        <D.27378>:
        <D.27379>:
        <D.27380>:
        <D.27381>:
        <D.27382>:
        <D.27383>:
        <D.27384>:
        <D.27385>:
        <D.27386>:
        <D.27387>:
        <D.27388>:
        <D.27389>:
        goto <D.27368>;
        <D.27390>:
        __assert_fail ("0", "mini-x86.c", 4229, &__PRETTY_FUNCTION__);
        <D.27368>:
        D.31409 = cfg->native_code;
        D.37245 = ins->data.op[1].many_blocks;
        D.37246 = *D.37245;
        D.37247 = D.37246->native_offset;
        D.37250 = (sizetype) D.37247;
        D.37251 = D.31409 + D.37250;
        D.37252 = (int) D.37251;
        pos.4868 = (int) pos;
        disp = D.37252 - pos.4868;
        if (size != 0) goto <D.42394>; else goto <D.42395>;
        <D.42394>:
        {
          union x86_imm_buf imb;

          try
            {
              D.42396 = disp + -4;
              imb.val = D.42396;
              pos.4869 = pos;
              pos = pos.4869 + 1;
              D.42398 = imb.b[0];
              *pos.4869 = D.42398;
              pos.4870 = pos;
              pos = pos.4870 + 1;
              D.42400 = imb.b[1];
              *pos.4870 = D.42400;
              pos.4871 = pos;
              pos = pos.4871 + 1;
              D.42402 = imb.b[2];
              *pos.4871 = D.42402;
              pos.4872 = pos;
              pos = pos.4872 + 1;
              D.42404 = imb.b[3];
              *pos.4872 = D.42404;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.42405>;
        <D.42395>:
        disp.4873 = (unsigned int) disp;
        D.42407 = disp.4873 + 127;
        if (D.42407 <= 255) goto <D.42408>; else goto <D.42409>;
        <D.42408>:
        D.42410 = (unsigned char) disp;
        D.42411 = D.42410 + 255;
        *pos = D.42411;
        pos = pos + 1;
        goto <D.42412>;
        <D.42409>:
        __assert_fail ("0", "mini-x86.c", 4229, &__PRETTY_FUNCTION__);
        <D.42412>:
        <D.42405>:
      }
    }
    goto <D.42413>;
    <D.42361>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.37246);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.42416>; else goto <D.42414>;
    <D.42416>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37327 = D.37246->max_offset;
    D.37328 = D.37327 - cpos;
    D.37329 = (unsigned int) D.37328;
    D.37330 = D.37329 + 128;
    if (D.37330 <= 255) goto <D.42417>; else goto <D.42414>;
    <D.42417>:
    if (0 != 0) goto <D.42418>; else goto <D.42419>;
    <D.42418>:
    code.4874 = code;
    code = code.4874 + 1;
    D.39678 = 124;
    *code.4874 = D.39678;
    goto <D.42421>;
    <D.42419>:
    code.4875 = code;
    code = code.4875 + 1;
    D.39681 = 114;
    *code.4875 = D.39681;
    <D.42421>:
    *code = 0;
    code = code + 1;
    goto <D.42415>;
    <D.42414>:
    code.4876 = code;
    code = code.4876 + 1;
    *code.4876 = 15;
    if (0 != 0) goto <D.42424>; else goto <D.42425>;
    <D.42424>:
    code.4877 = code;
    code = code.4877 + 1;
    D.39678 = 124;
    D.41709 = D.39678 + 16;
    *code.4877 = D.41709;
    goto <D.42427>;
    <D.42425>:
    code.4878 = code;
    code = code.4878 + 1;
    D.39681 = 114;
    D.41712 = D.39681 + 16;
    *code.4878 = D.41712;
    <D.42427>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4879 = code;
          code = code.4879 + 1;
          D.42430 = imb.b[0];
          *code.4879 = D.42430;
          code.4880 = code;
          code = code.4880 + 1;
          D.42432 = imb.b[1];
          *code.4880 = D.42432;
          code.4881 = code;
          code = code.4881 + 1;
          D.42434 = imb.b[2];
          *code.4881 = D.42434;
          code.4882 = code;
          code = code.4882 + 1;
          D.42436 = imb.b[3];
          *code.4882 = D.42436;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42415>:
    <D.42413>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = br1 + 1;
      size = 0;
      D.42437 = MEM[(unsigned char *)br1];
      D.42438 = (int) D.42437;
      switch (D.42438) <default: <D.27420>, case 15: <D.27399>, case 112: <D.27404>, case 113: <D.27405>, case 114: <D.27406>, case 115: <D.27407>, case 116: <D.27408>, case 117: <D.27409>, case 118: <D.27410>, case 119: <D.27411>, case 120: <D.27412>, case 121: <D.27413>, case 122: <D.27414>, case 123: <D.27415>, case 124: <D.27416>, case 125: <D.27417>, case 126: <D.27418>, case 127: <D.27419>, case 224: <D.27400>, case 225: <D.27401>, case 226: <D.27402>, case 232: <D.27396>, case 233: <D.27397>, case 235: <D.27403>>
      <D.27396>:
      <D.27397>:
      size = size + 1;
      goto <D.27398>;
      <D.27399>:
      D.42439 = *pos;
      D.42440 = D.42439 + 144;
      if (D.42440 > 31) goto <D.42441>; else goto <D.42442>;
      <D.42441>:
      __assert_fail ("0", "mini-x86.c", 4230, &__PRETTY_FUNCTION__);
      <D.42442>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27398>;
      <D.27400>:
      <D.27401>:
      <D.27402>:
      <D.27403>:
      <D.27404>:
      <D.27405>:
      <D.27406>:
      <D.27407>:
      <D.27408>:
      <D.27409>:
      <D.27410>:
      <D.27411>:
      <D.27412>:
      <D.27413>:
      <D.27414>:
      <D.27415>:
      <D.27416>:
      <D.27417>:
      <D.27418>:
      <D.27419>:
      goto <D.27398>;
      <D.27420>:
      __assert_fail ("0", "mini-x86.c", 4230, &__PRETTY_FUNCTION__);
      <D.27398>:
      code.422 = (int) code;
      pos.4883 = (int) pos;
      disp = code.422 - pos.4883;
      if (size != 0) goto <D.42444>; else goto <D.42445>;
      <D.42444>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42446 = disp + -4;
            imb.val = D.42446;
            pos.4884 = pos;
            pos = pos.4884 + 1;
            D.42448 = imb.b[0];
            *pos.4884 = D.42448;
            pos.4885 = pos;
            pos = pos.4885 + 1;
            D.42450 = imb.b[1];
            *pos.4885 = D.42450;
            pos.4886 = pos;
            pos = pos.4886 + 1;
            D.42452 = imb.b[2];
            *pos.4886 = D.42452;
            pos.4887 = pos;
            pos = pos.4887 + 1;
            D.42454 = imb.b[3];
            *pos.4887 = D.42454;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42455>;
      <D.42445>:
      disp.4888 = (unsigned int) disp;
      D.42457 = disp.4888 + 127;
      if (D.42457 <= 255) goto <D.42458>; else goto <D.42459>;
      <D.42458>:
      D.42460 = (unsigned char) disp;
      D.42461 = D.42460 + 255;
      *pos = D.42461;
      pos = pos + 1;
      goto <D.42462>;
      <D.42459>:
      __assert_fail ("0", "mini-x86.c", 4230, &__PRETTY_FUNCTION__);
      <D.42462>:
      <D.42455>:
    }
  }
  goto <D.42463>;
  <D.42354>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42464>; else goto <D.42465>;
  <D.42464>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4889 = (unsigned int) offset;
    D.42467 = offset.4889 + 128;
    if (D.42467 <= 255) goto <D.42468>; else goto <D.42469>;
    <D.42468>:
    if (0 != 0) goto <D.42470>; else goto <D.42471>;
    <D.42470>:
    code.4890 = code;
    code = code.4890 + 1;
    D.39678 = 124;
    *code.4890 = D.39678;
    goto <D.42473>;
    <D.42471>:
    code.4891 = code;
    code = code.4891 + 1;
    D.39681 = 114;
    *code.4891 = D.39681;
    <D.42473>:
    D.42475 = (unsigned char) offset;
    *code = D.42475;
    code = code + 1;
    goto <D.42476>;
    <D.42469>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4892 = code;
    code = code.4892 + 1;
    *code.4892 = 15;
    if (0 != 0) goto <D.42478>; else goto <D.42479>;
    <D.42478>:
    code.4893 = code;
    code = code.4893 + 1;
    D.39678 = 124;
    D.41709 = D.39678 + 16;
    *code.4893 = D.41709;
    goto <D.42481>;
    <D.42479>:
    code.4894 = code;
    code = code.4894 + 1;
    D.39681 = 114;
    D.41712 = D.39681 + 16;
    *code.4894 = D.41712;
    <D.42481>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4895 = code;
          code = code.4895 + 1;
          D.42484 = imb.b[0];
          *code.4895 = D.42484;
          code.4896 = code;
          code = code.4896 + 1;
          D.42486 = imb.b[1];
          *code.4896 = D.42486;
          code.4897 = code;
          code = code.4897 + 1;
          D.42488 = imb.b[2];
          *code.4897 = D.42488;
          code.4898 = code;
          code = code.4898 + 1;
          D.42490 = imb.b[3];
          *code.4898 = D.42490;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42476>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42491 = MEM[(unsigned char *)branch_start];
      D.42492 = (int) D.42491;
      switch (D.42492) <default: <D.27452>, case 15: <D.27431>, case 112: <D.27436>, case 113: <D.27437>, case 114: <D.27438>, case 115: <D.27439>, case 116: <D.27440>, case 117: <D.27441>, case 118: <D.27442>, case 119: <D.27443>, case 120: <D.27444>, case 121: <D.27445>, case 122: <D.27446>, case 123: <D.27447>, case 124: <D.27448>, case 125: <D.27449>, case 126: <D.27450>, case 127: <D.27451>, case 224: <D.27432>, case 225: <D.27433>, case 226: <D.27434>, case 232: <D.27428>, case 233: <D.27429>, case 235: <D.27435>>
      <D.27428>:
      <D.27429>:
      size = size + 1;
      goto <D.27430>;
      <D.27431>:
      D.42493 = *pos;
      D.42494 = D.42493 + 144;
      if (D.42494 > 31) goto <D.42495>; else goto <D.42496>;
      <D.42495>:
      __assert_fail ("0", "mini-x86.c", 4232, &__PRETTY_FUNCTION__);
      <D.42496>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27430>;
      <D.27432>:
      <D.27433>:
      <D.27434>:
      <D.27435>:
      <D.27436>:
      <D.27437>:
      <D.27438>:
      <D.27439>:
      <D.27440>:
      <D.27441>:
      <D.27442>:
      <D.27443>:
      <D.27444>:
      <D.27445>:
      <D.27446>:
      <D.27447>:
      <D.27448>:
      <D.27449>:
      <D.27450>:
      <D.27451>:
      goto <D.27430>;
      <D.27452>:
      __assert_fail ("0", "mini-x86.c", 4232, &__PRETTY_FUNCTION__);
      <D.27430>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4899 = (int) pos;
      disp = D.37252 - pos.4899;
      if (size != 0) goto <D.42498>; else goto <D.42499>;
      <D.42498>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42500 = disp + -4;
            imb.val = D.42500;
            pos.4900 = pos;
            pos = pos.4900 + 1;
            D.42502 = imb.b[0];
            *pos.4900 = D.42502;
            pos.4901 = pos;
            pos = pos.4901 + 1;
            D.42504 = imb.b[1];
            *pos.4901 = D.42504;
            pos.4902 = pos;
            pos = pos.4902 + 1;
            D.42506 = imb.b[2];
            *pos.4902 = D.42506;
            pos.4903 = pos;
            pos = pos.4903 + 1;
            D.42508 = imb.b[3];
            *pos.4903 = D.42508;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42509>;
      <D.42499>:
      disp.4904 = (unsigned int) disp;
      D.42511 = disp.4904 + 127;
      if (D.42511 <= 255) goto <D.42512>; else goto <D.42513>;
      <D.42512>:
      D.42514 = (unsigned char) disp;
      D.42515 = D.42514 + 255;
      *pos = D.42515;
      pos = pos + 1;
      goto <D.42516>;
      <D.42513>:
      __assert_fail ("0", "mini-x86.c", 4232, &__PRETTY_FUNCTION__);
      <D.42516>:
      <D.42509>:
    }
  }
  goto <D.42517>;
  <D.42465>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42520>; else goto <D.42518>;
  <D.42520>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42521>; else goto <D.42518>;
  <D.42521>:
  if (0 != 0) goto <D.42522>; else goto <D.42523>;
  <D.42522>:
  code.4905 = code;
  code = code.4905 + 1;
  D.39678 = 124;
  *code.4905 = D.39678;
  goto <D.42525>;
  <D.42523>:
  code.4906 = code;
  code = code.4906 + 1;
  D.39681 = 114;
  *code.4906 = D.39681;
  <D.42525>:
  *code = 0;
  code = code + 1;
  goto <D.42519>;
  <D.42518>:
  code.4907 = code;
  code = code.4907 + 1;
  *code.4907 = 15;
  if (0 != 0) goto <D.42528>; else goto <D.42529>;
  <D.42528>:
  code.4908 = code;
  code = code.4908 + 1;
  D.39678 = 124;
  D.41709 = D.39678 + 16;
  *code.4908 = D.41709;
  goto <D.42531>;
  <D.42529>:
  code.4909 = code;
  code = code.4909 + 1;
  D.39681 = 114;
  D.41712 = D.39681 + 16;
  *code.4909 = D.41712;
  <D.42531>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4910 = code;
        code = code.4910 + 1;
        D.42534 = imb.b[0];
        *code.4910 = D.42534;
        code.4911 = code;
        code = code.4911 + 1;
        D.42536 = imb.b[1];
        *code.4911 = D.42536;
        code.4912 = code;
        code = code.4912 + 1;
        D.42538 = imb.b[2];
        *code.4912 = D.42538;
        code.4913 = code;
        code = code.4913 + 1;
        D.42540 = imb.b[3];
        *code.4913 = D.42540;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42519>:
  <D.42517>:
  <D.42463>:
  goto <D.24796>;
  <D.42352>:
  if (1 != 0) goto <D.42541>; else goto <D.42542>;
  <D.42541>:
  code.4914 = code;
  code = code.4914 + 1;
  *code.4914 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.4915 = code;
        code = code.4915 + 1;
        D.42545 = imb.b[0];
        *code.4915 = D.42545;
        code.4916 = code;
        code = code.4916 + 1;
        D.42547 = imb.b[1];
        *code.4916 = D.42547;
        code.4917 = code;
        code = code.4917 + 1;
        D.42549 = imb.b[2];
        *code.4917 = D.42549;
        code.4918 = code;
        code = code.4918 + 1;
        D.42551 = imb.b[3];
        *code.4918 = D.42551;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27456>;
  <D.42542>:
  if (0 != 0) goto <D.42552>; else goto <D.42553>;
  <D.42552>:
  code.4919 = code;
  code = code.4919 + 1;
  *code.4919 = 131;
  code.4920 = code;
  code = code.4920 + 1;
  *code.4920 = 248;
  *code = 0;
  code = code + 1;
  goto <D.42556>;
  <D.42553>:
  code.4921 = code;
  code = code.4921 + 1;
  *code.4921 = 129;
  code.4922 = code;
  code = code.4922 + 1;
  *code.4922 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.4923 = code;
        code = code.4923 + 1;
        D.42560 = imb.b[0];
        *code.4923 = D.42560;
        code.4924 = code;
        code = code.4924 + 1;
        D.42562 = imb.b[1];
        *code.4924 = D.42562;
        code.4925 = code;
        code = code.4925 + 1;
        D.42564 = imb.b[2];
        *code.4925 = D.42564;
        code.4926 = code;
        code = code.4926 + 1;
        D.42566 = imb.b[3];
        *code.4926 = D.42566;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42556>:
  <D.27456>:
  D.31501 = ins->opcode;
  if (D.31501 == 669) goto <D.42567>; else goto <D.42568>;
  <D.42567>:
  {
    guchar * is_not_zero_check;
    guchar * end_jump;

    is_not_zero_check = code;
    if (1 != 0) goto <D.42569>; else goto <D.42570>;
    <D.42569>:
    code.4927 = code;
    code = code.4927 + 1;
    D.39804 = 117;
    *code.4927 = D.39804;
    goto <D.42572>;
    <D.42570>:
    code.4928 = code;
    code = code.4928 + 1;
    D.39807 = 117;
    *code.4928 = D.39807;
    <D.42572>:
    *code = 0;
    code = code + 1;
    end_jump = code;
    code.4929 = code;
    code = code.4929 + 1;
    *code.4929 = 235;
    *code = 0;
    code = code + 1;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = is_not_zero_check + 1;
      size = 0;
      D.42575 = MEM[(unsigned char *)is_not_zero_check];
      D.42576 = (int) D.42575;
      switch (D.42576) <default: <D.27487>, case 15: <D.27466>, case 112: <D.27471>, case 113: <D.27472>, case 114: <D.27473>, case 115: <D.27474>, case 116: <D.27475>, case 117: <D.27476>, case 118: <D.27477>, case 119: <D.27478>, case 120: <D.27479>, case 121: <D.27480>, case 122: <D.27481>, case 123: <D.27482>, case 124: <D.27483>, case 125: <D.27484>, case 126: <D.27485>, case 127: <D.27486>, case 224: <D.27467>, case 225: <D.27468>, case 226: <D.27469>, case 232: <D.27463>, case 233: <D.27464>, case 235: <D.27470>>
      <D.27463>:
      <D.27464>:
      size = size + 1;
      goto <D.27465>;
      <D.27466>:
      D.42577 = *pos;
      D.42578 = D.42577 + 144;
      if (D.42578 > 31) goto <D.42579>; else goto <D.42580>;
      <D.42579>:
      __assert_fail ("0", "mini-x86.c", 4243, &__PRETTY_FUNCTION__);
      <D.42580>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27465>;
      <D.27467>:
      <D.27468>:
      <D.27469>:
      <D.27470>:
      <D.27471>:
      <D.27472>:
      <D.27473>:
      <D.27474>:
      <D.27475>:
      <D.27476>:
      <D.27477>:
      <D.27478>:
      <D.27479>:
      <D.27480>:
      <D.27481>:
      <D.27482>:
      <D.27483>:
      <D.27484>:
      <D.27485>:
      <D.27486>:
      goto <D.27465>;
      <D.27487>:
      __assert_fail ("0", "mini-x86.c", 4243, &__PRETTY_FUNCTION__);
      <D.27465>:
      code.422 = (int) code;
      pos.4930 = (int) pos;
      disp = code.422 - pos.4930;
      if (size != 0) goto <D.42582>; else goto <D.42583>;
      <D.42582>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42584 = disp + -4;
            imb.val = D.42584;
            pos.4931 = pos;
            pos = pos.4931 + 1;
            D.42586 = imb.b[0];
            *pos.4931 = D.42586;
            pos.4932 = pos;
            pos = pos.4932 + 1;
            D.42588 = imb.b[1];
            *pos.4932 = D.42588;
            pos.4933 = pos;
            pos = pos.4933 + 1;
            D.42590 = imb.b[2];
            *pos.4933 = D.42590;
            pos.4934 = pos;
            pos = pos.4934 + 1;
            D.42592 = imb.b[3];
            *pos.4934 = D.42592;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42593>;
      <D.42583>:
      disp.4935 = (unsigned int) disp;
      D.42595 = disp.4935 + 127;
      if (D.42595 <= 255) goto <D.42596>; else goto <D.42597>;
      <D.42596>:
      D.42598 = (unsigned char) disp;
      D.42599 = D.42598 + 255;
      *pos = D.42599;
      pos = pos + 1;
      goto <D.42600>;
      <D.42597>:
      __assert_fail ("0", "mini-x86.c", 4243, &__PRETTY_FUNCTION__);
      <D.42600>:
      <D.42593>:
    }
    if (1 != 0) goto <D.42601>; else goto <D.42602>;
    <D.42601>:
    code.4936 = code;
    code = code.4936 + 1;
    *code.4936 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4937 = code;
          code = code.4937 + 1;
          D.42605 = imb.b[0];
          *code.4937 = D.42605;
          code.4938 = code;
          code = code.4938 + 1;
          D.42607 = imb.b[1];
          *code.4938 = D.42607;
          code.4939 = code;
          code = code.4939 + 1;
          D.42609 = imb.b[2];
          *code.4939 = D.42609;
          code.4940 = code;
          code = code.4940 + 1;
          D.42611 = imb.b[3];
          *code.4940 = D.42611;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.27490>;
    <D.42602>:
    if (0 != 0) goto <D.42612>; else goto <D.42613>;
    <D.42612>:
    code.4941 = code;
    code = code.4941 + 1;
    *code.4941 = 131;
    code.4942 = code;
    code = code.4942 + 1;
    *code.4942 = 248;
    *code = 0;
    code = code + 1;
    goto <D.42616>;
    <D.42613>:
    code.4943 = code;
    code = code.4943 + 1;
    *code.4943 = 129;
    code.4944 = code;
    code = code.4944 + 1;
    *code.4944 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 17664;
          code.4945 = code;
          code = code.4945 + 1;
          D.42620 = imb.b[0];
          *code.4945 = D.42620;
          code.4946 = code;
          code = code.4946 + 1;
          D.42622 = imb.b[1];
          *code.4946 = D.42622;
          code.4947 = code;
          code = code.4947 + 1;
          D.42624 = imb.b[2];
          *code.4947 = D.42624;
          code.4948 = code;
          code = code.4948 + 1;
          D.42626 = imb.b[3];
          *code.4948 = D.42626;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42616>:
    <D.27490>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = end_jump + 1;
      size = 0;
      D.42627 = MEM[(unsigned char *)end_jump];
      D.42628 = (int) D.42627;
      switch (D.42628) <default: <D.27519>, case 15: <D.27498>, case 112: <D.27503>, case 113: <D.27504>, case 114: <D.27505>, case 115: <D.27506>, case 116: <D.27507>, case 117: <D.27508>, case 118: <D.27509>, case 119: <D.27510>, case 120: <D.27511>, case 121: <D.27512>, case 122: <D.27513>, case 123: <D.27514>, case 124: <D.27515>, case 125: <D.27516>, case 126: <D.27517>, case 127: <D.27518>, case 224: <D.27499>, case 225: <D.27500>, case 226: <D.27501>, case 232: <D.27495>, case 233: <D.27496>, case 235: <D.27502>>
      <D.27495>:
      <D.27496>:
      size = size + 1;
      goto <D.27497>;
      <D.27498>:
      D.42629 = *pos;
      D.42630 = D.42629 + 144;
      if (D.42630 > 31) goto <D.42631>; else goto <D.42632>;
      <D.42631>:
      __assert_fail ("0", "mini-x86.c", 4246, &__PRETTY_FUNCTION__);
      <D.42632>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27497>;
      <D.27499>:
      <D.27500>:
      <D.27501>:
      <D.27502>:
      <D.27503>:
      <D.27504>:
      <D.27505>:
      <D.27506>:
      <D.27507>:
      <D.27508>:
      <D.27509>:
      <D.27510>:
      <D.27511>:
      <D.27512>:
      <D.27513>:
      <D.27514>:
      <D.27515>:
      <D.27516>:
      <D.27517>:
      <D.27518>:
      goto <D.27497>;
      <D.27519>:
      __assert_fail ("0", "mini-x86.c", 4246, &__PRETTY_FUNCTION__);
      <D.27497>:
      code.422 = (int) code;
      pos.4949 = (int) pos;
      disp = code.422 - pos.4949;
      if (size != 0) goto <D.42634>; else goto <D.42635>;
      <D.42634>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42636 = disp + -4;
            imb.val = D.42636;
            pos.4950 = pos;
            pos = pos.4950 + 1;
            D.42638 = imb.b[0];
            *pos.4950 = D.42638;
            pos.4951 = pos;
            pos = pos.4951 + 1;
            D.42640 = imb.b[1];
            *pos.4951 = D.42640;
            pos.4952 = pos;
            pos = pos.4952 + 1;
            D.42642 = imb.b[2];
            *pos.4952 = D.42642;
            pos.4953 = pos;
            pos = pos.4953 + 1;
            D.42644 = imb.b[3];
            *pos.4953 = D.42644;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42645>;
      <D.42635>:
      disp.4954 = (unsigned int) disp;
      D.42647 = disp.4954 + 127;
      if (D.42647 <= 255) goto <D.42648>; else goto <D.42649>;
      <D.42648>:
      D.42650 = (unsigned char) disp;
      D.42651 = D.42650 + 255;
      *pos = D.42651;
      pos = pos + 1;
      goto <D.42652>;
      <D.42649>:
      __assert_fail ("0", "mini-x86.c", 4246, &__PRETTY_FUNCTION__);
      <D.42652>:
      <D.42645>:
    }
  }
  <D.42568>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42653>; else goto <D.42654>;
  <D.42653>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.4955 = (unsigned int) offset;
    D.42656 = offset.4955 + 128;
    if (D.42656 <= 255) goto <D.42657>; else goto <D.42658>;
    <D.42657>:
    if (0 != 0) goto <D.42659>; else goto <D.42660>;
    <D.42659>:
    code.4956 = code;
    code = code.4956 + 1;
    D.34479 = 116;
    *code.4956 = D.34479;
    goto <D.42662>;
    <D.42660>:
    code.4957 = code;
    code = code.4957 + 1;
    D.34482 = 116;
    *code.4957 = D.34482;
    <D.42662>:
    D.42664 = (unsigned char) offset;
    *code = D.42664;
    code = code + 1;
    goto <D.42665>;
    <D.42658>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.4958 = code;
    code = code.4958 + 1;
    *code.4958 = 15;
    if (0 != 0) goto <D.42667>; else goto <D.42668>;
    <D.42667>:
    code.4959 = code;
    code = code.4959 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.4959 = D.41341;
    goto <D.42670>;
    <D.42668>:
    code.4960 = code;
    code = code.4960 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.4960 = D.41344;
    <D.42670>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.4961 = code;
          code = code.4961 + 1;
          D.42673 = imb.b[0];
          *code.4961 = D.42673;
          code.4962 = code;
          code = code.4962 + 1;
          D.42675 = imb.b[1];
          *code.4962 = D.42675;
          code.4963 = code;
          code = code.4963 + 1;
          D.42677 = imb.b[2];
          *code.4963 = D.42677;
          code.4964 = code;
          code = code.4964 + 1;
          D.42679 = imb.b[3];
          *code.4964 = D.42679;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42665>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42680 = MEM[(unsigned char *)branch_start];
      D.42681 = (int) D.42680;
      switch (D.42681) <default: <D.27551>, case 15: <D.27530>, case 112: <D.27535>, case 113: <D.27536>, case 114: <D.27537>, case 115: <D.27538>, case 116: <D.27539>, case 117: <D.27540>, case 118: <D.27541>, case 119: <D.27542>, case 120: <D.27543>, case 121: <D.27544>, case 122: <D.27545>, case 123: <D.27546>, case 124: <D.27547>, case 125: <D.27548>, case 126: <D.27549>, case 127: <D.27550>, case 224: <D.27531>, case 225: <D.27532>, case 226: <D.27533>, case 232: <D.27527>, case 233: <D.27528>, case 235: <D.27534>>
      <D.27527>:
      <D.27528>:
      size = size + 1;
      goto <D.27529>;
      <D.27530>:
      D.42682 = *pos;
      D.42683 = D.42682 + 144;
      if (D.42683 > 31) goto <D.42684>; else goto <D.42685>;
      <D.42684>:
      __assert_fail ("0", "mini-x86.c", 4248, &__PRETTY_FUNCTION__);
      <D.42685>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27529>;
      <D.27531>:
      <D.27532>:
      <D.27533>:
      <D.27534>:
      <D.27535>:
      <D.27536>:
      <D.27537>:
      <D.27538>:
      <D.27539>:
      <D.27540>:
      <D.27541>:
      <D.27542>:
      <D.27543>:
      <D.27544>:
      <D.27545>:
      <D.27546>:
      <D.27547>:
      <D.27548>:
      <D.27549>:
      <D.27550>:
      goto <D.27529>;
      <D.27551>:
      __assert_fail ("0", "mini-x86.c", 4248, &__PRETTY_FUNCTION__);
      <D.27529>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.4965 = (int) pos;
      disp = D.37252 - pos.4965;
      if (size != 0) goto <D.42687>; else goto <D.42688>;
      <D.42687>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42689 = disp + -4;
            imb.val = D.42689;
            pos.4966 = pos;
            pos = pos.4966 + 1;
            D.42691 = imb.b[0];
            *pos.4966 = D.42691;
            pos.4967 = pos;
            pos = pos.4967 + 1;
            D.42693 = imb.b[1];
            *pos.4967 = D.42693;
            pos.4968 = pos;
            pos = pos.4968 + 1;
            D.42695 = imb.b[2];
            *pos.4968 = D.42695;
            pos.4969 = pos;
            pos = pos.4969 + 1;
            D.42697 = imb.b[3];
            *pos.4969 = D.42697;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42698>;
      <D.42688>:
      disp.4970 = (unsigned int) disp;
      D.42700 = disp.4970 + 127;
      if (D.42700 <= 255) goto <D.42701>; else goto <D.42702>;
      <D.42701>:
      D.42703 = (unsigned char) disp;
      D.42704 = D.42703 + 255;
      *pos = D.42704;
      pos = pos + 1;
      goto <D.42705>;
      <D.42702>:
      __assert_fail ("0", "mini-x86.c", 4248, &__PRETTY_FUNCTION__);
      <D.42705>:
      <D.42698>:
    }
  }
  goto <D.42706>;
  <D.42654>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42709>; else goto <D.42707>;
  <D.42709>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42710>; else goto <D.42707>;
  <D.42710>:
  if (0 != 0) goto <D.42711>; else goto <D.42712>;
  <D.42711>:
  code.4971 = code;
  code = code.4971 + 1;
  D.34479 = 116;
  *code.4971 = D.34479;
  goto <D.42714>;
  <D.42712>:
  code.4972 = code;
  code = code.4972 + 1;
  D.34482 = 116;
  *code.4972 = D.34482;
  <D.42714>:
  *code = 0;
  code = code + 1;
  goto <D.42708>;
  <D.42707>:
  code.4973 = code;
  code = code.4973 + 1;
  *code.4973 = 15;
  if (0 != 0) goto <D.42717>; else goto <D.42718>;
  <D.42717>:
  code.4974 = code;
  code = code.4974 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.4974 = D.41341;
  goto <D.42720>;
  <D.42718>:
  code.4975 = code;
  code = code.4975 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.4975 = D.41344;
  <D.42720>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4976 = code;
        code = code.4976 + 1;
        D.42723 = imb.b[0];
        *code.4976 = D.42723;
        code.4977 = code;
        code = code.4977 + 1;
        D.42725 = imb.b[1];
        *code.4977 = D.42725;
        code.4978 = code;
        code = code.4978 + 1;
        D.42727 = imb.b[2];
        *code.4978 = D.42727;
        code.4979 = code;
        code = code.4979 + 1;
        D.42729 = imb.b[3];
        *code.4979 = D.42729;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42708>:
  <D.42706>:
  goto <D.24796>;
  <D.27554>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.42730>; else goto <D.42731>;
  <D.42730>:
  {
    guchar * br1;

    br1 = code;
    if (0 != 0) goto <D.42732>; else goto <D.42733>;
    <D.42732>:
    code.4980 = code;
    code = code.4980 + 1;
    D.40234 = 122;
    *code.4980 = D.40234;
    goto <D.42735>;
    <D.42733>:
    code.4981 = code;
    code = code.4981 + 1;
    D.40237 = 122;
    *code.4981 = D.40237;
    <D.42735>:
    *code = 0;
    code = code + 1;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    if (D.37247 != 0) goto <D.42737>; else goto <D.42738>;
    <D.42737>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -2;
      branch_start = code;
      offset.4982 = (unsigned int) offset;
      D.42740 = offset.4982 + 128;
      if (D.42740 <= 255) goto <D.42741>; else goto <D.42742>;
      <D.42741>:
      if (0 != 0) goto <D.42743>; else goto <D.42744>;
      <D.42743>:
      code.4983 = code;
      code = code.4983 + 1;
      D.41120 = 126;
      *code.4983 = D.41120;
      goto <D.42746>;
      <D.42744>:
      code.4984 = code;
      code = code.4984 + 1;
      D.41124 = 118;
      *code.4984 = D.41124;
      <D.42746>:
      D.42748 = (unsigned char) offset;
      *code = D.42748;
      code = code + 1;
      goto <D.42749>;
      <D.42742>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -6;
      code.4985 = code;
      code = code.4985 + 1;
      *code.4985 = 15;
      if (0 != 0) goto <D.42751>; else goto <D.42752>;
      <D.42751>:
      code.4986 = code;
      code = code.4986 + 1;
      D.41120 = 126;
      D.42754 = D.41120 + 16;
      *code.4986 = D.42754;
      goto <D.42755>;
      <D.42752>:
      code.4987 = code;
      code = code.4987 + 1;
      D.41124 = 118;
      D.42757 = D.41124 + 16;
      *code.4987 = D.42757;
      <D.42755>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.4988 = code;
            code = code.4988 + 1;
            D.42759 = imb.b[0];
            *code.4988 = D.42759;
            code.4989 = code;
            code = code.4989 + 1;
            D.42761 = imb.b[1];
            *code.4989 = D.42761;
            code.4990 = code;
            code = code.4990 + 1;
            D.42763 = imb.b[2];
            *code.4990 = D.42763;
            code.4991 = code;
            code = code.4991 + 1;
            D.42765 = imb.b[3];
            *code.4991 = D.42765;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.42749>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.42766 = MEM[(unsigned char *)branch_start];
        D.42767 = (int) D.42766;
        switch (D.42767) <default: <D.27586>, case 15: <D.27565>, case 112: <D.27570>, case 113: <D.27571>, case 114: <D.27572>, case 115: <D.27573>, case 116: <D.27574>, case 117: <D.27575>, case 118: <D.27576>, case 119: <D.27577>, case 120: <D.27578>, case 121: <D.27579>, case 122: <D.27580>, case 123: <D.27581>, case 124: <D.27582>, case 125: <D.27583>, case 126: <D.27584>, case 127: <D.27585>, case 224: <D.27566>, case 225: <D.27567>, case 226: <D.27568>, case 232: <D.27562>, case 233: <D.27563>, case 235: <D.27569>>
        <D.27562>:
        <D.27563>:
        size = size + 1;
        goto <D.27564>;
        <D.27565>:
        D.42768 = *pos;
        D.42769 = D.42768 + 144;
        if (D.42769 > 31) goto <D.42770>; else goto <D.42771>;
        <D.42770>:
        __assert_fail ("0", "mini-x86.c", 4259, &__PRETTY_FUNCTION__);
        <D.42771>:
        size = size + 1;
        pos = pos + 1;
        goto <D.27564>;
        <D.27566>:
        <D.27567>:
        <D.27568>:
        <D.27569>:
        <D.27570>:
        <D.27571>:
        <D.27572>:
        <D.27573>:
        <D.27574>:
        <D.27575>:
        <D.27576>:
        <D.27577>:
        <D.27578>:
        <D.27579>:
        <D.27580>:
        <D.27581>:
        <D.27582>:
        <D.27583>:
        <D.27584>:
        <D.27585>:
        goto <D.27564>;
        <D.27586>:
        __assert_fail ("0", "mini-x86.c", 4259, &__PRETTY_FUNCTION__);
        <D.27564>:
        D.31409 = cfg->native_code;
        D.37245 = ins->data.op[1].many_blocks;
        D.37246 = *D.37245;
        D.37247 = D.37246->native_offset;
        D.37250 = (sizetype) D.37247;
        D.37251 = D.31409 + D.37250;
        D.37252 = (int) D.37251;
        pos.4992 = (int) pos;
        disp = D.37252 - pos.4992;
        if (size != 0) goto <D.42773>; else goto <D.42774>;
        <D.42773>:
        {
          union x86_imm_buf imb;

          try
            {
              D.42775 = disp + -4;
              imb.val = D.42775;
              pos.4993 = pos;
              pos = pos.4993 + 1;
              D.42777 = imb.b[0];
              *pos.4993 = D.42777;
              pos.4994 = pos;
              pos = pos.4994 + 1;
              D.42779 = imb.b[1];
              *pos.4994 = D.42779;
              pos.4995 = pos;
              pos = pos.4995 + 1;
              D.42781 = imb.b[2];
              *pos.4995 = D.42781;
              pos.4996 = pos;
              pos = pos.4996 + 1;
              D.42783 = imb.b[3];
              *pos.4996 = D.42783;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.42784>;
        <D.42774>:
        disp.4997 = (unsigned int) disp;
        D.42786 = disp.4997 + 127;
        if (D.42786 <= 255) goto <D.42787>; else goto <D.42788>;
        <D.42787>:
        D.42789 = (unsigned char) disp;
        D.42790 = D.42789 + 255;
        *pos = D.42790;
        pos = pos + 1;
        goto <D.42791>;
        <D.42788>:
        __assert_fail ("0", "mini-x86.c", 4259, &__PRETTY_FUNCTION__);
        <D.42791>:
        <D.42784>:
      }
    }
    goto <D.42792>;
    <D.42738>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.37246);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.42795>; else goto <D.42793>;
    <D.42795>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37327 = D.37246->max_offset;
    D.37328 = D.37327 - cpos;
    D.37329 = (unsigned int) D.37328;
    D.37330 = D.37329 + 128;
    if (D.37330 <= 255) goto <D.42796>; else goto <D.42793>;
    <D.42796>:
    if (0 != 0) goto <D.42797>; else goto <D.42798>;
    <D.42797>:
    code.4998 = code;
    code = code.4998 + 1;
    D.41120 = 126;
    *code.4998 = D.41120;
    goto <D.42800>;
    <D.42798>:
    code.4999 = code;
    code = code.4999 + 1;
    D.41124 = 118;
    *code.4999 = D.41124;
    <D.42800>:
    *code = 0;
    code = code + 1;
    goto <D.42794>;
    <D.42793>:
    code.5000 = code;
    code = code.5000 + 1;
    *code.5000 = 15;
    if (0 != 0) goto <D.42803>; else goto <D.42804>;
    <D.42803>:
    code.5001 = code;
    code = code.5001 + 1;
    D.41120 = 126;
    D.42754 = D.41120 + 16;
    *code.5001 = D.42754;
    goto <D.42806>;
    <D.42804>:
    code.5002 = code;
    code = code.5002 + 1;
    D.41124 = 118;
    D.42757 = D.41124 + 16;
    *code.5002 = D.42757;
    <D.42806>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5003 = code;
          code = code.5003 + 1;
          D.42809 = imb.b[0];
          *code.5003 = D.42809;
          code.5004 = code;
          code = code.5004 + 1;
          D.42811 = imb.b[1];
          *code.5004 = D.42811;
          code.5005 = code;
          code = code.5005 + 1;
          D.42813 = imb.b[2];
          *code.5005 = D.42813;
          code.5006 = code;
          code = code.5006 + 1;
          D.42815 = imb.b[3];
          *code.5006 = D.42815;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42794>:
    <D.42792>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = br1 + 1;
      size = 0;
      D.42816 = MEM[(unsigned char *)br1];
      D.42817 = (int) D.42816;
      switch (D.42817) <default: <D.27616>, case 15: <D.27595>, case 112: <D.27600>, case 113: <D.27601>, case 114: <D.27602>, case 115: <D.27603>, case 116: <D.27604>, case 117: <D.27605>, case 118: <D.27606>, case 119: <D.27607>, case 120: <D.27608>, case 121: <D.27609>, case 122: <D.27610>, case 123: <D.27611>, case 124: <D.27612>, case 125: <D.27613>, case 126: <D.27614>, case 127: <D.27615>, case 224: <D.27596>, case 225: <D.27597>, case 226: <D.27598>, case 232: <D.27592>, case 233: <D.27593>, case 235: <D.27599>>
      <D.27592>:
      <D.27593>:
      size = size + 1;
      goto <D.27594>;
      <D.27595>:
      D.42818 = *pos;
      D.42819 = D.42818 + 144;
      if (D.42819 > 31) goto <D.42820>; else goto <D.42821>;
      <D.42820>:
      __assert_fail ("0", "mini-x86.c", 4260, &__PRETTY_FUNCTION__);
      <D.42821>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27594>;
      <D.27596>:
      <D.27597>:
      <D.27598>:
      <D.27599>:
      <D.27600>:
      <D.27601>:
      <D.27602>:
      <D.27603>:
      <D.27604>:
      <D.27605>:
      <D.27606>:
      <D.27607>:
      <D.27608>:
      <D.27609>:
      <D.27610>:
      <D.27611>:
      <D.27612>:
      <D.27613>:
      <D.27614>:
      <D.27615>:
      goto <D.27594>;
      <D.27616>:
      __assert_fail ("0", "mini-x86.c", 4260, &__PRETTY_FUNCTION__);
      <D.27594>:
      code.422 = (int) code;
      pos.5007 = (int) pos;
      disp = code.422 - pos.5007;
      if (size != 0) goto <D.42823>; else goto <D.42824>;
      <D.42823>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42825 = disp + -4;
            imb.val = D.42825;
            pos.5008 = pos;
            pos = pos.5008 + 1;
            D.42827 = imb.b[0];
            *pos.5008 = D.42827;
            pos.5009 = pos;
            pos = pos.5009 + 1;
            D.42829 = imb.b[1];
            *pos.5009 = D.42829;
            pos.5010 = pos;
            pos = pos.5010 + 1;
            D.42831 = imb.b[2];
            *pos.5010 = D.42831;
            pos.5011 = pos;
            pos = pos.5011 + 1;
            D.42833 = imb.b[3];
            *pos.5011 = D.42833;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42834>;
      <D.42824>:
      disp.5012 = (unsigned int) disp;
      D.42836 = disp.5012 + 127;
      if (D.42836 <= 255) goto <D.42837>; else goto <D.42838>;
      <D.42837>:
      D.42839 = (unsigned char) disp;
      D.42840 = D.42839 + 255;
      *pos = D.42840;
      pos = pos + 1;
      goto <D.42841>;
      <D.42838>:
      __assert_fail ("0", "mini-x86.c", 4260, &__PRETTY_FUNCTION__);
      <D.42841>:
      <D.42834>:
    }
    goto <D.24796>;
  }
  <D.42731>:
  if (1 != 0) goto <D.42842>; else goto <D.42843>;
  <D.42842>:
  code.5013 = code;
  code = code.5013 + 1;
  *code.5013 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.5014 = code;
        code = code.5014 + 1;
        D.42846 = imb.b[0];
        *code.5014 = D.42846;
        code.5015 = code;
        code = code.5015 + 1;
        D.42848 = imb.b[1];
        *code.5015 = D.42848;
        code.5016 = code;
        code = code.5016 + 1;
        D.42850 = imb.b[2];
        *code.5016 = D.42850;
        code.5017 = code;
        code = code.5017 + 1;
        D.42852 = imb.b[3];
        *code.5017 = D.42852;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27619>;
  <D.42843>:
  if (0 != 0) goto <D.42853>; else goto <D.42854>;
  <D.42853>:
  code.5018 = code;
  code = code.5018 + 1;
  *code.5018 = 131;
  code.5019 = code;
  code = code.5019 + 1;
  *code.5019 = 248;
  *code = 0;
  code = code + 1;
  goto <D.42857>;
  <D.42854>:
  code.5020 = code;
  code = code.5020 + 1;
  *code.5020 = 129;
  code.5021 = code;
  code = code.5021 + 1;
  *code.5021 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.5022 = code;
        code = code.5022 + 1;
        D.42861 = imb.b[0];
        *code.5022 = D.42861;
        code.5023 = code;
        code = code.5023 + 1;
        D.42863 = imb.b[1];
        *code.5023 = D.42863;
        code.5024 = code;
        code = code.5024 + 1;
        D.42865 = imb.b[2];
        *code.5024 = D.42865;
        code.5025 = code;
        code = code.5025 + 1;
        D.42867 = imb.b[3];
        *code.5025 = D.42867;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42857>:
  <D.27619>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42868>; else goto <D.42869>;
  <D.42868>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5026 = (unsigned int) offset;
    D.42871 = offset.5026 + 128;
    if (D.42871 <= 255) goto <D.42872>; else goto <D.42873>;
    <D.42872>:
    if (0 != 0) goto <D.42874>; else goto <D.42875>;
    <D.42874>:
    code.5027 = code;
    code = code.5027 + 1;
    D.34479 = 116;
    *code.5027 = D.34479;
    goto <D.42877>;
    <D.42875>:
    code.5028 = code;
    code = code.5028 + 1;
    D.34482 = 116;
    *code.5028 = D.34482;
    <D.42877>:
    D.42879 = (unsigned char) offset;
    *code = D.42879;
    code = code + 1;
    goto <D.42880>;
    <D.42873>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5029 = code;
    code = code.5029 + 1;
    *code.5029 = 15;
    if (0 != 0) goto <D.42882>; else goto <D.42883>;
    <D.42882>:
    code.5030 = code;
    code = code.5030 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.5030 = D.41341;
    goto <D.42885>;
    <D.42883>:
    code.5031 = code;
    code = code.5031 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.5031 = D.41344;
    <D.42885>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5032 = code;
          code = code.5032 + 1;
          D.42888 = imb.b[0];
          *code.5032 = D.42888;
          code.5033 = code;
          code = code.5033 + 1;
          D.42890 = imb.b[1];
          *code.5033 = D.42890;
          code.5034 = code;
          code = code.5034 + 1;
          D.42892 = imb.b[2];
          *code.5034 = D.42892;
          code.5035 = code;
          code = code.5035 + 1;
          D.42894 = imb.b[3];
          *code.5035 = D.42894;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42880>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42895 = MEM[(unsigned char *)branch_start];
      D.42896 = (int) D.42895;
      switch (D.42896) <default: <D.27651>, case 15: <D.27630>, case 112: <D.27635>, case 113: <D.27636>, case 114: <D.27637>, case 115: <D.27638>, case 116: <D.27639>, case 117: <D.27640>, case 118: <D.27641>, case 119: <D.27642>, case 120: <D.27643>, case 121: <D.27644>, case 122: <D.27645>, case 123: <D.27646>, case 124: <D.27647>, case 125: <D.27648>, case 126: <D.27649>, case 127: <D.27650>, case 224: <D.27631>, case 225: <D.27632>, case 226: <D.27633>, case 232: <D.27627>, case 233: <D.27628>, case 235: <D.27634>>
      <D.27627>:
      <D.27628>:
      size = size + 1;
      goto <D.27629>;
      <D.27630>:
      D.42897 = *pos;
      D.42898 = D.42897 + 144;
      if (D.42898 > 31) goto <D.42899>; else goto <D.42900>;
      <D.42899>:
      __assert_fail ("0", "mini-x86.c", 4264, &__PRETTY_FUNCTION__);
      <D.42900>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27629>;
      <D.27631>:
      <D.27632>:
      <D.27633>:
      <D.27634>:
      <D.27635>:
      <D.27636>:
      <D.27637>:
      <D.27638>:
      <D.27639>:
      <D.27640>:
      <D.27641>:
      <D.27642>:
      <D.27643>:
      <D.27644>:
      <D.27645>:
      <D.27646>:
      <D.27647>:
      <D.27648>:
      <D.27649>:
      <D.27650>:
      goto <D.27629>;
      <D.27651>:
      __assert_fail ("0", "mini-x86.c", 4264, &__PRETTY_FUNCTION__);
      <D.27629>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5036 = (int) pos;
      disp = D.37252 - pos.5036;
      if (size != 0) goto <D.42902>; else goto <D.42903>;
      <D.42902>:
      {
        union x86_imm_buf imb;

        try
          {
            D.42904 = disp + -4;
            imb.val = D.42904;
            pos.5037 = pos;
            pos = pos.5037 + 1;
            D.42906 = imb.b[0];
            *pos.5037 = D.42906;
            pos.5038 = pos;
            pos = pos.5038 + 1;
            D.42908 = imb.b[1];
            *pos.5038 = D.42908;
            pos.5039 = pos;
            pos = pos.5039 + 1;
            D.42910 = imb.b[2];
            *pos.5039 = D.42910;
            pos.5040 = pos;
            pos = pos.5040 + 1;
            D.42912 = imb.b[3];
            *pos.5040 = D.42912;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42913>;
      <D.42903>:
      disp.5041 = (unsigned int) disp;
      D.42915 = disp.5041 + 127;
      if (D.42915 <= 255) goto <D.42916>; else goto <D.42917>;
      <D.42916>:
      D.42918 = (unsigned char) disp;
      D.42919 = D.42918 + 255;
      *pos = D.42919;
      pos = pos + 1;
      goto <D.42920>;
      <D.42917>:
      __assert_fail ("0", "mini-x86.c", 4264, &__PRETTY_FUNCTION__);
      <D.42920>:
      <D.42913>:
    }
  }
  goto <D.42921>;
  <D.42869>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.42924>; else goto <D.42922>;
  <D.42924>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.42925>; else goto <D.42922>;
  <D.42925>:
  if (0 != 0) goto <D.42926>; else goto <D.42927>;
  <D.42926>:
  code.5042 = code;
  code = code.5042 + 1;
  D.34479 = 116;
  *code.5042 = D.34479;
  goto <D.42929>;
  <D.42927>:
  code.5043 = code;
  code = code.5043 + 1;
  D.34482 = 116;
  *code.5043 = D.34482;
  <D.42929>:
  *code = 0;
  code = code + 1;
  goto <D.42923>;
  <D.42922>:
  code.5044 = code;
  code = code.5044 + 1;
  *code.5044 = 15;
  if (0 != 0) goto <D.42932>; else goto <D.42933>;
  <D.42932>:
  code.5045 = code;
  code = code.5045 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.5045 = D.41341;
  goto <D.42935>;
  <D.42933>:
  code.5046 = code;
  code = code.5046 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.5046 = D.41344;
  <D.42935>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5047 = code;
        code = code.5047 + 1;
        D.42938 = imb.b[0];
        *code.5047 = D.42938;
        code.5048 = code;
        code = code.5048 + 1;
        D.42940 = imb.b[1];
        *code.5048 = D.42940;
        code.5049 = code;
        code = code.5049 + 1;
        D.42942 = imb.b[2];
        *code.5049 = D.42942;
        code.5050 = code;
        code = code.5050 + 1;
        D.42944 = imb.b[3];
        *code.5050 = D.42944;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42923>:
  <D.42921>:
  if (1 != 0) goto <D.42945>; else goto <D.42946>;
  <D.42945>:
  code.5051 = code;
  code = code.5051 + 1;
  *code.5051 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.5052 = code;
        code = code.5052 + 1;
        D.42949 = imb.b[0];
        *code.5052 = D.42949;
        code.5053 = code;
        code = code.5053 + 1;
        D.42951 = imb.b[1];
        *code.5053 = D.42951;
        code.5054 = code;
        code = code.5054 + 1;
        D.42953 = imb.b[2];
        *code.5054 = D.42953;
        code.5055 = code;
        code = code.5055 + 1;
        D.42955 = imb.b[3];
        *code.5055 = D.42955;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27655>;
  <D.42946>:
  if (0 != 0) goto <D.42956>; else goto <D.42957>;
  <D.42956>:
  code.5056 = code;
  code = code.5056 + 1;
  *code.5056 = 131;
  code.5057 = code;
  code = code.5057 + 1;
  *code.5057 = 248;
  *code = 0;
  code = code + 1;
  goto <D.42960>;
  <D.42957>:
  code.5058 = code;
  code = code.5058 + 1;
  *code.5058 = 129;
  code.5059 = code;
  code = code.5059 + 1;
  *code.5059 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16384;
        code.5060 = code;
        code = code.5060 + 1;
        D.42964 = imb.b[0];
        *code.5060 = D.42964;
        code.5061 = code;
        code = code.5061 + 1;
        D.42966 = imb.b[1];
        *code.5061 = D.42966;
        code.5062 = code;
        code = code.5062 + 1;
        D.42968 = imb.b[2];
        *code.5062 = D.42968;
        code.5063 = code;
        code = code.5063 + 1;
        D.42970 = imb.b[3];
        *code.5063 = D.42970;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42960>:
  <D.27655>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.42971>; else goto <D.42972>;
  <D.42971>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5064 = (unsigned int) offset;
    D.42974 = offset.5064 + 128;
    if (D.42974 <= 255) goto <D.42975>; else goto <D.42976>;
    <D.42975>:
    if (0 != 0) goto <D.42977>; else goto <D.42978>;
    <D.42977>:
    code.5065 = code;
    code = code.5065 + 1;
    D.34479 = 116;
    *code.5065 = D.34479;
    goto <D.42980>;
    <D.42978>:
    code.5066 = code;
    code = code.5066 + 1;
    D.34482 = 116;
    *code.5066 = D.34482;
    <D.42980>:
    D.42982 = (unsigned char) offset;
    *code = D.42982;
    code = code + 1;
    goto <D.42983>;
    <D.42976>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5067 = code;
    code = code.5067 + 1;
    *code.5067 = 15;
    if (0 != 0) goto <D.42985>; else goto <D.42986>;
    <D.42985>:
    code.5068 = code;
    code = code.5068 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.5068 = D.41341;
    goto <D.42988>;
    <D.42986>:
    code.5069 = code;
    code = code.5069 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.5069 = D.41344;
    <D.42988>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5070 = code;
          code = code.5070 + 1;
          D.42991 = imb.b[0];
          *code.5070 = D.42991;
          code.5071 = code;
          code = code.5071 + 1;
          D.42993 = imb.b[1];
          *code.5071 = D.42993;
          code.5072 = code;
          code = code.5072 + 1;
          D.42995 = imb.b[2];
          *code.5072 = D.42995;
          code.5073 = code;
          code = code.5073 + 1;
          D.42997 = imb.b[3];
          *code.5073 = D.42997;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42983>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.42998 = MEM[(unsigned char *)branch_start];
      D.42999 = (int) D.42998;
      switch (D.42999) <default: <D.27687>, case 15: <D.27666>, case 112: <D.27671>, case 113: <D.27672>, case 114: <D.27673>, case 115: <D.27674>, case 116: <D.27675>, case 117: <D.27676>, case 118: <D.27677>, case 119: <D.27678>, case 120: <D.27679>, case 121: <D.27680>, case 122: <D.27681>, case 123: <D.27682>, case 124: <D.27683>, case 125: <D.27684>, case 126: <D.27685>, case 127: <D.27686>, case 224: <D.27667>, case 225: <D.27668>, case 226: <D.27669>, case 232: <D.27663>, case 233: <D.27664>, case 235: <D.27670>>
      <D.27663>:
      <D.27664>:
      size = size + 1;
      goto <D.27665>;
      <D.27666>:
      D.43000 = *pos;
      D.43001 = D.43000 + 144;
      if (D.43001 > 31) goto <D.43002>; else goto <D.43003>;
      <D.43002>:
      __assert_fail ("0", "mini-x86.c", 4266, &__PRETTY_FUNCTION__);
      <D.43003>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27665>;
      <D.27667>:
      <D.27668>:
      <D.27669>:
      <D.27670>:
      <D.27671>:
      <D.27672>:
      <D.27673>:
      <D.27674>:
      <D.27675>:
      <D.27676>:
      <D.27677>:
      <D.27678>:
      <D.27679>:
      <D.27680>:
      <D.27681>:
      <D.27682>:
      <D.27683>:
      <D.27684>:
      <D.27685>:
      <D.27686>:
      goto <D.27665>;
      <D.27687>:
      __assert_fail ("0", "mini-x86.c", 4266, &__PRETTY_FUNCTION__);
      <D.27665>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5074 = (int) pos;
      disp = D.37252 - pos.5074;
      if (size != 0) goto <D.43005>; else goto <D.43006>;
      <D.43005>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43007 = disp + -4;
            imb.val = D.43007;
            pos.5075 = pos;
            pos = pos.5075 + 1;
            D.43009 = imb.b[0];
            *pos.5075 = D.43009;
            pos.5076 = pos;
            pos = pos.5076 + 1;
            D.43011 = imb.b[1];
            *pos.5076 = D.43011;
            pos.5077 = pos;
            pos = pos.5077 + 1;
            D.43013 = imb.b[2];
            *pos.5077 = D.43013;
            pos.5078 = pos;
            pos = pos.5078 + 1;
            D.43015 = imb.b[3];
            *pos.5078 = D.43015;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43016>;
      <D.43006>:
      disp.5079 = (unsigned int) disp;
      D.43018 = disp.5079 + 127;
      if (D.43018 <= 255) goto <D.43019>; else goto <D.43020>;
      <D.43019>:
      D.43021 = (unsigned char) disp;
      D.43022 = D.43021 + 255;
      *pos = D.43022;
      pos = pos + 1;
      goto <D.43023>;
      <D.43020>:
      __assert_fail ("0", "mini-x86.c", 4266, &__PRETTY_FUNCTION__);
      <D.43023>:
      <D.43016>:
    }
  }
  goto <D.43024>;
  <D.42972>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43027>; else goto <D.43025>;
  <D.43027>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43028>; else goto <D.43025>;
  <D.43028>:
  if (0 != 0) goto <D.43029>; else goto <D.43030>;
  <D.43029>:
  code.5080 = code;
  code = code.5080 + 1;
  D.34479 = 116;
  *code.5080 = D.34479;
  goto <D.43032>;
  <D.43030>:
  code.5081 = code;
  code = code.5081 + 1;
  D.34482 = 116;
  *code.5081 = D.34482;
  <D.43032>:
  *code = 0;
  code = code + 1;
  goto <D.43026>;
  <D.43025>:
  code.5082 = code;
  code = code.5082 + 1;
  *code.5082 = 15;
  if (0 != 0) goto <D.43035>; else goto <D.43036>;
  <D.43035>:
  code.5083 = code;
  code = code.5083 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.5083 = D.41341;
  goto <D.43038>;
  <D.43036>:
  code.5084 = code;
  code = code.5084 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.5084 = D.41344;
  <D.43038>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5085 = code;
        code = code.5085 + 1;
        D.43041 = imb.b[0];
        *code.5085 = D.43041;
        code.5086 = code;
        code = code.5086 + 1;
        D.43043 = imb.b[1];
        *code.5086 = D.43043;
        code.5087 = code;
        code = code.5087 + 1;
        D.43045 = imb.b[2];
        *code.5087 = D.43045;
        code.5088 = code;
        code = code.5088 + 1;
        D.43047 = imb.b[3];
        *code.5088 = D.43047;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43026>:
  <D.43024>:
  goto <D.24796>;
  <D.27690>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.43048>; else goto <D.43049>;
  <D.43048>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.43050>; else goto <D.43051>;
  <D.43050>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5089 = (unsigned int) offset;
    D.43053 = offset.5089 + 128;
    if (D.43053 <= 255) goto <D.43054>; else goto <D.43055>;
    <D.43054>:
    if (0 != 0) goto <D.43056>; else goto <D.43057>;
    <D.43056>:
    code.5090 = code;
    code = code.5090 + 1;
    D.41120 = 126;
    *code.5090 = D.41120;
    goto <D.43059>;
    <D.43057>:
    code.5091 = code;
    code = code.5091 + 1;
    D.41124 = 118;
    *code.5091 = D.41124;
    <D.43059>:
    D.43061 = (unsigned char) offset;
    *code = D.43061;
    code = code + 1;
    goto <D.43062>;
    <D.43055>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5092 = code;
    code = code.5092 + 1;
    *code.5092 = 15;
    if (0 != 0) goto <D.43064>; else goto <D.43065>;
    <D.43064>:
    code.5093 = code;
    code = code.5093 + 1;
    D.41120 = 126;
    D.42754 = D.41120 + 16;
    *code.5093 = D.42754;
    goto <D.43067>;
    <D.43065>:
    code.5094 = code;
    code = code.5094 + 1;
    D.41124 = 118;
    D.42757 = D.41124 + 16;
    *code.5094 = D.42757;
    <D.43067>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5095 = code;
          code = code.5095 + 1;
          D.43070 = imb.b[0];
          *code.5095 = D.43070;
          code.5096 = code;
          code = code.5096 + 1;
          D.43072 = imb.b[1];
          *code.5096 = D.43072;
          code.5097 = code;
          code = code.5097 + 1;
          D.43074 = imb.b[2];
          *code.5097 = D.43074;
          code.5098 = code;
          code = code.5098 + 1;
          D.43076 = imb.b[3];
          *code.5098 = D.43076;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43062>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.43077 = MEM[(unsigned char *)branch_start];
      D.43078 = (int) D.43077;
      switch (D.43078) <default: <D.27721>, case 15: <D.27700>, case 112: <D.27705>, case 113: <D.27706>, case 114: <D.27707>, case 115: <D.27708>, case 116: <D.27709>, case 117: <D.27710>, case 118: <D.27711>, case 119: <D.27712>, case 120: <D.27713>, case 121: <D.27714>, case 122: <D.27715>, case 123: <D.27716>, case 124: <D.27717>, case 125: <D.27718>, case 126: <D.27719>, case 127: <D.27720>, case 224: <D.27701>, case 225: <D.27702>, case 226: <D.27703>, case 232: <D.27697>, case 233: <D.27698>, case 235: <D.27704>>
      <D.27697>:
      <D.27698>:
      size = size + 1;
      goto <D.27699>;
      <D.27700>:
      D.43079 = *pos;
      D.43080 = D.43079 + 144;
      if (D.43080 > 31) goto <D.43081>; else goto <D.43082>;
      <D.43081>:
      __assert_fail ("0", "mini-x86.c", 4271, &__PRETTY_FUNCTION__);
      <D.43082>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27699>;
      <D.27701>:
      <D.27702>:
      <D.27703>:
      <D.27704>:
      <D.27705>:
      <D.27706>:
      <D.27707>:
      <D.27708>:
      <D.27709>:
      <D.27710>:
      <D.27711>:
      <D.27712>:
      <D.27713>:
      <D.27714>:
      <D.27715>:
      <D.27716>:
      <D.27717>:
      <D.27718>:
      <D.27719>:
      <D.27720>:
      goto <D.27699>;
      <D.27721>:
      __assert_fail ("0", "mini-x86.c", 4271, &__PRETTY_FUNCTION__);
      <D.27699>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5099 = (int) pos;
      disp = D.37252 - pos.5099;
      if (size != 0) goto <D.43084>; else goto <D.43085>;
      <D.43084>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43086 = disp + -4;
            imb.val = D.43086;
            pos.5100 = pos;
            pos = pos.5100 + 1;
            D.43088 = imb.b[0];
            *pos.5100 = D.43088;
            pos.5101 = pos;
            pos = pos.5101 + 1;
            D.43090 = imb.b[1];
            *pos.5101 = D.43090;
            pos.5102 = pos;
            pos = pos.5102 + 1;
            D.43092 = imb.b[2];
            *pos.5102 = D.43092;
            pos.5103 = pos;
            pos = pos.5103 + 1;
            D.43094 = imb.b[3];
            *pos.5103 = D.43094;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43095>;
      <D.43085>:
      disp.5104 = (unsigned int) disp;
      D.43097 = disp.5104 + 127;
      if (D.43097 <= 255) goto <D.43098>; else goto <D.43099>;
      <D.43098>:
      D.43100 = (unsigned char) disp;
      D.43101 = D.43100 + 255;
      *pos = D.43101;
      pos = pos + 1;
      goto <D.43102>;
      <D.43099>:
      __assert_fail ("0", "mini-x86.c", 4271, &__PRETTY_FUNCTION__);
      <D.43102>:
      <D.43095>:
    }
  }
  goto <D.43103>;
  <D.43051>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43106>; else goto <D.43104>;
  <D.43106>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43107>; else goto <D.43104>;
  <D.43107>:
  if (0 != 0) goto <D.43108>; else goto <D.43109>;
  <D.43108>:
  code.5105 = code;
  code = code.5105 + 1;
  D.41120 = 126;
  *code.5105 = D.41120;
  goto <D.43111>;
  <D.43109>:
  code.5106 = code;
  code = code.5106 + 1;
  D.41124 = 118;
  *code.5106 = D.41124;
  <D.43111>:
  *code = 0;
  code = code + 1;
  goto <D.43105>;
  <D.43104>:
  code.5107 = code;
  code = code.5107 + 1;
  *code.5107 = 15;
  if (0 != 0) goto <D.43114>; else goto <D.43115>;
  <D.43114>:
  code.5108 = code;
  code = code.5108 + 1;
  D.41120 = 126;
  D.42754 = D.41120 + 16;
  *code.5108 = D.42754;
  goto <D.43117>;
  <D.43115>:
  code.5109 = code;
  code = code.5109 + 1;
  D.41124 = 118;
  D.42757 = D.41124 + 16;
  *code.5109 = D.42757;
  <D.43117>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5110 = code;
        code = code.5110 + 1;
        D.43120 = imb.b[0];
        *code.5110 = D.43120;
        code.5111 = code;
        code = code.5111 + 1;
        D.43122 = imb.b[1];
        *code.5111 = D.43122;
        code.5112 = code;
        code = code.5112 + 1;
        D.43124 = imb.b[2];
        *code.5112 = D.43124;
        code.5113 = code;
        code = code.5113 + 1;
        D.43126 = imb.b[3];
        *code.5113 = D.43126;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43105>:
  <D.43103>:
  goto <D.24796>;
  <D.43049>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.43127>; else goto <D.43128>;
  <D.43127>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5114 = (unsigned int) offset;
    D.43130 = offset.5114 + 128;
    if (D.43130 <= 255) goto <D.43131>; else goto <D.43132>;
    <D.43131>:
    if (0 != 0) goto <D.43133>; else goto <D.43134>;
    <D.43133>:
    code.5115 = code;
    code = code.5115 + 1;
    D.39804 = 117;
    *code.5115 = D.39804;
    goto <D.43136>;
    <D.43134>:
    code.5116 = code;
    code = code.5116 + 1;
    D.39807 = 117;
    *code.5116 = D.39807;
    <D.43136>:
    D.43138 = (unsigned char) offset;
    *code = D.43138;
    code = code + 1;
    goto <D.43139>;
    <D.43132>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5117 = code;
    code = code.5117 + 1;
    *code.5117 = 15;
    if (0 != 0) goto <D.43141>; else goto <D.43142>;
    <D.43141>:
    code.5118 = code;
    code = code.5118 + 1;
    D.39804 = 117;
    D.41551 = D.39804 + 16;
    *code.5118 = D.41551;
    goto <D.43144>;
    <D.43142>:
    code.5119 = code;
    code = code.5119 + 1;
    D.39807 = 117;
    D.41554 = D.39807 + 16;
    *code.5119 = D.41554;
    <D.43144>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5120 = code;
          code = code.5120 + 1;
          D.43147 = imb.b[0];
          *code.5120 = D.43147;
          code.5121 = code;
          code = code.5121 + 1;
          D.43149 = imb.b[1];
          *code.5121 = D.43149;
          code.5122 = code;
          code = code.5122 + 1;
          D.43151 = imb.b[2];
          *code.5122 = D.43151;
          code.5123 = code;
          code = code.5123 + 1;
          D.43153 = imb.b[3];
          *code.5123 = D.43153;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43139>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.43154 = MEM[(unsigned char *)branch_start];
      D.43155 = (int) D.43154;
      switch (D.43155) <default: <D.27754>, case 15: <D.27733>, case 112: <D.27738>, case 113: <D.27739>, case 114: <D.27740>, case 115: <D.27741>, case 116: <D.27742>, case 117: <D.27743>, case 118: <D.27744>, case 119: <D.27745>, case 120: <D.27746>, case 121: <D.27747>, case 122: <D.27748>, case 123: <D.27749>, case 124: <D.27750>, case 125: <D.27751>, case 126: <D.27752>, case 127: <D.27753>, case 224: <D.27734>, case 225: <D.27735>, case 226: <D.27736>, case 232: <D.27730>, case 233: <D.27731>, case 235: <D.27737>>
      <D.27730>:
      <D.27731>:
      size = size + 1;
      goto <D.27732>;
      <D.27733>:
      D.43156 = *pos;
      D.43157 = D.43156 + 144;
      if (D.43157 > 31) goto <D.43158>; else goto <D.43159>;
      <D.43158>:
      __assert_fail ("0", "mini-x86.c", 4274, &__PRETTY_FUNCTION__);
      <D.43159>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27732>;
      <D.27734>:
      <D.27735>:
      <D.27736>:
      <D.27737>:
      <D.27738>:
      <D.27739>:
      <D.27740>:
      <D.27741>:
      <D.27742>:
      <D.27743>:
      <D.27744>:
      <D.27745>:
      <D.27746>:
      <D.27747>:
      <D.27748>:
      <D.27749>:
      <D.27750>:
      <D.27751>:
      <D.27752>:
      <D.27753>:
      goto <D.27732>;
      <D.27754>:
      __assert_fail ("0", "mini-x86.c", 4274, &__PRETTY_FUNCTION__);
      <D.27732>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5124 = (int) pos;
      disp = D.37252 - pos.5124;
      if (size != 0) goto <D.43161>; else goto <D.43162>;
      <D.43161>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43163 = disp + -4;
            imb.val = D.43163;
            pos.5125 = pos;
            pos = pos.5125 + 1;
            D.43165 = imb.b[0];
            *pos.5125 = D.43165;
            pos.5126 = pos;
            pos = pos.5126 + 1;
            D.43167 = imb.b[1];
            *pos.5126 = D.43167;
            pos.5127 = pos;
            pos = pos.5127 + 1;
            D.43169 = imb.b[2];
            *pos.5127 = D.43169;
            pos.5128 = pos;
            pos = pos.5128 + 1;
            D.43171 = imb.b[3];
            *pos.5128 = D.43171;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43172>;
      <D.43162>:
      disp.5129 = (unsigned int) disp;
      D.43174 = disp.5129 + 127;
      if (D.43174 <= 255) goto <D.43175>; else goto <D.43176>;
      <D.43175>:
      D.43177 = (unsigned char) disp;
      D.43178 = D.43177 + 255;
      *pos = D.43178;
      pos = pos + 1;
      goto <D.43179>;
      <D.43176>:
      __assert_fail ("0", "mini-x86.c", 4274, &__PRETTY_FUNCTION__);
      <D.43179>:
      <D.43172>:
    }
  }
  goto <D.43180>;
  <D.43128>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43183>; else goto <D.43181>;
  <D.43183>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43184>; else goto <D.43181>;
  <D.43184>:
  if (0 != 0) goto <D.43185>; else goto <D.43186>;
  <D.43185>:
  code.5130 = code;
  code = code.5130 + 1;
  D.39804 = 117;
  *code.5130 = D.39804;
  goto <D.43188>;
  <D.43186>:
  code.5131 = code;
  code = code.5131 + 1;
  D.39807 = 117;
  *code.5131 = D.39807;
  <D.43188>:
  *code = 0;
  code = code + 1;
  goto <D.43182>;
  <D.43181>:
  code.5132 = code;
  code = code.5132 + 1;
  *code.5132 = 15;
  if (0 != 0) goto <D.43191>; else goto <D.43192>;
  <D.43191>:
  code.5133 = code;
  code = code.5133 + 1;
  D.39804 = 117;
  D.41551 = D.39804 + 16;
  *code.5133 = D.41551;
  goto <D.43194>;
  <D.43192>:
  code.5134 = code;
  code = code.5134 + 1;
  D.39807 = 117;
  D.41554 = D.39807 + 16;
  *code.5134 = D.41554;
  <D.43194>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5135 = code;
        code = code.5135 + 1;
        D.43197 = imb.b[0];
        *code.5135 = D.43197;
        code.5136 = code;
        code = code.5136 + 1;
        D.43199 = imb.b[1];
        *code.5136 = D.43199;
        code.5137 = code;
        code = code.5137 + 1;
        D.43201 = imb.b[2];
        *code.5137 = D.43201;
        code.5138 = code;
        code = code.5138 + 1;
        D.43203 = imb.b[3];
        *code.5138 = D.43203;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43182>:
  <D.43180>:
  goto <D.24796>;
  <D.27757>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.43204>; else goto <D.43205>;
  <D.43204>:
  {
    guchar * br1;

    br1 = code;
    if (0 != 0) goto <D.43206>; else goto <D.43207>;
    <D.43206>:
    code.5139 = code;
    code = code.5139 + 1;
    D.40234 = 122;
    *code.5139 = D.40234;
    goto <D.43209>;
    <D.43207>:
    code.5140 = code;
    code = code.5140 + 1;
    D.40237 = 122;
    *code.5140 = D.40237;
    <D.43209>:
    *code = 0;
    code = code + 1;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    if (D.37247 != 0) goto <D.43211>; else goto <D.43212>;
    <D.43211>:
    {
      int offset;
      guint8 * branch_start;

      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -2;
      branch_start = code;
      offset.5141 = (unsigned int) offset;
      D.43214 = offset.5141 + 128;
      if (D.43214 <= 255) goto <D.43215>; else goto <D.43216>;
      <D.43215>:
      if (0 != 0) goto <D.43217>; else goto <D.43218>;
      <D.43217>:
      code.5142 = code;
      code = code.5142 + 1;
      D.40676 = 125;
      *code.5142 = D.40676;
      goto <D.43220>;
      <D.43218>:
      code.5143 = code;
      code = code.5143 + 1;
      D.40680 = 115;
      *code.5143 = D.40680;
      <D.43220>:
      D.43222 = (unsigned char) offset;
      *code = D.43222;
      code = code + 1;
      goto <D.43223>;
      <D.43216>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      code.422 = (int) code;
      D.37253 = D.37252 - code.422;
      offset = D.37253 + -6;
      code.5144 = code;
      code = code.5144 + 1;
      *code.5144 = 15;
      if (0 != 0) goto <D.43225>; else goto <D.43226>;
      <D.43225>:
      code.5145 = code;
      code = code.5145 + 1;
      D.40676 = 125;
      D.43228 = D.40676 + 16;
      *code.5145 = D.43228;
      goto <D.43229>;
      <D.43226>:
      code.5146 = code;
      code = code.5146 + 1;
      D.40680 = 115;
      D.43231 = D.40680 + 16;
      *code.5146 = D.43231;
      <D.43229>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.5147 = code;
            code = code.5147 + 1;
            D.43233 = imb.b[0];
            *code.5147 = D.43233;
            code.5148 = code;
            code = code.5148 + 1;
            D.43235 = imb.b[1];
            *code.5148 = D.43235;
            code.5149 = code;
            code = code.5149 + 1;
            D.43237 = imb.b[2];
            *code.5149 = D.43237;
            code.5150 = code;
            code = code.5150 + 1;
            D.43239 = imb.b[3];
            *code.5150 = D.43239;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.43223>:
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = branch_start + 1;
        size = 0;
        D.43240 = MEM[(unsigned char *)branch_start];
        D.43241 = (int) D.43240;
        switch (D.43241) <default: <D.27789>, case 15: <D.27768>, case 112: <D.27773>, case 113: <D.27774>, case 114: <D.27775>, case 115: <D.27776>, case 116: <D.27777>, case 117: <D.27778>, case 118: <D.27779>, case 119: <D.27780>, case 120: <D.27781>, case 121: <D.27782>, case 122: <D.27783>, case 123: <D.27784>, case 124: <D.27785>, case 125: <D.27786>, case 126: <D.27787>, case 127: <D.27788>, case 224: <D.27769>, case 225: <D.27770>, case 226: <D.27771>, case 232: <D.27765>, case 233: <D.27766>, case 235: <D.27772>>
        <D.27765>:
        <D.27766>:
        size = size + 1;
        goto <D.27767>;
        <D.27768>:
        D.43242 = *pos;
        D.43243 = D.43242 + 144;
        if (D.43243 > 31) goto <D.43244>; else goto <D.43245>;
        <D.43244>:
        __assert_fail ("0", "mini-x86.c", 4285, &__PRETTY_FUNCTION__);
        <D.43245>:
        size = size + 1;
        pos = pos + 1;
        goto <D.27767>;
        <D.27769>:
        <D.27770>:
        <D.27771>:
        <D.27772>:
        <D.27773>:
        <D.27774>:
        <D.27775>:
        <D.27776>:
        <D.27777>:
        <D.27778>:
        <D.27779>:
        <D.27780>:
        <D.27781>:
        <D.27782>:
        <D.27783>:
        <D.27784>:
        <D.27785>:
        <D.27786>:
        <D.27787>:
        <D.27788>:
        goto <D.27767>;
        <D.27789>:
        __assert_fail ("0", "mini-x86.c", 4285, &__PRETTY_FUNCTION__);
        <D.27767>:
        D.31409 = cfg->native_code;
        D.37245 = ins->data.op[1].many_blocks;
        D.37246 = *D.37245;
        D.37247 = D.37246->native_offset;
        D.37250 = (sizetype) D.37247;
        D.37251 = D.31409 + D.37250;
        D.37252 = (int) D.37251;
        pos.5151 = (int) pos;
        disp = D.37252 - pos.5151;
        if (size != 0) goto <D.43247>; else goto <D.43248>;
        <D.43247>:
        {
          union x86_imm_buf imb;

          try
            {
              D.43249 = disp + -4;
              imb.val = D.43249;
              pos.5152 = pos;
              pos = pos.5152 + 1;
              D.43251 = imb.b[0];
              *pos.5152 = D.43251;
              pos.5153 = pos;
              pos = pos.5153 + 1;
              D.43253 = imb.b[1];
              *pos.5153 = D.43253;
              pos.5154 = pos;
              pos = pos.5154 + 1;
              D.43255 = imb.b[2];
              *pos.5154 = D.43255;
              pos.5155 = pos;
              pos = pos.5155 + 1;
              D.43257 = imb.b[3];
              *pos.5155 = D.43257;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.43258>;
        <D.43248>:
        disp.5156 = (unsigned int) disp;
        D.43260 = disp.5156 + 127;
        if (D.43260 <= 255) goto <D.43261>; else goto <D.43262>;
        <D.43261>:
        D.43263 = (unsigned char) disp;
        D.43264 = D.43263 + 255;
        *pos = D.43264;
        pos = pos + 1;
        goto <D.43265>;
        <D.43262>:
        __assert_fail ("0", "mini-x86.c", 4285, &__PRETTY_FUNCTION__);
        <D.43265>:
        <D.43258>:
      }
    }
    goto <D.43266>;
    <D.43212>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    code.422 = (int) code;
    D.31409 = cfg->native_code;
    D.31488 = (int) D.31409;
    D.31489 = code.422 - D.31488;
    mono_add_patch_info (cfg, D.31489, 0, D.37246);
    D.31411 = cfg->opt;
    D.35226 = D.31411 & 2;
    if (D.35226 != 0) goto <D.43269>; else goto <D.43267>;
    <D.43269>:
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37327 = D.37246->max_offset;
    D.37328 = D.37327 - cpos;
    D.37329 = (unsigned int) D.37328;
    D.37330 = D.37329 + 128;
    if (D.37330 <= 255) goto <D.43270>; else goto <D.43267>;
    <D.43270>:
    if (0 != 0) goto <D.43271>; else goto <D.43272>;
    <D.43271>:
    code.5157 = code;
    code = code.5157 + 1;
    D.40676 = 125;
    *code.5157 = D.40676;
    goto <D.43274>;
    <D.43272>:
    code.5158 = code;
    code = code.5158 + 1;
    D.40680 = 115;
    *code.5158 = D.40680;
    <D.43274>:
    *code = 0;
    code = code + 1;
    goto <D.43268>;
    <D.43267>:
    code.5159 = code;
    code = code.5159 + 1;
    *code.5159 = 15;
    if (0 != 0) goto <D.43277>; else goto <D.43278>;
    <D.43277>:
    code.5160 = code;
    code = code.5160 + 1;
    D.40676 = 125;
    D.43228 = D.40676 + 16;
    *code.5160 = D.43228;
    goto <D.43280>;
    <D.43278>:
    code.5161 = code;
    code = code.5161 + 1;
    D.40680 = 115;
    D.43231 = D.40680 + 16;
    *code.5161 = D.43231;
    <D.43280>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5162 = code;
          code = code.5162 + 1;
          D.43283 = imb.b[0];
          *code.5162 = D.43283;
          code.5163 = code;
          code = code.5163 + 1;
          D.43285 = imb.b[1];
          *code.5163 = D.43285;
          code.5164 = code;
          code = code.5164 + 1;
          D.43287 = imb.b[2];
          *code.5164 = D.43287;
          code.5165 = code;
          code = code.5165 + 1;
          D.43289 = imb.b[3];
          *code.5165 = D.43289;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43268>:
    <D.43266>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = br1 + 1;
      size = 0;
      D.43290 = MEM[(unsigned char *)br1];
      D.43291 = (int) D.43290;
      switch (D.43291) <default: <D.27819>, case 15: <D.27798>, case 112: <D.27803>, case 113: <D.27804>, case 114: <D.27805>, case 115: <D.27806>, case 116: <D.27807>, case 117: <D.27808>, case 118: <D.27809>, case 119: <D.27810>, case 120: <D.27811>, case 121: <D.27812>, case 122: <D.27813>, case 123: <D.27814>, case 124: <D.27815>, case 125: <D.27816>, case 126: <D.27817>, case 127: <D.27818>, case 224: <D.27799>, case 225: <D.27800>, case 226: <D.27801>, case 232: <D.27795>, case 233: <D.27796>, case 235: <D.27802>>
      <D.27795>:
      <D.27796>:
      size = size + 1;
      goto <D.27797>;
      <D.27798>:
      D.43292 = *pos;
      D.43293 = D.43292 + 144;
      if (D.43293 > 31) goto <D.43294>; else goto <D.43295>;
      <D.43294>:
      __assert_fail ("0", "mini-x86.c", 4286, &__PRETTY_FUNCTION__);
      <D.43295>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27797>;
      <D.27799>:
      <D.27800>:
      <D.27801>:
      <D.27802>:
      <D.27803>:
      <D.27804>:
      <D.27805>:
      <D.27806>:
      <D.27807>:
      <D.27808>:
      <D.27809>:
      <D.27810>:
      <D.27811>:
      <D.27812>:
      <D.27813>:
      <D.27814>:
      <D.27815>:
      <D.27816>:
      <D.27817>:
      <D.27818>:
      goto <D.27797>;
      <D.27819>:
      __assert_fail ("0", "mini-x86.c", 4286, &__PRETTY_FUNCTION__);
      <D.27797>:
      code.422 = (int) code;
      pos.5166 = (int) pos;
      disp = code.422 - pos.5166;
      if (size != 0) goto <D.43297>; else goto <D.43298>;
      <D.43297>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43299 = disp + -4;
            imb.val = D.43299;
            pos.5167 = pos;
            pos = pos.5167 + 1;
            D.43301 = imb.b[0];
            *pos.5167 = D.43301;
            pos.5168 = pos;
            pos = pos.5168 + 1;
            D.43303 = imb.b[1];
            *pos.5168 = D.43303;
            pos.5169 = pos;
            pos = pos.5169 + 1;
            D.43305 = imb.b[2];
            *pos.5169 = D.43305;
            pos.5170 = pos;
            pos = pos.5170 + 1;
            D.43307 = imb.b[3];
            *pos.5170 = D.43307;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43308>;
      <D.43298>:
      disp.5171 = (unsigned int) disp;
      D.43310 = disp.5171 + 127;
      if (D.43310 <= 255) goto <D.43311>; else goto <D.43312>;
      <D.43311>:
      D.43313 = (unsigned char) disp;
      D.43314 = D.43313 + 255;
      *pos = D.43314;
      pos = pos + 1;
      goto <D.43315>;
      <D.43312>:
      __assert_fail ("0", "mini-x86.c", 4286, &__PRETTY_FUNCTION__);
      <D.43315>:
      <D.43308>:
    }
    goto <D.24796>;
  }
  <D.43205>:
  if (1 != 0) goto <D.43316>; else goto <D.43317>;
  <D.43316>:
  code.5172 = code;
  code = code.5172 + 1;
  *code.5172 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 768;
        code.5173 = code;
        code = code.5173 + 1;
        D.43320 = imb.b[0];
        *code.5173 = D.43320;
        code.5174 = code;
        code = code.5174 + 1;
        D.43322 = imb.b[1];
        *code.5174 = D.43322;
        code.5175 = code;
        code = code.5175 + 1;
        D.43324 = imb.b[2];
        *code.5175 = D.43324;
        code.5176 = code;
        code = code.5176 + 1;
        D.43326 = imb.b[3];
        *code.5176 = D.43326;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27822>;
  <D.43317>:
  if (0 != 0) goto <D.43327>; else goto <D.43328>;
  <D.43327>:
  code.5177 = code;
  code = code.5177 + 1;
  *code.5177 = 131;
  code.5178 = code;
  code = code.5178 + 1;
  *code.5178 = 224;
  *code = 0;
  code = code + 1;
  goto <D.43331>;
  <D.43328>:
  code.5179 = code;
  code = code.5179 + 1;
  *code.5179 = 129;
  code.5180 = code;
  code = code.5180 + 1;
  *code.5180 = 224;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 768;
        code.5181 = code;
        code = code.5181 + 1;
        D.43335 = imb.b[0];
        *code.5181 = D.43335;
        code.5182 = code;
        code = code.5182 + 1;
        D.43337 = imb.b[1];
        *code.5182 = D.43337;
        code.5183 = code;
        code = code.5183 + 1;
        D.43339 = imb.b[2];
        *code.5183 = D.43339;
        code.5184 = code;
        code = code.5184 + 1;
        D.43341 = imb.b[3];
        *code.5184 = D.43341;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43331>:
  <D.27822>:
  if (1 != 0) goto <D.43342>; else goto <D.43343>;
  <D.43342>:
  code.5185 = code;
  code = code.5185 + 1;
  *code.5185 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5186 = code;
        code = code.5186 + 1;
        D.43346 = imb.b[0];
        *code.5186 = D.43346;
        code.5187 = code;
        code = code.5187 + 1;
        D.43348 = imb.b[1];
        *code.5187 = D.43348;
        code.5188 = code;
        code = code.5188 + 1;
        D.43350 = imb.b[2];
        *code.5188 = D.43350;
        code.5189 = code;
        code = code.5189 + 1;
        D.43352 = imb.b[3];
        *code.5189 = D.43352;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27825>;
  <D.43343>:
  if (1 != 0) goto <D.43353>; else goto <D.43354>;
  <D.43353>:
  code.5190 = code;
  code = code.5190 + 1;
  *code.5190 = 131;
  code.5191 = code;
  code = code.5191 + 1;
  *code.5191 = 248;
  *code = 0;
  code = code + 1;
  goto <D.43357>;
  <D.43354>:
  code.5192 = code;
  code = code.5192 + 1;
  *code.5192 = 129;
  code.5193 = code;
  code = code.5193 + 1;
  *code.5193 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5194 = code;
        code = code.5194 + 1;
        D.43361 = imb.b[0];
        *code.5194 = D.43361;
        code.5195 = code;
        code = code.5195 + 1;
        D.43363 = imb.b[1];
        *code.5195 = D.43363;
        code.5196 = code;
        code = code.5196 + 1;
        D.43365 = imb.b[2];
        *code.5196 = D.43365;
        code.5197 = code;
        code = code.5197 + 1;
        D.43367 = imb.b[3];
        *code.5197 = D.43367;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43357>:
  <D.27825>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.43368>; else goto <D.43369>;
  <D.43368>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5198 = (unsigned int) offset;
    D.43371 = offset.5198 + 128;
    if (D.43371 <= 255) goto <D.43372>; else goto <D.43373>;
    <D.43372>:
    if (0 != 0) goto <D.43374>; else goto <D.43375>;
    <D.43374>:
    code.5199 = code;
    code = code.5199 + 1;
    D.34479 = 116;
    *code.5199 = D.34479;
    goto <D.43377>;
    <D.43375>:
    code.5200 = code;
    code = code.5200 + 1;
    D.34482 = 116;
    *code.5200 = D.34482;
    <D.43377>:
    D.43379 = (unsigned char) offset;
    *code = D.43379;
    code = code + 1;
    goto <D.43380>;
    <D.43373>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5201 = code;
    code = code.5201 + 1;
    *code.5201 = 15;
    if (0 != 0) goto <D.43382>; else goto <D.43383>;
    <D.43382>:
    code.5202 = code;
    code = code.5202 + 1;
    D.34479 = 116;
    D.41341 = D.34479 + 16;
    *code.5202 = D.41341;
    goto <D.43385>;
    <D.43383>:
    code.5203 = code;
    code = code.5203 + 1;
    D.34482 = 116;
    D.41344 = D.34482 + 16;
    *code.5203 = D.41344;
    <D.43385>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5204 = code;
          code = code.5204 + 1;
          D.43388 = imb.b[0];
          *code.5204 = D.43388;
          code.5205 = code;
          code = code.5205 + 1;
          D.43390 = imb.b[1];
          *code.5205 = D.43390;
          code.5206 = code;
          code = code.5206 + 1;
          D.43392 = imb.b[2];
          *code.5206 = D.43392;
          code.5207 = code;
          code = code.5207 + 1;
          D.43394 = imb.b[3];
          *code.5207 = D.43394;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43380>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.43395 = MEM[(unsigned char *)branch_start];
      D.43396 = (int) D.43395;
      switch (D.43396) <default: <D.27857>, case 15: <D.27836>, case 112: <D.27841>, case 113: <D.27842>, case 114: <D.27843>, case 115: <D.27844>, case 116: <D.27845>, case 117: <D.27846>, case 118: <D.27847>, case 119: <D.27848>, case 120: <D.27849>, case 121: <D.27850>, case 122: <D.27851>, case 123: <D.27852>, case 124: <D.27853>, case 125: <D.27854>, case 126: <D.27855>, case 127: <D.27856>, case 224: <D.27837>, case 225: <D.27838>, case 226: <D.27839>, case 232: <D.27833>, case 233: <D.27834>, case 235: <D.27840>>
      <D.27833>:
      <D.27834>:
      size = size + 1;
      goto <D.27835>;
      <D.27836>:
      D.43397 = *pos;
      D.43398 = D.43397 + 144;
      if (D.43398 > 31) goto <D.43399>; else goto <D.43400>;
      <D.43399>:
      __assert_fail ("0", "mini-x86.c", 4291, &__PRETTY_FUNCTION__);
      <D.43400>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27835>;
      <D.27837>:
      <D.27838>:
      <D.27839>:
      <D.27840>:
      <D.27841>:
      <D.27842>:
      <D.27843>:
      <D.27844>:
      <D.27845>:
      <D.27846>:
      <D.27847>:
      <D.27848>:
      <D.27849>:
      <D.27850>:
      <D.27851>:
      <D.27852>:
      <D.27853>:
      <D.27854>:
      <D.27855>:
      <D.27856>:
      goto <D.27835>;
      <D.27857>:
      __assert_fail ("0", "mini-x86.c", 4291, &__PRETTY_FUNCTION__);
      <D.27835>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5208 = (int) pos;
      disp = D.37252 - pos.5208;
      if (size != 0) goto <D.43402>; else goto <D.43403>;
      <D.43402>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43404 = disp + -4;
            imb.val = D.43404;
            pos.5209 = pos;
            pos = pos.5209 + 1;
            D.43406 = imb.b[0];
            *pos.5209 = D.43406;
            pos.5210 = pos;
            pos = pos.5210 + 1;
            D.43408 = imb.b[1];
            *pos.5210 = D.43408;
            pos.5211 = pos;
            pos = pos.5211 + 1;
            D.43410 = imb.b[2];
            *pos.5211 = D.43410;
            pos.5212 = pos;
            pos = pos.5212 + 1;
            D.43412 = imb.b[3];
            *pos.5212 = D.43412;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43413>;
      <D.43403>:
      disp.5213 = (unsigned int) disp;
      D.43415 = disp.5213 + 127;
      if (D.43415 <= 255) goto <D.43416>; else goto <D.43417>;
      <D.43416>:
      D.43418 = (unsigned char) disp;
      D.43419 = D.43418 + 255;
      *pos = D.43419;
      pos = pos + 1;
      goto <D.43420>;
      <D.43417>:
      __assert_fail ("0", "mini-x86.c", 4291, &__PRETTY_FUNCTION__);
      <D.43420>:
      <D.43413>:
    }
  }
  goto <D.43421>;
  <D.43369>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43424>; else goto <D.43422>;
  <D.43424>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43425>; else goto <D.43422>;
  <D.43425>:
  if (0 != 0) goto <D.43426>; else goto <D.43427>;
  <D.43426>:
  code.5214 = code;
  code = code.5214 + 1;
  D.34479 = 116;
  *code.5214 = D.34479;
  goto <D.43429>;
  <D.43427>:
  code.5215 = code;
  code = code.5215 + 1;
  D.34482 = 116;
  *code.5215 = D.34482;
  <D.43429>:
  *code = 0;
  code = code + 1;
  goto <D.43423>;
  <D.43422>:
  code.5216 = code;
  code = code.5216 + 1;
  *code.5216 = 15;
  if (0 != 0) goto <D.43432>; else goto <D.43433>;
  <D.43432>:
  code.5217 = code;
  code = code.5217 + 1;
  D.34479 = 116;
  D.41341 = D.34479 + 16;
  *code.5217 = D.41341;
  goto <D.43435>;
  <D.43433>:
  code.5218 = code;
  code = code.5218 + 1;
  D.34482 = 116;
  D.41344 = D.34482 + 16;
  *code.5218 = D.41344;
  <D.43435>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5219 = code;
        code = code.5219 + 1;
        D.43438 = imb.b[0];
        *code.5219 = D.43438;
        code.5220 = code;
        code = code.5220 + 1;
        D.43440 = imb.b[1];
        *code.5220 = D.43440;
        code.5221 = code;
        code = code.5221 + 1;
        D.43442 = imb.b[2];
        *code.5221 = D.43442;
        code.5222 = code;
        code = code.5222 + 1;
        D.43444 = imb.b[3];
        *code.5222 = D.43444;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43423>:
  <D.43421>:
  goto <D.24796>;
  <D.27860>:
  D.31411 = cfg->opt;
  D.40186 = D.31411 & 16384;
  if (D.40186 != 0) goto <D.43445>; else goto <D.43446>;
  <D.43445>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.43447>; else goto <D.43448>;
  <D.43447>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5223 = (unsigned int) offset;
    D.43450 = offset.5223 + 128;
    if (D.43450 <= 255) goto <D.43451>; else goto <D.43452>;
    <D.43451>:
    if (0 != 0) goto <D.43453>; else goto <D.43454>;
    <D.43453>:
    code.5224 = code;
    code = code.5224 + 1;
    D.40234 = 122;
    *code.5224 = D.40234;
    goto <D.43456>;
    <D.43454>:
    code.5225 = code;
    code = code.5225 + 1;
    D.40237 = 122;
    *code.5225 = D.40237;
    <D.43456>:
    D.43458 = (unsigned char) offset;
    *code = D.43458;
    code = code + 1;
    goto <D.43459>;
    <D.43452>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5226 = code;
    code = code.5226 + 1;
    *code.5226 = 15;
    if (0 != 0) goto <D.43461>; else goto <D.43462>;
    <D.43461>:
    code.5227 = code;
    code = code.5227 + 1;
    D.40234 = 122;
    D.41630 = D.40234 + 16;
    *code.5227 = D.41630;
    goto <D.43464>;
    <D.43462>:
    code.5228 = code;
    code = code.5228 + 1;
    D.40237 = 122;
    D.41633 = D.40237 + 16;
    *code.5228 = D.41633;
    <D.43464>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5229 = code;
          code = code.5229 + 1;
          D.43467 = imb.b[0];
          *code.5229 = D.43467;
          code.5230 = code;
          code = code.5230 + 1;
          D.43469 = imb.b[1];
          *code.5230 = D.43469;
          code.5231 = code;
          code = code.5231 + 1;
          D.43471 = imb.b[2];
          *code.5231 = D.43471;
          code.5232 = code;
          code = code.5232 + 1;
          D.43473 = imb.b[3];
          *code.5232 = D.43473;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43459>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.43474 = MEM[(unsigned char *)branch_start];
      D.43475 = (int) D.43474;
      switch (D.43475) <default: <D.27891>, case 15: <D.27870>, case 112: <D.27875>, case 113: <D.27876>, case 114: <D.27877>, case 115: <D.27878>, case 116: <D.27879>, case 117: <D.27880>, case 118: <D.27881>, case 119: <D.27882>, case 120: <D.27883>, case 121: <D.27884>, case 122: <D.27885>, case 123: <D.27886>, case 124: <D.27887>, case 125: <D.27888>, case 126: <D.27889>, case 127: <D.27890>, case 224: <D.27871>, case 225: <D.27872>, case 226: <D.27873>, case 232: <D.27867>, case 233: <D.27868>, case 235: <D.27874>>
      <D.27867>:
      <D.27868>:
      size = size + 1;
      goto <D.27869>;
      <D.27870>:
      D.43476 = *pos;
      D.43477 = D.43476 + 144;
      if (D.43477 > 31) goto <D.43478>; else goto <D.43479>;
      <D.43478>:
      __assert_fail ("0", "mini-x86.c", 4296, &__PRETTY_FUNCTION__);
      <D.43479>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27869>;
      <D.27871>:
      <D.27872>:
      <D.27873>:
      <D.27874>:
      <D.27875>:
      <D.27876>:
      <D.27877>:
      <D.27878>:
      <D.27879>:
      <D.27880>:
      <D.27881>:
      <D.27882>:
      <D.27883>:
      <D.27884>:
      <D.27885>:
      <D.27886>:
      <D.27887>:
      <D.27888>:
      <D.27889>:
      <D.27890>:
      goto <D.27869>;
      <D.27891>:
      __assert_fail ("0", "mini-x86.c", 4296, &__PRETTY_FUNCTION__);
      <D.27869>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5233 = (int) pos;
      disp = D.37252 - pos.5233;
      if (size != 0) goto <D.43481>; else goto <D.43482>;
      <D.43481>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43483 = disp + -4;
            imb.val = D.43483;
            pos.5234 = pos;
            pos = pos.5234 + 1;
            D.43485 = imb.b[0];
            *pos.5234 = D.43485;
            pos.5235 = pos;
            pos = pos.5235 + 1;
            D.43487 = imb.b[1];
            *pos.5235 = D.43487;
            pos.5236 = pos;
            pos = pos.5236 + 1;
            D.43489 = imb.b[2];
            *pos.5236 = D.43489;
            pos.5237 = pos;
            pos = pos.5237 + 1;
            D.43491 = imb.b[3];
            *pos.5237 = D.43491;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43492>;
      <D.43482>:
      disp.5238 = (unsigned int) disp;
      D.43494 = disp.5238 + 127;
      if (D.43494 <= 255) goto <D.43495>; else goto <D.43496>;
      <D.43495>:
      D.43497 = (unsigned char) disp;
      D.43498 = D.43497 + 255;
      *pos = D.43498;
      pos = pos + 1;
      goto <D.43499>;
      <D.43496>:
      __assert_fail ("0", "mini-x86.c", 4296, &__PRETTY_FUNCTION__);
      <D.43499>:
      <D.43492>:
    }
  }
  goto <D.43500>;
  <D.43448>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43503>; else goto <D.43501>;
  <D.43503>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43504>; else goto <D.43501>;
  <D.43504>:
  if (0 != 0) goto <D.43505>; else goto <D.43506>;
  <D.43505>:
  code.5239 = code;
  code = code.5239 + 1;
  D.40234 = 122;
  *code.5239 = D.40234;
  goto <D.43508>;
  <D.43506>:
  code.5240 = code;
  code = code.5240 + 1;
  D.40237 = 122;
  *code.5240 = D.40237;
  <D.43508>:
  *code = 0;
  code = code + 1;
  goto <D.43502>;
  <D.43501>:
  code.5241 = code;
  code = code.5241 + 1;
  *code.5241 = 15;
  if (0 != 0) goto <D.43511>; else goto <D.43512>;
  <D.43511>:
  code.5242 = code;
  code = code.5242 + 1;
  D.40234 = 122;
  D.41630 = D.40234 + 16;
  *code.5242 = D.41630;
  goto <D.43514>;
  <D.43512>:
  code.5243 = code;
  code = code.5243 + 1;
  D.40237 = 122;
  D.41633 = D.40237 + 16;
  *code.5243 = D.41633;
  <D.43514>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5244 = code;
        code = code.5244 + 1;
        D.43517 = imb.b[0];
        *code.5244 = D.43517;
        code.5245 = code;
        code = code.5245 + 1;
        D.43519 = imb.b[1];
        *code.5245 = D.43519;
        code.5246 = code;
        code = code.5246 + 1;
        D.43521 = imb.b[2];
        *code.5246 = D.43521;
        code.5247 = code;
        code = code.5247 + 1;
        D.43523 = imb.b[3];
        *code.5247 = D.43523;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43502>:
  <D.43500>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.43524>; else goto <D.43525>;
  <D.43524>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5248 = (unsigned int) offset;
    D.43527 = offset.5248 + 128;
    if (D.43527 <= 255) goto <D.43528>; else goto <D.43529>;
    <D.43528>:
    if (0 != 0) goto <D.43530>; else goto <D.43531>;
    <D.43530>:
    code.5249 = code;
    code = code.5249 + 1;
    D.40676 = 125;
    *code.5249 = D.40676;
    goto <D.43533>;
    <D.43531>:
    code.5250 = code;
    code = code.5250 + 1;
    D.40680 = 115;
    *code.5250 = D.40680;
    <D.43533>:
    D.43535 = (unsigned char) offset;
    *code = D.43535;
    code = code + 1;
    goto <D.43536>;
    <D.43529>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5251 = code;
    code = code.5251 + 1;
    *code.5251 = 15;
    if (0 != 0) goto <D.43538>; else goto <D.43539>;
    <D.43538>:
    code.5252 = code;
    code = code.5252 + 1;
    D.40676 = 125;
    D.43228 = D.40676 + 16;
    *code.5252 = D.43228;
    goto <D.43541>;
    <D.43539>:
    code.5253 = code;
    code = code.5253 + 1;
    D.40680 = 115;
    D.43231 = D.40680 + 16;
    *code.5253 = D.43231;
    <D.43541>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5254 = code;
          code = code.5254 + 1;
          D.43544 = imb.b[0];
          *code.5254 = D.43544;
          code.5255 = code;
          code = code.5255 + 1;
          D.43546 = imb.b[1];
          *code.5255 = D.43546;
          code.5256 = code;
          code = code.5256 + 1;
          D.43548 = imb.b[2];
          *code.5256 = D.43548;
          code.5257 = code;
          code = code.5257 + 1;
          D.43550 = imb.b[3];
          *code.5257 = D.43550;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43536>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.43551 = MEM[(unsigned char *)branch_start];
      D.43552 = (int) D.43551;
      switch (D.43552) <default: <D.27924>, case 15: <D.27903>, case 112: <D.27908>, case 113: <D.27909>, case 114: <D.27910>, case 115: <D.27911>, case 116: <D.27912>, case 117: <D.27913>, case 118: <D.27914>, case 119: <D.27915>, case 120: <D.27916>, case 121: <D.27917>, case 122: <D.27918>, case 123: <D.27919>, case 124: <D.27920>, case 125: <D.27921>, case 126: <D.27922>, case 127: <D.27923>, case 224: <D.27904>, case 225: <D.27905>, case 226: <D.27906>, case 232: <D.27900>, case 233: <D.27901>, case 235: <D.27907>>
      <D.27900>:
      <D.27901>:
      size = size + 1;
      goto <D.27902>;
      <D.27903>:
      D.43553 = *pos;
      D.43554 = D.43553 + 144;
      if (D.43554 > 31) goto <D.43555>; else goto <D.43556>;
      <D.43555>:
      __assert_fail ("0", "mini-x86.c", 4297, &__PRETTY_FUNCTION__);
      <D.43556>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27902>;
      <D.27904>:
      <D.27905>:
      <D.27906>:
      <D.27907>:
      <D.27908>:
      <D.27909>:
      <D.27910>:
      <D.27911>:
      <D.27912>:
      <D.27913>:
      <D.27914>:
      <D.27915>:
      <D.27916>:
      <D.27917>:
      <D.27918>:
      <D.27919>:
      <D.27920>:
      <D.27921>:
      <D.27922>:
      <D.27923>:
      goto <D.27902>;
      <D.27924>:
      __assert_fail ("0", "mini-x86.c", 4297, &__PRETTY_FUNCTION__);
      <D.27902>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5258 = (int) pos;
      disp = D.37252 - pos.5258;
      if (size != 0) goto <D.43558>; else goto <D.43559>;
      <D.43558>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43560 = disp + -4;
            imb.val = D.43560;
            pos.5259 = pos;
            pos = pos.5259 + 1;
            D.43562 = imb.b[0];
            *pos.5259 = D.43562;
            pos.5260 = pos;
            pos = pos.5260 + 1;
            D.43564 = imb.b[1];
            *pos.5260 = D.43564;
            pos.5261 = pos;
            pos = pos.5261 + 1;
            D.43566 = imb.b[2];
            *pos.5261 = D.43566;
            pos.5262 = pos;
            pos = pos.5262 + 1;
            D.43568 = imb.b[3];
            *pos.5262 = D.43568;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43569>;
      <D.43559>:
      disp.5263 = (unsigned int) disp;
      D.43571 = disp.5263 + 127;
      if (D.43571 <= 255) goto <D.43572>; else goto <D.43573>;
      <D.43572>:
      D.43574 = (unsigned char) disp;
      D.43575 = D.43574 + 255;
      *pos = D.43575;
      pos = pos + 1;
      goto <D.43576>;
      <D.43573>:
      __assert_fail ("0", "mini-x86.c", 4297, &__PRETTY_FUNCTION__);
      <D.43576>:
      <D.43569>:
    }
  }
  goto <D.43577>;
  <D.43525>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43580>; else goto <D.43578>;
  <D.43580>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43581>; else goto <D.43578>;
  <D.43581>:
  if (0 != 0) goto <D.43582>; else goto <D.43583>;
  <D.43582>:
  code.5264 = code;
  code = code.5264 + 1;
  D.40676 = 125;
  *code.5264 = D.40676;
  goto <D.43585>;
  <D.43583>:
  code.5265 = code;
  code = code.5265 + 1;
  D.40680 = 115;
  *code.5265 = D.40680;
  <D.43585>:
  *code = 0;
  code = code + 1;
  goto <D.43579>;
  <D.43578>:
  code.5266 = code;
  code = code.5266 + 1;
  *code.5266 = 15;
  if (0 != 0) goto <D.43588>; else goto <D.43589>;
  <D.43588>:
  code.5267 = code;
  code = code.5267 + 1;
  D.40676 = 125;
  D.43228 = D.40676 + 16;
  *code.5267 = D.43228;
  goto <D.43591>;
  <D.43589>:
  code.5268 = code;
  code = code.5268 + 1;
  D.40680 = 115;
  D.43231 = D.40680 + 16;
  *code.5268 = D.43231;
  <D.43591>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5269 = code;
        code = code.5269 + 1;
        D.43594 = imb.b[0];
        *code.5269 = D.43594;
        code.5270 = code;
        code = code.5270 + 1;
        D.43596 = imb.b[1];
        *code.5270 = D.43596;
        code.5271 = code;
        code = code.5271 + 1;
        D.43598 = imb.b[2];
        *code.5271 = D.43598;
        code.5272 = code;
        code = code.5272 + 1;
        D.43600 = imb.b[3];
        *code.5272 = D.43600;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43579>:
  <D.43577>:
  goto <D.24796>;
  <D.43446>:
  if (1 != 0) goto <D.43601>; else goto <D.43602>;
  <D.43601>:
  code.5273 = code;
  code = code.5273 + 1;
  *code.5273 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.5274 = code;
        code = code.5274 + 1;
        D.43605 = imb.b[0];
        *code.5274 = D.43605;
        code.5275 = code;
        code = code.5275 + 1;
        D.43607 = imb.b[1];
        *code.5275 = D.43607;
        code.5276 = code;
        code = code.5276 + 1;
        D.43609 = imb.b[2];
        *code.5276 = D.43609;
        code.5277 = code;
        code = code.5277 + 1;
        D.43611 = imb.b[3];
        *code.5277 = D.43611;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.27928>;
  <D.43602>:
  if (0 != 0) goto <D.43612>; else goto <D.43613>;
  <D.43612>:
  code.5278 = code;
  code = code.5278 + 1;
  *code.5278 = 131;
  code.5279 = code;
  code = code.5279 + 1;
  *code.5279 = 248;
  *code = 0;
  code = code + 1;
  goto <D.43616>;
  <D.43613>:
  code.5280 = code;
  code = code.5280 + 1;
  *code.5280 = 129;
  code.5281 = code;
  code = code.5281 + 1;
  *code.5281 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.5282 = code;
        code = code.5282 + 1;
        D.43620 = imb.b[0];
        *code.5282 = D.43620;
        code.5283 = code;
        code = code.5283 + 1;
        D.43622 = imb.b[1];
        *code.5283 = D.43622;
        code.5284 = code;
        code = code.5284 + 1;
        D.43624 = imb.b[2];
        *code.5284 = D.43624;
        code.5285 = code;
        code = code.5285 + 1;
        D.43626 = imb.b[3];
        *code.5285 = D.43626;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43616>:
  <D.27928>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37247 = D.37246->native_offset;
  if (D.37247 != 0) goto <D.43627>; else goto <D.43628>;
  <D.43627>:
  {
    int offset;
    guint8 * branch_start;

    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -2;
    branch_start = code;
    offset.5286 = (unsigned int) offset;
    D.43630 = offset.5286 + 128;
    if (D.43630 <= 255) goto <D.43631>; else goto <D.43632>;
    <D.43631>:
    if (0 != 0) goto <D.43633>; else goto <D.43634>;
    <D.43633>:
    code.5287 = code;
    code = code.5287 + 1;
    D.39804 = 117;
    *code.5287 = D.39804;
    goto <D.43636>;
    <D.43634>:
    code.5288 = code;
    code = code.5288 + 1;
    D.39807 = 117;
    *code.5288 = D.39807;
    <D.43636>:
    D.43638 = (unsigned char) offset;
    *code = D.43638;
    code = code + 1;
    goto <D.43639>;
    <D.43632>:
    D.31409 = cfg->native_code;
    D.37245 = ins->data.op[1].many_blocks;
    D.37246 = *D.37245;
    D.37247 = D.37246->native_offset;
    D.37250 = (sizetype) D.37247;
    D.37251 = D.31409 + D.37250;
    D.37252 = (int) D.37251;
    code.422 = (int) code;
    D.37253 = D.37252 - code.422;
    offset = D.37253 + -6;
    code.5289 = code;
    code = code.5289 + 1;
    *code.5289 = 15;
    if (0 != 0) goto <D.43641>; else goto <D.43642>;
    <D.43641>:
    code.5290 = code;
    code = code.5290 + 1;
    D.39804 = 117;
    D.41551 = D.39804 + 16;
    *code.5290 = D.41551;
    goto <D.43644>;
    <D.43642>:
    code.5291 = code;
    code = code.5291 + 1;
    D.39807 = 117;
    D.41554 = D.39807 + 16;
    *code.5291 = D.41554;
    <D.43644>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5292 = code;
          code = code.5292 + 1;
          D.43647 = imb.b[0];
          *code.5292 = D.43647;
          code.5293 = code;
          code = code.5293 + 1;
          D.43649 = imb.b[1];
          *code.5293 = D.43649;
          code.5294 = code;
          code = code.5294 + 1;
          D.43651 = imb.b[2];
          *code.5294 = D.43651;
          code.5295 = code;
          code = code.5295 + 1;
          D.43653 = imb.b[3];
          *code.5295 = D.43653;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43639>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = branch_start + 1;
      size = 0;
      D.43654 = MEM[(unsigned char *)branch_start];
      D.43655 = (int) D.43654;
      switch (D.43655) <default: <D.27960>, case 15: <D.27939>, case 112: <D.27944>, case 113: <D.27945>, case 114: <D.27946>, case 115: <D.27947>, case 116: <D.27948>, case 117: <D.27949>, case 118: <D.27950>, case 119: <D.27951>, case 120: <D.27952>, case 121: <D.27953>, case 122: <D.27954>, case 123: <D.27955>, case 124: <D.27956>, case 125: <D.27957>, case 126: <D.27958>, case 127: <D.27959>, case 224: <D.27940>, case 225: <D.27941>, case 226: <D.27942>, case 232: <D.27936>, case 233: <D.27937>, case 235: <D.27943>>
      <D.27936>:
      <D.27937>:
      size = size + 1;
      goto <D.27938>;
      <D.27939>:
      D.43656 = *pos;
      D.43657 = D.43656 + 144;
      if (D.43657 > 31) goto <D.43658>; else goto <D.43659>;
      <D.43658>:
      __assert_fail ("0", "mini-x86.c", 4301, &__PRETTY_FUNCTION__);
      <D.43659>:
      size = size + 1;
      pos = pos + 1;
      goto <D.27938>;
      <D.27940>:
      <D.27941>:
      <D.27942>:
      <D.27943>:
      <D.27944>:
      <D.27945>:
      <D.27946>:
      <D.27947>:
      <D.27948>:
      <D.27949>:
      <D.27950>:
      <D.27951>:
      <D.27952>:
      <D.27953>:
      <D.27954>:
      <D.27955>:
      <D.27956>:
      <D.27957>:
      <D.27958>:
      <D.27959>:
      goto <D.27938>;
      <D.27960>:
      __assert_fail ("0", "mini-x86.c", 4301, &__PRETTY_FUNCTION__);
      <D.27938>:
      D.31409 = cfg->native_code;
      D.37245 = ins->data.op[1].many_blocks;
      D.37246 = *D.37245;
      D.37247 = D.37246->native_offset;
      D.37250 = (sizetype) D.37247;
      D.37251 = D.31409 + D.37250;
      D.37252 = (int) D.37251;
      pos.5296 = (int) pos;
      disp = D.37252 - pos.5296;
      if (size != 0) goto <D.43661>; else goto <D.43662>;
      <D.43661>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43663 = disp + -4;
            imb.val = D.43663;
            pos.5297 = pos;
            pos = pos.5297 + 1;
            D.43665 = imb.b[0];
            *pos.5297 = D.43665;
            pos.5298 = pos;
            pos = pos.5298 + 1;
            D.43667 = imb.b[1];
            *pos.5298 = D.43667;
            pos.5299 = pos;
            pos = pos.5299 + 1;
            D.43669 = imb.b[2];
            *pos.5299 = D.43669;
            pos.5300 = pos;
            pos = pos.5300 + 1;
            D.43671 = imb.b[3];
            *pos.5300 = D.43671;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43672>;
      <D.43662>:
      disp.5301 = (unsigned int) disp;
      D.43674 = disp.5301 + 127;
      if (D.43674 <= 255) goto <D.43675>; else goto <D.43676>;
      <D.43675>:
      D.43677 = (unsigned char) disp;
      D.43678 = D.43677 + 255;
      *pos = D.43678;
      pos = pos + 1;
      goto <D.43679>;
      <D.43676>:
      __assert_fail ("0", "mini-x86.c", 4301, &__PRETTY_FUNCTION__);
      <D.43679>:
      <D.43672>:
    }
  }
  goto <D.43680>;
  <D.43628>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  mono_add_patch_info (cfg, D.31489, 0, D.37246);
  D.31411 = cfg->opt;
  D.35226 = D.31411 & 2;
  if (D.35226 != 0) goto <D.43683>; else goto <D.43681>;
  <D.43683>:
  D.37245 = ins->data.op[1].many_blocks;
  D.37246 = *D.37245;
  D.37327 = D.37246->max_offset;
  D.37328 = D.37327 - cpos;
  D.37329 = (unsigned int) D.37328;
  D.37330 = D.37329 + 128;
  if (D.37330 <= 255) goto <D.43684>; else goto <D.43681>;
  <D.43684>:
  if (0 != 0) goto <D.43685>; else goto <D.43686>;
  <D.43685>:
  code.5302 = code;
  code = code.5302 + 1;
  D.39804 = 117;
  *code.5302 = D.39804;
  goto <D.43688>;
  <D.43686>:
  code.5303 = code;
  code = code.5303 + 1;
  D.39807 = 117;
  *code.5303 = D.39807;
  <D.43688>:
  *code = 0;
  code = code + 1;
  goto <D.43682>;
  <D.43681>:
  code.5304 = code;
  code = code.5304 + 1;
  *code.5304 = 15;
  if (0 != 0) goto <D.43691>; else goto <D.43692>;
  <D.43691>:
  code.5305 = code;
  code = code.5305 + 1;
  D.39804 = 117;
  D.41551 = D.39804 + 16;
  *code.5305 = D.41551;
  goto <D.43694>;
  <D.43692>:
  code.5306 = code;
  code = code.5306 + 1;
  D.39807 = 117;
  D.41554 = D.39807 + 16;
  *code.5306 = D.41554;
  <D.43694>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5307 = code;
        code = code.5307 + 1;
        D.43697 = imb.b[0];
        *code.5307 = D.43697;
        code.5308 = code;
        code = code.5308 + 1;
        D.43699 = imb.b[1];
        *code.5308 = D.43699;
        code.5309 = code;
        code = code.5309 + 1;
        D.43701 = imb.b[2];
        *code.5309 = D.43701;
        code.5310 = code;
        code = code.5310 + 1;
        D.43703 = imb.b[3];
        *code.5310 = D.43703;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43682>:
  <D.43680>:
  goto <D.24796>;
  <D.27963>:
  {
    guchar * br1;

    code.5311 = code;
    code = code.5311 + 1;
    *code.5311 = 80;
    code.5312 = code;
    code = code.5312 + 1;
    *code.5312 = 217;
    code.5313 = code;
    code = code.5313 + 1;
    *code.5313 = 229;
    code.5314 = code;
    code = code.5314 + 1;
    *code.5314 = 223;
    code.5315 = code;
    code = code.5315 + 1;
    *code.5315 = 224;
    if (1 != 0) goto <D.43709>; else goto <D.43710>;
    <D.43709>:
    code.5316 = code;
    code = code.5316 + 1;
    *code.5316 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 16640;
          code.5317 = code;
          code = code.5317 + 1;
          D.43713 = imb.b[0];
          *code.5317 = D.43713;
          code.5318 = code;
          code = code.5318 + 1;
          D.43715 = imb.b[1];
          *code.5318 = D.43715;
          code.5319 = code;
          code = code.5319 + 1;
          D.43717 = imb.b[2];
          *code.5319 = D.43717;
          code.5320 = code;
          code = code.5320 + 1;
          D.43719 = imb.b[3];
          *code.5320 = D.43719;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.27966>;
    <D.43710>:
    if (0 != 0) goto <D.43720>; else goto <D.43721>;
    <D.43720>:
    code.5321 = code;
    code = code.5321 + 1;
    *code.5321 = 131;
    code.5322 = code;
    code = code.5322 + 1;
    *code.5322 = 224;
    *code = 0;
    code = code + 1;
    goto <D.43724>;
    <D.43721>:
    code.5323 = code;
    code = code.5323 + 1;
    *code.5323 = 129;
    code.5324 = code;
    code = code.5324 + 1;
    *code.5324 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 16640;
          code.5325 = code;
          code = code.5325 + 1;
          D.43728 = imb.b[0];
          *code.5325 = D.43728;
          code.5326 = code;
          code = code.5326 + 1;
          D.43730 = imb.b[1];
          *code.5326 = D.43730;
          code.5327 = code;
          code = code.5327 + 1;
          D.43732 = imb.b[2];
          *code.5327 = D.43732;
          code.5328 = code;
          code = code.5328 + 1;
          D.43734 = imb.b[3];
          *code.5328 = D.43734;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43724>:
    <D.27966>:
    if (1 != 0) goto <D.43735>; else goto <D.43736>;
    <D.43735>:
    code.5329 = code;
    code = code.5329 + 1;
    *code.5329 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 256;
          code.5330 = code;
          code = code.5330 + 1;
          D.43739 = imb.b[0];
          *code.5330 = D.43739;
          code.5331 = code;
          code = code.5331 + 1;
          D.43741 = imb.b[1];
          *code.5331 = D.43741;
          code.5332 = code;
          code = code.5332 + 1;
          D.43743 = imb.b[2];
          *code.5332 = D.43743;
          code.5333 = code;
          code = code.5333 + 1;
          D.43745 = imb.b[3];
          *code.5333 = D.43745;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.27969>;
    <D.43736>:
    if (0 != 0) goto <D.43746>; else goto <D.43747>;
    <D.43746>:
    code.5334 = code;
    code = code.5334 + 1;
    *code.5334 = 131;
    code.5335 = code;
    code = code.5335 + 1;
    *code.5335 = 248;
    *code = 0;
    code = code + 1;
    goto <D.43750>;
    <D.43747>:
    code.5336 = code;
    code = code.5336 + 1;
    *code.5336 = 129;
    code.5337 = code;
    code = code.5337 + 1;
    *code.5337 = 248;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 256;
          code.5338 = code;
          code = code.5338 + 1;
          D.43754 = imb.b[0];
          *code.5338 = D.43754;
          code.5339 = code;
          code = code.5339 + 1;
          D.43756 = imb.b[1];
          *code.5339 = D.43756;
          code.5340 = code;
          code = code.5340 + 1;
          D.43758 = imb.b[2];
          *code.5340 = D.43758;
          code.5341 = code;
          code = code.5341 + 1;
          D.43760 = imb.b[3];
          *code.5341 = D.43760;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43750>:
    <D.27969>:
    code.5342 = code;
    code = code.5342 + 1;
    *code.5342 = 88;
    br1 = code;
    if (0 != 0) goto <D.43762>; else goto <D.43763>;
    <D.43762>:
    code.5343 = code;
    code = code.5343 + 1;
    D.39804 = 117;
    *code.5343 = D.39804;
    goto <D.43765>;
    <D.43763>:
    code.5344 = code;
    code = code.5344 + 1;
    D.39807 = 117;
    *code.5344 = D.39807;
    <D.43765>:
    *code = 0;
    code = code + 1;
    code.5345 = code;
    code = code.5345 + 1;
    *code.5345 = 221;
    code.5346 = code;
    code = code.5346 + 1;
    *code.5346 = 216;
    {
      struct MonoInst * tins;

      tins = mono_branch_optimize_exception_target (cfg, bb, "ArithmeticException");
      if (tins == 0B) goto <D.43769>; else goto <D.43770>;
      <D.43769>:
      code.422 = (int) code;
      D.31409 = cfg->native_code;
      D.31488 = (int) D.31409;
      D.31489 = code.422 - D.31488;
      mono_add_patch_info (cfg, D.31489, 9, "ArithmeticException");
      code.5347 = code;
      code = code.5347 + 1;
      *code.5347 = 15;
      if (0 != 0) goto <D.43772>; else goto <D.43773>;
      <D.43772>:
      code.5348 = code;
      code = code.5348 + 1;
      D.34479 = 116;
      D.41341 = D.34479 + 16;
      *code.5348 = D.41341;
      goto <D.43775>;
      <D.43773>:
      code.5349 = code;
      code = code.5349 + 1;
      D.34482 = 116;
      D.41344 = D.34482 + 16;
      *code.5349 = D.41344;
      <D.43775>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.5350 = code;
            code = code.5350 + 1;
            D.43778 = imb.b[0];
            *code.5350 = D.43778;
            code.5351 = code;
            code = code.5351 + 1;
            D.43780 = imb.b[1];
            *code.5351 = D.43780;
            code.5352 = code;
            code = code.5352 + 1;
            D.43782 = imb.b[2];
            *code.5352 = D.43782;
            code.5353 = code;
            code = code.5353 + 1;
            D.43784 = imb.b[3];
            *code.5353 = D.43784;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43785>;
      <D.43770>:
      D.43786 = tins->data.op[1].many_blocks;
      D.43787 = *D.43786;
      D.43788 = D.43787->native_offset;
      if (D.43788 != 0) goto <D.43789>; else goto <D.43790>;
      <D.43789>:
      {
        int offset;
        guint8 * branch_start;

        D.31409 = cfg->native_code;
        D.43786 = tins->data.op[1].many_blocks;
        D.43787 = *D.43786;
        D.43788 = D.43787->native_offset;
        D.43791 = (sizetype) D.43788;
        D.43792 = D.31409 + D.43791;
        D.43793 = (int) D.43792;
        code.422 = (int) code;
        D.43794 = D.43793 - code.422;
        offset = D.43794 + -2;
        branch_start = code;
        offset.5354 = (unsigned int) offset;
        D.43796 = offset.5354 + 128;
        if (D.43796 <= 255) goto <D.43797>; else goto <D.43798>;
        <D.43797>:
        if (0 != 0) goto <D.43799>; else goto <D.43800>;
        <D.43799>:
        code.5355 = code;
        code = code.5355 + 1;
        D.34479 = 116;
        *code.5355 = D.34479;
        goto <D.43802>;
        <D.43800>:
        code.5356 = code;
        code = code.5356 + 1;
        D.34482 = 116;
        *code.5356 = D.34482;
        <D.43802>:
        D.43804 = (unsigned char) offset;
        *code = D.43804;
        code = code + 1;
        goto <D.43805>;
        <D.43798>:
        D.31409 = cfg->native_code;
        D.43786 = tins->data.op[1].many_blocks;
        D.43787 = *D.43786;
        D.43788 = D.43787->native_offset;
        D.43791 = (sizetype) D.43788;
        D.43792 = D.31409 + D.43791;
        D.43793 = (int) D.43792;
        code.422 = (int) code;
        D.43794 = D.43793 - code.422;
        offset = D.43794 + -6;
        code.5357 = code;
        code = code.5357 + 1;
        *code.5357 = 15;
        if (0 != 0) goto <D.43807>; else goto <D.43808>;
        <D.43807>:
        code.5358 = code;
        code = code.5358 + 1;
        D.34479 = 116;
        D.41341 = D.34479 + 16;
        *code.5358 = D.41341;
        goto <D.43810>;
        <D.43808>:
        code.5359 = code;
        code = code.5359 + 1;
        D.34482 = 116;
        D.41344 = D.34482 + 16;
        *code.5359 = D.41344;
        <D.43810>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = offset;
              code.5360 = code;
              code = code.5360 + 1;
              D.43813 = imb.b[0];
              *code.5360 = D.43813;
              code.5361 = code;
              code = code.5361 + 1;
              D.43815 = imb.b[1];
              *code.5361 = D.43815;
              code.5362 = code;
              code = code.5362 + 1;
              D.43817 = imb.b[2];
              *code.5362 = D.43817;
              code.5363 = code;
              code = code.5363 + 1;
              D.43819 = imb.b[3];
              *code.5363 = D.43819;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.43805>:
        {
          unsigned char * pos;
          int disp;
          int size;

          pos = branch_start + 1;
          size = 0;
          D.43820 = MEM[(unsigned char *)branch_start];
          D.43821 = (int) D.43820;
          switch (D.43821) <default: <D.28003>, case 15: <D.27982>, case 112: <D.27987>, case 113: <D.27988>, case 114: <D.27989>, case 115: <D.27990>, case 116: <D.27991>, case 117: <D.27992>, case 118: <D.27993>, case 119: <D.27994>, case 120: <D.27995>, case 121: <D.27996>, case 122: <D.27997>, case 123: <D.27998>, case 124: <D.27999>, case 125: <D.28000>, case 126: <D.28001>, case 127: <D.28002>, case 224: <D.27983>, case 225: <D.27984>, case 226: <D.27985>, case 232: <D.27979>, case 233: <D.27980>, case 235: <D.27986>>
          <D.27979>:
          <D.27980>:
          size = size + 1;
          goto <D.27981>;
          <D.27982>:
          D.43822 = *pos;
          D.43823 = D.43822 + 144;
          if (D.43823 > 31) goto <D.43824>; else goto <D.43825>;
          <D.43824>:
          __assert_fail ("0", "mini-x86.c", 4317, &__PRETTY_FUNCTION__);
          <D.43825>:
          size = size + 1;
          pos = pos + 1;
          goto <D.27981>;
          <D.27983>:
          <D.27984>:
          <D.27985>:
          <D.27986>:
          <D.27987>:
          <D.27988>:
          <D.27989>:
          <D.27990>:
          <D.27991>:
          <D.27992>:
          <D.27993>:
          <D.27994>:
          <D.27995>:
          <D.27996>:
          <D.27997>:
          <D.27998>:
          <D.27999>:
          <D.28000>:
          <D.28001>:
          <D.28002>:
          goto <D.27981>;
          <D.28003>:
          __assert_fail ("0", "mini-x86.c", 4317, &__PRETTY_FUNCTION__);
          <D.27981>:
          D.31409 = cfg->native_code;
          D.43786 = tins->data.op[1].many_blocks;
          D.43787 = *D.43786;
          D.43788 = D.43787->native_offset;
          D.43791 = (sizetype) D.43788;
          D.43792 = D.31409 + D.43791;
          D.43793 = (int) D.43792;
          pos.5364 = (int) pos;
          disp = D.43793 - pos.5364;
          if (size != 0) goto <D.43827>; else goto <D.43828>;
          <D.43827>:
          {
            union x86_imm_buf imb;

            try
              {
                D.43829 = disp + -4;
                imb.val = D.43829;
                pos.5365 = pos;
                pos = pos.5365 + 1;
                D.43831 = imb.b[0];
                *pos.5365 = D.43831;
                pos.5366 = pos;
                pos = pos.5366 + 1;
                D.43833 = imb.b[1];
                *pos.5366 = D.43833;
                pos.5367 = pos;
                pos = pos.5367 + 1;
                D.43835 = imb.b[2];
                *pos.5367 = D.43835;
                pos.5368 = pos;
                pos = pos.5368 + 1;
                D.43837 = imb.b[3];
                *pos.5368 = D.43837;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.43838>;
          <D.43828>:
          disp.5369 = (unsigned int) disp;
          D.43840 = disp.5369 + 127;
          if (D.43840 <= 255) goto <D.43841>; else goto <D.43842>;
          <D.43841>:
          D.43843 = (unsigned char) disp;
          D.43844 = D.43843 + 255;
          *pos = D.43844;
          pos = pos + 1;
          goto <D.43845>;
          <D.43842>:
          __assert_fail ("0", "mini-x86.c", 4317, &__PRETTY_FUNCTION__);
          <D.43845>:
          <D.43838>:
        }
      }
      goto <D.43846>;
      <D.43790>:
      D.43786 = tins->data.op[1].many_blocks;
      D.43787 = *D.43786;
      code.422 = (int) code;
      D.31409 = cfg->native_code;
      D.31488 = (int) D.31409;
      D.31489 = code.422 - D.31488;
      mono_add_patch_info (cfg, D.31489, 0, D.43787);
      D.31411 = cfg->opt;
      D.35226 = D.31411 & 2;
      if (D.35226 != 0) goto <D.43849>; else goto <D.43847>;
      <D.43849>:
      D.43786 = tins->data.op[1].many_blocks;
      D.43787 = *D.43786;
      D.43850 = D.43787->max_offset;
      D.43851 = D.43850 - cpos;
      D.43852 = (unsigned int) D.43851;
      D.43853 = D.43852 + 128;
      if (D.43853 <= 255) goto <D.43854>; else goto <D.43847>;
      <D.43854>:
      if (0 != 0) goto <D.43855>; else goto <D.43856>;
      <D.43855>:
      code.5370 = code;
      code = code.5370 + 1;
      D.34479 = 116;
      *code.5370 = D.34479;
      goto <D.43858>;
      <D.43856>:
      code.5371 = code;
      code = code.5371 + 1;
      D.34482 = 116;
      *code.5371 = D.34482;
      <D.43858>:
      *code = 0;
      code = code + 1;
      goto <D.43848>;
      <D.43847>:
      code.5372 = code;
      code = code.5372 + 1;
      *code.5372 = 15;
      if (0 != 0) goto <D.43861>; else goto <D.43862>;
      <D.43861>:
      code.5373 = code;
      code = code.5373 + 1;
      D.34479 = 116;
      D.41341 = D.34479 + 16;
      *code.5373 = D.41341;
      goto <D.43864>;
      <D.43862>:
      code.5374 = code;
      code = code.5374 + 1;
      D.34482 = 116;
      D.41344 = D.34482 + 16;
      *code.5374 = D.41344;
      <D.43864>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.5375 = code;
            code = code.5375 + 1;
            D.43867 = imb.b[0];
            *code.5375 = D.43867;
            code.5376 = code;
            code = code.5376 + 1;
            D.43869 = imb.b[1];
            *code.5376 = D.43869;
            code.5377 = code;
            code = code.5377 + 1;
            D.43871 = imb.b[2];
            *code.5377 = D.43871;
            code.5378 = code;
            code = code.5378 + 1;
            D.43873 = imb.b[3];
            *code.5378 = D.43873;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.43848>:
      <D.43846>:
      <D.43785>:
    }
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = br1 + 1;
      size = 0;
      D.43874 = MEM[(unsigned char *)br1];
      D.43875 = (int) D.43874;
      switch (D.43875) <default: <D.28033>, case 15: <D.28012>, case 112: <D.28017>, case 113: <D.28018>, case 114: <D.28019>, case 115: <D.28020>, case 116: <D.28021>, case 117: <D.28022>, case 118: <D.28023>, case 119: <D.28024>, case 120: <D.28025>, case 121: <D.28026>, case 122: <D.28027>, case 123: <D.28028>, case 124: <D.28029>, case 125: <D.28030>, case 126: <D.28031>, case 127: <D.28032>, case 224: <D.28013>, case 225: <D.28014>, case 226: <D.28015>, case 232: <D.28009>, case 233: <D.28010>, case 235: <D.28016>>
      <D.28009>:
      <D.28010>:
      size = size + 1;
      goto <D.28011>;
      <D.28012>:
      D.43876 = *pos;
      D.43877 = D.43876 + 144;
      if (D.43877 > 31) goto <D.43878>; else goto <D.43879>;
      <D.43878>:
      __assert_fail ("0", "mini-x86.c", 4319, &__PRETTY_FUNCTION__);
      <D.43879>:
      size = size + 1;
      pos = pos + 1;
      goto <D.28011>;
      <D.28013>:
      <D.28014>:
      <D.28015>:
      <D.28016>:
      <D.28017>:
      <D.28018>:
      <D.28019>:
      <D.28020>:
      <D.28021>:
      <D.28022>:
      <D.28023>:
      <D.28024>:
      <D.28025>:
      <D.28026>:
      <D.28027>:
      <D.28028>:
      <D.28029>:
      <D.28030>:
      <D.28031>:
      <D.28032>:
      goto <D.28011>;
      <D.28033>:
      __assert_fail ("0", "mini-x86.c", 4319, &__PRETTY_FUNCTION__);
      <D.28011>:
      code.422 = (int) code;
      pos.5379 = (int) pos;
      disp = code.422 - pos.5379;
      if (size != 0) goto <D.43881>; else goto <D.43882>;
      <D.43881>:
      {
        union x86_imm_buf imb;

        try
          {
            D.43883 = disp + -4;
            imb.val = D.43883;
            pos.5380 = pos;
            pos = pos.5380 + 1;
            D.43885 = imb.b[0];
            *pos.5380 = D.43885;
            pos.5381 = pos;
            pos = pos.5381 + 1;
            D.43887 = imb.b[1];
            *pos.5381 = D.43887;
            pos.5382 = pos;
            pos = pos.5382 + 1;
            D.43889 = imb.b[2];
            *pos.5382 = D.43889;
            pos.5383 = pos;
            pos = pos.5383 + 1;
            D.43891 = imb.b[3];
            *pos.5383 = D.43891;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.43892>;
      <D.43882>:
      disp.5384 = (unsigned int) disp;
      D.43894 = disp.5384 + 127;
      if (D.43894 <= 255) goto <D.43895>; else goto <D.43896>;
      <D.43895>:
      D.43897 = (unsigned char) disp;
      D.43898 = D.43897 + 255;
      *pos = D.43898;
      pos = pos + 1;
      goto <D.43899>;
      <D.43896>:
      __assert_fail ("0", "mini-x86.c", 4319, &__PRETTY_FUNCTION__);
      <D.43899>:
      <D.43892>:
    }
    goto <D.24796>;
  }
  <D.28035>:
  D.31551 = ins->data.op[0].const_val;
  D.31604 = ins->dreg;
  code = mono_x86_emit_tls_get (code, D.31604, D.31551);
  goto <D.24796>;
  <D.28036>:
  D.31548 = ins->sreg1;
  D.31604 = ins->dreg;
  code = emit_tls_get_reg (code, D.31604, D.31548);
  goto <D.24796>;
  <D.28037>:
  D.31551 = ins->data.op[0].const_val;
  D.31548 = ins->sreg1;
  code = mono_x86_emit_tls_set (code, D.31548, D.31551);
  goto <D.24796>;
  <D.28038>:
  D.31527 = ins->sreg2;
  D.31548 = ins->sreg1;
  code = emit_tls_set_reg (code, D.31548, D.31527);
  goto <D.24796>;
  <D.28039>:
  D.43900 = ins->backend.memory_barrier_kind;
  switch (D.43900) <default: <D.43991>, case 2: <D.28040>, case 4: <D.28041>>
  <D.28040>:
  <D.28041>:
  code.5385 = code;
  code = code.5385 + 1;
  *code.5385 = 240;
  if (1 != 0) goto <D.43902>; else goto <D.43903>;
  <D.43902>:
  code.5386 = code;
  code = code.5386 + 1;
  *code.5386 = 131;
  if (1 != 0) goto <D.43905>; else goto <D.43906>;
  <D.43905>:
  if (1 != 0) goto <D.43907>; else goto <D.43908>;
  <D.43907>:
  code.5387 = code;
  code = code.5387 + 1;
  *code.5387 = 4;
  code.5388 = code;
  code = code.5388 + 1;
  *code.5388 = 36;
  goto <D.43911>;
  <D.43908>:
  if (1 != 0) goto <D.43912>; else goto <D.43913>;
  <D.43912>:
  code.5389 = code;
  code = code.5389 + 1;
  *code.5389 = 68;
  code.5390 = code;
  code = code.5390 + 1;
  *code.5390 = 36;
  *code = 0;
  code = code + 1;
  goto <D.43916>;
  <D.43913>:
  code.5391 = code;
  code = code.5391 + 1;
  *code.5391 = 132;
  code.5392 = code;
  code = code.5392 + 1;
  *code.5392 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5393 = code;
        code = code.5393 + 1;
        D.43920 = imb.b[0];
        *code.5393 = D.43920;
        code.5394 = code;
        code = code.5394 + 1;
        D.43922 = imb.b[1];
        *code.5394 = D.43922;
        code.5395 = code;
        code = code.5395 + 1;
        D.43924 = imb.b[2];
        *code.5395 = D.43924;
        code.5396 = code;
        code = code.5396 + 1;
        D.43926 = imb.b[3];
        *code.5396 = D.43926;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43916>:
  <D.43911>:
  goto <D.28043>;
  <D.43906>:
  if (1 != 0) goto <D.43927>; else goto <D.43928>;
  <D.43927>:
  code.5397 = code;
  code = code.5397 + 1;
  *code.5397 = 4;
  goto <D.28043>;
  <D.43928>:
  if (1 != 0) goto <D.43930>; else goto <D.43931>;
  <D.43930>:
  code.5398 = code;
  code = code.5398 + 1;
  *code.5398 = 68;
  *code = 0;
  code = code + 1;
  goto <D.43933>;
  <D.43931>:
  code.5399 = code;
  code = code.5399 + 1;
  *code.5399 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5400 = code;
        code = code.5400 + 1;
        D.43936 = imb.b[0];
        *code.5400 = D.43936;
        code.5401 = code;
        code = code.5401 + 1;
        D.43938 = imb.b[1];
        *code.5401 = D.43938;
        code.5402 = code;
        code = code.5402 + 1;
        D.43940 = imb.b[2];
        *code.5402 = D.43940;
        code.5403 = code;
        code = code.5403 + 1;
        D.43942 = imb.b[3];
        *code.5403 = D.43942;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43933>:
  <D.28043>:
  *code = 0;
  code = code + 1;
  goto <D.43943>;
  <D.43903>:
  code.5404 = code;
  code = code.5404 + 1;
  *code.5404 = 129;
  if (1 != 0) goto <D.43945>; else goto <D.43946>;
  <D.43945>:
  if (1 != 0) goto <D.43947>; else goto <D.43948>;
  <D.43947>:
  code.5405 = code;
  code = code.5405 + 1;
  *code.5405 = 4;
  code.5406 = code;
  code = code.5406 + 1;
  *code.5406 = 36;
  goto <D.43951>;
  <D.43948>:
  if (1 != 0) goto <D.43952>; else goto <D.43953>;
  <D.43952>:
  code.5407 = code;
  code = code.5407 + 1;
  *code.5407 = 68;
  code.5408 = code;
  code = code.5408 + 1;
  *code.5408 = 36;
  *code = 0;
  code = code + 1;
  goto <D.43956>;
  <D.43953>:
  code.5409 = code;
  code = code.5409 + 1;
  *code.5409 = 132;
  code.5410 = code;
  code = code.5410 + 1;
  *code.5410 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5411 = code;
        code = code.5411 + 1;
        D.43960 = imb.b[0];
        *code.5411 = D.43960;
        code.5412 = code;
        code = code.5412 + 1;
        D.43962 = imb.b[1];
        *code.5412 = D.43962;
        code.5413 = code;
        code = code.5413 + 1;
        D.43964 = imb.b[2];
        *code.5413 = D.43964;
        code.5414 = code;
        code = code.5414 + 1;
        D.43966 = imb.b[3];
        *code.5414 = D.43966;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43956>:
  <D.43951>:
  goto <D.28046>;
  <D.43946>:
  if (1 != 0) goto <D.43967>; else goto <D.43968>;
  <D.43967>:
  code.5415 = code;
  code = code.5415 + 1;
  *code.5415 = 4;
  goto <D.28046>;
  <D.43968>:
  if (1 != 0) goto <D.43970>; else goto <D.43971>;
  <D.43970>:
  code.5416 = code;
  code = code.5416 + 1;
  *code.5416 = 68;
  *code = 0;
  code = code + 1;
  goto <D.43973>;
  <D.43971>:
  code.5417 = code;
  code = code.5417 + 1;
  *code.5417 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5418 = code;
        code = code.5418 + 1;
        D.43976 = imb.b[0];
        *code.5418 = D.43976;
        code.5419 = code;
        code = code.5419 + 1;
        D.43978 = imb.b[1];
        *code.5419 = D.43978;
        code.5420 = code;
        code = code.5420 + 1;
        D.43980 = imb.b[2];
        *code.5420 = D.43980;
        code.5421 = code;
        code = code.5421 + 1;
        D.43982 = imb.b[3];
        *code.5421 = D.43982;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43973>:
  <D.28046>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5422 = code;
        code = code.5422 + 1;
        D.43984 = imb.b[0];
        *code.5422 = D.43984;
        code.5423 = code;
        code = code.5423 + 1;
        D.43986 = imb.b[1];
        *code.5423 = D.43986;
        code.5424 = code;
        code = code.5424 + 1;
        D.43988 = imb.b[2];
        *code.5424 = D.43988;
        code.5425 = code;
        code = code.5425 + 1;
        D.43990 = imb.b[3];
        *code.5425 = D.43990;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43943>:
  goto <D.28049>;
  <D.43991>:
  <D.28049>:
  goto <D.24796>;
  <D.28050>:
  {
    int dreg;

    dreg = ins->dreg;
    D.31548 = ins->sreg1;
    if (D.31548 == dreg) goto <D.43992>; else goto <D.43993>;
    <D.43992>:
    code.5426 = code;
    code = code.5426 + 1;
    D.31527 = ins->sreg2;
    D.34084 = (unsigned char) D.31527;
    D.34085 = D.34084 + 80;
    *code.5426 = D.34085;
    dreg = ins->sreg2;
    <D.43993>:
    D.31527 = ins->sreg2;
    if (D.31527 != dreg) goto <D.43995>; else goto <D.43996>;
    <D.43995>:
    switch (4) <default: <D.28056>, case 1: <D.28052>, case 2: <D.28054>, case 4: <D.28055>>
    <D.28052>:
    code.5427 = code;
    code = code.5427 + 1;
    *code.5427 = 138;
    goto <D.28053>;
    <D.28054>:
    code.5428 = code;
    code = code.5428 + 1;
    *code.5428 = 102;
    <D.28055>:
    code.5429 = code;
    code = code.5429 + 1;
    *code.5429 = 139;
    goto <D.28053>;
    <D.28056>:
    __assert_fail ("0", "mini-x86.c", 4359, &__PRETTY_FUNCTION__);
    <D.28053>:
    code.5430 = code;
    code = code.5430 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31527 = ins->sreg2;
    D.31528 = (signed char) D.31527;
    D.31529 = D.31528 & 7;
    D.37391 = D.32533 | D.31529;
    D.37392 = (unsigned char) D.37391;
    *code.5430 = D.37392;
    <D.43996>:
    code.5431 = code;
    code = code.5431 + 1;
    *code.5431 = 240;
    code.5432 = code;
    code = code.5432 + 1;
    *code.5432 = 15;
    if (0 != 0) goto <D.44003>; else goto <D.44004>;
    <D.44003>:
    code.5433 = code;
    code = code.5433 + 1;
    *code.5433 = 192;
    goto <D.44006>;
    <D.44004>:
    code.5434 = code;
    code = code.5434 + 1;
    *code.5434 = 193;
    <D.44006>:
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.44008>; else goto <D.44009>;
    <D.44008>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.44010>; else goto <D.44011>;
    <D.44010>:
    code.5435 = code;
    code = code.5435 + 1;
    D.44013 = dreg & 7;
    D.44014 = D.44013 << 3;
    D.44015 = (signed char) D.44014;
    D.44016 = D.44015 | 4;
    D.44017 = (unsigned char) D.44016;
    *code.5435 = D.44017;
    code.5436 = code;
    code = code.5436 + 1;
    *code.5436 = 36;
    goto <D.44019>;
    <D.44011>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.44020>; else goto <D.44021>;
    <D.44020>:
    code.5437 = code;
    code = code.5437 + 1;
    D.44013 = dreg & 7;
    D.44014 = D.44013 << 3;
    D.44015 = (signed char) D.44014;
    D.44023 = D.44015 | 68;
    D.44024 = (unsigned char) D.44023;
    *code.5437 = D.44024;
    code.5438 = code;
    code = code.5438 + 1;
    *code.5438 = 36;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.44026>;
    <D.44021>:
    code.5439 = code;
    code = code.5439 + 1;
    D.44013 = dreg & 7;
    D.44014 = D.44013 << 3;
    D.44015 = (signed char) D.44014;
    D.44028 = D.44015 | -124;
    D.44029 = (unsigned char) D.44028;
    *code.5439 = D.44029;
    code.5440 = code;
    code = code.5440 + 1;
    *code.5440 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.5441 = code;
          code = code.5441 + 1;
          D.44032 = imb.b[0];
          *code.5441 = D.44032;
          code.5442 = code;
          code = code.5442 + 1;
          D.44034 = imb.b[1];
          *code.5442 = D.44034;
          code.5443 = code;
          code = code.5443 + 1;
          D.44036 = imb.b[2];
          *code.5443 = D.44036;
          code.5444 = code;
          code = code.5444 + 1;
          D.44038 = imb.b[3];
          *code.5444 = D.44038;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44026>:
    <D.44019>:
    goto <D.28058>;
    <D.44009>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.44039>; else goto <D.44040>;
    <D.44039>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.44041>; else goto <D.44042>;
    <D.44041>:
    code.5445 = code;
    code = code.5445 + 1;
    D.44013 = dreg & 7;
    D.44014 = D.44013 << 3;
    D.44015 = (signed char) D.44014;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.44044 = D.44015 | D.31586;
    D.44045 = (unsigned char) D.44044;
    *code.5445 = D.44045;
    goto <D.28058>;
    <D.44042>:
    <D.44040>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.44046>; else goto <D.44047>;
    <D.44046>:
    code.5446 = code;
    code = code.5446 + 1;
    D.44013 = dreg & 7;
    D.44014 = D.44013 << 3;
    D.44015 = (signed char) D.44014;
    D.44049 = D.44015 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.44050 = D.44049 | D.31586;
    D.44051 = (unsigned char) D.44050;
    *code.5446 = D.44051;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.44052>;
    <D.44047>:
    code.5447 = code;
    code = code.5447 + 1;
    D.44013 = dreg & 7;
    D.44014 = D.44013 << 3;
    D.44015 = (signed char) D.44014;
    D.44054 = D.44015 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.44055 = D.44054 | D.31586;
    D.44056 = (unsigned char) D.44055;
    *code.5447 = D.44056;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.5448 = code;
          code = code.5448 + 1;
          D.44058 = imb.b[0];
          *code.5448 = D.44058;
          code.5449 = code;
          code = code.5449 + 1;
          D.44060 = imb.b[1];
          *code.5449 = D.44060;
          code.5450 = code;
          code = code.5450 + 1;
          D.44062 = imb.b[2];
          *code.5450 = D.44062;
          code.5451 = code;
          code = code.5451 + 1;
          D.44064 = imb.b[3];
          *code.5451 = D.44064;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44052>:
    <D.28058>:
    D.31604 = ins->dreg;
    if (D.31604 != dreg) goto <D.44065>; else goto <D.44066>;
    <D.44065>:
    switch (4) <default: <D.28064>, case 1: <D.28060>, case 2: <D.28062>, case 4: <D.28063>>
    <D.28060>:
    code.5452 = code;
    code = code.5452 + 1;
    *code.5452 = 138;
    goto <D.28061>;
    <D.28062>:
    code.5453 = code;
    code = code.5453 + 1;
    *code.5453 = 102;
    <D.28063>:
    code.5454 = code;
    code = code.5454 + 1;
    *code.5454 = 139;
    goto <D.28061>;
    <D.28064>:
    __assert_fail ("0", "mini-x86.c", 4365, &__PRETTY_FUNCTION__);
    <D.28061>:
    code.5455 = code;
    code = code.5455 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.44071 = (signed char) dreg;
    D.44072 = D.44071 & 7;
    D.44073 = D.32533 | D.44072;
    D.44074 = (unsigned char) D.44073;
    *code.5455 = D.44074;
    code.5456 = code;
    code = code.5456 + 1;
    D.44076 = (unsigned char) dreg;
    D.44077 = D.44076 + 88;
    *code.5456 = D.44077;
    <D.44066>:
    goto <D.24796>;
  }
  <D.28065>:
  {
    int dreg;

    dreg = ins->dreg;
    D.44078 = BIT_FIELD_REF <*cfg, 8, 3432>;
    D.44079 = D.44078 & 8;
    D.44080 = D.44079 == 0;
    D.44081 = (long int) D.44080;
    D.44082 = __builtin_expect (D.44081, 0);
    if (D.44082 != 0) goto <D.44083>; else goto <D.44084>;
    <D.44083>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4374, "cfg->has_atomic_add_new_i4");
    <D.44084>:
    D.31527 = ins->sreg2;
    if (D.31527 == dreg) goto <D.44085>; else goto <D.44086>;
    <D.44085>:
    if (dreg == 3) goto <D.44087>; else goto <D.44088>;
    <D.44087>:
    dreg = 7;
    D.31548 = ins->sreg1;
    if (D.31548 == 7) goto <D.44089>; else goto <D.44090>;
    <D.44089>:
    dreg = 6;
    <D.44090>:
    goto <D.44091>;
    <D.44088>:
    dreg = 3;
    D.31548 = ins->sreg1;
    if (D.31548 == 3) goto <D.44092>; else goto <D.44093>;
    <D.44092>:
    dreg = 7;
    <D.44093>:
    <D.44091>:
    goto <D.44094>;
    <D.44086>:
    D.31548 = ins->sreg1;
    if (D.31548 == dreg) goto <D.44095>; else goto <D.44096>;
    <D.44095>:
    if (dreg == 3) goto <D.44097>; else goto <D.44098>;
    <D.44097>:
    dreg = 7;
    D.31527 = ins->sreg2;
    if (D.31527 == 7) goto <D.44099>; else goto <D.44100>;
    <D.44099>:
    dreg = 6;
    <D.44100>:
    goto <D.44101>;
    <D.44098>:
    dreg = 3;
    D.31527 = ins->sreg2;
    if (D.31527 == 3) goto <D.44102>; else goto <D.44103>;
    <D.44102>:
    dreg = 7;
    <D.44103>:
    <D.44101>:
    <D.44096>:
    <D.44094>:
    D.31604 = ins->dreg;
    if (D.31604 != dreg) goto <D.44104>; else goto <D.44105>;
    <D.44104>:
    code.5457 = code;
    code = code.5457 + 1;
    D.44107 = (unsigned char) dreg;
    D.44108 = D.44107 + 80;
    *code.5457 = D.44108;
    <D.44105>:
    switch (4) <default: <D.28071>, case 1: <D.28067>, case 2: <D.28069>, case 4: <D.28070>>
    <D.28067>:
    code.5458 = code;
    code = code.5458 + 1;
    *code.5458 = 138;
    goto <D.28068>;
    <D.28069>:
    code.5459 = code;
    code = code.5459 + 1;
    *code.5459 = 102;
    <D.28070>:
    code.5460 = code;
    code = code.5460 + 1;
    *code.5460 = 139;
    goto <D.28068>;
    <D.28071>:
    __assert_fail ("0", "mini-x86.c", 4403, &__PRETTY_FUNCTION__);
    <D.28068>:
    code.5461 = code;
    code = code.5461 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44116 = D.44115 | -64;
    D.31527 = ins->sreg2;
    D.31528 = (signed char) D.31527;
    D.31529 = D.31528 & 7;
    D.44117 = D.44116 | D.31529;
    D.44118 = (unsigned char) D.44117;
    *code.5461 = D.44118;
    code.5462 = code;
    code = code.5462 + 1;
    *code.5462 = 240;
    code.5463 = code;
    code = code.5463 + 1;
    *code.5463 = 15;
    if (0 != 0) goto <D.44121>; else goto <D.44122>;
    <D.44121>:
    code.5464 = code;
    code = code.5464 + 1;
    *code.5464 = 192;
    goto <D.44124>;
    <D.44122>:
    code.5465 = code;
    code = code.5465 + 1;
    *code.5465 = 193;
    <D.44124>:
    D.31548 = ins->sreg1;
    if (D.31548 == 4) goto <D.44126>; else goto <D.44127>;
    <D.44126>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.44128>; else goto <D.44129>;
    <D.44128>:
    code.5466 = code;
    code = code.5466 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44131 = D.44115 | 4;
    D.44132 = (unsigned char) D.44131;
    *code.5466 = D.44132;
    code.5467 = code;
    code = code.5467 + 1;
    *code.5467 = 36;
    goto <D.44134>;
    <D.44129>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.44135>; else goto <D.44136>;
    <D.44135>:
    code.5468 = code;
    code = code.5468 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44138 = D.44115 | 68;
    D.44139 = (unsigned char) D.44138;
    *code.5468 = D.44139;
    code.5469 = code;
    code = code.5469 + 1;
    *code.5469 = 36;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.44141>;
    <D.44136>:
    code.5470 = code;
    code = code.5470 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44143 = D.44115 | -124;
    D.44144 = (unsigned char) D.44143;
    *code.5470 = D.44144;
    code.5471 = code;
    code = code.5471 + 1;
    *code.5471 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.5472 = code;
          code = code.5472 + 1;
          D.44147 = imb.b[0];
          *code.5472 = D.44147;
          code.5473 = code;
          code = code.5473 + 1;
          D.44149 = imb.b[1];
          *code.5473 = D.44149;
          code.5474 = code;
          code = code.5474 + 1;
          D.44151 = imb.b[2];
          *code.5474 = D.44151;
          code.5475 = code;
          code = code.5475 + 1;
          D.44153 = imb.b[3];
          *code.5475 = D.44153;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44141>:
    <D.44134>:
    goto <D.28073>;
    <D.44127>:
    D.31551 = ins->data.op[0].const_val;
    if (D.31551 == 0) goto <D.44154>; else goto <D.44155>;
    <D.44154>:
    D.31548 = ins->sreg1;
    if (D.31548 != 5) goto <D.44156>; else goto <D.44157>;
    <D.44156>:
    code.5476 = code;
    code = code.5476 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.44159 = D.44115 | D.31586;
    D.44160 = (unsigned char) D.44159;
    *code.5476 = D.44160;
    goto <D.28073>;
    <D.44157>:
    <D.44155>:
    D.31551 = ins->data.op[0].const_val;
    D.31557 = (unsigned int) D.31551;
    D.31558 = D.31557 + 128;
    if (D.31558 <= 255) goto <D.44161>; else goto <D.44162>;
    <D.44161>:
    code.5477 = code;
    code = code.5477 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44164 = D.44115 | 64;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.44165 = D.44164 | D.31586;
    D.44166 = (unsigned char) D.44165;
    *code.5477 = D.44166;
    D.31551 = ins->data.op[0].const_val;
    D.31563 = (unsigned char) D.31551;
    *code = D.31563;
    code = code + 1;
    goto <D.44167>;
    <D.44162>:
    code.5478 = code;
    code = code.5478 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44169 = D.44115 | -128;
    D.31548 = ins->sreg1;
    D.31585 = (signed char) D.31548;
    D.31586 = D.31585 & 7;
    D.44170 = D.44169 | D.31586;
    D.44171 = (unsigned char) D.44170;
    *code.5478 = D.44171;
    {
      union x86_imm_buf imb;

      try
        {
          D.31551 = ins->data.op[0].const_val;
          imb.val = D.31551;
          code.5479 = code;
          code = code.5479 + 1;
          D.44173 = imb.b[0];
          *code.5479 = D.44173;
          code.5480 = code;
          code = code.5480 + 1;
          D.44175 = imb.b[1];
          *code.5480 = D.44175;
          code.5481 = code;
          code = code.5481 + 1;
          D.44177 = imb.b[2];
          *code.5481 = D.44177;
          code.5482 = code;
          code = code.5482 + 1;
          D.44179 = imb.b[3];
          *code.5482 = D.44179;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44167>:
    <D.28073>:
    code.5483 = code;
    code = code.5483 + 1;
    *code.5483 = 3;
    code.5484 = code;
    code = code.5484 + 1;
    D.44113 = dreg & 7;
    D.44114 = D.44113 << 3;
    D.44115 = (signed char) D.44114;
    D.44116 = D.44115 | -64;
    D.31527 = ins->sreg2;
    D.31528 = (signed char) D.31527;
    D.31529 = D.31528 & 7;
    D.44117 = D.44116 | D.31529;
    D.44118 = (unsigned char) D.44117;
    *code.5484 = D.44118;
    D.31604 = ins->dreg;
    if (D.31604 != dreg) goto <D.44182>; else goto <D.44183>;
    <D.44182>:
    switch (4) <default: <D.28079>, case 1: <D.28075>, case 2: <D.28077>, case 4: <D.28078>>
    <D.28075>:
    code.5485 = code;
    code = code.5485 + 1;
    *code.5485 = 138;
    goto <D.28076>;
    <D.28077>:
    code.5486 = code;
    code = code.5486 + 1;
    *code.5486 = 102;
    <D.28078>:
    code.5487 = code;
    code = code.5487 + 1;
    *code.5487 = 139;
    goto <D.28076>;
    <D.28079>:
    __assert_fail ("0", "mini-x86.c", 4410, &__PRETTY_FUNCTION__);
    <D.28076>:
    code.5488 = code;
    code = code.5488 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.44188 = (signed char) dreg;
    D.44189 = D.44188 & 7;
    D.44190 = D.32533 | D.44189;
    D.44191 = (unsigned char) D.44190;
    *code.5488 = D.44191;
    code.5489 = code;
    code = code.5489 + 1;
    D.44107 = (unsigned char) dreg;
    D.44193 = D.44107 + 88;
    *code.5489 = D.44193;
    <D.44183>:
    goto <D.24796>;
  }
  <D.28080>:
  {
    guchar * br[2];
    int sreg2;
    int breg;

    try
      {
        sreg2 = ins->sreg2;
        breg = ins->sreg1;
        D.44078 = BIT_FIELD_REF <*cfg, 8, 3432>;
        D.44194 = D.44078 & 16;
        D.44195 = D.44194 == 0;
        D.44196 = (long int) D.44195;
        D.44197 = __builtin_expect (D.44196, 0);
        if (D.44197 != 0) goto <D.44198>; else goto <D.44199>;
        <D.44198>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4421, "cfg->has_atomic_exchange_i4");
        <D.44199>:
        D.31604 = ins->dreg;
        D.34254 = D.31604 != 0;
        D.34255 = (long int) D.34254;
        D.34256 = __builtin_expect (D.34255, 0);
        if (D.34256 != 0) goto <D.44200>; else goto <D.44201>;
        <D.44200>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4427, "ins->dreg == X86_EAX");
        <D.44201>:
        D.31527 = ins->sreg2;
        if (D.31527 == 0) goto <D.44202>; else goto <D.44203>;
        <D.44202>:
        if (breg == 2) goto <D.44205>; else goto <D.44206>;
        <D.44205>:
        iftmp.5490 = 3;
        goto <D.44207>;
        <D.44206>:
        iftmp.5490 = 2;
        <D.44207>:
        sreg2 = iftmp.5490;
        code.5491 = code;
        code = code.5491 + 1;
        D.44209 = (unsigned char) sreg2;
        D.44210 = D.44209 + 80;
        *code.5491 = D.44210;
        switch (4) <default: <D.28088>, case 1: <D.28084>, case 2: <D.28086>, case 4: <D.28087>>
        <D.28084>:
        code.5492 = code;
        code = code.5492 + 1;
        *code.5492 = 138;
        goto <D.28085>;
        <D.28086>:
        code.5493 = code;
        code = code.5493 + 1;
        *code.5493 = 102;
        <D.28087>:
        code.5494 = code;
        code = code.5494 + 1;
        *code.5494 = 139;
        goto <D.28085>;
        <D.28088>:
        __assert_fail ("0", "mini-x86.c", 4433, &__PRETTY_FUNCTION__);
        <D.28085>:
        code.5495 = code;
        code = code.5495 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44218 = D.44217 | -64;
        D.44219 = (unsigned char) D.44218;
        *code.5495 = D.44219;
        <D.44203>:
        if (breg == 0) goto <D.44220>; else goto <D.44221>;
        <D.44220>:
        if (sreg2 == 6) goto <D.44223>; else goto <D.44224>;
        <D.44223>:
        iftmp.5496 = 7;
        goto <D.44225>;
        <D.44224>:
        iftmp.5496 = 6;
        <D.44225>:
        breg = iftmp.5496;
        code.5497 = code;
        code = code.5497 + 1;
        D.44227 = (unsigned char) breg;
        D.44228 = D.44227 + 80;
        *code.5497 = D.44228;
        switch (4) <default: <D.28093>, case 1: <D.28089>, case 2: <D.28091>, case 4: <D.28092>>
        <D.28089>:
        code.5498 = code;
        code = code.5498 + 1;
        *code.5498 = 138;
        goto <D.28090>;
        <D.28091>:
        code.5499 = code;
        code = code.5499 + 1;
        *code.5499 = 102;
        <D.28092>:
        code.5500 = code;
        code = code.5500 + 1;
        *code.5500 = 139;
        goto <D.28090>;
        <D.28093>:
        __assert_fail ("0", "mini-x86.c", 4439, &__PRETTY_FUNCTION__);
        <D.28090>:
        code.5501 = code;
        code = code.5501 + 1;
        D.44233 = breg & 7;
        D.44234 = D.44233 << 3;
        D.44235 = (signed char) D.44234;
        D.44236 = D.44235 | -64;
        D.44237 = (unsigned char) D.44236;
        *code.5501 = D.44237;
        <D.44221>:
        switch (4) <default: <D.28098>, case 1: <D.28094>, case 2: <D.28096>, case 4: <D.28097>>
        <D.28094>:
        code.5502 = code;
        code = code.5502 + 1;
        *code.5502 = 138;
        goto <D.28095>;
        <D.28096>:
        code.5503 = code;
        code = code.5503 + 1;
        *code.5503 = 102;
        <D.28097>:
        code.5504 = code;
        code = code.5504 + 1;
        *code.5504 = 139;
        goto <D.28095>;
        <D.28098>:
        __assert_fail ("0", "mini-x86.c", 4442, &__PRETTY_FUNCTION__);
        <D.28095>:
        if (breg == 4) goto <D.44241>; else goto <D.44242>;
        <D.44241>:
        D.31551 = ins->data.op[0].const_val;
        if (D.31551 == 0) goto <D.44243>; else goto <D.44244>;
        <D.44243>:
        code.5505 = code;
        code = code.5505 + 1;
        *code.5505 = 4;
        code.5506 = code;
        code = code.5506 + 1;
        *code.5506 = 36;
        goto <D.44247>;
        <D.44244>:
        D.31551 = ins->data.op[0].const_val;
        D.31557 = (unsigned int) D.31551;
        D.31558 = D.31557 + 128;
        if (D.31558 <= 255) goto <D.44248>; else goto <D.44249>;
        <D.44248>:
        code.5507 = code;
        code = code.5507 + 1;
        *code.5507 = 68;
        code.5508 = code;
        code = code.5508 + 1;
        *code.5508 = 36;
        D.31551 = ins->data.op[0].const_val;
        D.31563 = (unsigned char) D.31551;
        *code = D.31563;
        code = code + 1;
        goto <D.44252>;
        <D.44249>:
        code.5509 = code;
        code = code.5509 + 1;
        *code.5509 = 132;
        code.5510 = code;
        code = code.5510 + 1;
        *code.5510 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              D.31551 = ins->data.op[0].const_val;
              imb.val = D.31551;
              code.5511 = code;
              code = code.5511 + 1;
              D.44256 = imb.b[0];
              *code.5511 = D.44256;
              code.5512 = code;
              code = code.5512 + 1;
              D.44258 = imb.b[1];
              *code.5512 = D.44258;
              code.5513 = code;
              code = code.5513 + 1;
              D.44260 = imb.b[2];
              *code.5513 = D.44260;
              code.5514 = code;
              code = code.5514 + 1;
              D.44262 = imb.b[3];
              *code.5514 = D.44262;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44252>:
        <D.44247>:
        goto <D.28100>;
        <D.44242>:
        D.31551 = ins->data.op[0].const_val;
        if (D.31551 == 0) goto <D.44263>; else goto <D.44264>;
        <D.44263>:
        if (breg != 5) goto <D.44265>; else goto <D.44266>;
        <D.44265>:
        code.5515 = code;
        code = code.5515 + 1;
        D.44268 = (unsigned char) breg;
        D.44269 = D.44268 & 7;
        *code.5515 = D.44269;
        goto <D.28100>;
        <D.44266>:
        <D.44264>:
        D.31551 = ins->data.op[0].const_val;
        D.31557 = (unsigned int) D.31551;
        D.31558 = D.31557 + 128;
        if (D.31558 <= 255) goto <D.44270>; else goto <D.44271>;
        <D.44270>:
        code.5516 = code;
        code = code.5516 + 1;
        D.44273 = (signed char) breg;
        D.44274 = D.44273 & 7;
        D.44275 = D.44274 | 64;
        D.44276 = (unsigned char) D.44275;
        *code.5516 = D.44276;
        D.31551 = ins->data.op[0].const_val;
        D.31563 = (unsigned char) D.31551;
        *code = D.31563;
        code = code + 1;
        goto <D.44277>;
        <D.44271>:
        code.5517 = code;
        code = code.5517 + 1;
        D.44273 = (signed char) breg;
        D.44274 = D.44273 & 7;
        D.44279 = D.44274 | -128;
        D.44280 = (unsigned char) D.44279;
        *code.5517 = D.44280;
        {
          union x86_imm_buf imb;

          try
            {
              D.31551 = ins->data.op[0].const_val;
              imb.val = D.31551;
              code.5518 = code;
              code = code.5518 + 1;
              D.44282 = imb.b[0];
              *code.5518 = D.44282;
              code.5519 = code;
              code = code.5519 + 1;
              D.44284 = imb.b[1];
              *code.5519 = D.44284;
              code.5520 = code;
              code = code.5520 + 1;
              D.44286 = imb.b[2];
              *code.5520 = D.44286;
              code.5521 = code;
              code = code.5521 + 1;
              D.44288 = imb.b[3];
              *code.5521 = D.44288;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44277>:
        <D.28100>:
        br[0] = code;
        code.5522 = code;
        code = code.5522 + 1;
        *code.5522 = 240;
        code.5523 = code;
        code = code.5523 + 1;
        *code.5523 = 15;
        code.5524 = code;
        code = code.5524 + 1;
        *code.5524 = 177;
        if (breg == 4) goto <D.44292>; else goto <D.44293>;
        <D.44292>:
        D.31551 = ins->data.op[0].const_val;
        if (D.31551 == 0) goto <D.44294>; else goto <D.44295>;
        <D.44294>:
        code.5525 = code;
        code = code.5525 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44297 = D.44217 | 4;
        D.44298 = (unsigned char) D.44297;
        *code.5525 = D.44298;
        code.5526 = code;
        code = code.5526 + 1;
        *code.5526 = 36;
        goto <D.44300>;
        <D.44295>:
        D.31551 = ins->data.op[0].const_val;
        D.31557 = (unsigned int) D.31551;
        D.31558 = D.31557 + 128;
        if (D.31558 <= 255) goto <D.44301>; else goto <D.44302>;
        <D.44301>:
        code.5527 = code;
        code = code.5527 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44304 = D.44217 | 68;
        D.44305 = (unsigned char) D.44304;
        *code.5527 = D.44305;
        code.5528 = code;
        code = code.5528 + 1;
        *code.5528 = 36;
        D.31551 = ins->data.op[0].const_val;
        D.31563 = (unsigned char) D.31551;
        *code = D.31563;
        code = code + 1;
        goto <D.44307>;
        <D.44302>:
        code.5529 = code;
        code = code.5529 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44309 = D.44217 | -124;
        D.44310 = (unsigned char) D.44309;
        *code.5529 = D.44310;
        code.5530 = code;
        code = code.5530 + 1;
        *code.5530 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              D.31551 = ins->data.op[0].const_val;
              imb.val = D.31551;
              code.5531 = code;
              code = code.5531 + 1;
              D.44313 = imb.b[0];
              *code.5531 = D.44313;
              code.5532 = code;
              code = code.5532 + 1;
              D.44315 = imb.b[1];
              *code.5532 = D.44315;
              code.5533 = code;
              code = code.5533 + 1;
              D.44317 = imb.b[2];
              *code.5533 = D.44317;
              code.5534 = code;
              code = code.5534 + 1;
              D.44319 = imb.b[3];
              *code.5534 = D.44319;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44307>:
        <D.44300>:
        goto <D.28103>;
        <D.44293>:
        D.31551 = ins->data.op[0].const_val;
        if (D.31551 == 0) goto <D.44320>; else goto <D.44321>;
        <D.44320>:
        if (breg != 5) goto <D.44322>; else goto <D.44323>;
        <D.44322>:
        code.5535 = code;
        code = code.5535 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44273 = (signed char) breg;
        D.44274 = D.44273 & 7;
        D.44325 = D.44217 | D.44274;
        D.44326 = (unsigned char) D.44325;
        *code.5535 = D.44326;
        goto <D.28103>;
        <D.44323>:
        <D.44321>:
        D.31551 = ins->data.op[0].const_val;
        D.31557 = (unsigned int) D.31551;
        D.31558 = D.31557 + 128;
        if (D.31558 <= 255) goto <D.44327>; else goto <D.44328>;
        <D.44327>:
        code.5536 = code;
        code = code.5536 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44330 = D.44217 | 64;
        D.44273 = (signed char) breg;
        D.44274 = D.44273 & 7;
        D.44331 = D.44330 | D.44274;
        D.44332 = (unsigned char) D.44331;
        *code.5536 = D.44332;
        D.31551 = ins->data.op[0].const_val;
        D.31563 = (unsigned char) D.31551;
        *code = D.31563;
        code = code + 1;
        goto <D.44333>;
        <D.44328>:
        code.5537 = code;
        code = code.5537 + 1;
        D.44215 = sreg2 & 7;
        D.44216 = D.44215 << 3;
        D.44217 = (signed char) D.44216;
        D.44335 = D.44217 | -128;
        D.44273 = (signed char) breg;
        D.44274 = D.44273 & 7;
        D.44336 = D.44335 | D.44274;
        D.44337 = (unsigned char) D.44336;
        *code.5537 = D.44337;
        {
          union x86_imm_buf imb;

          try
            {
              D.31551 = ins->data.op[0].const_val;
              imb.val = D.31551;
              code.5538 = code;
              code = code.5538 + 1;
              D.44339 = imb.b[0];
              *code.5538 = D.44339;
              code.5539 = code;
              code = code.5539 + 1;
              D.44341 = imb.b[1];
              *code.5539 = D.44341;
              code.5540 = code;
              code = code.5540 + 1;
              D.44343 = imb.b[2];
              *code.5540 = D.44343;
              code.5541 = code;
              code = code.5541 + 1;
              D.44345 = imb.b[3];
              *code.5541 = D.44345;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44333>:
        <D.28103>:
        br[1] = code;
        if (0 != 0) goto <D.44346>; else goto <D.44347>;
        <D.44346>:
        code.5542 = code;
        code = code.5542 + 1;
        D.39804 = 117;
        *code.5542 = D.39804;
        goto <D.44349>;
        <D.44347>:
        code.5543 = code;
        code = code.5543 + 1;
        D.39807 = 117;
        *code.5543 = D.39807;
        <D.44349>:
        *code = 255;
        code = code + 1;
        {
          unsigned char * pos;
          int disp;
          int size;

          D.44351 = br[1];
          pos = D.44351 + 1;
          size = 0;
          D.44351 = br[1];
          D.44352 = MEM[(unsigned char *)D.44351];
          D.44353 = (int) D.44352;
          switch (D.44353) <default: <D.28132>, case 15: <D.28111>, case 112: <D.28116>, case 113: <D.28117>, case 114: <D.28118>, case 115: <D.28119>, case 116: <D.28120>, case 117: <D.28121>, case 118: <D.28122>, case 119: <D.28123>, case 120: <D.28124>, case 121: <D.28125>, case 122: <D.28126>, case 123: <D.28127>, case 124: <D.28128>, case 125: <D.28129>, case 126: <D.28130>, case 127: <D.28131>, case 224: <D.28112>, case 225: <D.28113>, case 226: <D.28114>, case 232: <D.28108>, case 233: <D.28109>, case 235: <D.28115>>
          <D.28108>:
          <D.28109>:
          size = size + 1;
          goto <D.28110>;
          <D.28111>:
          D.44354 = *pos;
          D.44355 = D.44354 + 144;
          if (D.44355 > 31) goto <D.44356>; else goto <D.44357>;
          <D.44356>:
          __assert_fail ("0", "mini-x86.c", 4447, &__PRETTY_FUNCTION__);
          <D.44357>:
          size = size + 1;
          pos = pos + 1;
          goto <D.28110>;
          <D.28112>:
          <D.28113>:
          <D.28114>:
          <D.28115>:
          <D.28116>:
          <D.28117>:
          <D.28118>:
          <D.28119>:
          <D.28120>:
          <D.28121>:
          <D.28122>:
          <D.28123>:
          <D.28124>:
          <D.28125>:
          <D.28126>:
          <D.28127>:
          <D.28128>:
          <D.28129>:
          <D.28130>:
          <D.28131>:
          goto <D.28110>;
          <D.28132>:
          __assert_fail ("0", "mini-x86.c", 4447, &__PRETTY_FUNCTION__);
          <D.28110>:
          D.44358 = br[0];
          D.44359 = (int) D.44358;
          pos.5544 = (int) pos;
          disp = D.44359 - pos.5544;
          if (size != 0) goto <D.44361>; else goto <D.44362>;
          <D.44361>:
          {
            union x86_imm_buf imb;

            try
              {
                D.44363 = disp + -4;
                imb.val = D.44363;
                pos.5545 = pos;
                pos = pos.5545 + 1;
                D.44365 = imb.b[0];
                *pos.5545 = D.44365;
                pos.5546 = pos;
                pos = pos.5546 + 1;
                D.44367 = imb.b[1];
                *pos.5546 = D.44367;
                pos.5547 = pos;
                pos = pos.5547 + 1;
                D.44369 = imb.b[2];
                *pos.5547 = D.44369;
                pos.5548 = pos;
                pos = pos.5548 + 1;
                D.44371 = imb.b[3];
                *pos.5548 = D.44371;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.44372>;
          <D.44362>:
          disp.5549 = (unsigned int) disp;
          D.44374 = disp.5549 + 127;
          if (D.44374 <= 255) goto <D.44375>; else goto <D.44376>;
          <D.44375>:
          D.44377 = (unsigned char) disp;
          D.44378 = D.44377 + 255;
          *pos = D.44378;
          pos = pos + 1;
          goto <D.44379>;
          <D.44376>:
          __assert_fail ("0", "mini-x86.c", 4447, &__PRETTY_FUNCTION__);
          <D.44379>:
          <D.44372>:
        }
        D.31548 = ins->sreg1;
        if (D.31548 != breg) goto <D.44380>; else goto <D.44381>;
        <D.44380>:
        code.5550 = code;
        code = code.5550 + 1;
        D.44227 = (unsigned char) breg;
        D.44383 = D.44227 + 88;
        *code.5550 = D.44383;
        <D.44381>:
        D.31527 = ins->sreg2;
        if (D.31527 != sreg2) goto <D.44384>; else goto <D.44385>;
        <D.44384>:
        code.5551 = code;
        code = code.5551 + 1;
        D.44209 = (unsigned char) sreg2;
        D.44387 = D.44209 + 88;
        *code.5551 = D.44387;
        <D.44385>:
        goto <D.24796>;
      }
    finally
      {
        br = {CLOBBER};
      }
  }
  <D.28134>:
  D.31604 = ins->dreg;
  D.34254 = D.31604 != 0;
  D.34255 = (long int) D.34254;
  D.34256 = __builtin_expect (D.34255, 0);
  if (D.34256 != 0) goto <D.44388>; else goto <D.44389>;
  <D.44388>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4458, "ins->dreg == X86_EAX");
  <D.44389>:
  D.44390 = ins->sreg3;
  D.44391 = D.44390 != 0;
  D.44392 = (long int) D.44391;
  D.44393 = __builtin_expect (D.44392, 0);
  if (D.44393 != 0) goto <D.44394>; else goto <D.44395>;
  <D.44394>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4459, "ins->sreg3 == X86_EAX");
  <D.44395>:
  D.31548 = ins->sreg1;
  D.35826 = D.31548 == 0;
  D.44396 = (long int) D.35826;
  D.44397 = __builtin_expect (D.44396, 0);
  if (D.44397 != 0) goto <D.44398>; else goto <D.44399>;
  <D.44398>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4460, "ins->sreg1 != X86_EAX");
  <D.44399>:
  D.31548 = ins->sreg1;
  D.31527 = ins->sreg2;
  D.44400 = D.31548 == D.31527;
  D.44401 = (long int) D.44400;
  D.44402 = __builtin_expect (D.44401, 0);
  if (D.44402 != 0) goto <D.44403>; else goto <D.44404>;
  <D.44403>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4461, "ins->sreg1 != ins->sreg2");
  <D.44404>:
  code.5552 = code;
  code = code.5552 + 1;
  *code.5552 = 240;
  code.5553 = code;
  code = code.5553 + 1;
  *code.5553 = 15;
  code.5554 = code;
  code = code.5554 + 1;
  *code.5554 = 177;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.44408>; else goto <D.44409>;
  <D.44408>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.44410>; else goto <D.44411>;
  <D.44410>:
  code.5555 = code;
  code = code.5555 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32607 = D.32606 | 4;
  D.32608 = (unsigned char) D.32607;
  *code.5555 = D.32608;
  code.5556 = code;
  code = code.5556 + 1;
  *code.5556 = 36;
  goto <D.44414>;
  <D.44411>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.44415>; else goto <D.44416>;
  <D.44415>:
  code.5557 = code;
  code = code.5557 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32614 = D.32606 | 68;
  D.32615 = (unsigned char) D.32614;
  *code.5557 = D.32615;
  code.5558 = code;
  code = code.5558 + 1;
  *code.5558 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.44419>;
  <D.44416>:
  code.5559 = code;
  code = code.5559 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32619 = D.32606 | -124;
  D.32620 = (unsigned char) D.32619;
  *code.5559 = D.32620;
  code.5560 = code;
  code = code.5560 + 1;
  *code.5560 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.5561 = code;
        code = code.5561 + 1;
        D.44423 = imb.b[0];
        *code.5561 = D.44423;
        code.5562 = code;
        code = code.5562 + 1;
        D.44425 = imb.b[1];
        *code.5562 = D.44425;
        code.5563 = code;
        code = code.5563 + 1;
        D.44427 = imb.b[2];
        *code.5563 = D.44427;
        code.5564 = code;
        code = code.5564 + 1;
        D.44429 = imb.b[3];
        *code.5564 = D.44429;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44419>:
  <D.44414>:
  goto <D.28136>;
  <D.44409>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.44430>; else goto <D.44431>;
  <D.44430>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.44432>; else goto <D.44433>;
  <D.44432>:
  code.5565 = code;
  code = code.5565 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32635 = D.32606 | D.31586;
  D.32636 = (unsigned char) D.32635;
  *code.5565 = D.32636;
  goto <D.28136>;
  <D.44433>:
  <D.44431>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.44435>; else goto <D.44436>;
  <D.44435>:
  code.5566 = code;
  code = code.5566 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32640 = D.32606 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32641 = D.32640 | D.31586;
  D.32642 = (unsigned char) D.32641;
  *code.5566 = D.32642;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.44438>;
  <D.44436>:
  code.5567 = code;
  code = code.5567 + 1;
  D.31527 = ins->sreg2;
  D.32604 = D.31527 & 7;
  D.32605 = D.32604 << 3;
  D.32606 = (signed char) D.32605;
  D.32645 = D.32606 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32646 = D.32645 | D.31586;
  D.32647 = (unsigned char) D.32646;
  *code.5567 = D.32647;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.5568 = code;
        code = code.5568 + 1;
        D.44441 = imb.b[0];
        *code.5568 = D.44441;
        code.5569 = code;
        code = code.5569 + 1;
        D.44443 = imb.b[1];
        *code.5569 = D.44443;
        code.5570 = code;
        code = code.5570 + 1;
        D.44445 = imb.b[2];
        *code.5570 = D.44445;
        code.5571 = code;
        code = code.5571 + 1;
        D.44447 = imb.b[3];
        *code.5571 = D.44447;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44438>:
  <D.28136>:
  goto <D.24796>;
  <D.28138>:
  {
    int ptr;
    int value;
    guchar * br;
    int nursery_shift;
    int card_table_shift;
    void * card_table_mask;
    size_t nursery_size;
    gulong card_table;
    gulong nursery_start;
    gboolean card_table_nursery_check;

    try
      {
        ptr = ins->sreg1;
        value = ins->sreg2;
        br = 0B;
        D.44448 = mono_gc_get_card_table (&card_table_shift, &card_table_mask);
        card_table = (gulong) D.44448;
        D.44449 = mono_gc_get_nursery (&nursery_shift, &nursery_size);
        nursery_start = (gulong) D.44449;
        card_table_nursery_check = mono_gc_card_table_nursery_check ();
        D.31548 = ins->sreg1;
        D.34249 = D.31548 != 0;
        D.34250 = (long int) D.34249;
        D.34251 = __builtin_expect (D.34250, 0);
        if (D.34251 != 0) goto <D.44450>; else goto <D.44451>;
        <D.44450>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4484, "ins->sreg1 == X86_EAX");
        <D.44451>:
        if (card_table_nursery_check != 0) goto <D.44452>; else goto <D.44453>;
        <D.44452>:
        if (value != 2) goto <D.44454>; else goto <D.44455>;
        <D.44454>:
        switch (4) <default: <D.28153>, case 1: <D.28149>, case 2: <D.28151>, case 4: <D.28152>>
        <D.28149>:
        code.5572 = code;
        code = code.5572 + 1;
        *code.5572 = 138;
        goto <D.28150>;
        <D.28151>:
        code.5573 = code;
        code = code.5573 + 1;
        *code.5573 = 102;
        <D.28152>:
        code.5574 = code;
        code = code.5574 + 1;
        *code.5574 = 139;
        goto <D.28150>;
        <D.28153>:
        __assert_fail ("0", "mini-x86.c", 4501, &__PRETTY_FUNCTION__);
        <D.28150>:
        code.5575 = code;
        code = code.5575 + 1;
        D.44460 = (signed char) value;
        D.44461 = D.44460 & 7;
        D.44462 = D.44461 | -48;
        D.44463 = (unsigned char) D.44462;
        *code.5575 = D.44463;
        <D.44455>:
        nursery_shift.5576 = nursery_shift;
        if (nursery_shift.5576 == 1) goto <D.44465>; else goto <D.44466>;
        <D.44465>:
        code.5577 = code;
        code = code.5577 + 1;
        *code.5577 = 209;
        code.5578 = code;
        code = code.5578 + 1;
        *code.5578 = 234;
        goto <D.44469>;
        <D.44466>:
        code.5579 = code;
        code = code.5579 + 1;
        *code.5579 = 193;
        code.5580 = code;
        code = code.5580 + 1;
        *code.5580 = 234;
        nursery_shift.5576 = nursery_shift;
        D.44472 = (unsigned char) nursery_shift.5576;
        *code = D.44472;
        code = code + 1;
        <D.44469>:
        if (0 != 0) goto <D.44473>; else goto <D.44474>;
        <D.44473>:
        code.5581 = code;
        code = code.5581 + 1;
        *code.5581 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              nursery_shift.5576 = nursery_shift;
              D.44476 = nursery_start >> nursery_shift.5576;
              D.44477 = (int) D.44476;
              imb.val = D.44477;
              code.5582 = code;
              code = code.5582 + 1;
              D.44479 = imb.b[0];
              *code.5582 = D.44479;
              code.5583 = code;
              code = code.5583 + 1;
              D.44481 = imb.b[1];
              *code.5583 = D.44481;
              code.5584 = code;
              code = code.5584 + 1;
              D.44483 = imb.b[2];
              *code.5584 = D.44483;
              code.5585 = code;
              code = code.5585 + 1;
              D.44485 = imb.b[3];
              *code.5585 = D.44485;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28155>;
        <D.44474>:
        nursery_shift.5576 = nursery_shift;
        D.44476 = nursery_start >> nursery_shift.5576;
        D.44477 = (int) D.44476;
        if (D.44477 >= -128) goto <D.44488>; else goto <D.44486>;
        <D.44488>:
        nursery_shift.5576 = nursery_shift;
        D.44476 = nursery_start >> nursery_shift.5576;
        D.44477 = (int) D.44476;
        if (D.44477 <= 127) goto <D.44489>; else goto <D.44486>;
        <D.44489>:
        code.5586 = code;
        code = code.5586 + 1;
        *code.5586 = 131;
        code.5587 = code;
        code = code.5587 + 1;
        *code.5587 = 250;
        nursery_shift.5576 = nursery_shift;
        D.44476 = nursery_start >> nursery_shift.5576;
        D.44492 = (unsigned char) D.44476;
        *code = D.44492;
        code = code + 1;
        goto <D.44487>;
        <D.44486>:
        code.5588 = code;
        code = code.5588 + 1;
        *code.5588 = 129;
        code.5589 = code;
        code = code.5589 + 1;
        *code.5589 = 250;
        {
          union x86_imm_buf imb;

          try
            {
              nursery_shift.5576 = nursery_shift;
              D.44476 = nursery_start >> nursery_shift.5576;
              D.44477 = (int) D.44476;
              imb.val = D.44477;
              code.5590 = code;
              code = code.5590 + 1;
              D.44496 = imb.b[0];
              *code.5590 = D.44496;
              code.5591 = code;
              code = code.5591 + 1;
              D.44498 = imb.b[1];
              *code.5591 = D.44498;
              code.5592 = code;
              code = code.5592 + 1;
              D.44500 = imb.b[2];
              *code.5592 = D.44500;
              code.5593 = code;
              code = code.5593 + 1;
              D.44502 = imb.b[3];
              *code.5593 = D.44502;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44487>:
        <D.28155>:
        br = code;
        if (0 != 0) goto <D.44503>; else goto <D.44504>;
        <D.44503>:
        code.5594 = code;
        code = code.5594 + 1;
        D.39804 = 117;
        *code.5594 = D.39804;
        goto <D.44506>;
        <D.44504>:
        code.5595 = code;
        code = code.5595 + 1;
        D.39807 = 117;
        *code.5595 = D.39807;
        <D.44506>:
        *code = 255;
        code = code + 1;
        <D.44453>:
        switch (4) <default: <D.28161>, case 1: <D.28157>, case 2: <D.28159>, case 4: <D.28160>>
        <D.28157>:
        code.5596 = code;
        code = code.5596 + 1;
        *code.5596 = 138;
        goto <D.28158>;
        <D.28159>:
        code.5597 = code;
        code = code.5597 + 1;
        *code.5597 = 102;
        <D.28160>:
        code.5598 = code;
        code = code.5598 + 1;
        *code.5598 = 139;
        goto <D.28158>;
        <D.28161>:
        __assert_fail ("0", "mini-x86.c", 4506, &__PRETTY_FUNCTION__);
        <D.28158>:
        code.5599 = code;
        code = code.5599 + 1;
        D.44512 = (signed char) ptr;
        D.44513 = D.44512 & 7;
        D.44514 = D.44513 | -48;
        D.44515 = (unsigned char) D.44514;
        *code.5599 = D.44515;
        card_table_shift.5600 = card_table_shift;
        if (card_table_shift.5600 == 1) goto <D.44517>; else goto <D.44518>;
        <D.44517>:
        code.5601 = code;
        code = code.5601 + 1;
        *code.5601 = 209;
        code.5602 = code;
        code = code.5602 + 1;
        *code.5602 = 234;
        goto <D.44521>;
        <D.44518>:
        code.5603 = code;
        code = code.5603 + 1;
        *code.5603 = 193;
        code.5604 = code;
        code = code.5604 + 1;
        *code.5604 = 234;
        card_table_shift.5600 = card_table_shift;
        D.44524 = (unsigned char) card_table_shift.5600;
        *code = D.44524;
        code = code + 1;
        <D.44521>:
        card_table_mask.5605 = card_table_mask;
        if (card_table_mask.5605 != 0B) goto <D.44526>; else goto <D.44527>;
        <D.44526>:
        if (0 != 0) goto <D.44528>; else goto <D.44529>;
        <D.44528>:
        code.5606 = code;
        code = code.5606 + 1;
        *code.5606 = 37;
        {
          union x86_imm_buf imb;

          try
            {
              card_table_mask.5605 = card_table_mask;
              card_table_mask.5607 = (int) card_table_mask.5605;
              imb.val = card_table_mask.5607;
              code.5608 = code;
              code = code.5608 + 1;
              D.44533 = imb.b[0];
              *code.5608 = D.44533;
              code.5609 = code;
              code = code.5609 + 1;
              D.44535 = imb.b[1];
              *code.5609 = D.44535;
              code.5610 = code;
              code = code.5610 + 1;
              D.44537 = imb.b[2];
              *code.5610 = D.44537;
              code.5611 = code;
              code = code.5611 + 1;
              D.44539 = imb.b[3];
              *code.5611 = D.44539;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28163>;
        <D.44529>:
        card_table_mask.5605 = card_table_mask;
        card_table_mask.5612 = (unsigned int) card_table_mask.5605;
        D.44541 = card_table_mask.5612 + 128;
        if (D.44541 <= 255) goto <D.44542>; else goto <D.44543>;
        <D.44542>:
        code.5613 = code;
        code = code.5613 + 1;
        *code.5613 = 131;
        code.5614 = code;
        code = code.5614 + 1;
        *code.5614 = 226;
        card_table_mask.5605 = card_table_mask;
        card_table_mask.5607 = (int) card_table_mask.5605;
        D.44546 = (unsigned char) card_table_mask.5607;
        *code = D.44546;
        code = code + 1;
        goto <D.44547>;
        <D.44543>:
        code.5615 = code;
        code = code.5615 + 1;
        *code.5615 = 129;
        code.5616 = code;
        code = code.5616 + 1;
        *code.5616 = 226;
        {
          union x86_imm_buf imb;

          try
            {
              card_table_mask.5605 = card_table_mask;
              card_table_mask.5607 = (int) card_table_mask.5605;
              imb.val = card_table_mask.5607;
              code.5617 = code;
              code = code.5617 + 1;
              D.44551 = imb.b[0];
              *code.5617 = D.44551;
              code.5618 = code;
              code = code.5618 + 1;
              D.44553 = imb.b[1];
              *code.5618 = D.44553;
              code.5619 = code;
              code = code.5619 + 1;
              D.44555 = imb.b[2];
              *code.5619 = D.44555;
              code.5620 = code;
              code = code.5620 + 1;
              D.44557 = imb.b[3];
              *code.5620 = D.44557;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44547>:
        <D.28163>:
        <D.44527>:
        if (1 != 0) goto <D.44558>; else goto <D.44559>;
        <D.44558>:
        code.5621 = code;
        code = code.5621 + 1;
        *code.5621 = 198;
        if (0 != 0) goto <D.44561>; else goto <D.44562>;
        <D.44561>:
        if (card_table == 0) goto <D.44563>; else goto <D.44564>;
        <D.44563>:
        code.5622 = code;
        code = code.5622 + 1;
        *code.5622 = 4;
        code.5623 = code;
        code = code.5623 + 1;
        *code.5623 = 36;
        goto <D.44567>;
        <D.44564>:
        card_table.5624 = (int) card_table;
        D.44569 = card_table.5624 >= -128;
        card_table.5624 = (int) card_table;
        D.44570 = card_table.5624 <= 127;
        D.44571 = D.44569 & D.44570;
        if (D.44571 != 0) goto <D.44572>; else goto <D.44573>;
        <D.44572>:
        code.5625 = code;
        code = code.5625 + 1;
        *code.5625 = 68;
        code.5626 = code;
        code = code.5626 + 1;
        *code.5626 = 36;
        D.44576 = (unsigned char) card_table;
        *code = D.44576;
        code = code + 1;
        goto <D.44577>;
        <D.44573>:
        code.5627 = code;
        code = code.5627 + 1;
        *code.5627 = 132;
        code.5628 = code;
        code = code.5628 + 1;
        *code.5628 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              card_table.5624 = (int) card_table;
              imb.val = card_table.5624;
              code.5629 = code;
              code = code.5629 + 1;
              D.44581 = imb.b[0];
              *code.5629 = D.44581;
              code.5630 = code;
              code = code.5630 + 1;
              D.44583 = imb.b[1];
              *code.5630 = D.44583;
              code.5631 = code;
              code = code.5631 + 1;
              D.44585 = imb.b[2];
              *code.5631 = D.44585;
              code.5632 = code;
              code = code.5632 + 1;
              D.44587 = imb.b[3];
              *code.5632 = D.44587;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44577>:
        <D.44567>:
        goto <D.28166>;
        <D.44562>:
        if (card_table == 0) goto <D.44588>; else goto <D.44589>;
        <D.44588>:
        code.5633 = code;
        code = code.5633 + 1;
        *code.5633 = 2;
        goto <D.28166>;
        <D.44589>:
        card_table.5624 = (int) card_table;
        D.44569 = card_table.5624 >= -128;
        card_table.5624 = (int) card_table;
        D.44570 = card_table.5624 <= 127;
        D.44571 = D.44569 & D.44570;
        if (D.44571 != 0) goto <D.44591>; else goto <D.44592>;
        <D.44591>:
        code.5634 = code;
        code = code.5634 + 1;
        *code.5634 = 66;
        D.44576 = (unsigned char) card_table;
        *code = D.44576;
        code = code + 1;
        goto <D.44594>;
        <D.44592>:
        code.5635 = code;
        code = code.5635 + 1;
        *code.5635 = 130;
        {
          union x86_imm_buf imb;

          try
            {
              card_table.5624 = (int) card_table;
              imb.val = card_table.5624;
              code.5636 = code;
              code = code.5636 + 1;
              D.44597 = imb.b[0];
              *code.5636 = D.44597;
              code.5637 = code;
              code = code.5637 + 1;
              D.44599 = imb.b[1];
              *code.5637 = D.44599;
              code.5638 = code;
              code = code.5638 + 1;
              D.44601 = imb.b[2];
              *code.5638 = D.44601;
              code.5639 = code;
              code = code.5639 + 1;
              D.44603 = imb.b[3];
              *code.5639 = D.44603;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44594>:
        <D.28166>:
        *code = 1;
        code = code + 1;
        goto <D.44604>;
        <D.44559>:
        if (0 != 0) goto <D.44605>; else goto <D.44606>;
        <D.44605>:
        code.5640 = code;
        code = code.5640 + 1;
        *code.5640 = 102;
        code.5641 = code;
        code = code.5641 + 1;
        *code.5641 = 199;
        if (0 != 0) goto <D.44609>; else goto <D.44610>;
        <D.44609>:
        if (card_table == 0) goto <D.44611>; else goto <D.44612>;
        <D.44611>:
        code.5642 = code;
        code = code.5642 + 1;
        *code.5642 = 4;
        code.5643 = code;
        code = code.5643 + 1;
        *code.5643 = 36;
        goto <D.44615>;
        <D.44612>:
        card_table.5624 = (int) card_table;
        D.44569 = card_table.5624 >= -128;
        card_table.5624 = (int) card_table;
        D.44570 = card_table.5624 <= 127;
        D.44571 = D.44569 & D.44570;
        if (D.44571 != 0) goto <D.44616>; else goto <D.44617>;
        <D.44616>:
        code.5644 = code;
        code = code.5644 + 1;
        *code.5644 = 68;
        code.5645 = code;
        code = code.5645 + 1;
        *code.5645 = 36;
        D.44576 = (unsigned char) card_table;
        *code = D.44576;
        code = code + 1;
        goto <D.44620>;
        <D.44617>:
        code.5646 = code;
        code = code.5646 + 1;
        *code.5646 = 132;
        code.5647 = code;
        code = code.5647 + 1;
        *code.5647 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              card_table.5624 = (int) card_table;
              imb.val = card_table.5624;
              code.5648 = code;
              code = code.5648 + 1;
              D.44624 = imb.b[0];
              *code.5648 = D.44624;
              code.5649 = code;
              code = code.5649 + 1;
              D.44626 = imb.b[1];
              *code.5649 = D.44626;
              code.5650 = code;
              code = code.5650 + 1;
              D.44628 = imb.b[2];
              *code.5650 = D.44628;
              code.5651 = code;
              code = code.5651 + 1;
              D.44630 = imb.b[3];
              *code.5651 = D.44630;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44620>:
        <D.44615>:
        goto <D.28169>;
        <D.44610>:
        if (card_table == 0) goto <D.44631>; else goto <D.44632>;
        <D.44631>:
        code.5652 = code;
        code = code.5652 + 1;
        *code.5652 = 2;
        goto <D.28169>;
        <D.44632>:
        card_table.5624 = (int) card_table;
        D.44569 = card_table.5624 >= -128;
        card_table.5624 = (int) card_table;
        D.44570 = card_table.5624 <= 127;
        D.44571 = D.44569 & D.44570;
        if (D.44571 != 0) goto <D.44634>; else goto <D.44635>;
        <D.44634>:
        code.5653 = code;
        code = code.5653 + 1;
        *code.5653 = 66;
        D.44576 = (unsigned char) card_table;
        *code = D.44576;
        code = code + 1;
        goto <D.44637>;
        <D.44635>:
        code.5654 = code;
        code = code.5654 + 1;
        *code.5654 = 130;
        {
          union x86_imm_buf imb;

          try
            {
              card_table.5624 = (int) card_table;
              imb.val = card_table.5624;
              code.5655 = code;
              code = code.5655 + 1;
              D.44640 = imb.b[0];
              *code.5655 = D.44640;
              code.5656 = code;
              code = code.5656 + 1;
              D.44642 = imb.b[1];
              *code.5656 = D.44642;
              code.5657 = code;
              code = code.5657 + 1;
              D.44644 = imb.b[2];
              *code.5657 = D.44644;
              code.5658 = code;
              code = code.5658 + 1;
              D.44646 = imb.b[3];
              *code.5658 = D.44646;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44637>:
        <D.28169>:
        MEM[(short int *)code] = 1;
        code = code + 2;
        goto <D.44647>;
        <D.44606>:
        code.5659 = code;
        code = code.5659 + 1;
        *code.5659 = 199;
        if (0 != 0) goto <D.44649>; else goto <D.44650>;
        <D.44649>:
        if (card_table == 0) goto <D.44651>; else goto <D.44652>;
        <D.44651>:
        code.5660 = code;
        code = code.5660 + 1;
        *code.5660 = 4;
        code.5661 = code;
        code = code.5661 + 1;
        *code.5661 = 36;
        goto <D.44655>;
        <D.44652>:
        card_table.5624 = (int) card_table;
        D.44569 = card_table.5624 >= -128;
        card_table.5624 = (int) card_table;
        D.44570 = card_table.5624 <= 127;
        D.44571 = D.44569 & D.44570;
        if (D.44571 != 0) goto <D.44656>; else goto <D.44657>;
        <D.44656>:
        code.5662 = code;
        code = code.5662 + 1;
        *code.5662 = 68;
        code.5663 = code;
        code = code.5663 + 1;
        *code.5663 = 36;
        D.44576 = (unsigned char) card_table;
        *code = D.44576;
        code = code + 1;
        goto <D.44660>;
        <D.44657>:
        code.5664 = code;
        code = code.5664 + 1;
        *code.5664 = 132;
        code.5665 = code;
        code = code.5665 + 1;
        *code.5665 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              card_table.5624 = (int) card_table;
              imb.val = card_table.5624;
              code.5666 = code;
              code = code.5666 + 1;
              D.44664 = imb.b[0];
              *code.5666 = D.44664;
              code.5667 = code;
              code = code.5667 + 1;
              D.44666 = imb.b[1];
              *code.5667 = D.44666;
              code.5668 = code;
              code = code.5668 + 1;
              D.44668 = imb.b[2];
              *code.5668 = D.44668;
              code.5669 = code;
              code = code.5669 + 1;
              D.44670 = imb.b[3];
              *code.5669 = D.44670;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44660>:
        <D.44655>:
        goto <D.28172>;
        <D.44650>:
        if (card_table == 0) goto <D.44671>; else goto <D.44672>;
        <D.44671>:
        code.5670 = code;
        code = code.5670 + 1;
        *code.5670 = 2;
        goto <D.28172>;
        <D.44672>:
        card_table.5624 = (int) card_table;
        D.44569 = card_table.5624 >= -128;
        card_table.5624 = (int) card_table;
        D.44570 = card_table.5624 <= 127;
        D.44571 = D.44569 & D.44570;
        if (D.44571 != 0) goto <D.44674>; else goto <D.44675>;
        <D.44674>:
        code.5671 = code;
        code = code.5671 + 1;
        *code.5671 = 66;
        D.44576 = (unsigned char) card_table;
        *code = D.44576;
        code = code + 1;
        goto <D.44677>;
        <D.44675>:
        code.5672 = code;
        code = code.5672 + 1;
        *code.5672 = 130;
        {
          union x86_imm_buf imb;

          try
            {
              card_table.5624 = (int) card_table;
              imb.val = card_table.5624;
              code.5673 = code;
              code = code.5673 + 1;
              D.44680 = imb.b[0];
              *code.5673 = D.44680;
              code.5674 = code;
              code = code.5674 + 1;
              D.44682 = imb.b[1];
              *code.5674 = D.44682;
              code.5675 = code;
              code = code.5675 + 1;
              D.44684 = imb.b[2];
              *code.5675 = D.44684;
              code.5676 = code;
              code = code.5676 + 1;
              D.44686 = imb.b[3];
              *code.5676 = D.44686;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44677>:
        <D.28172>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1;
              code.5677 = code;
              code = code.5677 + 1;
              D.44688 = imb.b[0];
              *code.5677 = D.44688;
              code.5678 = code;
              code = code.5678 + 1;
              D.44690 = imb.b[1];
              *code.5678 = D.44690;
              code.5679 = code;
              code = code.5679 + 1;
              D.44692 = imb.b[2];
              *code.5679 = D.44692;
              code.5680 = code;
              code = code.5680 + 1;
              D.44694 = imb.b[3];
              *code.5680 = D.44694;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44647>:
        <D.44604>:
        if (card_table_nursery_check != 0) goto <D.44695>; else goto <D.44696>;
        <D.44695>:
        {
          unsigned char * pos;
          int disp;
          int size;

          pos = br + 1;
          size = 0;
          D.44697 = MEM[(unsigned char *)br];
          D.44698 = (int) D.44697;
          switch (D.44698) <default: <D.28202>, case 15: <D.28181>, case 112: <D.28186>, case 113: <D.28187>, case 114: <D.28188>, case 115: <D.28189>, case 116: <D.28190>, case 117: <D.28191>, case 118: <D.28192>, case 119: <D.28193>, case 120: <D.28194>, case 121: <D.28195>, case 122: <D.28196>, case 123: <D.28197>, case 124: <D.28198>, case 125: <D.28199>, case 126: <D.28200>, case 127: <D.28201>, case 224: <D.28182>, case 225: <D.28183>, case 226: <D.28184>, case 232: <D.28178>, case 233: <D.28179>, case 235: <D.28185>>
          <D.28178>:
          <D.28179>:
          size = size + 1;
          goto <D.28180>;
          <D.28181>:
          D.44699 = *pos;
          D.44700 = D.44699 + 144;
          if (D.44700 > 31) goto <D.44701>; else goto <D.44702>;
          <D.44701>:
          __assert_fail ("0", "mini-x86.c", 4512, &__PRETTY_FUNCTION__);
          <D.44702>:
          size = size + 1;
          pos = pos + 1;
          goto <D.28180>;
          <D.28182>:
          <D.28183>:
          <D.28184>:
          <D.28185>:
          <D.28186>:
          <D.28187>:
          <D.28188>:
          <D.28189>:
          <D.28190>:
          <D.28191>:
          <D.28192>:
          <D.28193>:
          <D.28194>:
          <D.28195>:
          <D.28196>:
          <D.28197>:
          <D.28198>:
          <D.28199>:
          <D.28200>:
          <D.28201>:
          goto <D.28180>;
          <D.28202>:
          __assert_fail ("0", "mini-x86.c", 4512, &__PRETTY_FUNCTION__);
          <D.28180>:
          code.422 = (int) code;
          pos.5681 = (int) pos;
          disp = code.422 - pos.5681;
          if (size != 0) goto <D.44704>; else goto <D.44705>;
          <D.44704>:
          {
            union x86_imm_buf imb;

            try
              {
                D.44706 = disp + -4;
                imb.val = D.44706;
                pos.5682 = pos;
                pos = pos.5682 + 1;
                D.44708 = imb.b[0];
                *pos.5682 = D.44708;
                pos.5683 = pos;
                pos = pos.5683 + 1;
                D.44710 = imb.b[1];
                *pos.5683 = D.44710;
                pos.5684 = pos;
                pos = pos.5684 + 1;
                D.44712 = imb.b[2];
                *pos.5684 = D.44712;
                pos.5685 = pos;
                pos = pos.5685 + 1;
                D.44714 = imb.b[3];
                *pos.5685 = D.44714;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.44715>;
          <D.44705>:
          disp.5686 = (unsigned int) disp;
          D.44717 = disp.5686 + 127;
          if (D.44717 <= 255) goto <D.44718>; else goto <D.44719>;
          <D.44718>:
          D.44720 = (unsigned char) disp;
          D.44721 = D.44720 + 255;
          *pos = D.44721;
          pos = pos + 1;
          goto <D.44722>;
          <D.44719>:
          __assert_fail ("0", "mini-x86.c", 4512, &__PRETTY_FUNCTION__);
          <D.44722>:
          <D.44715>:
        }
        <D.44696>:
        goto <D.24796>;
      }
    finally
      {
        nursery_shift = {CLOBBER};
        card_table_shift = {CLOBBER};
        card_table_mask = {CLOBBER};
        nursery_size = {CLOBBER};
      }
  }
  <D.28204>:
  code.5687 = code;
  code = code.5687 + 1;
  *code.5687 = 15;
  code.5688 = code;
  code = code.5688 + 1;
  *code.5688 = 88;
  code.5689 = code;
  code = code.5689 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5689 = D.32567;
  goto <D.24796>;
  <D.28205>:
  code.5690 = code;
  code = code.5690 + 1;
  *code.5690 = 15;
  code.5691 = code;
  code = code.5691 + 1;
  *code.5691 = 94;
  code.5692 = code;
  code = code.5692 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5692 = D.32567;
  goto <D.24796>;
  <D.28206>:
  code.5693 = code;
  code = code.5693 + 1;
  *code.5693 = 15;
  code.5694 = code;
  code = code.5694 + 1;
  *code.5694 = 89;
  code.5695 = code;
  code = code.5695 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5695 = D.32567;
  goto <D.24796>;
  <D.28207>:
  code.5696 = code;
  code = code.5696 + 1;
  *code.5696 = 15;
  code.5697 = code;
  code = code.5697 + 1;
  *code.5697 = 92;
  code.5698 = code;
  code = code.5698 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5698 = D.32567;
  goto <D.24796>;
  <D.28208>:
  code.5699 = code;
  code = code.5699 + 1;
  *code.5699 = 15;
  code.5700 = code;
  code = code.5700 + 1;
  *code.5700 = 95;
  code.5701 = code;
  code = code.5701 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5701 = D.32567;
  goto <D.24796>;
  <D.28209>:
  code.5702 = code;
  code = code.5702 + 1;
  *code.5702 = 15;
  code.5703 = code;
  code = code.5703 + 1;
  *code.5703 = 93;
  code.5704 = code;
  code = code.5704 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5704 = D.32567;
  goto <D.24796>;
  <D.28210>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44741 = D.31557 > 7;
  D.44742 = (long int) D.44741;
  D.44743 = __builtin_expect (D.44742, 0);
  if (D.44743 != 0) goto <D.44744>; else goto <D.44745>;
  <D.44744>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4535, "ins->inst_c0 >= 0 && ins->inst_c0 <= 7");
  <D.44745>:
  code.5705 = code;
  code = code.5705 + 1;
  *code.5705 = 15;
  code.5706 = code;
  code = code.5706 + 1;
  *code.5706 = 194;
  code.5707 = code;
  code = code.5707 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5707 = D.32567;
  code.5708 = code;
  code = code.5708 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.5708 = D.44750;
  goto <D.24796>;
  <D.28211>:
  code.5709 = code;
  code = code.5709 + 1;
  *code.5709 = 15;
  code.5710 = code;
  code = code.5710 + 1;
  *code.5710 = 84;
  code.5711 = code;
  code = code.5711 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5711 = D.32567;
  goto <D.24796>;
  <D.28212>:
  code.5712 = code;
  code = code.5712 + 1;
  *code.5712 = 15;
  code.5713 = code;
  code = code.5713 + 1;
  *code.5713 = 85;
  code.5714 = code;
  code = code.5714 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5714 = D.32567;
  goto <D.24796>;
  <D.28213>:
  code.5715 = code;
  code = code.5715 + 1;
  *code.5715 = 15;
  code.5716 = code;
  code = code.5716 + 1;
  *code.5716 = 86;
  code.5717 = code;
  code = code.5717 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5717 = D.32567;
  goto <D.24796>;
  <D.28214>:
  code.5718 = code;
  code = code.5718 + 1;
  *code.5718 = 15;
  code.5719 = code;
  code = code.5719 + 1;
  *code.5719 = 87;
  code.5720 = code;
  code = code.5720 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5720 = D.32567;
  goto <D.24796>;
  <D.28215>:
  code.5721 = code;
  code = code.5721 + 1;
  *code.5721 = 15;
  code.5722 = code;
  code = code.5722 + 1;
  *code.5722 = 81;
  code.5723 = code;
  code = code.5723 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5723 = D.32535;
  goto <D.24796>;
  <D.28216>:
  code.5724 = code;
  code = code.5724 + 1;
  *code.5724 = 15;
  code.5725 = code;
  code = code.5725 + 1;
  *code.5725 = 82;
  code.5726 = code;
  code = code.5726 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5726 = D.32535;
  goto <D.24796>;
  <D.28217>:
  code.5727 = code;
  code = code.5727 + 1;
  *code.5727 = 15;
  code.5728 = code;
  code = code.5728 + 1;
  *code.5728 = 83;
  code.5729 = code;
  code = code.5729 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5729 = D.32535;
  goto <D.24796>;
  <D.28218>:
  code.5730 = code;
  code = code.5730 + 1;
  *code.5730 = 242;
  code.5731 = code;
  code = code.5731 + 1;
  *code.5731 = 15;
  code.5732 = code;
  code = code.5732 + 1;
  *code.5732 = 208;
  code.5733 = code;
  code = code.5733 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5733 = D.32567;
  goto <D.24796>;
  <D.28219>:
  code.5734 = code;
  code = code.5734 + 1;
  *code.5734 = 242;
  code.5735 = code;
  code = code.5735 + 1;
  *code.5735 = 15;
  code.5736 = code;
  code = code.5736 + 1;
  *code.5736 = 124;
  code.5737 = code;
  code = code.5737 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5737 = D.32567;
  goto <D.24796>;
  <D.28220>:
  code.5738 = code;
  code = code.5738 + 1;
  *code.5738 = 242;
  code.5739 = code;
  code = code.5739 + 1;
  *code.5739 = 15;
  code.5740 = code;
  code = code.5740 + 1;
  *code.5740 = 125;
  code.5741 = code;
  code = code.5741 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5741 = D.32567;
  goto <D.24796>;
  <D.28221>:
  code.5742 = code;
  code = code.5742 + 1;
  *code.5742 = 243;
  code.5743 = code;
  code = code.5743 + 1;
  *code.5743 = 15;
  code.5744 = code;
  code = code.5744 + 1;
  *code.5744 = 22;
  code.5745 = code;
  code = code.5745 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5745 = D.32535;
  goto <D.24796>;
  <D.28222>:
  code.5746 = code;
  code = code.5746 + 1;
  *code.5746 = 243;
  code.5747 = code;
  code = code.5747 + 1;
  *code.5747 = 15;
  code.5748 = code;
  code = code.5748 + 1;
  *code.5748 = 18;
  code.5749 = code;
  code = code.5749 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5749 = D.32535;
  goto <D.24796>;
  <D.28223>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44792 = D.31557 > 255;
  D.44793 = (long int) D.44792;
  D.44794 = __builtin_expect (D.44793, 0);
  if (D.44794 != 0) goto <D.44795>; else goto <D.44796>;
  <D.44795>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4576, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.44796>:
  code.5750 = code;
  code = code.5750 + 1;
  *code.5750 = 243;
  code.5751 = code;
  code = code.5751 + 1;
  *code.5751 = 15;
  code.5752 = code;
  code = code.5752 + 1;
  *code.5752 = 112;
  code.5753 = code;
  code = code.5753 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5753 = D.32535;
  code.5754 = code;
  code = code.5754 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.5754 = D.44750;
  goto <D.24796>;
  <D.28224>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44792 = D.31557 > 255;
  D.44793 = (long int) D.44792;
  D.44794 = __builtin_expect (D.44793, 0);
  if (D.44794 != 0) goto <D.44802>; else goto <D.44803>;
  <D.44802>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4580, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.44803>:
  code.5755 = code;
  code = code.5755 + 1;
  *code.5755 = 242;
  code.5756 = code;
  code = code.5756 + 1;
  *code.5756 = 15;
  code.5757 = code;
  code = code.5757 + 1;
  *code.5757 = 112;
  code.5758 = code;
  code = code.5758 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5758 = D.32535;
  code.5759 = code;
  code = code.5759 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.5759 = D.44750;
  goto <D.24796>;
  <D.28225>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44792 = D.31557 > 255;
  D.44793 = (long int) D.44792;
  D.44794 = __builtin_expect (D.44793, 0);
  if (D.44794 != 0) goto <D.44809>; else goto <D.44810>;
  <D.44809>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4584, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.44810>:
  code.5760 = code;
  code = code.5760 + 1;
  *code.5760 = 102;
  code.5761 = code;
  code = code.5761 + 1;
  *code.5761 = 15;
  code.5762 = code;
  code = code.5762 + 1;
  *code.5762 = 112;
  code.5763 = code;
  code = code.5763 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5763 = D.32535;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.24796>;
  <D.28226>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44792 = D.31557 > 255;
  D.44793 = (long int) D.44792;
  D.44794 = __builtin_expect (D.44793, 0);
  if (D.44794 != 0) goto <D.44815>; else goto <D.44816>;
  <D.44815>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4588, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.44816>:
  code.5764 = code;
  code = code.5764 + 1;
  *code.5764 = 15;
  code.5765 = code;
  code = code.5765 + 1;
  *code.5765 = 198;
  code.5766 = code;
  code = code.5766 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5766 = D.32567;
  code.5767 = code;
  code = code.5767 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.5767 = D.44750;
  goto <D.24796>;
  <D.28227>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44821 = D.31557 > 3;
  D.44822 = (long int) D.44821;
  D.44823 = __builtin_expect (D.44822, 0);
  if (D.44823 != 0) goto <D.44824>; else goto <D.44825>;
  <D.44824>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4592, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0x3");
  <D.44825>:
  code.5768 = code;
  code = code.5768 + 1;
  *code.5768 = 102;
  code.5769 = code;
  code = code.5769 + 1;
  *code.5769 = 15;
  code.5770 = code;
  code = code.5770 + 1;
  *code.5770 = 198;
  code.5771 = code;
  code = code.5771 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5771 = D.32567;
  code.5772 = code;
  code = code.5772 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.5772 = D.44750;
  goto <D.24796>;
  <D.28228>:
  code.5773 = code;
  code = code.5773 + 1;
  *code.5773 = 102;
  code.5774 = code;
  code = code.5774 + 1;
  *code.5774 = 15;
  code.5775 = code;
  code = code.5775 + 1;
  *code.5775 = 88;
  code.5776 = code;
  code = code.5776 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5776 = D.32567;
  goto <D.24796>;
  <D.28229>:
  code.5777 = code;
  code = code.5777 + 1;
  *code.5777 = 102;
  code.5778 = code;
  code = code.5778 + 1;
  *code.5778 = 15;
  code.5779 = code;
  code = code.5779 + 1;
  *code.5779 = 94;
  code.5780 = code;
  code = code.5780 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5780 = D.32567;
  goto <D.24796>;
  <D.28230>:
  code.5781 = code;
  code = code.5781 + 1;
  *code.5781 = 102;
  code.5782 = code;
  code = code.5782 + 1;
  *code.5782 = 15;
  code.5783 = code;
  code = code.5783 + 1;
  *code.5783 = 89;
  code.5784 = code;
  code = code.5784 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5784 = D.32567;
  goto <D.24796>;
  <D.28231>:
  code.5785 = code;
  code = code.5785 + 1;
  *code.5785 = 102;
  code.5786 = code;
  code = code.5786 + 1;
  *code.5786 = 15;
  code.5787 = code;
  code = code.5787 + 1;
  *code.5787 = 92;
  code.5788 = code;
  code = code.5788 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5788 = D.32567;
  goto <D.24796>;
  <D.28232>:
  code.5789 = code;
  code = code.5789 + 1;
  *code.5789 = 102;
  code.5790 = code;
  code = code.5790 + 1;
  *code.5790 = 15;
  code.5791 = code;
  code = code.5791 + 1;
  *code.5791 = 95;
  code.5792 = code;
  code = code.5792 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5792 = D.32567;
  goto <D.24796>;
  <D.28233>:
  code.5793 = code;
  code = code.5793 + 1;
  *code.5793 = 102;
  code.5794 = code;
  code = code.5794 + 1;
  *code.5794 = 15;
  code.5795 = code;
  code = code.5795 + 1;
  *code.5795 = 93;
  code.5796 = code;
  code = code.5796 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5796 = D.32567;
  goto <D.24796>;
  <D.28234>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.44741 = D.31557 > 7;
  D.44742 = (long int) D.44741;
  D.44743 = __builtin_expect (D.44742, 0);
  if (D.44743 != 0) goto <D.44855>; else goto <D.44856>;
  <D.44855>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4615, "ins->inst_c0 >= 0 && ins->inst_c0 <= 7");
  <D.44856>:
  code.5797 = code;
  code = code.5797 + 1;
  *code.5797 = 102;
  code.5798 = code;
  code = code.5798 + 1;
  *code.5798 = 15;
  code.5799 = code;
  code = code.5799 + 1;
  *code.5799 = 194;
  code.5800 = code;
  code = code.5800 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5800 = D.32567;
  code.5801 = code;
  code = code.5801 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.5801 = D.44750;
  goto <D.24796>;
  <D.28235>:
  code.5802 = code;
  code = code.5802 + 1;
  *code.5802 = 102;
  code.5803 = code;
  code = code.5803 + 1;
  *code.5803 = 15;
  code.5804 = code;
  code = code.5804 + 1;
  *code.5804 = 84;
  code.5805 = code;
  code = code.5805 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5805 = D.32567;
  goto <D.24796>;
  <D.28236>:
  code.5806 = code;
  code = code.5806 + 1;
  *code.5806 = 102;
  code.5807 = code;
  code = code.5807 + 1;
  *code.5807 = 15;
  code.5808 = code;
  code = code.5808 + 1;
  *code.5808 = 85;
  code.5809 = code;
  code = code.5809 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5809 = D.32567;
  goto <D.24796>;
  <D.28237>:
  code.5810 = code;
  code = code.5810 + 1;
  *code.5810 = 102;
  code.5811 = code;
  code = code.5811 + 1;
  *code.5811 = 15;
  code.5812 = code;
  code = code.5812 + 1;
  *code.5812 = 86;
  code.5813 = code;
  code = code.5813 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5813 = D.32567;
  goto <D.24796>;
  <D.28238>:
  code.5814 = code;
  code = code.5814 + 1;
  *code.5814 = 102;
  code.5815 = code;
  code = code.5815 + 1;
  *code.5815 = 15;
  code.5816 = code;
  code = code.5816 + 1;
  *code.5816 = 87;
  code.5817 = code;
  code = code.5817 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5817 = D.32567;
  goto <D.24796>;
  <D.28239>:
  code.5818 = code;
  code = code.5818 + 1;
  *code.5818 = 102;
  code.5819 = code;
  code = code.5819 + 1;
  *code.5819 = 15;
  code.5820 = code;
  code = code.5820 + 1;
  *code.5820 = 81;
  code.5821 = code;
  code = code.5821 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5821 = D.32535;
  goto <D.24796>;
  <D.28240>:
  code.5822 = code;
  code = code.5822 + 1;
  *code.5822 = 102;
  code.5823 = code;
  code = code.5823 + 1;
  *code.5823 = 15;
  code.5824 = code;
  code = code.5824 + 1;
  *code.5824 = 208;
  code.5825 = code;
  code = code.5825 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5825 = D.32567;
  goto <D.24796>;
  <D.28241>:
  code.5826 = code;
  code = code.5826 + 1;
  *code.5826 = 102;
  code.5827 = code;
  code = code.5827 + 1;
  *code.5827 = 15;
  code.5828 = code;
  code = code.5828 + 1;
  *code.5828 = 124;
  code.5829 = code;
  code = code.5829 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5829 = D.32567;
  goto <D.24796>;
  <D.28242>:
  code.5830 = code;
  code = code.5830 + 1;
  *code.5830 = 102;
  code.5831 = code;
  code = code.5831 + 1;
  *code.5831 = 15;
  code.5832 = code;
  code = code.5832 + 1;
  *code.5832 = 125;
  code.5833 = code;
  code = code.5833 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5833 = D.32567;
  goto <D.24796>;
  <D.28243>:
  code.5834 = code;
  code = code.5834 + 1;
  *code.5834 = 242;
  code.5835 = code;
  code = code.5835 + 1;
  *code.5835 = 15;
  code.5836 = code;
  code = code.5836 + 1;
  *code.5836 = 18;
  code.5837 = code;
  code = code.5837 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5837 = D.32535;
  goto <D.24796>;
  <D.28244>:
  code.5838 = code;
  code = code.5838 + 1;
  *code.5838 = 102;
  code.5839 = code;
  code = code.5839 + 1;
  *code.5839 = 15;
  code.5840 = code;
  code = code.5840 + 1;
  *code.5840 = 215;
  code.5841 = code;
  code = code.5841 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.5841 = D.32535;
  goto <D.24796>;
  <D.28245>:
  code.5842 = code;
  code = code.5842 + 1;
  *code.5842 = 102;
  code.5843 = code;
  code = code.5843 + 1;
  *code.5843 = 15;
  code.5844 = code;
  code = code.5844 + 1;
  *code.5844 = 219;
  code.5845 = code;
  code = code.5845 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5845 = D.32567;
  goto <D.24796>;
  <D.28246>:
  code.5846 = code;
  code = code.5846 + 1;
  *code.5846 = 102;
  code.5847 = code;
  code = code.5847 + 1;
  *code.5847 = 15;
  code.5848 = code;
  code = code.5848 + 1;
  *code.5848 = 235;
  code.5849 = code;
  code = code.5849 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5849 = D.32567;
  goto <D.24796>;
  <D.28247>:
  code.5850 = code;
  code = code.5850 + 1;
  *code.5850 = 102;
  code.5851 = code;
  code = code.5851 + 1;
  *code.5851 = 15;
  code.5852 = code;
  code = code.5852 + 1;
  *code.5852 = 239;
  code.5853 = code;
  code = code.5853 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5853 = D.32567;
  goto <D.24796>;
  <D.28248>:
  code.5854 = code;
  code = code.5854 + 1;
  *code.5854 = 102;
  code.5855 = code;
  code = code.5855 + 1;
  *code.5855 = 15;
  code.5856 = code;
  code = code.5856 + 1;
  *code.5856 = 252;
  code.5857 = code;
  code = code.5857 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5857 = D.32567;
  goto <D.24796>;
  <D.28249>:
  code.5858 = code;
  code = code.5858 + 1;
  *code.5858 = 102;
  code.5859 = code;
  code = code.5859 + 1;
  *code.5859 = 15;
  code.5860 = code;
  code = code.5860 + 1;
  *code.5860 = 253;
  code.5861 = code;
  code = code.5861 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5861 = D.32567;
  goto <D.24796>;
  <D.28250>:
  code.5862 = code;
  code = code.5862 + 1;
  *code.5862 = 102;
  code.5863 = code;
  code = code.5863 + 1;
  *code.5863 = 15;
  code.5864 = code;
  code = code.5864 + 1;
  *code.5864 = 254;
  code.5865 = code;
  code = code.5865 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5865 = D.32567;
  goto <D.24796>;
  <D.28251>:
  code.5866 = code;
  code = code.5866 + 1;
  *code.5866 = 102;
  code.5867 = code;
  code = code.5867 + 1;
  *code.5867 = 15;
  code.5868 = code;
  code = code.5868 + 1;
  *code.5868 = 212;
  code.5869 = code;
  code = code.5869 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5869 = D.32567;
  goto <D.24796>;
  <D.28252>:
  code.5870 = code;
  code = code.5870 + 1;
  *code.5870 = 102;
  code.5871 = code;
  code = code.5871 + 1;
  *code.5871 = 15;
  code.5872 = code;
  code = code.5872 + 1;
  *code.5872 = 248;
  code.5873 = code;
  code = code.5873 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5873 = D.32567;
  goto <D.24796>;
  <D.28253>:
  code.5874 = code;
  code = code.5874 + 1;
  *code.5874 = 102;
  code.5875 = code;
  code = code.5875 + 1;
  *code.5875 = 15;
  code.5876 = code;
  code = code.5876 + 1;
  *code.5876 = 249;
  code.5877 = code;
  code = code.5877 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5877 = D.32567;
  goto <D.24796>;
  <D.28254>:
  code.5878 = code;
  code = code.5878 + 1;
  *code.5878 = 102;
  code.5879 = code;
  code = code.5879 + 1;
  *code.5879 = 15;
  code.5880 = code;
  code = code.5880 + 1;
  *code.5880 = 250;
  code.5881 = code;
  code = code.5881 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5881 = D.32567;
  goto <D.24796>;
  <D.28255>:
  code.5882 = code;
  code = code.5882 + 1;
  *code.5882 = 102;
  code.5883 = code;
  code = code.5883 + 1;
  *code.5883 = 15;
  code.5884 = code;
  code = code.5884 + 1;
  *code.5884 = 251;
  code.5885 = code;
  code = code.5885 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5885 = D.32567;
  goto <D.24796>;
  <D.28256>:
  code.5886 = code;
  code = code.5886 + 1;
  *code.5886 = 102;
  code.5887 = code;
  code = code.5887 + 1;
  *code.5887 = 15;
  code.5888 = code;
  code = code.5888 + 1;
  *code.5888 = 222;
  code.5889 = code;
  code = code.5889 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5889 = D.32567;
  goto <D.24796>;
  <D.28257>:
  code.5890 = code;
  code = code.5890 + 1;
  *code.5890 = 102;
  code.5891 = code;
  code = code.5891 + 1;
  *code.5891 = 15;
  code.5892 = code;
  code = code.5892 + 1;
  *code.5892 = 56;
  code.5893 = code;
  code = code.5893 + 1;
  *code.5893 = 62;
  code.5894 = code;
  code = code.5894 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5894 = D.32567;
  goto <D.24796>;
  <D.28258>:
  code.5895 = code;
  code = code.5895 + 1;
  *code.5895 = 102;
  code.5896 = code;
  code = code.5896 + 1;
  *code.5896 = 15;
  code.5897 = code;
  code = code.5897 + 1;
  *code.5897 = 56;
  code.5898 = code;
  code = code.5898 + 1;
  *code.5898 = 63;
  code.5899 = code;
  code = code.5899 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5899 = D.32567;
  goto <D.24796>;
  <D.28259>:
  code.5900 = code;
  code = code.5900 + 1;
  *code.5900 = 102;
  code.5901 = code;
  code = code.5901 + 1;
  *code.5901 = 15;
  code.5902 = code;
  code = code.5902 + 1;
  *code.5902 = 56;
  code.5903 = code;
  code = code.5903 + 1;
  *code.5903 = 60;
  code.5904 = code;
  code = code.5904 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5904 = D.32567;
  goto <D.24796>;
  <D.28260>:
  code.5905 = code;
  code = code.5905 + 1;
  *code.5905 = 102;
  code.5906 = code;
  code = code.5906 + 1;
  *code.5906 = 15;
  code.5907 = code;
  code = code.5907 + 1;
  *code.5907 = 238;
  code.5908 = code;
  code = code.5908 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5908 = D.32567;
  goto <D.24796>;
  <D.28261>:
  code.5909 = code;
  code = code.5909 + 1;
  *code.5909 = 102;
  code.5910 = code;
  code = code.5910 + 1;
  *code.5910 = 15;
  code.5911 = code;
  code = code.5911 + 1;
  *code.5911 = 56;
  code.5912 = code;
  code = code.5912 + 1;
  *code.5912 = 61;
  code.5913 = code;
  code = code.5913 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5913 = D.32567;
  goto <D.24796>;
  <D.28262>:
  code.5914 = code;
  code = code.5914 + 1;
  *code.5914 = 102;
  code.5915 = code;
  code = code.5915 + 1;
  *code.5915 = 15;
  code.5916 = code;
  code = code.5916 + 1;
  *code.5916 = 224;
  code.5917 = code;
  code = code.5917 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5917 = D.32567;
  goto <D.24796>;
  <D.28263>:
  code.5918 = code;
  code = code.5918 + 1;
  *code.5918 = 102;
  code.5919 = code;
  code = code.5919 + 1;
  *code.5919 = 15;
  code.5920 = code;
  code = code.5920 + 1;
  *code.5920 = 227;
  code.5921 = code;
  code = code.5921 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5921 = D.32567;
  goto <D.24796>;
  <D.28264>:
  code.5922 = code;
  code = code.5922 + 1;
  *code.5922 = 102;
  code.5923 = code;
  code = code.5923 + 1;
  *code.5923 = 15;
  code.5924 = code;
  code = code.5924 + 1;
  *code.5924 = 218;
  code.5925 = code;
  code = code.5925 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5925 = D.32567;
  goto <D.24796>;
  <D.28265>:
  code.5926 = code;
  code = code.5926 + 1;
  *code.5926 = 102;
  code.5927 = code;
  code = code.5927 + 1;
  *code.5927 = 15;
  code.5928 = code;
  code = code.5928 + 1;
  *code.5928 = 56;
  code.5929 = code;
  code = code.5929 + 1;
  *code.5929 = 58;
  code.5930 = code;
  code = code.5930 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5930 = D.32567;
  goto <D.24796>;
  <D.28266>:
  code.5931 = code;
  code = code.5931 + 1;
  *code.5931 = 102;
  code.5932 = code;
  code = code.5932 + 1;
  *code.5932 = 15;
  code.5933 = code;
  code = code.5933 + 1;
  *code.5933 = 56;
  code.5934 = code;
  code = code.5934 + 1;
  *code.5934 = 59;
  code.5935 = code;
  code = code.5935 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5935 = D.32567;
  goto <D.24796>;
  <D.28267>:
  code.5936 = code;
  code = code.5936 + 1;
  *code.5936 = 102;
  code.5937 = code;
  code = code.5937 + 1;
  *code.5937 = 15;
  code.5938 = code;
  code = code.5938 + 1;
  *code.5938 = 56;
  code.5939 = code;
  code = code.5939 + 1;
  *code.5939 = 56;
  code.5940 = code;
  code = code.5940 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5940 = D.32567;
  goto <D.24796>;
  <D.28268>:
  code.5941 = code;
  code = code.5941 + 1;
  *code.5941 = 102;
  code.5942 = code;
  code = code.5942 + 1;
  *code.5942 = 15;
  code.5943 = code;
  code = code.5943 + 1;
  *code.5943 = 234;
  code.5944 = code;
  code = code.5944 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5944 = D.32567;
  goto <D.24796>;
  <D.28269>:
  code.5945 = code;
  code = code.5945 + 1;
  *code.5945 = 102;
  code.5946 = code;
  code = code.5946 + 1;
  *code.5946 = 15;
  code.5947 = code;
  code = code.5947 + 1;
  *code.5947 = 56;
  code.5948 = code;
  code = code.5948 + 1;
  *code.5948 = 57;
  code.5949 = code;
  code = code.5949 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5949 = D.32567;
  goto <D.24796>;
  <D.28270>:
  code.5950 = code;
  code = code.5950 + 1;
  *code.5950 = 102;
  code.5951 = code;
  code = code.5951 + 1;
  *code.5951 = 15;
  code.5952 = code;
  code = code.5952 + 1;
  *code.5952 = 116;
  code.5953 = code;
  code = code.5953 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5953 = D.32567;
  goto <D.24796>;
  <D.28271>:
  code.5954 = code;
  code = code.5954 + 1;
  *code.5954 = 102;
  code.5955 = code;
  code = code.5955 + 1;
  *code.5955 = 15;
  code.5956 = code;
  code = code.5956 + 1;
  *code.5956 = 117;
  code.5957 = code;
  code = code.5957 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5957 = D.32567;
  goto <D.24796>;
  <D.28272>:
  code.5958 = code;
  code = code.5958 + 1;
  *code.5958 = 102;
  code.5959 = code;
  code = code.5959 + 1;
  *code.5959 = 15;
  code.5960 = code;
  code = code.5960 + 1;
  *code.5960 = 118;
  code.5961 = code;
  code = code.5961 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5961 = D.32567;
  goto <D.24796>;
  <D.28273>:
  code.5962 = code;
  code = code.5962 + 1;
  *code.5962 = 102;
  code.5963 = code;
  code = code.5963 + 1;
  *code.5963 = 15;
  code.5964 = code;
  code = code.5964 + 1;
  *code.5964 = 56;
  code.5965 = code;
  code = code.5965 + 1;
  *code.5965 = 41;
  code.5966 = code;
  code = code.5966 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5966 = D.32567;
  goto <D.24796>;
  <D.28274>:
  code.5967 = code;
  code = code.5967 + 1;
  *code.5967 = 102;
  code.5968 = code;
  code = code.5968 + 1;
  *code.5968 = 15;
  code.5969 = code;
  code = code.5969 + 1;
  *code.5969 = 100;
  code.5970 = code;
  code = code.5970 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5970 = D.32567;
  goto <D.24796>;
  <D.28275>:
  code.5971 = code;
  code = code.5971 + 1;
  *code.5971 = 102;
  code.5972 = code;
  code = code.5972 + 1;
  *code.5972 = 15;
  code.5973 = code;
  code = code.5973 + 1;
  *code.5973 = 101;
  code.5974 = code;
  code = code.5974 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5974 = D.32567;
  goto <D.24796>;
  <D.28276>:
  code.5975 = code;
  code = code.5975 + 1;
  *code.5975 = 102;
  code.5976 = code;
  code = code.5976 + 1;
  *code.5976 = 15;
  code.5977 = code;
  code = code.5977 + 1;
  *code.5977 = 102;
  code.5978 = code;
  code = code.5978 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5978 = D.32567;
  goto <D.24796>;
  <D.28277>:
  code.5979 = code;
  code = code.5979 + 1;
  *code.5979 = 102;
  code.5980 = code;
  code = code.5980 + 1;
  *code.5980 = 15;
  code.5981 = code;
  code = code.5981 + 1;
  *code.5981 = 56;
  code.5982 = code;
  code = code.5982 + 1;
  *code.5982 = 55;
  code.5983 = code;
  code = code.5983 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5983 = D.32567;
  goto <D.24796>;
  <D.28278>:
  code.5984 = code;
  code = code.5984 + 1;
  *code.5984 = 102;
  code.5985 = code;
  code = code.5985 + 1;
  *code.5985 = 15;
  code.5986 = code;
  code = code.5986 + 1;
  *code.5986 = 246;
  code.5987 = code;
  code = code.5987 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5987 = D.32567;
  goto <D.24796>;
  <D.28279>:
  code.5988 = code;
  code = code.5988 + 1;
  *code.5988 = 102;
  code.5989 = code;
  code = code.5989 + 1;
  *code.5989 = 15;
  code.5990 = code;
  code = code.5990 + 1;
  *code.5990 = 96;
  code.5991 = code;
  code = code.5991 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5991 = D.32567;
  goto <D.24796>;
  <D.28280>:
  code.5992 = code;
  code = code.5992 + 1;
  *code.5992 = 102;
  code.5993 = code;
  code = code.5993 + 1;
  *code.5993 = 15;
  code.5994 = code;
  code = code.5994 + 1;
  *code.5994 = 97;
  code.5995 = code;
  code = code.5995 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5995 = D.32567;
  goto <D.24796>;
  <D.28281>:
  code.5996 = code;
  code = code.5996 + 1;
  *code.5996 = 102;
  code.5997 = code;
  code = code.5997 + 1;
  *code.5997 = 15;
  code.5998 = code;
  code = code.5998 + 1;
  *code.5998 = 98;
  code.5999 = code;
  code = code.5999 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.5999 = D.32567;
  goto <D.24796>;
  <D.28282>:
  code.6000 = code;
  code = code.6000 + 1;
  *code.6000 = 102;
  code.6001 = code;
  code = code.6001 + 1;
  *code.6001 = 15;
  code.6002 = code;
  code = code.6002 + 1;
  *code.6002 = 108;
  code.6003 = code;
  code = code.6003 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6003 = D.32567;
  goto <D.24796>;
  <D.28283>:
  code.6004 = code;
  code = code.6004 + 1;
  *code.6004 = 15;
  code.6005 = code;
  code = code.6005 + 1;
  *code.6005 = 20;
  code.6006 = code;
  code = code.6006 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6006 = D.32567;
  goto <D.24796>;
  <D.28284>:
  code.6007 = code;
  code = code.6007 + 1;
  *code.6007 = 102;
  code.6008 = code;
  code = code.6008 + 1;
  *code.6008 = 15;
  code.6009 = code;
  code = code.6009 + 1;
  *code.6009 = 20;
  code.6010 = code;
  code = code.6010 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6010 = D.32567;
  goto <D.24796>;
  <D.28285>:
  code.6011 = code;
  code = code.6011 + 1;
  *code.6011 = 102;
  code.6012 = code;
  code = code.6012 + 1;
  *code.6012 = 15;
  code.6013 = code;
  code = code.6013 + 1;
  *code.6013 = 104;
  code.6014 = code;
  code = code.6014 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6014 = D.32567;
  goto <D.24796>;
  <D.28286>:
  code.6015 = code;
  code = code.6015 + 1;
  *code.6015 = 102;
  code.6016 = code;
  code = code.6016 + 1;
  *code.6016 = 15;
  code.6017 = code;
  code = code.6017 + 1;
  *code.6017 = 105;
  code.6018 = code;
  code = code.6018 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6018 = D.32567;
  goto <D.24796>;
  <D.28287>:
  code.6019 = code;
  code = code.6019 + 1;
  *code.6019 = 102;
  code.6020 = code;
  code = code.6020 + 1;
  *code.6020 = 15;
  code.6021 = code;
  code = code.6021 + 1;
  *code.6021 = 106;
  code.6022 = code;
  code = code.6022 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6022 = D.32567;
  goto <D.24796>;
  <D.28288>:
  code.6023 = code;
  code = code.6023 + 1;
  *code.6023 = 102;
  code.6024 = code;
  code = code.6024 + 1;
  *code.6024 = 15;
  code.6025 = code;
  code = code.6025 + 1;
  *code.6025 = 109;
  code.6026 = code;
  code = code.6026 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6026 = D.32567;
  goto <D.24796>;
  <D.28289>:
  code.6027 = code;
  code = code.6027 + 1;
  *code.6027 = 15;
  code.6028 = code;
  code = code.6028 + 1;
  *code.6028 = 21;
  code.6029 = code;
  code = code.6029 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6029 = D.32567;
  goto <D.24796>;
  <D.28290>:
  code.6030 = code;
  code = code.6030 + 1;
  *code.6030 = 102;
  code.6031 = code;
  code = code.6031 + 1;
  *code.6031 = 15;
  code.6032 = code;
  code = code.6032 + 1;
  *code.6032 = 21;
  code.6033 = code;
  code = code.6033 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6033 = D.32567;
  goto <D.24796>;
  <D.28291>:
  code.6034 = code;
  code = code.6034 + 1;
  *code.6034 = 102;
  code.6035 = code;
  code = code.6035 + 1;
  *code.6035 = 15;
  code.6036 = code;
  code = code.6036 + 1;
  *code.6036 = 99;
  code.6037 = code;
  code = code.6037 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6037 = D.32567;
  goto <D.24796>;
  <D.28292>:
  code.6038 = code;
  code = code.6038 + 1;
  *code.6038 = 102;
  code.6039 = code;
  code = code.6039 + 1;
  *code.6039 = 15;
  code.6040 = code;
  code = code.6040 + 1;
  *code.6040 = 107;
  code.6041 = code;
  code = code.6041 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6041 = D.32567;
  goto <D.24796>;
  <D.28293>:
  code.6042 = code;
  code = code.6042 + 1;
  *code.6042 = 102;
  code.6043 = code;
  code = code.6043 + 1;
  *code.6043 = 15;
  code.6044 = code;
  code = code.6044 + 1;
  *code.6044 = 103;
  code.6045 = code;
  code = code.6045 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6045 = D.32567;
  goto <D.24796>;
  <D.28294>:
  code.6046 = code;
  code = code.6046 + 1;
  *code.6046 = 102;
  code.6047 = code;
  code = code.6047 + 1;
  *code.6047 = 15;
  code.6048 = code;
  code = code.6048 + 1;
  *code.6048 = 56;
  code.6049 = code;
  code = code.6049 + 1;
  *code.6049 = 43;
  code.6050 = code;
  code = code.6050 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6050 = D.32567;
  goto <D.24796>;
  <D.28295>:
  code.6051 = code;
  code = code.6051 + 1;
  *code.6051 = 102;
  code.6052 = code;
  code = code.6052 + 1;
  *code.6052 = 15;
  code.6053 = code;
  code = code.6053 + 1;
  *code.6053 = 220;
  code.6054 = code;
  code = code.6054 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6054 = D.32567;
  goto <D.24796>;
  <D.28296>:
  code.6055 = code;
  code = code.6055 + 1;
  *code.6055 = 102;
  code.6056 = code;
  code = code.6056 + 1;
  *code.6056 = 15;
  code.6057 = code;
  code = code.6057 + 1;
  *code.6057 = 216;
  code.6058 = code;
  code = code.6058 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6058 = D.32567;
  goto <D.24796>;
  <D.28297>:
  code.6059 = code;
  code = code.6059 + 1;
  *code.6059 = 102;
  code.6060 = code;
  code = code.6060 + 1;
  *code.6060 = 15;
  code.6061 = code;
  code = code.6061 + 1;
  *code.6061 = 221;
  code.6062 = code;
  code = code.6062 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6062 = D.32567;
  goto <D.24796>;
  <D.28298>:
  code.6063 = code;
  code = code.6063 + 1;
  *code.6063 = 102;
  code.6064 = code;
  code = code.6064 + 1;
  *code.6064 = 15;
  code.6065 = code;
  code = code.6065 + 1;
  *code.6065 = 217;
  code.6066 = code;
  code = code.6066 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6066 = D.32567;
  goto <D.24796>;
  <D.28299>:
  code.6067 = code;
  code = code.6067 + 1;
  *code.6067 = 102;
  code.6068 = code;
  code = code.6068 + 1;
  *code.6068 = 15;
  code.6069 = code;
  code = code.6069 + 1;
  *code.6069 = 236;
  code.6070 = code;
  code = code.6070 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6070 = D.32567;
  goto <D.24796>;
  <D.28300>:
  code.6071 = code;
  code = code.6071 + 1;
  *code.6071 = 102;
  code.6072 = code;
  code = code.6072 + 1;
  *code.6072 = 15;
  code.6073 = code;
  code = code.6073 + 1;
  *code.6073 = 232;
  code.6074 = code;
  code = code.6074 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6074 = D.32567;
  goto <D.24796>;
  <D.28301>:
  code.6075 = code;
  code = code.6075 + 1;
  *code.6075 = 102;
  code.6076 = code;
  code = code.6076 + 1;
  *code.6076 = 15;
  code.6077 = code;
  code = code.6077 + 1;
  *code.6077 = 237;
  code.6078 = code;
  code = code.6078 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6078 = D.32567;
  goto <D.24796>;
  <D.28302>:
  code.6079 = code;
  code = code.6079 + 1;
  *code.6079 = 102;
  code.6080 = code;
  code = code.6080 + 1;
  *code.6080 = 15;
  code.6081 = code;
  code = code.6081 + 1;
  *code.6081 = 233;
  code.6082 = code;
  code = code.6082 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6082 = D.32567;
  goto <D.24796>;
  <D.28303>:
  code.6083 = code;
  code = code.6083 + 1;
  *code.6083 = 102;
  code.6084 = code;
  code = code.6084 + 1;
  *code.6084 = 15;
  code.6085 = code;
  code = code.6085 + 1;
  *code.6085 = 213;
  code.6086 = code;
  code = code.6086 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6086 = D.32567;
  goto <D.24796>;
  <D.28304>:
  code.6087 = code;
  code = code.6087 + 1;
  *code.6087 = 102;
  code.6088 = code;
  code = code.6088 + 1;
  *code.6088 = 15;
  code.6089 = code;
  code = code.6089 + 1;
  *code.6089 = 56;
  code.6090 = code;
  code = code.6090 + 1;
  *code.6090 = 64;
  code.6091 = code;
  code = code.6091 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6091 = D.32567;
  goto <D.24796>;
  <D.28305>:
  code.6092 = code;
  code = code.6092 + 1;
  *code.6092 = 102;
  code.6093 = code;
  code = code.6093 + 1;
  *code.6093 = 15;
  code.6094 = code;
  code = code.6094 + 1;
  *code.6094 = 244;
  code.6095 = code;
  code = code.6095 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6095 = D.32567;
  goto <D.24796>;
  <D.28306>:
  code.6096 = code;
  code = code.6096 + 1;
  *code.6096 = 102;
  code.6097 = code;
  code = code.6097 + 1;
  *code.6097 = 15;
  code.6098 = code;
  code = code.6098 + 1;
  *code.6098 = 228;
  code.6099 = code;
  code = code.6099 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6099 = D.32567;
  goto <D.24796>;
  <D.28307>:
  code.6100 = code;
  code = code.6100 + 1;
  *code.6100 = 102;
  code.6101 = code;
  code = code.6101 + 1;
  *code.6101 = 15;
  code.6102 = code;
  code = code.6102 + 1;
  *code.6102 = 229;
  code.6103 = code;
  code = code.6103 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6103 = D.32567;
  goto <D.24796>;
  <D.28308>:
  code.6104 = code;
  code = code.6104 + 1;
  *code.6104 = 102;
  code.6105 = code;
  code = code.6105 + 1;
  *code.6105 = 15;
  code.6106 = code;
  code = code.6106 + 1;
  *code.6106 = 113;
  code.6107 = code;
  code = code.6107 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33978 = D.31638 | -48;
  D.33979 = (unsigned char) D.33978;
  *code.6107 = D.33979;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28309>:
  code.6108 = code;
  code = code.6108 + 1;
  *code.6108 = 102;
  code.6109 = code;
  code = code.6109 + 1;
  *code.6109 = 15;
  code.6110 = code;
  code = code.6110 + 1;
  *code.6110 = 209;
  code.6111 = code;
  code = code.6111 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6111 = D.37392;
  goto <D.24796>;
  <D.28310>:
  code.6112 = code;
  code = code.6112 + 1;
  *code.6112 = 102;
  code.6113 = code;
  code = code.6113 + 1;
  *code.6113 = 15;
  code.6114 = code;
  code = code.6114 + 1;
  *code.6114 = 113;
  code.6115 = code;
  code = code.6115 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.6115 = D.34420;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28311>:
  code.6116 = code;
  code = code.6116 + 1;
  *code.6116 = 102;
  code.6117 = code;
  code = code.6117 + 1;
  *code.6117 = 15;
  code.6118 = code;
  code = code.6118 + 1;
  *code.6118 = 225;
  code.6119 = code;
  code = code.6119 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6119 = D.37392;
  goto <D.24796>;
  <D.28312>:
  code.6120 = code;
  code = code.6120 + 1;
  *code.6120 = 102;
  code.6121 = code;
  code = code.6121 + 1;
  *code.6121 = 15;
  code.6122 = code;
  code = code.6122 + 1;
  *code.6122 = 113;
  code.6123 = code;
  code = code.6123 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.45184 = D.31638 | -16;
  D.45185 = (unsigned char) D.45184;
  *code.6123 = D.45185;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28313>:
  code.6124 = code;
  code = code.6124 + 1;
  *code.6124 = 102;
  code.6125 = code;
  code = code.6125 + 1;
  *code.6125 = 15;
  code.6126 = code;
  code = code.6126 + 1;
  *code.6126 = 241;
  code.6127 = code;
  code = code.6127 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6127 = D.37392;
  goto <D.24796>;
  <D.28314>:
  code.6128 = code;
  code = code.6128 + 1;
  *code.6128 = 102;
  code.6129 = code;
  code = code.6129 + 1;
  *code.6129 = 15;
  code.6130 = code;
  code = code.6130 + 1;
  *code.6130 = 114;
  code.6131 = code;
  code = code.6131 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33978 = D.31638 | -48;
  D.33979 = (unsigned char) D.33978;
  *code.6131 = D.33979;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28315>:
  code.6132 = code;
  code = code.6132 + 1;
  *code.6132 = 102;
  code.6133 = code;
  code = code.6133 + 1;
  *code.6133 = 15;
  code.6134 = code;
  code = code.6134 + 1;
  *code.6134 = 210;
  code.6135 = code;
  code = code.6135 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6135 = D.37392;
  goto <D.24796>;
  <D.28316>:
  code.6136 = code;
  code = code.6136 + 1;
  *code.6136 = 102;
  code.6137 = code;
  code = code.6137 + 1;
  *code.6137 = 15;
  code.6138 = code;
  code = code.6138 + 1;
  *code.6138 = 114;
  code.6139 = code;
  code = code.6139 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34419 = D.31638 | -32;
  D.34420 = (unsigned char) D.34419;
  *code.6139 = D.34420;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28317>:
  code.6140 = code;
  code = code.6140 + 1;
  *code.6140 = 102;
  code.6141 = code;
  code = code.6141 + 1;
  *code.6141 = 15;
  code.6142 = code;
  code = code.6142 + 1;
  *code.6142 = 226;
  code.6143 = code;
  code = code.6143 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6143 = D.37392;
  goto <D.24796>;
  <D.28318>:
  code.6144 = code;
  code = code.6144 + 1;
  *code.6144 = 102;
  code.6145 = code;
  code = code.6145 + 1;
  *code.6145 = 15;
  code.6146 = code;
  code = code.6146 + 1;
  *code.6146 = 114;
  code.6147 = code;
  code = code.6147 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.45184 = D.31638 | -16;
  D.45185 = (unsigned char) D.45184;
  *code.6147 = D.45185;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28319>:
  code.6148 = code;
  code = code.6148 + 1;
  *code.6148 = 102;
  code.6149 = code;
  code = code.6149 + 1;
  *code.6149 = 15;
  code.6150 = code;
  code = code.6150 + 1;
  *code.6150 = 242;
  code.6151 = code;
  code = code.6151 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6151 = D.37392;
  goto <D.24796>;
  <D.28320>:
  code.6152 = code;
  code = code.6152 + 1;
  *code.6152 = 102;
  code.6153 = code;
  code = code.6153 + 1;
  *code.6153 = 15;
  code.6154 = code;
  code = code.6154 + 1;
  *code.6154 = 115;
  code.6155 = code;
  code = code.6155 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.33978 = D.31638 | -48;
  D.33979 = (unsigned char) D.33978;
  *code.6155 = D.33979;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28321>:
  code.6156 = code;
  code = code.6156 + 1;
  *code.6156 = 102;
  code.6157 = code;
  code = code.6157 + 1;
  *code.6157 = 15;
  code.6158 = code;
  code = code.6158 + 1;
  *code.6158 = 211;
  code.6159 = code;
  code = code.6159 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6159 = D.37392;
  goto <D.24796>;
  <D.28322>:
  code.6160 = code;
  code = code.6160 + 1;
  *code.6160 = 102;
  code.6161 = code;
  code = code.6161 + 1;
  *code.6161 = 15;
  code.6162 = code;
  code = code.6162 + 1;
  *code.6162 = 115;
  code.6163 = code;
  code = code.6163 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.45184 = D.31638 | -16;
  D.45185 = (unsigned char) D.45184;
  *code.6163 = D.45185;
  D.31653 = ins->data.op[1].const_val;
  D.31654 = (unsigned char) D.31653;
  *code = D.31654;
  code = code + 1;
  goto <D.24796>;
  <D.28323>:
  code.6164 = code;
  code = code.6164 + 1;
  *code.6164 = 102;
  code.6165 = code;
  code = code.6165 + 1;
  *code.6165 = 15;
  code.6166 = code;
  code = code.6166 + 1;
  *code.6166 = 243;
  code.6167 = code;
  code = code.6167 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6167 = D.37392;
  goto <D.24796>;
  <D.28324>:
  code.6168 = code;
  code = code.6168 + 1;
  *code.6168 = 102;
  code.6169 = code;
  code = code.6169 + 1;
  *code.6169 = 15;
  code.6170 = code;
  code = code.6170 + 1;
  *code.6170 = 110;
  code.6171 = code;
  code = code.6171 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6171 = D.32535;
  goto <D.24796>;
  <D.28325>:
  code.6172 = code;
  code = code.6172 + 1;
  *code.6172 = 102;
  code.6173 = code;
  code = code.6173 + 1;
  *code.6173 = 15;
  code.6174 = code;
  code = code.6174 + 1;
  *code.6174 = 126;
  code.6175 = code;
  code = code.6175 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.45238 = D.32565 | D.31638;
  D.45239 = (unsigned char) D.45238;
  *code.6175 = D.45239;
  goto <D.24796>;
  <D.28326>:
  <D.28327>:
  code.6176 = code;
  code = code.6176 + 1;
  *code.6176 = 102;
  code.6177 = code;
  code = code.6177 + 1;
  *code.6177 = 15;
  code.6178 = code;
  code = code.6178 + 1;
  *code.6178 = 126;
  code.6179 = code;
  code = code.6179 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.45238 = D.32565 | D.31638;
  D.45239 = (unsigned char) D.45238;
  *code.6179 = D.45239;
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 != 0) goto <D.45244>; else goto <D.45245>;
  <D.45244>:
  D.31551 = ins->data.op[0].const_val;
  D.45246 = D.31551 * 8;
  if (D.45246 == 1) goto <D.45247>; else goto <D.45248>;
  <D.45247>:
  code.6180 = code;
  code = code.6180 + 1;
  *code.6180 = 209;
  code.6181 = code;
  code = code.6181 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.6181 = D.34011;
  goto <D.45251>;
  <D.45248>:
  code.6182 = code;
  code = code.6182 + 1;
  *code.6182 = 193;
  code.6183 = code;
  code = code.6183 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.6183 = D.34011;
  D.31551 = ins->data.op[0].const_val;
  D.45254 = (unsigned char) D.31551;
  D.45255 = D.45254 * 8;
  *code = D.45255;
  code = code + 1;
  <D.45251>:
  <D.45245>:
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.45256>; else goto <D.45257>;
    <D.45256>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4923, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.45257>:
    code.6184 = code;
    code = code.6184 + 1;
    *code.6184 = 15;
    D.31501 = ins->opcode;
    if (D.31501 == 928) goto <D.45259>; else goto <D.45260>;
    <D.45259>:
    op = op + 8;
    <D.45260>:
    if (0 != 0) goto <D.45261>; else goto <D.45262>;
    <D.45261>:
    op = op + 1;
    <D.45262>:
    code.6185 = code;
    code = code.6185 + 1;
    *code.6185 = op;
    code.6186 = code;
    code = code.6186 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.6186 = D.34303;
  }
  goto <D.24796>;
  <D.28329>:
  <D.28330>:
  code.6187 = code;
  code = code.6187 + 1;
  *code.6187 = 102;
  code.6188 = code;
  code = code.6188 + 1;
  *code.6188 = 15;
  code.6189 = code;
  code = code.6189 + 1;
  *code.6189 = 126;
  code.6190 = code;
  code = code.6190 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.45238 = D.32565 | D.31638;
  D.45239 = (unsigned char) D.45238;
  *code.6190 = D.45239;
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 != 0) goto <D.45269>; else goto <D.45270>;
  <D.45269>:
  if (0 != 0) goto <D.45271>; else goto <D.45272>;
  <D.45271>:
  code.6191 = code;
  code = code.6191 + 1;
  *code.6191 = 209;
  code.6192 = code;
  code = code.6192 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.6192 = D.34011;
  goto <D.45275>;
  <D.45272>:
  code.6193 = code;
  code = code.6193 + 1;
  *code.6193 = 193;
  code.6194 = code;
  code = code.6194 + 1;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34010 = D.31638 | -24;
  D.34011 = (unsigned char) D.34010;
  *code.6194 = D.34011;
  *code = 16;
  code = code + 1;
  <D.45275>:
  <D.45270>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.45278>; else goto <D.45279>;
    <D.45278>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 4930, "1 || X86_IS_BYTE_REG (ins->dreg)");
    <D.45279>:
    code.6195 = code;
    code = code.6195 + 1;
    *code.6195 = 15;
    D.31501 = ins->opcode;
    if (D.31501 == 926) goto <D.45281>; else goto <D.45282>;
    <D.45281>:
    op = op + 8;
    <D.45282>:
    if (1 != 0) goto <D.45283>; else goto <D.45284>;
    <D.45283>:
    op = op + 1;
    <D.45284>:
    code.6196 = code;
    code = code.6196 + 1;
    *code.6196 = op;
    code.6197 = code;
    code = code.6197 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.6197 = D.34303;
  }
  goto <D.24796>;
  <D.28332>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 != 0) goto <D.45287>; else goto <D.45288>;
  <D.45287>:
  code.6198 = code;
  code = code.6198 + 1;
  *code.6198 = 102;
  code.6199 = code;
  code = code.6199 + 1;
  *code.6199 = 15;
  code.6200 = code;
  code = code.6200 + 1;
  *code.6200 = 23;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45294>; else goto <D.45295>;
  <D.45294>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45297>; else goto <D.45298>;
  <D.45297>:
  code.6201 = code;
  code = code.6201 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.6201 = D.32039;
  code.6202 = code;
  code = code.6202 + 1;
  *code.6202 = 36;
  goto <D.45301>;
  <D.45298>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45304>; else goto <D.45305>;
  <D.45304>:
  code.6203 = code;
  code = code.6203 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.6203 = D.32046;
  code.6204 = code;
  code = code.6204 + 1;
  *code.6204 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45309>;
  <D.45305>:
  code.6205 = code;
  code = code.6205 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.6205 = D.32051;
  code.6206 = code;
  code = code.6206 + 1;
  *code.6206 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6207 = code;
        code = code.6207 + 1;
        D.45313 = imb.b[0];
        *code.6207 = D.45313;
        code.6208 = code;
        code = code.6208 + 1;
        D.45315 = imb.b[1];
        *code.6208 = D.45315;
        code.6209 = code;
        code = code.6209 + 1;
        D.45317 = imb.b[2];
        *code.6209 = D.45317;
        code.6210 = code;
        code = code.6210 + 1;
        D.45319 = imb.b[3];
        *code.6210 = D.45319;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45309>:
  <D.45301>:
  goto <D.28334>;
  <D.45295>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45320>; else goto <D.45321>;
  <D.45320>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45322>; else goto <D.45323>;
  <D.45322>:
  code.6211 = code;
  code = code.6211 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45327 = D.32037 | D.45326;
  D.45328 = (unsigned char) D.45327;
  *code.6211 = D.45328;
  goto <D.28334>;
  <D.45323>:
  <D.45321>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45329>; else goto <D.45330>;
  <D.45329>:
  code.6212 = code;
  code = code.6212 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45332 = D.32071 | D.45326;
  D.45333 = (unsigned char) D.45332;
  *code.6212 = D.45333;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45334>;
  <D.45330>:
  code.6213 = code;
  code = code.6213 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45336 = D.32076 | D.45326;
  D.45337 = (unsigned char) D.45336;
  *code.6213 = D.45337;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6214 = code;
        code = code.6214 + 1;
        D.45339 = imb.b[0];
        *code.6214 = D.45339;
        code.6215 = code;
        code = code.6215 + 1;
        D.45341 = imb.b[1];
        *code.6215 = D.45341;
        code.6216 = code;
        code = code.6216 + 1;
        D.45343 = imb.b[2];
        *code.6216 = D.45343;
        code.6217 = code;
        code = code.6217 + 1;
        D.45345 = imb.b[3];
        *code.6217 = D.45345;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45334>:
  <D.28334>:
  goto <D.45346>;
  <D.45288>:
  code.6218 = code;
  code = code.6218 + 1;
  *code.6218 = 242;
  code.6219 = code;
  code = code.6219 + 1;
  *code.6219 = 15;
  code.6220 = code;
  code = code.6220 + 1;
  *code.6220 = 17;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45350>; else goto <D.45351>;
  <D.45350>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45352>; else goto <D.45353>;
  <D.45352>:
  code.6221 = code;
  code = code.6221 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.6221 = D.32039;
  code.6222 = code;
  code = code.6222 + 1;
  *code.6222 = 36;
  goto <D.45356>;
  <D.45353>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45357>; else goto <D.45358>;
  <D.45357>:
  code.6223 = code;
  code = code.6223 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.6223 = D.32046;
  code.6224 = code;
  code = code.6224 + 1;
  *code.6224 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45361>;
  <D.45358>:
  code.6225 = code;
  code = code.6225 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.6225 = D.32051;
  code.6226 = code;
  code = code.6226 + 1;
  *code.6226 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6227 = code;
        code = code.6227 + 1;
        D.45365 = imb.b[0];
        *code.6227 = D.45365;
        code.6228 = code;
        code = code.6228 + 1;
        D.45367 = imb.b[1];
        *code.6228 = D.45367;
        code.6229 = code;
        code = code.6229 + 1;
        D.45369 = imb.b[2];
        *code.6229 = D.45369;
        code.6230 = code;
        code = code.6230 + 1;
        D.45371 = imb.b[3];
        *code.6230 = D.45371;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45361>:
  <D.45356>:
  goto <D.28337>;
  <D.45351>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45372>; else goto <D.45373>;
  <D.45372>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45374>; else goto <D.45375>;
  <D.45374>:
  code.6231 = code;
  code = code.6231 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45327 = D.32037 | D.45326;
  D.45328 = (unsigned char) D.45327;
  *code.6231 = D.45328;
  goto <D.28337>;
  <D.45375>:
  <D.45373>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45377>; else goto <D.45378>;
  <D.45377>:
  code.6232 = code;
  code = code.6232 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45332 = D.32071 | D.45326;
  D.45333 = (unsigned char) D.45332;
  *code.6232 = D.45333;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45380>;
  <D.45378>:
  code.6233 = code;
  code = code.6233 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45336 = D.32076 | D.45326;
  D.45337 = (unsigned char) D.45336;
  *code.6233 = D.45337;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6234 = code;
        code = code.6234 + 1;
        D.45383 = imb.b[0];
        *code.6234 = D.45383;
        code.6235 = code;
        code = code.6235 + 1;
        D.45385 = imb.b[1];
        *code.6235 = D.45385;
        code.6236 = code;
        code = code.6236 + 1;
        D.45387 = imb.b[2];
        *code.6236 = D.45387;
        code.6237 = code;
        code = code.6237 + 1;
        D.45389 = imb.b[3];
        *code.6237 = D.45389;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45380>:
  <D.28337>:
  <D.45346>:
  code.6238 = code;
  code = code.6238 + 1;
  *code.6238 = 221;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45391>; else goto <D.45392>;
  <D.45391>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45393>; else goto <D.45394>;
  <D.45393>:
  code.6239 = code;
  code = code.6239 + 1;
  *code.6239 = 4;
  code.6240 = code;
  code = code.6240 + 1;
  *code.6240 = 36;
  goto <D.45397>;
  <D.45394>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45398>; else goto <D.45399>;
  <D.45398>:
  code.6241 = code;
  code = code.6241 + 1;
  *code.6241 = 68;
  code.6242 = code;
  code = code.6242 + 1;
  *code.6242 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45402>;
  <D.45399>:
  code.6243 = code;
  code = code.6243 + 1;
  *code.6243 = 132;
  code.6244 = code;
  code = code.6244 + 1;
  *code.6244 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6245 = code;
        code = code.6245 + 1;
        D.45406 = imb.b[0];
        *code.6245 = D.45406;
        code.6246 = code;
        code = code.6246 + 1;
        D.45408 = imb.b[1];
        *code.6246 = D.45408;
        code.6247 = code;
        code = code.6247 + 1;
        D.45410 = imb.b[2];
        *code.6247 = D.45410;
        code.6248 = code;
        code = code.6248 + 1;
        D.45412 = imb.b[3];
        *code.6248 = D.45412;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45402>:
  <D.45397>:
  goto <D.28340>;
  <D.45392>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45413>; else goto <D.45414>;
  <D.45413>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45415>; else goto <D.45416>;
  <D.45415>:
  code.6249 = code;
  code = code.6249 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45418 = (unsigned char) D.45293;
  D.45419 = D.45418 & 7;
  *code.6249 = D.45419;
  goto <D.28340>;
  <D.45416>:
  <D.45414>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45420>; else goto <D.45421>;
  <D.45420>:
  code.6250 = code;
  code = code.6250 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45423 = D.45326 | 64;
  D.45424 = (unsigned char) D.45423;
  *code.6250 = D.45424;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45425>;
  <D.45421>:
  code.6251 = code;
  code = code.6251 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45427 = D.45326 | -128;
  D.45428 = (unsigned char) D.45427;
  *code.6251 = D.45428;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6252 = code;
        code = code.6252 + 1;
        D.45430 = imb.b[0];
        *code.6252 = D.45430;
        code.6253 = code;
        code = code.6253 + 1;
        D.45432 = imb.b[1];
        *code.6253 = D.45432;
        code.6254 = code;
        code = code.6254 + 1;
        D.45434 = imb.b[2];
        *code.6254 = D.45434;
        code.6255 = code;
        code = code.6255 + 1;
        D.45436 = imb.b[3];
        *code.6255 = D.45436;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45425>:
  <D.28340>:
  goto <D.24796>;
  <D.28342>:
  code.6256 = code;
  code = code.6256 + 1;
  *code.6256 = 102;
  code.6257 = code;
  code = code.6257 + 1;
  *code.6257 = 15;
  code.6258 = code;
  code = code.6258 + 1;
  *code.6258 = 196;
  code.6259 = code;
  code = code.6259 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6259 = D.32567;
  code.6260 = code;
  code = code.6260 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.6260 = D.44750;
  goto <D.24796>;
  <D.28343>:
  code.6261 = code;
  code = code.6261 + 1;
  *code.6261 = 102;
  code.6262 = code;
  code = code.6262 + 1;
  *code.6262 = 15;
  code.6263 = code;
  code = code.6263 + 1;
  *code.6263 = 197;
  code.6264 = code;
  code = code.6264 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6264 = D.32535;
  code.6265 = code;
  code = code.6265 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.44750 = (unsigned char) D.31551;
  *code.6265 = D.44750;
  goto <D.24796>;
  <D.28344>:
  D.31548 = ins->sreg1;
  if (D.31548 == 0) goto <D.45447>; else goto <D.45448>;
  <D.45447>:
  code.6266 = code;
  code = code.6266 + 1;
  *code.6266 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        D.45451 = D.31551 & 1;
        if (D.45451 != 0) goto <D.45452>; else goto <D.45453>;
        <D.45452>:
        iftmp.6267 = 255;
        goto <D.45454>;
        <D.45453>:
        iftmp.6267 = 65280;
        <D.45454>:
        imb.val = iftmp.6267;
        code.6268 = code;
        code = code.6268 + 1;
        D.45456 = imb.b[0];
        *code.6268 = D.45456;
        code.6269 = code;
        code = code.6269 + 1;
        D.45458 = imb.b[1];
        *code.6269 = D.45458;
        code.6270 = code;
        code = code.6270 + 1;
        D.45460 = imb.b[2];
        *code.6270 = D.45460;
        code.6271 = code;
        code = code.6271 + 1;
        D.45462 = imb.b[3];
        *code.6271 = D.45462;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.28346>;
  <D.45448>:
  if (0 != 0) goto <D.45463>; else goto <D.45464>;
  <D.45463>:
  code.6272 = code;
  code = code.6272 + 1;
  *code.6272 = 131;
  code.6273 = code;
  code = code.6273 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.6273 = D.34069;
  D.31551 = ins->data.op[0].const_val;
  D.45451 = D.31551 & 1;
  if (D.45451 != 0) goto <D.45468>; else goto <D.45469>;
  <D.45468>:
  iftmp.6274 = 255;
  goto <D.45470>;
  <D.45469>:
  iftmp.6274 = 0;
  <D.45470>:
  *code = iftmp.6274;
  code = code + 1;
  goto <D.45471>;
  <D.45464>:
  code.6275 = code;
  code = code.6275 + 1;
  *code.6275 = 129;
  code.6276 = code;
  code = code.6276 + 1;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.34068 = D.31586 | -32;
  D.34069 = (unsigned char) D.34068;
  *code.6276 = D.34069;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        D.45451 = D.31551 & 1;
        if (D.45451 != 0) goto <D.45475>; else goto <D.45476>;
        <D.45475>:
        iftmp.6277 = 255;
        goto <D.45477>;
        <D.45476>:
        iftmp.6277 = 65280;
        <D.45477>:
        imb.val = iftmp.6277;
        code.6278 = code;
        code = code.6278 + 1;
        D.45479 = imb.b[0];
        *code.6278 = D.45479;
        code.6279 = code;
        code = code.6279 + 1;
        D.45481 = imb.b[1];
        *code.6279 = D.45481;
        code.6280 = code;
        code = code.6280 + 1;
        D.45483 = imb.b[2];
        *code.6280 = D.45483;
        code.6281 = code;
        code = code.6281 + 1;
        D.45485 = imb.b[3];
        *code.6281 = D.45485;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45471>:
  <D.28346>:
  D.31551 = ins->data.op[0].const_val;
  D.45451 = D.31551 & 1;
  if (D.45451 != 0) goto <D.45486>; else goto <D.45487>;
  <D.45486>:
  if (0 != 0) goto <D.45488>; else goto <D.45489>;
  <D.45488>:
  code.6282 = code;
  code = code.6282 + 1;
  *code.6282 = 209;
  code.6283 = code;
  code = code.6283 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.31534 = D.31529 | -32;
  D.31535 = (unsigned char) D.31534;
  *code.6283 = D.31535;
  goto <D.45492>;
  <D.45489>:
  code.6284 = code;
  code = code.6284 + 1;
  *code.6284 = 193;
  code.6285 = code;
  code = code.6285 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.31534 = D.31529 | -32;
  D.31535 = (unsigned char) D.31534;
  *code.6285 = D.31535;
  *code = 8;
  code = code + 1;
  <D.45492>:
  <D.45487>:
  code.6286 = code;
  code = code.6286 + 1;
  *code.6286 = 11;
  code.6287 = code;
  code = code.6287 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32565 = D.32037 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.32566 = D.32565 | D.31529;
  D.32567 = (unsigned char) D.32566;
  *code.6287 = D.32567;
  code.6288 = code;
  code = code.6288 + 1;
  *code.6288 = 102;
  code.6289 = code;
  code = code.6289 + 1;
  *code.6289 = 15;
  code.6290 = code;
  code = code.6290 + 1;
  *code.6290 = 196;
  code.6291 = code;
  code = code.6291 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6291 = D.32535;
  code.6292 = code;
  code = code.6292 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.45502 = D.31551 / 2;
  D.45503 = (unsigned char) D.45502;
  *code.6292 = D.45503;
  goto <D.24796>;
  <D.28348>:
  code.6293 = code;
  code = code.6293 + 1;
  *code.6293 = 102;
  code.6294 = code;
  code = code.6294 + 1;
  *code.6294 = 15;
  code.6295 = code;
  code = code.6295 + 1;
  *code.6295 = 196;
  code.6296 = code;
  code = code.6296 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6296 = D.37392;
  code.6297 = code;
  code = code.6297 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  D.45509 = D.31563 * 2;
  *code.6297 = D.45509;
  if (0 != 0) goto <D.45510>; else goto <D.45511>;
  <D.45510>:
  code.6298 = code;
  code = code.6298 + 1;
  *code.6298 = 209;
  code.6299 = code;
  code = code.6299 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.31530 = D.31529 | -24;
  D.31531 = (unsigned char) D.31530;
  *code.6299 = D.31531;
  goto <D.45514>;
  <D.45511>:
  code.6300 = code;
  code = code.6300 + 1;
  *code.6300 = 193;
  code.6301 = code;
  code = code.6301 + 1;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.31530 = D.31529 | -24;
  D.31531 = (unsigned char) D.31530;
  *code.6301 = D.31531;
  *code = 16;
  code = code + 1;
  <D.45514>:
  code.6302 = code;
  code = code.6302 + 1;
  *code.6302 = 102;
  code.6303 = code;
  code = code.6303 + 1;
  *code.6303 = 15;
  code.6304 = code;
  code = code.6304 + 1;
  *code.6304 = 196;
  code.6305 = code;
  code = code.6305 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31527 = ins->sreg2;
  D.31528 = (signed char) D.31527;
  D.31529 = D.31528 & 7;
  D.37391 = D.32533 | D.31529;
  D.37392 = (unsigned char) D.37391;
  *code.6305 = D.37392;
  code.6306 = code;
  code = code.6306 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  D.45509 = D.31563 * 2;
  D.45522 = D.45509 + 1;
  *code.6306 = D.45522;
  goto <D.24796>;
  <D.28349>:
  code.6307 = code;
  code = code.6307 + 1;
  *code.6307 = 217;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45524>; else goto <D.45525>;
  <D.45524>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45526>; else goto <D.45527>;
  <D.45526>:
  code.6308 = code;
  code = code.6308 + 1;
  *code.6308 = 28;
  code.6309 = code;
  code = code.6309 + 1;
  *code.6309 = 36;
  goto <D.45530>;
  <D.45527>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45531>; else goto <D.45532>;
  <D.45531>:
  code.6310 = code;
  code = code.6310 + 1;
  *code.6310 = 92;
  code.6311 = code;
  code = code.6311 + 1;
  *code.6311 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45535>;
  <D.45532>:
  code.6312 = code;
  code = code.6312 + 1;
  *code.6312 = 156;
  code.6313 = code;
  code = code.6313 + 1;
  *code.6313 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6314 = code;
        code = code.6314 + 1;
        D.45539 = imb.b[0];
        *code.6314 = D.45539;
        code.6315 = code;
        code = code.6315 + 1;
        D.45541 = imb.b[1];
        *code.6315 = D.45541;
        code.6316 = code;
        code = code.6316 + 1;
        D.45543 = imb.b[2];
        *code.6316 = D.45543;
        code.6317 = code;
        code = code.6317 + 1;
        D.45545 = imb.b[3];
        *code.6317 = D.45545;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45535>:
  <D.45530>:
  goto <D.28351>;
  <D.45525>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45546>; else goto <D.45547>;
  <D.45546>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45548>; else goto <D.45549>;
  <D.45548>:
  code.6318 = code;
  code = code.6318 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45551 = D.45326 | 24;
  D.45552 = (unsigned char) D.45551;
  *code.6318 = D.45552;
  goto <D.28351>;
  <D.45549>:
  <D.45547>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45553>; else goto <D.45554>;
  <D.45553>:
  code.6319 = code;
  code = code.6319 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45556 = D.45326 | 88;
  D.45557 = (unsigned char) D.45556;
  *code.6319 = D.45557;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45558>;
  <D.45554>:
  code.6320 = code;
  code = code.6320 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45560 = D.45326 | -104;
  D.45561 = (unsigned char) D.45560;
  *code.6320 = D.45561;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6321 = code;
        code = code.6321 + 1;
        D.45563 = imb.b[0];
        *code.6321 = D.45563;
        code.6322 = code;
        code = code.6322 + 1;
        D.45565 = imb.b[1];
        *code.6322 = D.45565;
        code.6323 = code;
        code = code.6323 + 1;
        D.45567 = imb.b[2];
        *code.6323 = D.45567;
        code.6324 = code;
        code = code.6324 + 1;
        D.45569 = imb.b[3];
        *code.6324 = D.45569;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45558>:
  <D.28351>:
  code.6325 = code;
  code = code.6325 + 1;
  *code.6325 = 102;
  code.6326 = code;
  code = code.6326 + 1;
  *code.6326 = 15;
  code.6327 = code;
  code = code.6327 + 1;
  *code.6327 = 196;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45573>; else goto <D.45574>;
  <D.45573>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45575>; else goto <D.45576>;
  <D.45575>:
  code.6328 = code;
  code = code.6328 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6328 = D.32289;
  code.6329 = code;
  code = code.6329 + 1;
  *code.6329 = 36;
  goto <D.45579>;
  <D.45576>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45580>; else goto <D.45581>;
  <D.45580>:
  code.6330 = code;
  code = code.6330 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6330 = D.32296;
  code.6331 = code;
  code = code.6331 + 1;
  *code.6331 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45584>;
  <D.45581>:
  code.6332 = code;
  code = code.6332 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6332 = D.32301;
  code.6333 = code;
  code = code.6333 + 1;
  *code.6333 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6334 = code;
        code = code.6334 + 1;
        D.45588 = imb.b[0];
        *code.6334 = D.45588;
        code.6335 = code;
        code = code.6335 + 1;
        D.45590 = imb.b[1];
        *code.6335 = D.45590;
        code.6336 = code;
        code = code.6336 + 1;
        D.45592 = imb.b[2];
        *code.6336 = D.45592;
        code.6337 = code;
        code = code.6337 + 1;
        D.45594 = imb.b[3];
        *code.6337 = D.45594;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45584>:
  <D.45579>:
  goto <D.28354>;
  <D.45574>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45595>; else goto <D.45596>;
  <D.45595>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45597>; else goto <D.45598>;
  <D.45597>:
  code.6338 = code;
  code = code.6338 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6338 = D.45601;
  goto <D.28354>;
  <D.45598>:
  <D.45596>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45602>; else goto <D.45603>;
  <D.45602>:
  code.6339 = code;
  code = code.6339 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6339 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45607>;
  <D.45603>:
  code.6340 = code;
  code = code.6340 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6340 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6341 = code;
        code = code.6341 + 1;
        D.45612 = imb.b[0];
        *code.6341 = D.45612;
        code.6342 = code;
        code = code.6342 + 1;
        D.45614 = imb.b[1];
        *code.6342 = D.45614;
        code.6343 = code;
        code = code.6343 + 1;
        D.45616 = imb.b[2];
        *code.6343 = D.45616;
        code.6344 = code;
        code = code.6344 + 1;
        D.45618 = imb.b[3];
        *code.6344 = D.45618;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45607>:
  <D.28354>:
  code.6345 = code;
  code = code.6345 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  D.45509 = D.31563 * 2;
  *code.6345 = D.45509;
  code.6346 = code;
  code = code.6346 + 1;
  *code.6346 = 102;
  code.6347 = code;
  code = code.6347 + 1;
  *code.6347 = 15;
  code.6348 = code;
  code = code.6348 + 1;
  *code.6348 = 196;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45623>; else goto <D.45624>;
  <D.45623>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == -2) goto <D.45625>; else goto <D.45626>;
  <D.45625>:
  code.6349 = code;
  code = code.6349 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6349 = D.32289;
  code.6350 = code;
  code = code.6350 + 1;
  *code.6350 = 36;
  goto <D.45629>;
  <D.45626>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45630 = D.45302 + 130;
  if (D.45630 <= 255) goto <D.45631>; else goto <D.45632>;
  <D.45631>:
  code.6351 = code;
  code = code.6351 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6351 = D.32296;
  code.6352 = code;
  code = code.6352 + 1;
  *code.6352 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45635 = (unsigned char) D.45296;
  D.45636 = D.45635 + 2;
  *code = D.45636;
  code = code + 1;
  goto <D.45637>;
  <D.45632>:
  code.6353 = code;
  code = code.6353 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6353 = D.32301;
  code.6354 = code;
  code = code.6354 + 1;
  *code.6354 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        D.45640 = D.45296 + 2;
        imb.val = D.45640;
        code.6355 = code;
        code = code.6355 + 1;
        D.45642 = imb.b[0];
        *code.6355 = D.45642;
        code.6356 = code;
        code = code.6356 + 1;
        D.45644 = imb.b[1];
        *code.6356 = D.45644;
        code.6357 = code;
        code = code.6357 + 1;
        D.45646 = imb.b[2];
        *code.6357 = D.45646;
        code.6358 = code;
        code = code.6358 + 1;
        D.45648 = imb.b[3];
        *code.6358 = D.45648;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45637>:
  <D.45629>:
  goto <D.28357>;
  <D.45624>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == -2) goto <D.45649>; else goto <D.45650>;
  <D.45649>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45651>; else goto <D.45652>;
  <D.45651>:
  code.6359 = code;
  code = code.6359 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6359 = D.45601;
  goto <D.28357>;
  <D.45652>:
  <D.45650>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45630 = D.45302 + 130;
  if (D.45630 <= 255) goto <D.45654>; else goto <D.45655>;
  <D.45654>:
  code.6360 = code;
  code = code.6360 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6360 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45635 = (unsigned char) D.45296;
  D.45636 = D.45635 + 2;
  *code = D.45636;
  code = code + 1;
  goto <D.45657>;
  <D.45655>:
  code.6361 = code;
  code = code.6361 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6361 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        D.45640 = D.45296 + 2;
        imb.val = D.45640;
        code.6362 = code;
        code = code.6362 + 1;
        D.45660 = imb.b[0];
        *code.6362 = D.45660;
        code.6363 = code;
        code = code.6363 + 1;
        D.45662 = imb.b[1];
        *code.6363 = D.45662;
        code.6364 = code;
        code = code.6364 + 1;
        D.45664 = imb.b[2];
        *code.6364 = D.45664;
        code.6365 = code;
        code = code.6365 + 1;
        D.45666 = imb.b[3];
        *code.6365 = D.45666;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45657>:
  <D.28357>:
  code.6366 = code;
  code = code.6366 + 1;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  D.45509 = D.31563 * 2;
  D.45522 = D.45509 + 1;
  *code.6366 = D.45522;
  goto <D.24796>;
  <D.28359>:
  code.6367 = code;
  code = code.6367 + 1;
  *code.6367 = 221;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45669>; else goto <D.45670>;
  <D.45669>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45671>; else goto <D.45672>;
  <D.45671>:
  code.6368 = code;
  code = code.6368 + 1;
  *code.6368 = 28;
  code.6369 = code;
  code = code.6369 + 1;
  *code.6369 = 36;
  goto <D.45675>;
  <D.45672>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45676>; else goto <D.45677>;
  <D.45676>:
  code.6370 = code;
  code = code.6370 + 1;
  *code.6370 = 92;
  code.6371 = code;
  code = code.6371 + 1;
  *code.6371 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45680>;
  <D.45677>:
  code.6372 = code;
  code = code.6372 + 1;
  *code.6372 = 156;
  code.6373 = code;
  code = code.6373 + 1;
  *code.6373 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6374 = code;
        code = code.6374 + 1;
        D.45684 = imb.b[0];
        *code.6374 = D.45684;
        code.6375 = code;
        code = code.6375 + 1;
        D.45686 = imb.b[1];
        *code.6375 = D.45686;
        code.6376 = code;
        code = code.6376 + 1;
        D.45688 = imb.b[2];
        *code.6376 = D.45688;
        code.6377 = code;
        code = code.6377 + 1;
        D.45690 = imb.b[3];
        *code.6377 = D.45690;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45680>:
  <D.45675>:
  goto <D.28361>;
  <D.45670>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45691>; else goto <D.45692>;
  <D.45691>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45693>; else goto <D.45694>;
  <D.45693>:
  code.6378 = code;
  code = code.6378 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45551 = D.45326 | 24;
  D.45552 = (unsigned char) D.45551;
  *code.6378 = D.45552;
  goto <D.28361>;
  <D.45694>:
  <D.45692>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45696>; else goto <D.45697>;
  <D.45696>:
  code.6379 = code;
  code = code.6379 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45556 = D.45326 | 88;
  D.45557 = (unsigned char) D.45556;
  *code.6379 = D.45557;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45699>;
  <D.45697>:
  code.6380 = code;
  code = code.6380 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45560 = D.45326 | -104;
  D.45561 = (unsigned char) D.45560;
  *code.6380 = D.45561;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6381 = code;
        code = code.6381 + 1;
        D.45702 = imb.b[0];
        *code.6381 = D.45702;
        code.6382 = code;
        code = code.6382 + 1;
        D.45704 = imb.b[1];
        *code.6382 = D.45704;
        code.6383 = code;
        code = code.6383 + 1;
        D.45706 = imb.b[2];
        *code.6383 = D.45706;
        code.6384 = code;
        code = code.6384 + 1;
        D.45708 = imb.b[3];
        *code.6384 = D.45708;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45699>:
  <D.28361>:
  D.31457 = cfg->verbose_level;
  if (D.31457 != 0) goto <D.45709>; else goto <D.45710>;
  <D.45709>:
  D.31551 = ins->data.op[0].const_val;
  printf ("CONVERTING a OP_INSERTX_R8_SLOW %d offset %x\n", D.31551, offset);
  <D.45710>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 != 0) goto <D.45711>; else goto <D.45712>;
  <D.45711>:
  code.6385 = code;
  code = code.6385 + 1;
  *code.6385 = 102;
  code.6386 = code;
  code = code.6386 + 1;
  *code.6386 = 15;
  code.6387 = code;
  code = code.6387 + 1;
  *code.6387 = 22;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45716>; else goto <D.45717>;
  <D.45716>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45718>; else goto <D.45719>;
  <D.45718>:
  code.6388 = code;
  code = code.6388 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6388 = D.32289;
  code.6389 = code;
  code = code.6389 + 1;
  *code.6389 = 36;
  goto <D.45722>;
  <D.45719>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45723>; else goto <D.45724>;
  <D.45723>:
  code.6390 = code;
  code = code.6390 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6390 = D.32296;
  code.6391 = code;
  code = code.6391 + 1;
  *code.6391 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45727>;
  <D.45724>:
  code.6392 = code;
  code = code.6392 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6392 = D.32301;
  code.6393 = code;
  code = code.6393 + 1;
  *code.6393 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6394 = code;
        code = code.6394 + 1;
        D.45731 = imb.b[0];
        *code.6394 = D.45731;
        code.6395 = code;
        code = code.6395 + 1;
        D.45733 = imb.b[1];
        *code.6395 = D.45733;
        code.6396 = code;
        code = code.6396 + 1;
        D.45735 = imb.b[2];
        *code.6396 = D.45735;
        code.6397 = code;
        code = code.6397 + 1;
        D.45737 = imb.b[3];
        *code.6397 = D.45737;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45727>:
  <D.45722>:
  goto <D.28364>;
  <D.45717>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45738>; else goto <D.45739>;
  <D.45738>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45740>; else goto <D.45741>;
  <D.45740>:
  code.6398 = code;
  code = code.6398 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6398 = D.45601;
  goto <D.28364>;
  <D.45741>:
  <D.45739>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45743>; else goto <D.45744>;
  <D.45743>:
  code.6399 = code;
  code = code.6399 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6399 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45746>;
  <D.45744>:
  code.6400 = code;
  code = code.6400 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6400 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6401 = code;
        code = code.6401 + 1;
        D.45749 = imb.b[0];
        *code.6401 = D.45749;
        code.6402 = code;
        code = code.6402 + 1;
        D.45751 = imb.b[1];
        *code.6402 = D.45751;
        code.6403 = code;
        code = code.6403 + 1;
        D.45753 = imb.b[2];
        *code.6403 = D.45753;
        code.6404 = code;
        code = code.6404 + 1;
        D.45755 = imb.b[3];
        *code.6404 = D.45755;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45746>:
  <D.28364>:
  goto <D.45756>;
  <D.45712>:
  code.6405 = code;
  code = code.6405 + 1;
  *code.6405 = 242;
  code.6406 = code;
  code = code.6406 + 1;
  *code.6406 = 15;
  code.6407 = code;
  code = code.6407 + 1;
  *code.6407 = 16;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.45760>; else goto <D.45761>;
  <D.45760>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45762>; else goto <D.45763>;
  <D.45762>:
  code.6408 = code;
  code = code.6408 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6408 = D.32289;
  code.6409 = code;
  code = code.6409 + 1;
  *code.6409 = 36;
  goto <D.45766>;
  <D.45763>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45767>; else goto <D.45768>;
  <D.45767>:
  code.6410 = code;
  code = code.6410 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6410 = D.32296;
  code.6411 = code;
  code = code.6411 + 1;
  *code.6411 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45771>;
  <D.45768>:
  code.6412 = code;
  code = code.6412 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6412 = D.32301;
  code.6413 = code;
  code = code.6413 + 1;
  *code.6413 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6414 = code;
        code = code.6414 + 1;
        D.45775 = imb.b[0];
        *code.6414 = D.45775;
        code.6415 = code;
        code = code.6415 + 1;
        D.45777 = imb.b[1];
        *code.6415 = D.45777;
        code.6416 = code;
        code = code.6416 + 1;
        D.45779 = imb.b[2];
        *code.6416 = D.45779;
        code.6417 = code;
        code = code.6417 + 1;
        D.45781 = imb.b[3];
        *code.6417 = D.45781;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45771>:
  <D.45766>:
  goto <D.28367>;
  <D.45761>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.45782>; else goto <D.45783>;
  <D.45782>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.45784>; else goto <D.45785>;
  <D.45784>:
  code.6418 = code;
  code = code.6418 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6418 = D.45601;
  goto <D.28367>;
  <D.45785>:
  <D.45783>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.45787>; else goto <D.45788>;
  <D.45787>:
  code.6419 = code;
  code = code.6419 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6419 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.45790>;
  <D.45788>:
  code.6420 = code;
  code = code.6420 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6420 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6421 = code;
        code = code.6421 + 1;
        D.45793 = imb.b[0];
        *code.6421 = D.45793;
        code.6422 = code;
        code = code.6422 + 1;
        D.45795 = imb.b[1];
        *code.6422 = D.45795;
        code.6423 = code;
        code = code.6423 + 1;
        D.45797 = imb.b[2];
        *code.6423 = D.45797;
        code.6424 = code;
        code = code.6424 + 1;
        D.45799 = imb.b[3];
        *code.6424 = D.45799;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45790>:
  <D.28367>:
  <D.45756>:
  goto <D.24796>;
  <D.28369>:
  <D.28370>:
  code.6425 = code;
  code = code.6425 + 1;
  *code.6425 = 15;
  code.6426 = code;
  code = code.6426 + 1;
  *code.6426 = 17;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.45802>; else goto <D.45803>;
  <D.45802>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45804>; else goto <D.45805>;
  <D.45804>:
  code.6427 = code;
  code = code.6427 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.6427 = D.32039;
  code.6428 = code;
  code = code.6428 + 1;
  *code.6428 = 36;
  goto <D.45808>;
  <D.45805>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45809>; else goto <D.45810>;
  <D.45809>:
  code.6429 = code;
  code = code.6429 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.6429 = D.32046;
  code.6430 = code;
  code = code.6430 + 1;
  *code.6430 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45813>;
  <D.45810>:
  code.6431 = code;
  code = code.6431 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.6431 = D.32051;
  code.6432 = code;
  code = code.6432 + 1;
  *code.6432 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6433 = code;
        code = code.6433 + 1;
        D.45817 = imb.b[0];
        *code.6433 = D.45817;
        code.6434 = code;
        code = code.6434 + 1;
        D.45819 = imb.b[1];
        *code.6434 = D.45819;
        code.6435 = code;
        code = code.6435 + 1;
        D.45821 = imb.b[2];
        *code.6435 = D.45821;
        code.6436 = code;
        code = code.6436 + 1;
        D.45823 = imb.b[3];
        *code.6436 = D.45823;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45813>:
  <D.45808>:
  goto <D.28372>;
  <D.45803>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45824>; else goto <D.45825>;
  <D.45824>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.45826>; else goto <D.45827>;
  <D.45826>:
  code.6437 = code;
  code = code.6437 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32066 = D.32037 | D.31638;
  D.32067 = (unsigned char) D.32066;
  *code.6437 = D.32067;
  goto <D.28372>;
  <D.45827>:
  <D.45825>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45829>; else goto <D.45830>;
  <D.45829>:
  code.6438 = code;
  code = code.6438 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32072 = D.32071 | D.31638;
  D.32073 = (unsigned char) D.32072;
  *code.6438 = D.32073;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45832>;
  <D.45830>:
  code.6439 = code;
  code = code.6439 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32077 = D.32076 | D.31638;
  D.32078 = (unsigned char) D.32077;
  *code.6439 = D.32078;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6440 = code;
        code = code.6440 + 1;
        D.45835 = imb.b[0];
        *code.6440 = D.45835;
        code.6441 = code;
        code = code.6441 + 1;
        D.45837 = imb.b[1];
        *code.6441 = D.45837;
        code.6442 = code;
        code = code.6442 + 1;
        D.45839 = imb.b[2];
        *code.6442 = D.45839;
        code.6443 = code;
        code = code.6443 + 1;
        D.45841 = imb.b[3];
        *code.6443 = D.45841;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45832>:
  <D.28372>:
  goto <D.24796>;
  <D.28374>:
  code.6444 = code;
  code = code.6444 + 1;
  *code.6444 = 15;
  code.6445 = code;
  code = code.6445 + 1;
  *code.6445 = 16;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.45844>; else goto <D.45845>;
  <D.45844>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45846>; else goto <D.45847>;
  <D.45846>:
  code.6446 = code;
  code = code.6446 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6446 = D.32289;
  code.6447 = code;
  code = code.6447 + 1;
  *code.6447 = 36;
  goto <D.45850>;
  <D.45847>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45851>; else goto <D.45852>;
  <D.45851>:
  code.6448 = code;
  code = code.6448 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6448 = D.32296;
  code.6449 = code;
  code = code.6449 + 1;
  *code.6449 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45855>;
  <D.45852>:
  code.6450 = code;
  code = code.6450 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6450 = D.32301;
  code.6451 = code;
  code = code.6451 + 1;
  *code.6451 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6452 = code;
        code = code.6452 + 1;
        D.45859 = imb.b[0];
        *code.6452 = D.45859;
        code.6453 = code;
        code = code.6453 + 1;
        D.45861 = imb.b[1];
        *code.6453 = D.45861;
        code.6454 = code;
        code = code.6454 + 1;
        D.45863 = imb.b[2];
        *code.6454 = D.45863;
        code.6455 = code;
        code = code.6455 + 1;
        D.45865 = imb.b[3];
        *code.6455 = D.45865;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45855>:
  <D.45850>:
  goto <D.28376>;
  <D.45845>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45866>; else goto <D.45867>;
  <D.45866>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.45868>; else goto <D.45869>;
  <D.45868>:
  code.6456 = code;
  code = code.6456 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32316 = D.32227 | D.31586;
  D.32317 = (unsigned char) D.32316;
  *code.6456 = D.32317;
  goto <D.28376>;
  <D.45869>:
  <D.45867>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45871>; else goto <D.45872>;
  <D.45871>:
  code.6457 = code;
  code = code.6457 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32322 = D.32321 | D.31586;
  D.32323 = (unsigned char) D.32322;
  *code.6457 = D.32323;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45874>;
  <D.45872>:
  code.6458 = code;
  code = code.6458 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32327 = D.32326 | D.31586;
  D.32328 = (unsigned char) D.32327;
  *code.6458 = D.32328;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6459 = code;
        code = code.6459 + 1;
        D.45877 = imb.b[0];
        *code.6459 = D.45877;
        code.6460 = code;
        code = code.6460 + 1;
        D.45879 = imb.b[1];
        *code.6460 = D.45879;
        code.6461 = code;
        code = code.6461 + 1;
        D.45881 = imb.b[2];
        *code.6461 = D.45881;
        code.6462 = code;
        code = code.6462 + 1;
        D.45883 = imb.b[3];
        *code.6462 = D.45883;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45874>:
  <D.28376>:
  goto <D.24796>;
  <D.28378>:
  code.6463 = code;
  code = code.6463 + 1;
  *code.6463 = 15;
  code.6464 = code;
  code = code.6464 + 1;
  *code.6464 = 40;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.45886>; else goto <D.45887>;
  <D.45886>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45888>; else goto <D.45889>;
  <D.45888>:
  code.6465 = code;
  code = code.6465 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6465 = D.32289;
  code.6466 = code;
  code = code.6466 + 1;
  *code.6466 = 36;
  goto <D.45892>;
  <D.45889>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45893>; else goto <D.45894>;
  <D.45893>:
  code.6467 = code;
  code = code.6467 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6467 = D.32296;
  code.6468 = code;
  code = code.6468 + 1;
  *code.6468 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45897>;
  <D.45894>:
  code.6469 = code;
  code = code.6469 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6469 = D.32301;
  code.6470 = code;
  code = code.6470 + 1;
  *code.6470 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6471 = code;
        code = code.6471 + 1;
        D.45901 = imb.b[0];
        *code.6471 = D.45901;
        code.6472 = code;
        code = code.6472 + 1;
        D.45903 = imb.b[1];
        *code.6472 = D.45903;
        code.6473 = code;
        code = code.6473 + 1;
        D.45905 = imb.b[2];
        *code.6473 = D.45905;
        code.6474 = code;
        code = code.6474 + 1;
        D.45907 = imb.b[3];
        *code.6474 = D.45907;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45897>:
  <D.45892>:
  goto <D.28380>;
  <D.45887>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45908>; else goto <D.45909>;
  <D.45908>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.45910>; else goto <D.45911>;
  <D.45910>:
  code.6475 = code;
  code = code.6475 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32316 = D.32227 | D.31586;
  D.32317 = (unsigned char) D.32316;
  *code.6475 = D.32317;
  goto <D.28380>;
  <D.45911>:
  <D.45909>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45913>; else goto <D.45914>;
  <D.45913>:
  code.6476 = code;
  code = code.6476 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32322 = D.32321 | D.31586;
  D.32323 = (unsigned char) D.32322;
  *code.6476 = D.32323;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45916>;
  <D.45914>:
  code.6477 = code;
  code = code.6477 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32327 = D.32326 | D.31586;
  D.32328 = (unsigned char) D.32327;
  *code.6477 = D.32328;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6478 = code;
        code = code.6478 + 1;
        D.45919 = imb.b[0];
        *code.6478 = D.45919;
        code.6479 = code;
        code = code.6479 + 1;
        D.45921 = imb.b[1];
        *code.6479 = D.45921;
        code.6480 = code;
        code = code.6480 + 1;
        D.45923 = imb.b[2];
        *code.6480 = D.45923;
        code.6481 = code;
        code = code.6481 + 1;
        D.45925 = imb.b[3];
        *code.6481 = D.45925;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45916>:
  <D.28380>:
  goto <D.24796>;
  <D.28382>:
  code.6482 = code;
  code = code.6482 + 1;
  *code.6482 = 15;
  code.6483 = code;
  code = code.6483 + 1;
  *code.6483 = 41;
  D.31604 = ins->dreg;
  if (D.31604 == 4) goto <D.45928>; else goto <D.45929>;
  <D.45928>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45930>; else goto <D.45931>;
  <D.45930>:
  code.6484 = code;
  code = code.6484 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.6484 = D.32039;
  code.6485 = code;
  code = code.6485 + 1;
  *code.6485 = 36;
  goto <D.45934>;
  <D.45931>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45935>; else goto <D.45936>;
  <D.45935>:
  code.6486 = code;
  code = code.6486 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.6486 = D.32046;
  code.6487 = code;
  code = code.6487 + 1;
  *code.6487 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45939>;
  <D.45936>:
  code.6488 = code;
  code = code.6488 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.6488 = D.32051;
  code.6489 = code;
  code = code.6489 + 1;
  *code.6489 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6490 = code;
        code = code.6490 + 1;
        D.45943 = imb.b[0];
        *code.6490 = D.45943;
        code.6491 = code;
        code = code.6491 + 1;
        D.45945 = imb.b[1];
        *code.6491 = D.45945;
        code.6492 = code;
        code = code.6492 + 1;
        D.45947 = imb.b[2];
        *code.6492 = D.45947;
        code.6493 = code;
        code = code.6493 + 1;
        D.45949 = imb.b[3];
        *code.6493 = D.45949;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45939>:
  <D.45934>:
  goto <D.28384>;
  <D.45929>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45950>; else goto <D.45951>;
  <D.45950>:
  D.31604 = ins->dreg;
  if (D.31604 != 5) goto <D.45952>; else goto <D.45953>;
  <D.45952>:
  code.6494 = code;
  code = code.6494 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32066 = D.32037 | D.31638;
  D.32067 = (unsigned char) D.32066;
  *code.6494 = D.32067;
  goto <D.28384>;
  <D.45953>:
  <D.45951>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45955>; else goto <D.45956>;
  <D.45955>:
  code.6495 = code;
  code = code.6495 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32072 = D.32071 | D.31638;
  D.32073 = (unsigned char) D.32072;
  *code.6495 = D.32073;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45958>;
  <D.45956>:
  code.6496 = code;
  code = code.6496 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.32077 = D.32076 | D.31638;
  D.32078 = (unsigned char) D.32077;
  *code.6496 = D.32078;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6497 = code;
        code = code.6497 + 1;
        D.45961 = imb.b[0];
        *code.6497 = D.45961;
        code.6498 = code;
        code = code.6498 + 1;
        D.45963 = imb.b[1];
        *code.6498 = D.45963;
        code.6499 = code;
        code = code.6499 + 1;
        D.45965 = imb.b[2];
        *code.6499 = D.45965;
        code.6500 = code;
        code = code.6500 + 1;
        D.45967 = imb.b[3];
        *code.6500 = D.45967;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45958>:
  <D.28384>:
  goto <D.24796>;
  <D.28386>:
  code.6501 = code;
  code = code.6501 + 1;
  *code.6501 = 15;
  code.6502 = code;
  code = code.6502 + 1;
  *code.6502 = 43;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.45970>; else goto <D.45971>;
  <D.45970>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45972>; else goto <D.45973>;
  <D.45972>:
  code.6503 = code;
  code = code.6503 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6503 = D.32289;
  code.6504 = code;
  code = code.6504 + 1;
  *code.6504 = 36;
  goto <D.45976>;
  <D.45973>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45977>; else goto <D.45978>;
  <D.45977>:
  code.6505 = code;
  code = code.6505 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6505 = D.32296;
  code.6506 = code;
  code = code.6506 + 1;
  *code.6506 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.45981>;
  <D.45978>:
  code.6507 = code;
  code = code.6507 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6507 = D.32301;
  code.6508 = code;
  code = code.6508 + 1;
  *code.6508 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6509 = code;
        code = code.6509 + 1;
        D.45985 = imb.b[0];
        *code.6509 = D.45985;
        code.6510 = code;
        code = code.6510 + 1;
        D.45987 = imb.b[1];
        *code.6510 = D.45987;
        code.6511 = code;
        code = code.6511 + 1;
        D.45989 = imb.b[2];
        *code.6511 = D.45989;
        code.6512 = code;
        code = code.6512 + 1;
        D.45991 = imb.b[3];
        *code.6512 = D.45991;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45981>:
  <D.45976>:
  goto <D.28388>;
  <D.45971>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.45992>; else goto <D.45993>;
  <D.45992>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.45994>; else goto <D.45995>;
  <D.45994>:
  code.6513 = code;
  code = code.6513 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32316 = D.32227 | D.31586;
  D.32317 = (unsigned char) D.32316;
  *code.6513 = D.32317;
  goto <D.28388>;
  <D.45995>:
  <D.45993>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.45997>; else goto <D.45998>;
  <D.45997>:
  code.6514 = code;
  code = code.6514 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32322 = D.32321 | D.31586;
  D.32323 = (unsigned char) D.32322;
  *code.6514 = D.32323;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.46000>;
  <D.45998>:
  code.6515 = code;
  code = code.6515 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32327 = D.32326 | D.31586;
  D.32328 = (unsigned char) D.32327;
  *code.6515 = D.32328;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6516 = code;
        code = code.6516 + 1;
        D.46003 = imb.b[0];
        *code.6516 = D.46003;
        code.6517 = code;
        code = code.6517 + 1;
        D.46005 = imb.b[1];
        *code.6517 = D.46005;
        code.6518 = code;
        code = code.6518 + 1;
        D.46007 = imb.b[2];
        *code.6518 = D.46007;
        code.6519 = code;
        code = code.6519 + 1;
        D.46009 = imb.b[3];
        *code.6519 = D.46009;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46000>:
  <D.28388>:
  goto <D.24796>;
  <D.28390>:
  code.6520 = code;
  code = code.6520 + 1;
  *code.6520 = 15;
  code.6521 = code;
  code = code.6521 + 1;
  *code.6521 = 24;
  D.31548 = ins->sreg1;
  if (D.31548 == 4) goto <D.46012>; else goto <D.46013>;
  <D.46012>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.46014>; else goto <D.46015>;
  <D.46014>:
  code.6522 = code;
  code = code.6522 + 1;
  D.46017 = ins->backend.arg_info;
  D.46018 = D.46017 & 7;
  D.46019 = D.46018 << 3;
  D.46020 = (signed char) D.46019;
  D.46021 = D.46020 | 4;
  D.46022 = (unsigned char) D.46021;
  *code.6522 = D.46022;
  code.6523 = code;
  code = code.6523 + 1;
  *code.6523 = 36;
  goto <D.46024>;
  <D.46015>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.46025>; else goto <D.46026>;
  <D.46025>:
  code.6524 = code;
  code = code.6524 + 1;
  D.46017 = ins->backend.arg_info;
  D.46018 = D.46017 & 7;
  D.46019 = D.46018 << 3;
  D.46020 = (signed char) D.46019;
  D.46028 = D.46020 | 68;
  D.46029 = (unsigned char) D.46028;
  *code.6524 = D.46029;
  code.6525 = code;
  code = code.6525 + 1;
  *code.6525 = 36;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.46031>;
  <D.46026>:
  code.6526 = code;
  code = code.6526 + 1;
  D.46017 = ins->backend.arg_info;
  D.46018 = D.46017 & 7;
  D.46019 = D.46018 << 3;
  D.46020 = (signed char) D.46019;
  D.46033 = D.46020 | -124;
  D.46034 = (unsigned char) D.46033;
  *code.6526 = D.46034;
  code.6527 = code;
  code = code.6527 + 1;
  *code.6527 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6528 = code;
        code = code.6528 + 1;
        D.46037 = imb.b[0];
        *code.6528 = D.46037;
        code.6529 = code;
        code = code.6529 + 1;
        D.46039 = imb.b[1];
        *code.6529 = D.46039;
        code.6530 = code;
        code = code.6530 + 1;
        D.46041 = imb.b[2];
        *code.6530 = D.46041;
        code.6531 = code;
        code = code.6531 + 1;
        D.46043 = imb.b[3];
        *code.6531 = D.46043;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46031>:
  <D.46024>:
  goto <D.28392>;
  <D.46013>:
  D.31551 = ins->data.op[0].const_val;
  if (D.31551 == 0) goto <D.46044>; else goto <D.46045>;
  <D.46044>:
  D.31548 = ins->sreg1;
  if (D.31548 != 5) goto <D.46046>; else goto <D.46047>;
  <D.46046>:
  code.6532 = code;
  code = code.6532 + 1;
  D.46017 = ins->backend.arg_info;
  D.46018 = D.46017 & 7;
  D.46019 = D.46018 << 3;
  D.46020 = (signed char) D.46019;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.46049 = D.46020 | D.31586;
  D.46050 = (unsigned char) D.46049;
  *code.6532 = D.46050;
  goto <D.28392>;
  <D.46047>:
  <D.46045>:
  D.31551 = ins->data.op[0].const_val;
  D.31557 = (unsigned int) D.31551;
  D.31558 = D.31557 + 128;
  if (D.31558 <= 255) goto <D.46051>; else goto <D.46052>;
  <D.46051>:
  code.6533 = code;
  code = code.6533 + 1;
  D.46017 = ins->backend.arg_info;
  D.46018 = D.46017 & 7;
  D.46019 = D.46018 << 3;
  D.46020 = (signed char) D.46019;
  D.46054 = D.46020 | 64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.46055 = D.46054 | D.31586;
  D.46056 = (unsigned char) D.46055;
  *code.6533 = D.46056;
  D.31551 = ins->data.op[0].const_val;
  D.31563 = (unsigned char) D.31551;
  *code = D.31563;
  code = code + 1;
  goto <D.46057>;
  <D.46052>:
  code.6534 = code;
  code = code.6534 + 1;
  D.46017 = ins->backend.arg_info;
  D.46018 = D.46017 & 7;
  D.46019 = D.46018 << 3;
  D.46020 = (signed char) D.46019;
  D.46059 = D.46020 | -128;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.46060 = D.46059 | D.31586;
  D.46061 = (unsigned char) D.46060;
  *code.6534 = D.46061;
  {
    union x86_imm_buf imb;

    try
      {
        D.31551 = ins->data.op[0].const_val;
        imb.val = D.31551;
        code.6535 = code;
        code = code.6535 + 1;
        D.46063 = imb.b[0];
        *code.6535 = D.46063;
        code.6536 = code;
        code = code.6536 + 1;
        D.46065 = imb.b[1];
        *code.6536 = D.46065;
        code.6537 = code;
        code = code.6537 + 1;
        D.46067 = imb.b[2];
        *code.6537 = D.46067;
        code.6538 = code;
        code = code.6538 + 1;
        D.46069 = imb.b[3];
        *code.6538 = D.46069;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46057>:
  <D.28392>:
  goto <D.24796>;
  <D.28394>:
  D.31604 = ins->dreg;
  D.31548 = ins->sreg1;
  if (D.31604 != D.31548) goto <D.46070>; else goto <D.46071>;
  <D.46070>:
  code.6539 = code;
  code = code.6539 + 1;
  *code.6539 = 15;
  code.6540 = code;
  code = code.6540 + 1;
  *code.6540 = 40;
  code.6541 = code;
  code = code.6541 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6541 = D.32535;
  <D.46071>:
  goto <D.24796>;
  <D.28395>:
  code.6542 = code;
  code = code.6542 + 1;
  *code.6542 = 102;
  code.6543 = code;
  code = code.6543 + 1;
  *code.6543 = 15;
  code.6544 = code;
  code = code.6544 + 1;
  *code.6544 = 239;
  code.6545 = code;
  code = code.6545 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.6545 = D.34303;
  goto <D.24796>;
  <D.28396>:
  switch (4) <default: <D.28401>, case 1: <D.28397>, case 2: <D.28399>, case 4: <D.28400>>
  <D.28397>:
  code.6546 = code;
  code = code.6546 + 1;
  *code.6546 = 136;
  goto <D.28398>;
  <D.28399>:
  code.6547 = code;
  code = code.6547 + 1;
  *code.6547 = 102;
  <D.28400>:
  code.6548 = code;
  code = code.6548 + 1;
  *code.6548 = 137;
  goto <D.28398>;
  <D.28401>:
  __assert_fail ("0", "mini-x86.c", 5011, &__PRETTY_FUNCTION__);
  <D.28398>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46082>; else goto <D.46083>;
  <D.46082>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46084>; else goto <D.46085>;
  <D.46084>:
  code.6549 = code;
  code = code.6549 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32038 = D.32037 | 4;
  D.32039 = (unsigned char) D.32038;
  *code.6549 = D.32039;
  code.6550 = code;
  code = code.6550 + 1;
  *code.6550 = 36;
  goto <D.46088>;
  <D.46085>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46089>; else goto <D.46090>;
  <D.46089>:
  code.6551 = code;
  code = code.6551 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32045 = D.32037 | 68;
  D.32046 = (unsigned char) D.32045;
  *code.6551 = D.32046;
  code.6552 = code;
  code = code.6552 + 1;
  *code.6552 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46093>;
  <D.46090>:
  code.6553 = code;
  code = code.6553 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32050 = D.32037 | -124;
  D.32051 = (unsigned char) D.32050;
  *code.6553 = D.32051;
  code.6554 = code;
  code = code.6554 + 1;
  *code.6554 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6555 = code;
        code = code.6555 + 1;
        D.46097 = imb.b[0];
        *code.6555 = D.46097;
        code.6556 = code;
        code = code.6556 + 1;
        D.46099 = imb.b[1];
        *code.6556 = D.46099;
        code.6557 = code;
        code = code.6557 + 1;
        D.46101 = imb.b[2];
        *code.6557 = D.46101;
        code.6558 = code;
        code = code.6558 + 1;
        D.46103 = imb.b[3];
        *code.6558 = D.46103;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46093>:
  <D.46088>:
  goto <D.28403>;
  <D.46083>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46104>; else goto <D.46105>;
  <D.46104>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46106>; else goto <D.46107>;
  <D.46106>:
  code.6559 = code;
  code = code.6559 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45327 = D.32037 | D.45326;
  D.45328 = (unsigned char) D.45327;
  *code.6559 = D.45328;
  goto <D.28403>;
  <D.46107>:
  <D.46105>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46109>; else goto <D.46110>;
  <D.46109>:
  code.6560 = code;
  code = code.6560 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32071 = D.32037 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45332 = D.32071 | D.45326;
  D.45333 = (unsigned char) D.45332;
  *code.6560 = D.45333;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46112>;
  <D.46110>:
  code.6561 = code;
  code = code.6561 + 1;
  D.31548 = ins->sreg1;
  D.32035 = D.31548 & 7;
  D.32036 = D.32035 << 3;
  D.32037 = (signed char) D.32036;
  D.32076 = D.32037 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45336 = D.32076 | D.45326;
  D.45337 = (unsigned char) D.45336;
  *code.6561 = D.45337;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6562 = code;
        code = code.6562 + 1;
        D.46115 = imb.b[0];
        *code.6562 = D.46115;
        code.6563 = code;
        code = code.6563 + 1;
        D.46117 = imb.b[1];
        *code.6563 = D.46117;
        code.6564 = code;
        code = code.6564 + 1;
        D.46119 = imb.b[2];
        *code.6564 = D.46119;
        code.6565 = code;
        code = code.6565 + 1;
        D.46121 = imb.b[3];
        *code.6565 = D.46121;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46112>:
  <D.28403>:
  code.6566 = code;
  code = code.6566 + 1;
  *code.6566 = 217;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46123>; else goto <D.46124>;
  <D.46123>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46125>; else goto <D.46126>;
  <D.46125>:
  code.6567 = code;
  code = code.6567 + 1;
  *code.6567 = 4;
  code.6568 = code;
  code = code.6568 + 1;
  *code.6568 = 36;
  goto <D.46129>;
  <D.46126>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46130>; else goto <D.46131>;
  <D.46130>:
  code.6569 = code;
  code = code.6569 + 1;
  *code.6569 = 68;
  code.6570 = code;
  code = code.6570 + 1;
  *code.6570 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46134>;
  <D.46131>:
  code.6571 = code;
  code = code.6571 + 1;
  *code.6571 = 132;
  code.6572 = code;
  code = code.6572 + 1;
  *code.6572 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6573 = code;
        code = code.6573 + 1;
        D.46138 = imb.b[0];
        *code.6573 = D.46138;
        code.6574 = code;
        code = code.6574 + 1;
        D.46140 = imb.b[1];
        *code.6574 = D.46140;
        code.6575 = code;
        code = code.6575 + 1;
        D.46142 = imb.b[2];
        *code.6575 = D.46142;
        code.6576 = code;
        code = code.6576 + 1;
        D.46144 = imb.b[3];
        *code.6576 = D.46144;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46134>:
  <D.46129>:
  goto <D.28406>;
  <D.46124>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46145>; else goto <D.46146>;
  <D.46145>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46147>; else goto <D.46148>;
  <D.46147>:
  code.6577 = code;
  code = code.6577 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45418 = (unsigned char) D.45293;
  D.45419 = D.45418 & 7;
  *code.6577 = D.45419;
  goto <D.28406>;
  <D.46148>:
  <D.46146>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46150>; else goto <D.46151>;
  <D.46150>:
  code.6578 = code;
  code = code.6578 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45423 = D.45326 | 64;
  D.45424 = (unsigned char) D.45423;
  *code.6578 = D.45424;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46153>;
  <D.46151>:
  code.6579 = code;
  code = code.6579 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45427 = D.45326 | -128;
  D.45428 = (unsigned char) D.45427;
  *code.6579 = D.45428;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6580 = code;
        code = code.6580 + 1;
        D.46156 = imb.b[0];
        *code.6580 = D.46156;
        code.6581 = code;
        code = code.6581 + 1;
        D.46158 = imb.b[1];
        *code.6581 = D.46158;
        code.6582 = code;
        code = code.6582 + 1;
        D.46160 = imb.b[2];
        *code.6582 = D.46160;
        code.6583 = code;
        code = code.6583 + 1;
        D.46162 = imb.b[3];
        *code.6583 = D.46162;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46153>:
  <D.28406>:
  goto <D.24796>;
  <D.28408>:
  code.6584 = code;
  code = code.6584 + 1;
  *code.6584 = 221;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46164>; else goto <D.46165>;
  <D.46164>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46166>; else goto <D.46167>;
  <D.46166>:
  code.6585 = code;
  code = code.6585 + 1;
  *code.6585 = 28;
  code.6586 = code;
  code = code.6586 + 1;
  *code.6586 = 36;
  goto <D.46170>;
  <D.46167>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46171>; else goto <D.46172>;
  <D.46171>:
  code.6587 = code;
  code = code.6587 + 1;
  *code.6587 = 92;
  code.6588 = code;
  code = code.6588 + 1;
  *code.6588 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46175>;
  <D.46172>:
  code.6589 = code;
  code = code.6589 + 1;
  *code.6589 = 156;
  code.6590 = code;
  code = code.6590 + 1;
  *code.6590 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6591 = code;
        code = code.6591 + 1;
        D.46179 = imb.b[0];
        *code.6591 = D.46179;
        code.6592 = code;
        code = code.6592 + 1;
        D.46181 = imb.b[1];
        *code.6592 = D.46181;
        code.6593 = code;
        code = code.6593 + 1;
        D.46183 = imb.b[2];
        *code.6593 = D.46183;
        code.6594 = code;
        code = code.6594 + 1;
        D.46185 = imb.b[3];
        *code.6594 = D.46185;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46175>:
  <D.46170>:
  goto <D.28410>;
  <D.46165>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46186>; else goto <D.46187>;
  <D.46186>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46188>; else goto <D.46189>;
  <D.46188>:
  code.6595 = code;
  code = code.6595 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45551 = D.45326 | 24;
  D.45552 = (unsigned char) D.45551;
  *code.6595 = D.45552;
  goto <D.28410>;
  <D.46189>:
  <D.46187>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46191>; else goto <D.46192>;
  <D.46191>:
  code.6596 = code;
  code = code.6596 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45556 = D.45326 | 88;
  D.45557 = (unsigned char) D.45556;
  *code.6596 = D.45557;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46194>;
  <D.46192>:
  code.6597 = code;
  code = code.6597 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45560 = D.45326 | -104;
  D.45561 = (unsigned char) D.45560;
  *code.6597 = D.45561;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6598 = code;
        code = code.6598 + 1;
        D.46197 = imb.b[0];
        *code.6598 = D.46197;
        code.6599 = code;
        code = code.6599 + 1;
        D.46199 = imb.b[1];
        *code.6599 = D.46199;
        code.6600 = code;
        code = code.6600 + 1;
        D.46201 = imb.b[2];
        *code.6600 = D.46201;
        code.6601 = code;
        code = code.6601 + 1;
        D.46203 = imb.b[3];
        *code.6601 = D.46203;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46194>:
  <D.28410>:
  code.6602 = code;
  code = code.6602 + 1;
  *code.6602 = 242;
  code.6603 = code;
  code = code.6603 + 1;
  *code.6603 = 15;
  code.6604 = code;
  code = code.6604 + 1;
  *code.6604 = 16;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46207>; else goto <D.46208>;
  <D.46207>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46209>; else goto <D.46210>;
  <D.46209>:
  code.6605 = code;
  code = code.6605 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6605 = D.32289;
  code.6606 = code;
  code = code.6606 + 1;
  *code.6606 = 36;
  goto <D.46213>;
  <D.46210>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46214>; else goto <D.46215>;
  <D.46214>:
  code.6607 = code;
  code = code.6607 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6607 = D.32296;
  code.6608 = code;
  code = code.6608 + 1;
  *code.6608 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46218>;
  <D.46215>:
  code.6609 = code;
  code = code.6609 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6609 = D.32301;
  code.6610 = code;
  code = code.6610 + 1;
  *code.6610 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6611 = code;
        code = code.6611 + 1;
        D.46222 = imb.b[0];
        *code.6611 = D.46222;
        code.6612 = code;
        code = code.6612 + 1;
        D.46224 = imb.b[1];
        *code.6612 = D.46224;
        code.6613 = code;
        code = code.6613 + 1;
        D.46226 = imb.b[2];
        *code.6613 = D.46226;
        code.6614 = code;
        code = code.6614 + 1;
        D.46228 = imb.b[3];
        *code.6614 = D.46228;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46218>:
  <D.46213>:
  goto <D.28413>;
  <D.46208>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46229>; else goto <D.46230>;
  <D.46229>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46231>; else goto <D.46232>;
  <D.46231>:
  code.6615 = code;
  code = code.6615 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6615 = D.45601;
  goto <D.28413>;
  <D.46232>:
  <D.46230>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46234>; else goto <D.46235>;
  <D.46234>:
  code.6616 = code;
  code = code.6616 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6616 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46237>;
  <D.46235>:
  code.6617 = code;
  code = code.6617 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6617 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6618 = code;
        code = code.6618 + 1;
        D.46240 = imb.b[0];
        *code.6618 = D.46240;
        code.6619 = code;
        code = code.6619 + 1;
        D.46242 = imb.b[1];
        *code.6619 = D.46242;
        code.6620 = code;
        code = code.6620 + 1;
        D.46244 = imb.b[2];
        *code.6620 = D.46244;
        code.6621 = code;
        code = code.6621 + 1;
        D.46246 = imb.b[3];
        *code.6621 = D.46246;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46237>:
  <D.28413>:
  goto <D.24796>;
  <D.28415>:
  code.6622 = code;
  code = code.6622 + 1;
  *code.6622 = 242;
  code.6623 = code;
  code = code.6623 + 1;
  *code.6623 = 15;
  code.6624 = code;
  code = code.6624 + 1;
  *code.6624 = 44;
  code.6625 = code;
  code = code.6625 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6625 = D.32535;
  D.46251 = ins->backend.source_opcode;
  D.46252 = (int) D.46251;
  switch (D.46252) <default: <D.46289>, case 681: <D.28416>, case 682: <D.28421>, case 689: <D.28423>, case 690: <D.28419>>
  <D.28416>:
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.46253>; else goto <D.46254>;
    <D.46253>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5024, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.46254>:
    code.6626 = code;
    code = code.6626 + 1;
    *code.6626 = 15;
    if (1 != 0) goto <D.46256>; else goto <D.46257>;
    <D.46256>:
    op = op + 8;
    <D.46257>:
    if (0 != 0) goto <D.46258>; else goto <D.46259>;
    <D.46258>:
    op = op + 1;
    <D.46259>:
    code.6627 = code;
    code = code.6627 + 1;
    *code.6627 = op;
    code.6628 = code;
    code = code.6628 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.6628 = D.34303;
  }
  goto <D.28418>;
  <D.28419>:
  {
    unsigned char op;

    op = 182;
    D.31604 = ins->dreg;
    D.36840 = D.31604 > 3;
    D.36841 = (long int) D.36840;
    D.36842 = __builtin_expect (D.36841, 0);
    if (D.36842 != 0) goto <D.46262>; else goto <D.46263>;
    <D.46262>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5027, "0 || X86_IS_BYTE_REG (ins->dreg)");
    <D.46263>:
    code.6629 = code;
    code = code.6629 + 1;
    *code.6629 = 15;
    if (0 != 0) goto <D.46265>; else goto <D.46266>;
    <D.46265>:
    op = op + 8;
    <D.46266>:
    if (0 != 0) goto <D.46267>; else goto <D.46268>;
    <D.46267>:
    op = op + 1;
    <D.46268>:
    code.6630 = code;
    code = code.6630 + 1;
    *code.6630 = op;
    code.6631 = code;
    code = code.6631 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.6631 = D.34303;
  }
  goto <D.28418>;
  <D.28421>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.46271>; else goto <D.46272>;
    <D.46271>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5030, "1 || X86_IS_BYTE_REG (ins->dreg)");
    <D.46272>:
    code.6632 = code;
    code = code.6632 + 1;
    *code.6632 = 15;
    if (1 != 0) goto <D.46274>; else goto <D.46275>;
    <D.46274>:
    op = op + 8;
    <D.46275>:
    if (1 != 0) goto <D.46276>; else goto <D.46277>;
    <D.46276>:
    op = op + 1;
    <D.46277>:
    code.6633 = code;
    code = code.6633 + 1;
    *code.6633 = op;
    code.6634 = code;
    code = code.6634 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.6634 = D.34303;
  }
  goto <D.28418>;
  <D.28423>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.46280>; else goto <D.46281>;
    <D.46280>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5033, "1 || X86_IS_BYTE_REG (ins->dreg)");
    <D.46281>:
    code.6635 = code;
    code = code.6635 + 1;
    *code.6635 = 15;
    if (0 != 0) goto <D.46283>; else goto <D.46284>;
    <D.46283>:
    op = op + 8;
    <D.46284>:
    if (1 != 0) goto <D.46285>; else goto <D.46286>;
    <D.46285>:
    op = op + 1;
    <D.46286>:
    code.6636 = code;
    code = code.6636 + 1;
    *code.6636 = op;
    code.6637 = code;
    code = code.6637 + 1;
    D.31604 = ins->dreg;
    D.32225 = D.31604 & 7;
    D.32226 = D.32225 << 3;
    D.32227 = (signed char) D.32226;
    D.32533 = D.32227 | -64;
    D.31604 = ins->dreg;
    D.31637 = (signed char) D.31604;
    D.31638 = D.31637 & 7;
    D.34302 = D.32533 | D.31638;
    D.34303 = (unsigned char) D.34302;
    *code.6637 = D.34303;
  }
  goto <D.28418>;
  <D.46289>:
  <D.28418>:
  goto <D.24796>;
  <D.28425>:
  switch (1) <default: <D.28430>, case 1: <D.28426>, case 2: <D.28428>, case 4: <D.28429>>
  <D.28426>:
  code.6638 = code;
  code = code.6638 + 1;
  *code.6638 = 138;
  goto <D.28427>;
  <D.28428>:
  code.6639 = code;
  code = code.6639 + 1;
  *code.6639 = 102;
  <D.28429>:
  code.6640 = code;
  code = code.6640 + 1;
  *code.6640 = 139;
  goto <D.28427>;
  <D.28430>:
  __assert_fail ("0", "mini-x86.c", 5041, &__PRETTY_FUNCTION__);
  <D.28427>:
  code.6641 = code;
  code = code.6641 + 1;
  D.31604 = ins->dreg;
  D.46294 = D.31604 + 4;
  D.46295 = D.46294 & 7;
  D.46296 = D.46295 << 3;
  D.46297 = (signed char) D.46296;
  D.46298 = D.46297 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.46299 = D.46298 | D.31638;
  D.46300 = (unsigned char) D.46299;
  *code.6641 = D.46300;
  code.6642 = code;
  code = code.6642 + 1;
  *code.6642 = 102;
  code.6643 = code;
  code = code.6643 + 1;
  *code.6643 = 15;
  code.6644 = code;
  code = code.6644 + 1;
  *code.6644 = 196;
  code.6645 = code;
  code = code.6645 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6645 = D.32535;
  code.6646 = code;
  code = code.6646 + 1;
  *code.6646 = 0;
  code.6647 = code;
  code = code.6647 + 1;
  *code.6647 = 102;
  code.6648 = code;
  code = code.6648 + 1;
  *code.6648 = 15;
  code.6649 = code;
  code = code.6649 + 1;
  *code.6649 = 196;
  code.6650 = code;
  code = code.6650 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6650 = D.32535;
  code.6651 = code;
  code = code.6651 + 1;
  *code.6651 = 1;
  code.6652 = code;
  code = code.6652 + 1;
  *code.6652 = 102;
  code.6653 = code;
  code = code.6653 + 1;
  *code.6653 = 15;
  code.6654 = code;
  code = code.6654 + 1;
  *code.6654 = 112;
  code.6655 = code;
  code = code.6655 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.6655 = D.34303;
  *code = 0;
  code = code + 1;
  goto <D.24796>;
  <D.28431>:
  code.6656 = code;
  code = code.6656 + 1;
  *code.6656 = 102;
  code.6657 = code;
  code = code.6657 + 1;
  *code.6657 = 15;
  code.6658 = code;
  code = code.6658 + 1;
  *code.6658 = 196;
  code.6659 = code;
  code = code.6659 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6659 = D.32535;
  code.6660 = code;
  code = code.6660 + 1;
  *code.6660 = 0;
  code.6661 = code;
  code = code.6661 + 1;
  *code.6661 = 102;
  code.6662 = code;
  code = code.6662 + 1;
  *code.6662 = 15;
  code.6663 = code;
  code = code.6663 + 1;
  *code.6663 = 196;
  code.6664 = code;
  code = code.6664 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6664 = D.32535;
  code.6665 = code;
  code = code.6665 + 1;
  *code.6665 = 1;
  code.6666 = code;
  code = code.6666 + 1;
  *code.6666 = 102;
  code.6667 = code;
  code = code.6667 + 1;
  *code.6667 = 15;
  code.6668 = code;
  code = code.6668 + 1;
  *code.6668 = 112;
  code.6669 = code;
  code = code.6669 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.6669 = D.34303;
  *code = 0;
  code = code + 1;
  goto <D.24796>;
  <D.28432>:
  code.6670 = code;
  code = code.6670 + 1;
  *code.6670 = 102;
  code.6671 = code;
  code = code.6671 + 1;
  *code.6671 = 15;
  code.6672 = code;
  code = code.6672 + 1;
  *code.6672 = 110;
  code.6673 = code;
  code = code.6673 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6673 = D.32535;
  code.6674 = code;
  code = code.6674 + 1;
  *code.6674 = 102;
  code.6675 = code;
  code = code.6675 + 1;
  *code.6675 = 15;
  code.6676 = code;
  code = code.6676 + 1;
  *code.6676 = 112;
  code.6677 = code;
  code = code.6677 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.6677 = D.34303;
  *code = 0;
  code = code + 1;
  goto <D.24796>;
  <D.28433>:
  code.6678 = code;
  code = code.6678 + 1;
  *code.6678 = 217;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46338>; else goto <D.46339>;
  <D.46338>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46340>; else goto <D.46341>;
  <D.46340>:
  code.6679 = code;
  code = code.6679 + 1;
  *code.6679 = 28;
  code.6680 = code;
  code = code.6680 + 1;
  *code.6680 = 36;
  goto <D.46344>;
  <D.46341>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46345>; else goto <D.46346>;
  <D.46345>:
  code.6681 = code;
  code = code.6681 + 1;
  *code.6681 = 92;
  code.6682 = code;
  code = code.6682 + 1;
  *code.6682 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46349>;
  <D.46346>:
  code.6683 = code;
  code = code.6683 + 1;
  *code.6683 = 156;
  code.6684 = code;
  code = code.6684 + 1;
  *code.6684 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6685 = code;
        code = code.6685 + 1;
        D.46353 = imb.b[0];
        *code.6685 = D.46353;
        code.6686 = code;
        code = code.6686 + 1;
        D.46355 = imb.b[1];
        *code.6686 = D.46355;
        code.6687 = code;
        code = code.6687 + 1;
        D.46357 = imb.b[2];
        *code.6687 = D.46357;
        code.6688 = code;
        code = code.6688 + 1;
        D.46359 = imb.b[3];
        *code.6688 = D.46359;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46349>:
  <D.46344>:
  goto <D.28435>;
  <D.46339>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46360>; else goto <D.46361>;
  <D.46360>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46362>; else goto <D.46363>;
  <D.46362>:
  code.6689 = code;
  code = code.6689 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45551 = D.45326 | 24;
  D.45552 = (unsigned char) D.45551;
  *code.6689 = D.45552;
  goto <D.28435>;
  <D.46363>:
  <D.46361>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46365>; else goto <D.46366>;
  <D.46365>:
  code.6690 = code;
  code = code.6690 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45556 = D.45326 | 88;
  D.45557 = (unsigned char) D.45556;
  *code.6690 = D.45557;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46368>;
  <D.46366>:
  code.6691 = code;
  code = code.6691 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45560 = D.45326 | -104;
  D.45561 = (unsigned char) D.45560;
  *code.6691 = D.45561;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6692 = code;
        code = code.6692 + 1;
        D.46371 = imb.b[0];
        *code.6692 = D.46371;
        code.6693 = code;
        code = code.6693 + 1;
        D.46373 = imb.b[1];
        *code.6693 = D.46373;
        code.6694 = code;
        code = code.6694 + 1;
        D.46375 = imb.b[2];
        *code.6694 = D.46375;
        code.6695 = code;
        code = code.6695 + 1;
        D.46377 = imb.b[3];
        *code.6695 = D.46377;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46368>:
  <D.28435>:
  code.6696 = code;
  code = code.6696 + 1;
  *code.6696 = 102;
  code.6697 = code;
  code = code.6697 + 1;
  *code.6697 = 15;
  code.6698 = code;
  code = code.6698 + 1;
  *code.6698 = 110;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46381>; else goto <D.46382>;
  <D.46381>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46383>; else goto <D.46384>;
  <D.46383>:
  code.6699 = code;
  code = code.6699 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6699 = D.32289;
  code.6700 = code;
  code = code.6700 + 1;
  *code.6700 = 36;
  goto <D.46387>;
  <D.46384>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46388>; else goto <D.46389>;
  <D.46388>:
  code.6701 = code;
  code = code.6701 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6701 = D.32296;
  code.6702 = code;
  code = code.6702 + 1;
  *code.6702 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46392>;
  <D.46389>:
  code.6703 = code;
  code = code.6703 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6703 = D.32301;
  code.6704 = code;
  code = code.6704 + 1;
  *code.6704 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6705 = code;
        code = code.6705 + 1;
        D.46396 = imb.b[0];
        *code.6705 = D.46396;
        code.6706 = code;
        code = code.6706 + 1;
        D.46398 = imb.b[1];
        *code.6706 = D.46398;
        code.6707 = code;
        code = code.6707 + 1;
        D.46400 = imb.b[2];
        *code.6707 = D.46400;
        code.6708 = code;
        code = code.6708 + 1;
        D.46402 = imb.b[3];
        *code.6708 = D.46402;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46392>:
  <D.46387>:
  goto <D.28438>;
  <D.46382>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46403>; else goto <D.46404>;
  <D.46403>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46405>; else goto <D.46406>;
  <D.46405>:
  code.6709 = code;
  code = code.6709 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6709 = D.45601;
  goto <D.28438>;
  <D.46406>:
  <D.46404>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46408>; else goto <D.46409>;
  <D.46408>:
  code.6710 = code;
  code = code.6710 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6710 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46411>;
  <D.46409>:
  code.6711 = code;
  code = code.6711 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6711 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6712 = code;
        code = code.6712 + 1;
        D.46414 = imb.b[0];
        *code.6712 = D.46414;
        code.6713 = code;
        code = code.6713 + 1;
        D.46416 = imb.b[1];
        *code.6713 = D.46416;
        code.6714 = code;
        code = code.6714 + 1;
        D.46418 = imb.b[2];
        *code.6714 = D.46418;
        code.6715 = code;
        code = code.6715 + 1;
        D.46420 = imb.b[3];
        *code.6715 = D.46420;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46411>:
  <D.28438>:
  code.6716 = code;
  code = code.6716 + 1;
  *code.6716 = 102;
  code.6717 = code;
  code = code.6717 + 1;
  *code.6717 = 15;
  code.6718 = code;
  code = code.6718 + 1;
  *code.6718 = 112;
  code.6719 = code;
  code = code.6719 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.6719 = D.34303;
  *code = 0;
  code = code + 1;
  goto <D.24796>;
  <D.28440>:
  code.6720 = code;
  code = code.6720 + 1;
  *code.6720 = 221;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46426>; else goto <D.46427>;
  <D.46426>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46428>; else goto <D.46429>;
  <D.46428>:
  code.6721 = code;
  code = code.6721 + 1;
  *code.6721 = 28;
  code.6722 = code;
  code = code.6722 + 1;
  *code.6722 = 36;
  goto <D.46432>;
  <D.46429>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46433>; else goto <D.46434>;
  <D.46433>:
  code.6723 = code;
  code = code.6723 + 1;
  *code.6723 = 92;
  code.6724 = code;
  code = code.6724 + 1;
  *code.6724 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46437>;
  <D.46434>:
  code.6725 = code;
  code = code.6725 + 1;
  *code.6725 = 156;
  code.6726 = code;
  code = code.6726 + 1;
  *code.6726 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6727 = code;
        code = code.6727 + 1;
        D.46441 = imb.b[0];
        *code.6727 = D.46441;
        code.6728 = code;
        code = code.6728 + 1;
        D.46443 = imb.b[1];
        *code.6728 = D.46443;
        code.6729 = code;
        code = code.6729 + 1;
        D.46445 = imb.b[2];
        *code.6729 = D.46445;
        code.6730 = code;
        code = code.6730 + 1;
        D.46447 = imb.b[3];
        *code.6730 = D.46447;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46437>:
  <D.46432>:
  goto <D.28442>;
  <D.46427>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46448>; else goto <D.46449>;
  <D.46448>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46450>; else goto <D.46451>;
  <D.46450>:
  code.6731 = code;
  code = code.6731 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45551 = D.45326 | 24;
  D.45552 = (unsigned char) D.45551;
  *code.6731 = D.45552;
  goto <D.28442>;
  <D.46451>:
  <D.46449>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46453>; else goto <D.46454>;
  <D.46453>:
  code.6732 = code;
  code = code.6732 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45556 = D.45326 | 88;
  D.45557 = (unsigned char) D.45556;
  *code.6732 = D.45557;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46456>;
  <D.46454>:
  code.6733 = code;
  code = code.6733 + 1;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45560 = D.45326 | -104;
  D.45561 = (unsigned char) D.45560;
  *code.6733 = D.45561;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6734 = code;
        code = code.6734 + 1;
        D.46459 = imb.b[0];
        *code.6734 = D.46459;
        code.6735 = code;
        code = code.6735 + 1;
        D.46461 = imb.b[1];
        *code.6735 = D.46461;
        code.6736 = code;
        code = code.6736 + 1;
        D.46463 = imb.b[2];
        *code.6736 = D.46463;
        code.6737 = code;
        code = code.6737 + 1;
        D.46465 = imb.b[3];
        *code.6737 = D.46465;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46456>:
  <D.28442>:
  code.6738 = code;
  code = code.6738 + 1;
  *code.6738 = 242;
  code.6739 = code;
  code = code.6739 + 1;
  *code.6739 = 15;
  code.6740 = code;
  code = code.6740 + 1;
  *code.6740 = 16;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 == 4) goto <D.46469>; else goto <D.46470>;
  <D.46469>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46471>; else goto <D.46472>;
  <D.46471>:
  code.6741 = code;
  code = code.6741 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32288 = D.32227 | 4;
  D.32289 = (unsigned char) D.32288;
  *code.6741 = D.32289;
  code.6742 = code;
  code = code.6742 + 1;
  *code.6742 = 36;
  goto <D.46475>;
  <D.46472>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46476>; else goto <D.46477>;
  <D.46476>:
  code.6743 = code;
  code = code.6743 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32295 = D.32227 | 68;
  D.32296 = (unsigned char) D.32295;
  *code.6743 = D.32296;
  code.6744 = code;
  code = code.6744 + 1;
  *code.6744 = 36;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46480>;
  <D.46477>:
  code.6745 = code;
  code = code.6745 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32300 = D.32227 | -124;
  D.32301 = (unsigned char) D.32300;
  *code.6745 = D.32301;
  code.6746 = code;
  code = code.6746 + 1;
  *code.6746 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6747 = code;
        code = code.6747 + 1;
        D.46484 = imb.b[0];
        *code.6747 = D.46484;
        code.6748 = code;
        code = code.6748 + 1;
        D.46486 = imb.b[1];
        *code.6748 = D.46486;
        code.6749 = code;
        code = code.6749 + 1;
        D.46488 = imb.b[2];
        *code.6749 = D.46488;
        code.6750 = code;
        code = code.6750 + 1;
        D.46490 = imb.b[3];
        *code.6750 = D.46490;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46480>:
  <D.46475>:
  goto <D.28445>;
  <D.46470>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  if (D.45296 == 0) goto <D.46491>; else goto <D.46492>;
  <D.46491>:
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  if (D.45293 != 5) goto <D.46493>; else goto <D.46494>;
  <D.46493>:
  code.6751 = code;
  code = code.6751 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45600 = D.32227 | D.45326;
  D.45601 = (unsigned char) D.45600;
  *code.6751 = D.45601;
  goto <D.28445>;
  <D.46494>:
  <D.46492>:
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45302 = (unsigned int) D.45296;
  D.45303 = D.45302 + 128;
  if (D.45303 <= 255) goto <D.46496>; else goto <D.46497>;
  <D.46496>:
  code.6752 = code;
  code = code.6752 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32321 = D.32227 | 64;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45605 = D.32321 | D.45326;
  D.45606 = (unsigned char) D.45605;
  *code.6752 = D.45606;
  D.45292 = ins->backend.spill_var;
  D.45296 = D.45292->data.op[0].const_val;
  D.45308 = (unsigned char) D.45296;
  *code = D.45308;
  code = code + 1;
  goto <D.46499>;
  <D.46497>:
  code.6753 = code;
  code = code.6753 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32326 = D.32227 | -128;
  D.45292 = ins->backend.spill_var;
  D.45293 = D.45292->sreg1;
  D.45325 = (signed char) D.45293;
  D.45326 = D.45325 & 7;
  D.45609 = D.32326 | D.45326;
  D.45610 = (unsigned char) D.45609;
  *code.6753 = D.45610;
  {
    union x86_imm_buf imb;

    try
      {
        D.45292 = ins->backend.spill_var;
        D.45296 = D.45292->data.op[0].const_val;
        imb.val = D.45296;
        code.6754 = code;
        code = code.6754 + 1;
        D.46502 = imb.b[0];
        *code.6754 = D.46502;
        code.6755 = code;
        code = code.6755 + 1;
        D.46504 = imb.b[1];
        *code.6755 = D.46504;
        code.6756 = code;
        code = code.6756 + 1;
        D.46506 = imb.b[2];
        *code.6756 = D.46506;
        code.6757 = code;
        code = code.6757 + 1;
        D.46508 = imb.b[3];
        *code.6757 = D.46508;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46499>:
  <D.28445>:
  code.6758 = code;
  code = code.6758 + 1;
  *code.6758 = 102;
  code.6759 = code;
  code = code.6759 + 1;
  *code.6759 = 15;
  code.6760 = code;
  code = code.6760 + 1;
  *code.6760 = 112;
  code.6761 = code;
  code = code.6761 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31604 = ins->dreg;
  D.31637 = (signed char) D.31604;
  D.31638 = D.31637 & 7;
  D.34302 = D.32533 | D.31638;
  D.34303 = (unsigned char) D.34302;
  *code.6761 = D.34303;
  *code = 68;
  code = code + 1;
  goto <D.24796>;
  <D.28447>:
  code.6762 = code;
  code = code.6762 + 1;
  *code.6762 = 243;
  code.6763 = code;
  code = code.6763 + 1;
  *code.6763 = 15;
  code.6764 = code;
  code = code.6764 + 1;
  *code.6764 = 230;
  code.6765 = code;
  code = code.6765 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6765 = D.32535;
  goto <D.24796>;
  <D.28448>:
  code.6766 = code;
  code = code.6766 + 1;
  *code.6766 = 15;
  code.6767 = code;
  code = code.6767 + 1;
  *code.6767 = 91;
  code.6768 = code;
  code = code.6768 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6768 = D.32535;
  goto <D.24796>;
  <D.28449>:
  code.6769 = code;
  code = code.6769 + 1;
  *code.6769 = 242;
  code.6770 = code;
  code = code.6770 + 1;
  *code.6770 = 15;
  code.6771 = code;
  code = code.6771 + 1;
  *code.6771 = 230;
  code.6772 = code;
  code = code.6772 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6772 = D.32535;
  goto <D.24796>;
  <D.28450>:
  code.6773 = code;
  code = code.6773 + 1;
  *code.6773 = 102;
  code.6774 = code;
  code = code.6774 + 1;
  *code.6774 = 15;
  code.6775 = code;
  code = code.6775 + 1;
  *code.6775 = 90;
  code.6776 = code;
  code = code.6776 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6776 = D.32535;
  goto <D.24796>;
  <D.28451>:
  code.6777 = code;
  code = code.6777 + 1;
  *code.6777 = 102;
  code.6778 = code;
  code = code.6778 + 1;
  *code.6778 = 15;
  code.6779 = code;
  code = code.6779 + 1;
  *code.6779 = 91;
  code.6780 = code;
  code = code.6780 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6780 = D.32535;
  goto <D.24796>;
  <D.28452>:
  code.6781 = code;
  code = code.6781 + 1;
  *code.6781 = 15;
  code.6782 = code;
  code = code.6782 + 1;
  *code.6782 = 90;
  code.6783 = code;
  code = code.6783 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6783 = D.32535;
  goto <D.24796>;
  <D.28453>:
  code.6784 = code;
  code = code.6784 + 1;
  *code.6784 = 102;
  code.6785 = code;
  code = code.6785 + 1;
  *code.6785 = 15;
  code.6786 = code;
  code = code.6786 + 1;
  *code.6786 = 230;
  code.6787 = code;
  code = code.6787 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6787 = D.32535;
  goto <D.24796>;
  <D.28454>:
  code.6788 = code;
  code = code.6788 + 1;
  *code.6788 = 243;
  code.6789 = code;
  code = code.6789 + 1;
  *code.6789 = 15;
  code.6790 = code;
  code = code.6790 + 1;
  *code.6790 = 91;
  code.6791 = code;
  code = code.6791 + 1;
  D.31604 = ins->dreg;
  D.32225 = D.31604 & 7;
  D.32226 = D.32225 << 3;
  D.32227 = (signed char) D.32226;
  D.32533 = D.32227 | -64;
  D.31548 = ins->sreg1;
  D.31585 = (signed char) D.31548;
  D.31586 = D.31585 & 7;
  D.32534 = D.32533 | D.31586;
  D.32535 = (unsigned char) D.32534;
  *code.6791 = D.32535;
  goto <D.24796>;
  <D.28455>:
  D.31457 = cfg->verbose_level;
  if (D.31457 > 1) goto <D.46543>; else goto <D.46544>;
  <D.46543>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46545 = cfg->vars;
  D.31551 = ins->data.op[0].const_val;
  D.46546 = (unsigned int) D.31551;
  D.46547 = D.46546 * 56;
  D.46548 = D.46545 + D.46547;
  D.46549 = D.46548->vreg;
  printf ("R%d START=0x%x\n", D.46549, D.31489);
  <D.46544>:
  D.46545 = cfg->vars;
  D.31551 = ins->data.op[0].const_val;
  D.46546 = (unsigned int) D.31551;
  D.46547 = D.46546 * 56;
  D.46548 = D.46545 + D.46547;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46548->live_range_start = D.31489;
  goto <D.24796>;
  <D.28456>:
  D.31457 = cfg->verbose_level;
  if (D.31457 > 1) goto <D.46550>; else goto <D.46551>;
  <D.46550>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46545 = cfg->vars;
  D.31551 = ins->data.op[0].const_val;
  D.46546 = (unsigned int) D.31551;
  D.46547 = D.46546 * 56;
  D.46548 = D.46545 + D.46547;
  D.46549 = D.46548->vreg;
  printf ("R%d END=0x%x\n", D.46549, D.31489);
  <D.46551>:
  D.46545 = cfg->vars;
  D.31551 = ins->data.op[0].const_val;
  D.46546 = (unsigned int) D.31551;
  D.46547 = D.46546 * 56;
  D.46548 = D.46545 + D.46547;
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46548->live_range_end = D.31489;
  goto <D.24796>;
  <D.28457>:
  goto <D.24796>;
  <D.28458>:
  <D.28459>:
  <D.28460>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  goto <D.24796>;
  <D.28461>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  ins->backend.pc_offset = D.31489;
  D.46552 = bb->spill_slot_defs;
  D.46553 = cfg->mempool;
  D.46554 = g_slist_prepend_mempool (D.46553, D.46552, ins);
  bb->spill_slot_defs = D.46554;
  goto <D.24796>;
  <D.28462>:
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.46555 = mono_inst_name (D.31502);
  monoeg_g_log (0B, 16, "unknown opcode %s\n", D.46555);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 5130);
  <D.24796>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46556 = (unsigned int) D.31489;
  D.46557 = D.46556 - offset;
  max_len.426 = (unsigned int) max_len;
  D.46558 = D.46557 > max_len.426;
  D.46559 = (long int) D.46558;
  D.46560 = __builtin_expect (D.46559, 0);
  if (D.46560 != 0) goto <D.46561>; else goto <D.46562>;
  <D.46561>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46556 = (unsigned int) D.31489;
  D.46557 = D.46556 - offset;
  D.31501 = ins->opcode;
  D.31502 = (int) D.31501;
  D.46563 = mono_inst_name (D.31502);
  monoeg_g_log (0B, 16, "wrong maximal instruction length of instruction %s (expected %d, got %d)", D.46563, max_len, D.46557);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 5137);
  <D.46562>:
  cpos = cpos + max_len;
  ins = ins->next;
  <D.28464>:
  if (ins != 0B) goto <D.28463>; else goto <D.28465>;
  <D.28465>:
  code.422 = (int) code;
  D.31409 = cfg->native_code;
  D.31488 = (int) D.31409;
  D.31489 = code.422 - D.31488;
  D.46556 = (unsigned int) D.31489;
  cfg->code_len = D.46556;
}


emit_move_return_value (struct MonoCompile * cfg, struct MonoInst * ins, guint8 * code)
{
  short unsigned int D.46660;
  int D.46661;
  int D.46662;
  guint8 * code.6792;
  guint8 * code.6793;
  guint8 * code.6794;
  guint8 * code.6795;
  int D.46669;
  int D.46670;
  signed char D.46671;
  signed char D.46672;
  unsigned char D.46673;
  guint8 * D.46674;
  static const char __PRETTY_FUNCTION__[23] = "emit_move_return_value";

  D.46660 = ins->opcode;
  D.46661 = (int) D.46660;
  switch (D.46661) <default: <D.24561>, case 346: <D.24551>, case 347: <D.24552>, case 348: <D.24553>>
  <D.24551>:
  <D.24552>:
  <D.24553>:
  D.46662 = ins->dreg;
  if (D.46662 != 0) goto <D.46663>; else goto <D.46664>;
  <D.46663>:
  switch (4) <default: <D.24558>, case 1: <D.24554>, case 2: <D.24556>, case 4: <D.24557>>
  <D.24554>:
  code.6792 = code;
  code = code.6792 + 1;
  *code.6792 = 138;
  goto <D.24555>;
  <D.24556>:
  code.6793 = code;
  code = code.6793 + 1;
  *code.6793 = 102;
  <D.24557>:
  code.6794 = code;
  code = code.6794 + 1;
  *code.6794 = 139;
  goto <D.24555>;
  <D.24558>:
  __assert_fail ("0", "mini-x86.c", 2299, &__PRETTY_FUNCTION__);
  <D.24555>:
  code.6795 = code;
  code = code.6795 + 1;
  D.46662 = ins->dreg;
  D.46669 = D.46662 & 7;
  D.46670 = D.46669 << 3;
  D.46671 = (signed char) D.46670;
  D.46672 = D.46671 | -64;
  D.46673 = (unsigned char) D.46672;
  *code.6795 = D.46673;
  <D.46664>:
  goto <D.24560>;
  <D.24561>:
  goto <D.24560>;
  <D.24560>:
  D.46674 = code;
  return D.46674;
}


mono_emit_stack_alloc (guchar * code, struct MonoInst * tree)
{
  guchar * code.6796;
  guchar * code.6797;
  guchar * code.6798;
  signed char D.46685;
  signed char D.46686;
  signed char D.46687;
  unsigned char D.46688;
  guchar * code.6799;
  unsigned char D.46690;
  guchar * code.6800;
  unsigned char D.46692;
  guchar * code.6801;
  unsigned char D.46694;
  guchar * code.6802;
  unsigned char D.46696;
  guchar * code.6803;
  unsigned char D.46700;
  guchar * code.6804;
  unsigned char D.46703;
  guchar * code.6805;
  guchar * code.6806;
  unsigned char D.46708;
  guchar * code.6807;
  unsigned char D.46710;
  guchar * code.6808;
  unsigned char D.46712;
  guchar * code.6809;
  unsigned char D.46714;
  guchar * code.6810;
  guchar * code.6811;
  guchar * code.6812;
  guchar * code.6813;
  guchar * code.6814;
  unsigned char D.46723;
  guchar * code.6815;
  unsigned char D.46725;
  guchar * code.6816;
  unsigned char D.46727;
  guchar * code.6817;
  unsigned char D.46729;
  guchar * code.6818;
  guchar * code.6819;
  guchar * code.6820;
  guchar * code.6821;
  guchar * code.6822;
  guchar * code.6823;
  guchar * code.6824;
  guchar * code.6825;
  unsigned char D.46746;
  guchar * code.6826;
  unsigned char D.46748;
  guchar * code.6827;
  unsigned char D.46750;
  guchar * code.6828;
  unsigned char D.46752;
  guchar * code.6829;
  guchar * code.6830;
  guchar * code.6831;
  guchar * code.6832;
  unsigned char D.46762;
  guchar * code.6833;
  unsigned char D.46764;
  guchar * code.6834;
  unsigned char D.46766;
  guchar * code.6835;
  unsigned char D.46768;
  unsigned char D.46769;
  int D.46770;
  int D.46771;
  guchar * code.6836;
  guchar * code.6837;
  guchar * code.6838;
  guchar * code.6839;
  guchar * code.6840;
  unsigned char D.46779;
  guchar * code.6841;
  unsigned char D.46781;
  guchar * code.6842;
  unsigned char D.46783;
  guchar * code.6843;
  unsigned char D.46785;
  guchar * code.6844;
  guchar * code.6845;
  guchar * code.6846;
  guchar * code.6847;
  guchar * code.6848;
  guchar * code.6849;
  guchar * code.6850;
  guchar * code.6851;
  guchar * code.6852;
  guchar * code.6853;
  unsigned char D.46804;
  guchar * code.6854;
  unsigned char D.46806;
  guchar * code.6855;
  unsigned char D.46808;
  guchar * code.6856;
  unsigned char D.46810;
  guchar * code.6857;
  guchar * code.6858;
  guchar * code.6859;
  guchar * code.6860;
  unsigned char D.46820;
  guchar * code.6861;
  unsigned char D.46822;
  guchar * code.6862;
  unsigned char D.46824;
  guchar * code.6863;
  unsigned char D.46826;
  guchar * code.6864;
  guchar * code.6865;
  guchar * code.6866;
  guchar * code.6867;
  guchar * code.6868;
  guchar * code.6869;
  guchar * code.6870;
  guchar * code.6871;
  unsigned char D.46837;
  guchar * code.6872;
  unsigned char D.46839;
  guchar * code.6873;
  unsigned char D.46841;
  guchar * code.6874;
  unsigned char D.46843;
  guchar * code.6875;
  guchar * code.6876;
  signed char D.46848;
  unsigned char D.46849;
  guchar * code.6877;
  guchar * code.6878;
  guchar * code.6879;
  unsigned char D.46854;
  guchar * code.6880;
  unsigned char D.46856;
  guchar * code.6881;
  unsigned char D.46858;
  guchar * code.6882;
  unsigned char D.46860;
  guchar * code.6883;
  guchar * code.6884;
  unsigned char D.46865;
  guchar * code.6885;
  unsigned char D.46867;
  guchar * code.6886;
  unsigned char D.46869;
  guchar * code.6887;
  unsigned char D.46871;
  guchar * code.6888;
  guchar * code.6889;
  signed char D.46876;
  unsigned char D.46877;
  guchar * code.6890;
  guchar * code.6891;
  guchar * code.6892;
  unsigned char D.46882;
  guchar * code.6893;
  unsigned char D.46884;
  guchar * code.6894;
  unsigned char D.46886;
  guchar * code.6895;
  unsigned char D.46888;
  guchar * code.6896;
  unsigned char D.46892;
  guchar * code.6897;
  unsigned char D.46895;
  guint8 * D.46896;
  unsigned char D.46897;
  int D.46898;
  unsigned char D.46899;
  unsigned char D.46900;
  guint8 * D.46903;
  int D.46904;
  int pos.6898;
  int D.46908;
  unsigned char * pos.6899;
  unsigned char D.46910;
  unsigned char * pos.6900;
  unsigned char D.46912;
  unsigned char * pos.6901;
  unsigned char D.46914;
  unsigned char * pos.6902;
  unsigned char D.46916;
  unsigned int disp.6903;
  unsigned int D.46919;
  unsigned char D.46922;
  unsigned char D.46923;
  guchar * code.6904;
  guchar * code.6905;
  int D.46927;
  int D.46928;
  signed char D.46929;
  signed char D.46930;
  signed char D.46931;
  unsigned char D.46932;
  guchar * code.6906;
  guchar * code.6907;
  guchar * code.6908;
  guchar * code.6909;
  signed char D.46940;
  unsigned char D.46941;
  guchar * code.6910;
  guint8 * D.46943;
  unsigned char D.46944;
  int D.46945;
  unsigned char D.46946;
  unsigned char D.46947;
  int code.6911;
  int pos.6912;
  int D.46954;
  unsigned char * pos.6913;
  unsigned char D.46956;
  unsigned char * pos.6914;
  unsigned char D.46958;
  unsigned char * pos.6915;
  unsigned char D.46960;
  unsigned char * pos.6916;
  unsigned char D.46962;
  unsigned int disp.6917;
  unsigned int D.46965;
  unsigned char D.46968;
  unsigned char D.46969;
  guchar * code.6918;
  guchar * code.6919;
  guint8 * D.46973;
  unsigned char D.46974;
  int D.46975;
  unsigned char D.46976;
  unsigned char D.46977;
  int pos.6920;
  int D.46983;
  unsigned char * pos.6921;
  unsigned char D.46985;
  unsigned char * pos.6922;
  unsigned char D.46987;
  unsigned char * pos.6923;
  unsigned char D.46989;
  unsigned char * pos.6924;
  unsigned char D.46991;
  unsigned int disp.6925;
  unsigned int D.46994;
  unsigned char D.46997;
  unsigned char D.46998;
  guint8 * D.47000;
  unsigned char D.47001;
  int D.47002;
  unsigned char D.47003;
  unsigned char D.47004;
  int pos.6926;
  int D.47010;
  unsigned char * pos.6927;
  unsigned char D.47012;
  unsigned char * pos.6928;
  unsigned char D.47014;
  unsigned char * pos.6929;
  unsigned char D.47016;
  unsigned char * pos.6930;
  unsigned char D.47018;
  unsigned int disp.6931;
  unsigned int D.47021;
  unsigned char D.47024;
  unsigned char D.47025;
  guchar * code.6932;
  guchar * code.6933;
  int D.47030;
  signed char D.47031;
  signed char D.47032;
  signed char D.47033;
  unsigned char D.47034;
  int D.47037;
  guchar * code.6934;
  guchar * code.6935;
  guchar * code.6936;
  guchar * code.6937;
  guchar * code.6938;
  guchar * code.6939;
  guchar * code.6940;
  guchar * code.6941;
  guchar * code.6942;
  guchar * code.6943;
  guchar * code.6944;
  signed char D.47066;
  unsigned char D.47067;
  guchar * code.6945;
  guchar * code.6946;
  guchar * code.6947;
  guchar * code.6948;
  guchar * code.6949;
  unsigned int offset.6950;
  unsigned int D.47079;
  guchar * code.6951;
  guchar * code.6952;
  unsigned char D.47084;
  guchar * code.6953;
  guchar * code.6954;
  guchar * code.6955;
  unsigned char D.47089;
  guchar * code.6956;
  unsigned char D.47091;
  guchar * code.6957;
  unsigned char D.47093;
  guchar * code.6958;
  unsigned char D.47095;
  guchar * code.6959;
  guchar * code.6960;
  guchar * code.6961;
  guchar * code.6962;
  unsigned char D.47105;
  guchar * code.6963;
  unsigned char D.47107;
  guchar * code.6964;
  unsigned char D.47109;
  guchar * code.6965;
  unsigned char D.47111;
  guchar * code.6966;
  guchar * code.6967;
  guchar * code.6968;
  guchar * code.6969;
  guchar * code.6970;
  guchar * code.6971;
  unsigned char * D.47130;
  int sreg;
  int need_touch;
  static const char __PRETTY_FUNCTION__[22] = "mono_emit_stack_alloc";

  sreg = tree->sreg1;
  need_touch = 0;
  if (need_touch != 0) goto <D.46677>; else goto <D.46678>;
  <D.46677>:
  {
    guint8 * br[5];

    try
      {
        if (sreg == 0) goto <D.46679>; else goto <D.46680>;
        <D.46679>:
        code.6796 = code;
        code = code.6796 + 1;
        *code.6796 = 169;
        goto <D.46682>;
        <D.46680>:
        code.6797 = code;
        code = code.6797 + 1;
        *code.6797 = 247;
        code.6798 = code;
        code = code.6798 + 1;
        D.46685 = (signed char) sreg;
        D.46686 = D.46685 & 7;
        D.46687 = D.46686 | -64;
        D.46688 = (unsigned char) D.46687;
        *code.6798 = D.46688;
        <D.46682>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -4096;
              code.6799 = code;
              code = code.6799 + 1;
              D.46690 = imb.b[0];
              *code.6799 = D.46690;
              code.6800 = code;
              code = code.6800 + 1;
              D.46692 = imb.b[1];
              *code.6800 = D.46692;
              code.6801 = code;
              code = code.6801 + 1;
              D.46694 = imb.b[2];
              *code.6801 = D.46694;
              code.6802 = code;
              code = code.6802 + 1;
              D.46696 = imb.b[3];
              *code.6802 = D.46696;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        br[0] = code;
        if (0 != 0) goto <D.46697>; else goto <D.46698>;
        <D.46697>:
        code.6803 = code;
        code = code.6803 + 1;
        D.46700 = 116;
        *code.6803 = D.46700;
        goto <D.46701>;
        <D.46698>:
        code.6804 = code;
        code = code.6804 + 1;
        D.46703 = 116;
        *code.6804 = D.46703;
        <D.46701>:
        *code = 0;
        code = code + 1;
        br[2] = code;
        if (0 != 0) goto <D.46704>; else goto <D.46705>;
        <D.46704>:
        code.6805 = code;
        code = code.6805 + 1;
        *code.6805 = 45;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.6806 = code;
              code = code.6806 + 1;
              D.46708 = imb.b[0];
              *code.6806 = D.46708;
              code.6807 = code;
              code = code.6807 + 1;
              D.46710 = imb.b[1];
              *code.6807 = D.46710;
              code.6808 = code;
              code = code.6808 + 1;
              D.46712 = imb.b[2];
              *code.6808 = D.46712;
              code.6809 = code;
              code = code.6809 + 1;
              D.46714 = imb.b[3];
              *code.6809 = D.46714;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.24405>;
        <D.46705>:
        if (0 != 0) goto <D.46715>; else goto <D.46716>;
        <D.46715>:
        code.6810 = code;
        code = code.6810 + 1;
        *code.6810 = 131;
        code.6811 = code;
        code = code.6811 + 1;
        *code.6811 = 236;
        *code = 0;
        code = code + 1;
        goto <D.46719>;
        <D.46716>:
        code.6812 = code;
        code = code.6812 + 1;
        *code.6812 = 129;
        code.6813 = code;
        code = code.6813 + 1;
        *code.6813 = 236;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.6814 = code;
              code = code.6814 + 1;
              D.46723 = imb.b[0];
              *code.6814 = D.46723;
              code.6815 = code;
              code = code.6815 + 1;
              D.46725 = imb.b[1];
              *code.6815 = D.46725;
              code.6816 = code;
              code = code.6816 + 1;
              D.46727 = imb.b[2];
              *code.6816 = D.46727;
              code.6817 = code;
              code = code.6817 + 1;
              D.46729 = imb.b[3];
              *code.6817 = D.46729;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46719>:
        <D.24405>:
        code.6818 = code;
        code = code.6818 + 1;
        *code.6818 = 133;
        if (1 != 0) goto <D.46731>; else goto <D.46732>;
        <D.46731>:
        if (1 != 0) goto <D.46733>; else goto <D.46734>;
        <D.46733>:
        code.6819 = code;
        code = code.6819 + 1;
        *code.6819 = 36;
        code.6820 = code;
        code = code.6820 + 1;
        *code.6820 = 36;
        goto <D.46737>;
        <D.46734>:
        if (1 != 0) goto <D.46738>; else goto <D.46739>;
        <D.46738>:
        code.6821 = code;
        code = code.6821 + 1;
        *code.6821 = 100;
        code.6822 = code;
        code = code.6822 + 1;
        *code.6822 = 36;
        *code = 0;
        code = code + 1;
        goto <D.46742>;
        <D.46739>:
        code.6823 = code;
        code = code.6823 + 1;
        *code.6823 = 164;
        code.6824 = code;
        code = code.6824 + 1;
        *code.6824 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6825 = code;
              code = code.6825 + 1;
              D.46746 = imb.b[0];
              *code.6825 = D.46746;
              code.6826 = code;
              code = code.6826 + 1;
              D.46748 = imb.b[1];
              *code.6826 = D.46748;
              code.6827 = code;
              code = code.6827 + 1;
              D.46750 = imb.b[2];
              *code.6827 = D.46750;
              code.6828 = code;
              code = code.6828 + 1;
              D.46752 = imb.b[3];
              *code.6828 = D.46752;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46742>:
        <D.46737>:
        goto <D.24408>;
        <D.46732>:
        if (1 != 0) goto <D.46753>; else goto <D.46754>;
        <D.46753>:
        code.6829 = code;
        code = code.6829 + 1;
        *code.6829 = 36;
        goto <D.24408>;
        <D.46754>:
        if (1 != 0) goto <D.46756>; else goto <D.46757>;
        <D.46756>:
        code.6830 = code;
        code = code.6830 + 1;
        *code.6830 = 100;
        *code = 0;
        code = code + 1;
        goto <D.46759>;
        <D.46757>:
        code.6831 = code;
        code = code.6831 + 1;
        *code.6831 = 164;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6832 = code;
              code = code.6832 + 1;
              D.46762 = imb.b[0];
              *code.6832 = D.46762;
              code.6833 = code;
              code = code.6833 + 1;
              D.46764 = imb.b[1];
              *code.6833 = D.46764;
              code.6834 = code;
              code = code.6834 + 1;
              D.46766 = imb.b[2];
              *code.6834 = D.46766;
              code.6835 = code;
              code = code.6835 + 1;
              D.46768 = imb.b[3];
              *code.6835 = D.46768;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46759>:
        <D.24408>:
        D.46769 = tree->flags;
        D.46770 = (int) D.46769;
        D.46771 = D.46770 & 1;
        if (D.46771 != 0) goto <D.46772>; else goto <D.46773>;
        <D.46772>:
        code.6836 = code;
        code = code.6836 + 1;
        *code.6836 = 80;
        code.6837 = code;
        code = code.6837 + 1;
        *code.6837 = 81;
        code.6838 = code;
        code = code.6838 + 1;
        *code.6838 = 87;
        code.6839 = code;
        code = code.6839 + 1;
        *code.6839 = 185;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1024;
              code.6840 = code;
              code = code.6840 + 1;
              D.46779 = imb.b[0];
              *code.6840 = D.46779;
              code.6841 = code;
              code = code.6841 + 1;
              D.46781 = imb.b[1];
              *code.6841 = D.46781;
              code.6842 = code;
              code = code.6842 + 1;
              D.46783 = imb.b[2];
              *code.6842 = D.46783;
              code.6843 = code;
              code = code.6843 + 1;
              D.46785 = imb.b[3];
              *code.6843 = D.46785;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        code.6844 = code;
        code = code.6844 + 1;
        *code.6844 = 51;
        code.6845 = code;
        code = code.6845 + 1;
        *code.6845 = 192;
        code.6846 = code;
        code = code.6846 + 1;
        *code.6846 = 141;
        if (1 != 0) goto <D.46789>; else goto <D.46790>;
        <D.46789>:
        if (0 != 0) goto <D.46791>; else goto <D.46792>;
        <D.46791>:
        code.6847 = code;
        code = code.6847 + 1;
        *code.6847 = 60;
        code.6848 = code;
        code = code.6848 + 1;
        *code.6848 = 36;
        goto <D.46795>;
        <D.46792>:
        if (1 != 0) goto <D.46796>; else goto <D.46797>;
        <D.46796>:
        code.6849 = code;
        code = code.6849 + 1;
        *code.6849 = 124;
        code.6850 = code;
        code = code.6850 + 1;
        *code.6850 = 36;
        *code = 12;
        code = code + 1;
        goto <D.46800>;
        <D.46797>:
        code.6851 = code;
        code = code.6851 + 1;
        *code.6851 = 188;
        code.6852 = code;
        code = code.6852 + 1;
        *code.6852 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 12;
              code.6853 = code;
              code = code.6853 + 1;
              D.46804 = imb.b[0];
              *code.6853 = D.46804;
              code.6854 = code;
              code = code.6854 + 1;
              D.46806 = imb.b[1];
              *code.6854 = D.46806;
              code.6855 = code;
              code = code.6855 + 1;
              D.46808 = imb.b[2];
              *code.6855 = D.46808;
              code.6856 = code;
              code = code.6856 + 1;
              D.46810 = imb.b[3];
              *code.6856 = D.46810;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46800>:
        <D.46795>:
        goto <D.24412>;
        <D.46790>:
        if (0 != 0) goto <D.46811>; else goto <D.46812>;
        <D.46811>:
        code.6857 = code;
        code = code.6857 + 1;
        *code.6857 = 60;
        goto <D.24412>;
        <D.46812>:
        if (1 != 0) goto <D.46814>; else goto <D.46815>;
        <D.46814>:
        code.6858 = code;
        code = code.6858 + 1;
        *code.6858 = 124;
        *code = 12;
        code = code + 1;
        goto <D.46817>;
        <D.46815>:
        code.6859 = code;
        code = code.6859 + 1;
        *code.6859 = 188;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 12;
              code.6860 = code;
              code = code.6860 + 1;
              D.46820 = imb.b[0];
              *code.6860 = D.46820;
              code.6861 = code;
              code = code.6861 + 1;
              D.46822 = imb.b[1];
              *code.6861 = D.46822;
              code.6862 = code;
              code = code.6862 + 1;
              D.46824 = imb.b[2];
              *code.6862 = D.46824;
              code.6863 = code;
              code = code.6863 + 1;
              D.46826 = imb.b[3];
              *code.6863 = D.46826;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46817>:
        <D.24412>:
        code.6864 = code;
        code = code.6864 + 1;
        *code.6864 = 252;
        code.6865 = code;
        code = code.6865 + 1;
        *code.6865 = 243;
        code.6866 = code;
        code = code.6866 + 1;
        *code.6866 = 171;
        code.6867 = code;
        code = code.6867 + 1;
        *code.6867 = 95;
        code.6868 = code;
        code = code.6868 + 1;
        *code.6868 = 89;
        code.6869 = code;
        code = code.6869 + 1;
        *code.6869 = 88;
        <D.46773>:
        if (sreg == 0) goto <D.46833>; else goto <D.46834>;
        <D.46833>:
        code.6870 = code;
        code = code.6870 + 1;
        *code.6870 = 45;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.6871 = code;
              code = code.6871 + 1;
              D.46837 = imb.b[0];
              *code.6871 = D.46837;
              code.6872 = code;
              code = code.6872 + 1;
              D.46839 = imb.b[1];
              *code.6872 = D.46839;
              code.6873 = code;
              code = code.6873 + 1;
              D.46841 = imb.b[2];
              *code.6873 = D.46841;
              code.6874 = code;
              code = code.6874 + 1;
              D.46843 = imb.b[3];
              *code.6874 = D.46843;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.24415>;
        <D.46834>:
        if (0 != 0) goto <D.46844>; else goto <D.46845>;
        <D.46844>:
        code.6875 = code;
        code = code.6875 + 1;
        *code.6875 = 131;
        code.6876 = code;
        code = code.6876 + 1;
        D.46685 = (signed char) sreg;
        D.46686 = D.46685 & 7;
        D.46848 = D.46686 | -24;
        D.46849 = (unsigned char) D.46848;
        *code.6876 = D.46849;
        *code = 0;
        code = code + 1;
        goto <D.46850>;
        <D.46845>:
        code.6877 = code;
        code = code.6877 + 1;
        *code.6877 = 129;
        code.6878 = code;
        code = code.6878 + 1;
        D.46685 = (signed char) sreg;
        D.46686 = D.46685 & 7;
        D.46848 = D.46686 | -24;
        D.46849 = (unsigned char) D.46848;
        *code.6878 = D.46849;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.6879 = code;
              code = code.6879 + 1;
              D.46854 = imb.b[0];
              *code.6879 = D.46854;
              code.6880 = code;
              code = code.6880 + 1;
              D.46856 = imb.b[1];
              *code.6880 = D.46856;
              code.6881 = code;
              code = code.6881 + 1;
              D.46858 = imb.b[2];
              *code.6881 = D.46858;
              code.6882 = code;
              code = code.6882 + 1;
              D.46860 = imb.b[3];
              *code.6882 = D.46860;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46850>:
        <D.24415>:
        if (sreg == 0) goto <D.46861>; else goto <D.46862>;
        <D.46861>:
        code.6883 = code;
        code = code.6883 + 1;
        *code.6883 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.6884 = code;
              code = code.6884 + 1;
              D.46865 = imb.b[0];
              *code.6884 = D.46865;
              code.6885 = code;
              code = code.6885 + 1;
              D.46867 = imb.b[1];
              *code.6885 = D.46867;
              code.6886 = code;
              code = code.6886 + 1;
              D.46869 = imb.b[2];
              *code.6886 = D.46869;
              code.6887 = code;
              code = code.6887 + 1;
              D.46871 = imb.b[3];
              *code.6887 = D.46871;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.24418>;
        <D.46862>:
        if (0 != 0) goto <D.46872>; else goto <D.46873>;
        <D.46872>:
        code.6888 = code;
        code = code.6888 + 1;
        *code.6888 = 131;
        code.6889 = code;
        code = code.6889 + 1;
        D.46685 = (signed char) sreg;
        D.46876 = D.46685 | -8;
        D.46877 = (unsigned char) D.46876;
        *code.6889 = D.46877;
        *code = 0;
        code = code + 1;
        goto <D.46878>;
        <D.46873>:
        code.6890 = code;
        code = code.6890 + 1;
        *code.6890 = 129;
        code.6891 = code;
        code = code.6891 + 1;
        D.46685 = (signed char) sreg;
        D.46876 = D.46685 | -8;
        D.46877 = (unsigned char) D.46876;
        *code.6891 = D.46877;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.6892 = code;
              code = code.6892 + 1;
              D.46882 = imb.b[0];
              *code.6892 = D.46882;
              code.6893 = code;
              code = code.6893 + 1;
              D.46884 = imb.b[1];
              *code.6893 = D.46884;
              code.6894 = code;
              code = code.6894 + 1;
              D.46886 = imb.b[2];
              *code.6894 = D.46886;
              code.6895 = code;
              code = code.6895 + 1;
              D.46888 = imb.b[3];
              *code.6895 = D.46888;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.46878>:
        <D.24418>:
        br[3] = code;
        if (0 != 0) goto <D.46889>; else goto <D.46890>;
        <D.46889>:
        code.6896 = code;
        code = code.6896 + 1;
        D.46892 = 125;
        *code.6896 = D.46892;
        goto <D.46893>;
        <D.46890>:
        code.6897 = code;
        code = code.6897 + 1;
        D.46895 = 115;
        *code.6897 = D.46895;
        <D.46893>:
        *code = 0;
        code = code + 1;
        {
          unsigned char * pos;
          int disp;
          int size;

          D.46896 = br[3];
          pos = D.46896 + 1;
          size = 0;
          D.46896 = br[3];
          D.46897 = MEM[(unsigned char *)D.46896];
          D.46898 = (int) D.46897;
          switch (D.46898) <default: <D.24448>, case 15: <D.24426>, case 112: <D.24432>, case 113: <D.24433>, case 114: <D.24434>, case 115: <D.24435>, case 116: <D.24436>, case 117: <D.24437>, case 118: <D.24438>, case 119: <D.24439>, case 120: <D.24440>, case 121: <D.24441>, case 122: <D.24442>, case 123: <D.24443>, case 124: <D.24444>, case 125: <D.24445>, case 126: <D.24446>, case 127: <D.24447>, case 224: <D.24428>, case 225: <D.24429>, case 226: <D.24430>, case 232: <D.24423>, case 233: <D.24424>, case 235: <D.24431>>
          <D.24423>:
          <D.24424>:
          size = size + 1;
          goto <D.24425>;
          <D.24426>:
          D.46899 = *pos;
          D.46900 = D.46899 + 144;
          if (D.46900 > 31) goto <D.46901>; else goto <D.46902>;
          <D.46901>:
          __assert_fail ("0", "mini-x86.c", 2239, &__PRETTY_FUNCTION__);
          <D.46902>:
          size = size + 1;
          pos = pos + 1;
          goto <D.24425>;
          <D.24428>:
          <D.24429>:
          <D.24430>:
          <D.24431>:
          <D.24432>:
          <D.24433>:
          <D.24434>:
          <D.24435>:
          <D.24436>:
          <D.24437>:
          <D.24438>:
          <D.24439>:
          <D.24440>:
          <D.24441>:
          <D.24442>:
          <D.24443>:
          <D.24444>:
          <D.24445>:
          <D.24446>:
          <D.24447>:
          goto <D.24425>;
          <D.24448>:
          __assert_fail ("0", "mini-x86.c", 2239, &__PRETTY_FUNCTION__);
          <D.24425>:
          D.46903 = br[2];
          D.46904 = (int) D.46903;
          pos.6898 = (int) pos;
          disp = D.46904 - pos.6898;
          if (size != 0) goto <D.46906>; else goto <D.46907>;
          <D.46906>:
          {
            union x86_imm_buf imb;

            try
              {
                D.46908 = disp + -4;
                imb.val = D.46908;
                pos.6899 = pos;
                pos = pos.6899 + 1;
                D.46910 = imb.b[0];
                *pos.6899 = D.46910;
                pos.6900 = pos;
                pos = pos.6900 + 1;
                D.46912 = imb.b[1];
                *pos.6900 = D.46912;
                pos.6901 = pos;
                pos = pos.6901 + 1;
                D.46914 = imb.b[2];
                *pos.6901 = D.46914;
                pos.6902 = pos;
                pos = pos.6902 + 1;
                D.46916 = imb.b[3];
                *pos.6902 = D.46916;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.46917>;
          <D.46907>:
          disp.6903 = (unsigned int) disp;
          D.46919 = disp.6903 + 127;
          if (D.46919 <= 255) goto <D.46920>; else goto <D.46921>;
          <D.46920>:
          D.46922 = (unsigned char) disp;
          D.46923 = D.46922 + 255;
          *pos = D.46923;
          pos = pos + 1;
          goto <D.46924>;
          <D.46921>:
          __assert_fail ("0", "mini-x86.c", 2239, &__PRETTY_FUNCTION__);
          <D.46924>:
          <D.46917>:
        }
        code.6904 = code;
        code = code.6904 + 1;
        *code.6904 = 133;
        code.6905 = code;
        code = code.6905 + 1;
        D.46927 = sreg & 7;
        D.46928 = D.46927 << 3;
        D.46929 = (signed char) D.46928;
        D.46930 = D.46929 | -64;
        D.46685 = (signed char) sreg;
        D.46686 = D.46685 & 7;
        D.46931 = D.46930 | D.46686;
        D.46932 = (unsigned char) D.46931;
        *code.6905 = D.46932;
        br[4] = code;
        if (0 != 0) goto <D.46933>; else goto <D.46934>;
        <D.46933>:
        code.6906 = code;
        code = code.6906 + 1;
        D.46700 = 116;
        *code.6906 = D.46700;
        goto <D.46936>;
        <D.46934>:
        code.6907 = code;
        code = code.6907 + 1;
        D.46703 = 116;
        *code.6907 = D.46703;
        <D.46936>:
        *code = 0;
        code = code + 1;
        code.6908 = code;
        code = code.6908 + 1;
        *code.6908 = 43;
        code.6909 = code;
        code = code.6909 + 1;
        D.46685 = (signed char) sreg;
        D.46686 = D.46685 & 7;
        D.46940 = D.46686 | -32;
        D.46941 = (unsigned char) D.46940;
        *code.6909 = D.46941;
        br[1] = code;
        code.6910 = code;
        code = code.6910 + 1;
        *code.6910 = 235;
        *code = 0;
        code = code + 1;
        {
          unsigned char * pos;
          int disp;
          int size;

          D.46943 = br[0];
          pos = D.46943 + 1;
          size = 0;
          D.46943 = br[0];
          D.46944 = MEM[(unsigned char *)D.46943];
          D.46945 = (int) D.46944;
          switch (D.46945) <default: <D.24477>, case 15: <D.24456>, case 112: <D.24461>, case 113: <D.24462>, case 114: <D.24463>, case 115: <D.24464>, case 116: <D.24465>, case 117: <D.24466>, case 118: <D.24467>, case 119: <D.24468>, case 120: <D.24469>, case 121: <D.24470>, case 122: <D.24471>, case 123: <D.24472>, case 124: <D.24473>, case 125: <D.24474>, case 126: <D.24475>, case 127: <D.24476>, case 224: <D.24457>, case 225: <D.24458>, case 226: <D.24459>, case 232: <D.24453>, case 233: <D.24454>, case 235: <D.24460>>
          <D.24453>:
          <D.24454>:
          size = size + 1;
          goto <D.24455>;
          <D.24456>:
          D.46946 = *pos;
          D.46947 = D.46946 + 144;
          if (D.46947 > 31) goto <D.46948>; else goto <D.46949>;
          <D.46948>:
          __assert_fail ("0", "mini-x86.c", 2246, &__PRETTY_FUNCTION__);
          <D.46949>:
          size = size + 1;
          pos = pos + 1;
          goto <D.24455>;
          <D.24457>:
          <D.24458>:
          <D.24459>:
          <D.24460>:
          <D.24461>:
          <D.24462>:
          <D.24463>:
          <D.24464>:
          <D.24465>:
          <D.24466>:
          <D.24467>:
          <D.24468>:
          <D.24469>:
          <D.24470>:
          <D.24471>:
          <D.24472>:
          <D.24473>:
          <D.24474>:
          <D.24475>:
          <D.24476>:
          goto <D.24455>;
          <D.24477>:
          __assert_fail ("0", "mini-x86.c", 2246, &__PRETTY_FUNCTION__);
          <D.24455>:
          code.6911 = (int) code;
          pos.6912 = (int) pos;
          disp = code.6911 - pos.6912;
          if (size != 0) goto <D.46952>; else goto <D.46953>;
          <D.46952>:
          {
            union x86_imm_buf imb;

            try
              {
                D.46954 = disp + -4;
                imb.val = D.46954;
                pos.6913 = pos;
                pos = pos.6913 + 1;
                D.46956 = imb.b[0];
                *pos.6913 = D.46956;
                pos.6914 = pos;
                pos = pos.6914 + 1;
                D.46958 = imb.b[1];
                *pos.6914 = D.46958;
                pos.6915 = pos;
                pos = pos.6915 + 1;
                D.46960 = imb.b[2];
                *pos.6915 = D.46960;
                pos.6916 = pos;
                pos = pos.6916 + 1;
                D.46962 = imb.b[3];
                *pos.6916 = D.46962;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.46963>;
          <D.46953>:
          disp.6917 = (unsigned int) disp;
          D.46965 = disp.6917 + 127;
          if (D.46965 <= 255) goto <D.46966>; else goto <D.46967>;
          <D.46966>:
          D.46968 = (unsigned char) disp;
          D.46969 = D.46968 + 255;
          *pos = D.46969;
          pos = pos + 1;
          goto <D.46970>;
          <D.46967>:
          __assert_fail ("0", "mini-x86.c", 2246, &__PRETTY_FUNCTION__);
          <D.46970>:
          <D.46963>:
        }
        code.6918 = code;
        code = code.6918 + 1;
        *code.6918 = 43;
        code.6919 = code;
        code = code.6919 + 1;
        D.46685 = (signed char) sreg;
        D.46686 = D.46685 & 7;
        D.46940 = D.46686 | -32;
        D.46941 = (unsigned char) D.46940;
        *code.6919 = D.46941;
        {
          unsigned char * pos;
          int disp;
          int size;

          D.46973 = br[1];
          pos = D.46973 + 1;
          size = 0;
          D.46973 = br[1];
          D.46974 = MEM[(unsigned char *)D.46973];
          D.46975 = (int) D.46974;
          switch (D.46975) <default: <D.24506>, case 15: <D.24485>, case 112: <D.24490>, case 113: <D.24491>, case 114: <D.24492>, case 115: <D.24493>, case 116: <D.24494>, case 117: <D.24495>, case 118: <D.24496>, case 119: <D.24497>, case 120: <D.24498>, case 121: <D.24499>, case 122: <D.24500>, case 123: <D.24501>, case 124: <D.24502>, case 125: <D.24503>, case 126: <D.24504>, case 127: <D.24505>, case 224: <D.24486>, case 225: <D.24487>, case 226: <D.24488>, case 232: <D.24482>, case 233: <D.24483>, case 235: <D.24489>>
          <D.24482>:
          <D.24483>:
          size = size + 1;
          goto <D.24484>;
          <D.24485>:
          D.46976 = *pos;
          D.46977 = D.46976 + 144;
          if (D.46977 > 31) goto <D.46978>; else goto <D.46979>;
          <D.46978>:
          __assert_fail ("0", "mini-x86.c", 2248, &__PRETTY_FUNCTION__);
          <D.46979>:
          size = size + 1;
          pos = pos + 1;
          goto <D.24484>;
          <D.24486>:
          <D.24487>:
          <D.24488>:
          <D.24489>:
          <D.24490>:
          <D.24491>:
          <D.24492>:
          <D.24493>:
          <D.24494>:
          <D.24495>:
          <D.24496>:
          <D.24497>:
          <D.24498>:
          <D.24499>:
          <D.24500>:
          <D.24501>:
          <D.24502>:
          <D.24503>:
          <D.24504>:
          <D.24505>:
          goto <D.24484>;
          <D.24506>:
          __assert_fail ("0", "mini-x86.c", 2248, &__PRETTY_FUNCTION__);
          <D.24484>:
          code.6911 = (int) code;
          pos.6920 = (int) pos;
          disp = code.6911 - pos.6920;
          if (size != 0) goto <D.46981>; else goto <D.46982>;
          <D.46981>:
          {
            union x86_imm_buf imb;

            try
              {
                D.46983 = disp + -4;
                imb.val = D.46983;
                pos.6921 = pos;
                pos = pos.6921 + 1;
                D.46985 = imb.b[0];
                *pos.6921 = D.46985;
                pos.6922 = pos;
                pos = pos.6922 + 1;
                D.46987 = imb.b[1];
                *pos.6922 = D.46987;
                pos.6923 = pos;
                pos = pos.6923 + 1;
                D.46989 = imb.b[2];
                *pos.6923 = D.46989;
                pos.6924 = pos;
                pos = pos.6924 + 1;
                D.46991 = imb.b[3];
                *pos.6924 = D.46991;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.46992>;
          <D.46982>:
          disp.6925 = (unsigned int) disp;
          D.46994 = disp.6925 + 127;
          if (D.46994 <= 255) goto <D.46995>; else goto <D.46996>;
          <D.46995>:
          D.46997 = (unsigned char) disp;
          D.46998 = D.46997 + 255;
          *pos = D.46998;
          pos = pos + 1;
          goto <D.46999>;
          <D.46996>:
          __assert_fail ("0", "mini-x86.c", 2248, &__PRETTY_FUNCTION__);
          <D.46999>:
          <D.46992>:
        }
        {
          unsigned char * pos;
          int disp;
          int size;

          D.47000 = br[4];
          pos = D.47000 + 1;
          size = 0;
          D.47000 = br[4];
          D.47001 = MEM[(unsigned char *)D.47000];
          D.47002 = (int) D.47001;
          switch (D.47002) <default: <D.24535>, case 15: <D.24514>, case 112: <D.24519>, case 113: <D.24520>, case 114: <D.24521>, case 115: <D.24522>, case 116: <D.24523>, case 117: <D.24524>, case 118: <D.24525>, case 119: <D.24526>, case 120: <D.24527>, case 121: <D.24528>, case 122: <D.24529>, case 123: <D.24530>, case 124: <D.24531>, case 125: <D.24532>, case 126: <D.24533>, case 127: <D.24534>, case 224: <D.24515>, case 225: <D.24516>, case 226: <D.24517>, case 232: <D.24511>, case 233: <D.24512>, case 235: <D.24518>>
          <D.24511>:
          <D.24512>:
          size = size + 1;
          goto <D.24513>;
          <D.24514>:
          D.47003 = *pos;
          D.47004 = D.47003 + 144;
          if (D.47004 > 31) goto <D.47005>; else goto <D.47006>;
          <D.47005>:
          __assert_fail ("0", "mini-x86.c", 2249, &__PRETTY_FUNCTION__);
          <D.47006>:
          size = size + 1;
          pos = pos + 1;
          goto <D.24513>;
          <D.24515>:
          <D.24516>:
          <D.24517>:
          <D.24518>:
          <D.24519>:
          <D.24520>:
          <D.24521>:
          <D.24522>:
          <D.24523>:
          <D.24524>:
          <D.24525>:
          <D.24526>:
          <D.24527>:
          <D.24528>:
          <D.24529>:
          <D.24530>:
          <D.24531>:
          <D.24532>:
          <D.24533>:
          <D.24534>:
          goto <D.24513>;
          <D.24535>:
          __assert_fail ("0", "mini-x86.c", 2249, &__PRETTY_FUNCTION__);
          <D.24513>:
          code.6911 = (int) code;
          pos.6926 = (int) pos;
          disp = code.6911 - pos.6926;
          if (size != 0) goto <D.47008>; else goto <D.47009>;
          <D.47008>:
          {
            union x86_imm_buf imb;

            try
              {
                D.47010 = disp + -4;
                imb.val = D.47010;
                pos.6927 = pos;
                pos = pos.6927 + 1;
                D.47012 = imb.b[0];
                *pos.6927 = D.47012;
                pos.6928 = pos;
                pos = pos.6928 + 1;
                D.47014 = imb.b[1];
                *pos.6928 = D.47014;
                pos.6929 = pos;
                pos = pos.6929 + 1;
                D.47016 = imb.b[2];
                *pos.6929 = D.47016;
                pos.6930 = pos;
                pos = pos.6930 + 1;
                D.47018 = imb.b[3];
                *pos.6930 = D.47018;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.47019>;
          <D.47009>:
          disp.6931 = (unsigned int) disp;
          D.47021 = disp.6931 + 127;
          if (D.47021 <= 255) goto <D.47022>; else goto <D.47023>;
          <D.47022>:
          D.47024 = (unsigned char) disp;
          D.47025 = D.47024 + 255;
          *pos = D.47025;
          pos = pos + 1;
          goto <D.47026>;
          <D.47023>:
          __assert_fail ("0", "mini-x86.c", 2249, &__PRETTY_FUNCTION__);
          <D.47026>:
          <D.47019>:
        }
      }
    finally
      {
        br = {CLOBBER};
      }
  }
  goto <D.47027>;
  <D.46678>:
  code.6932 = code;
  code = code.6932 + 1;
  *code.6932 = 43;
  code.6933 = code;
  code = code.6933 + 1;
  D.47030 = tree->sreg1;
  D.47031 = (signed char) D.47030;
  D.47032 = D.47031 & 7;
  D.47033 = D.47032 | -32;
  D.47034 = (unsigned char) D.47033;
  *code.6933 = D.47034;
  <D.47027>:
  D.46769 = tree->flags;
  D.46770 = (int) D.46769;
  D.46771 = D.46770 & 1;
  if (D.46771 != 0) goto <D.47035>; else goto <D.47036>;
  <D.47035>:
  {
    int offset;

    offset = 0;
    D.47037 = tree->dreg;
    if (D.47037 != 0) goto <D.47038>; else goto <D.47039>;
    <D.47038>:
    if (sreg != 0) goto <D.47040>; else goto <D.47041>;
    <D.47040>:
    code.6934 = code;
    code = code.6934 + 1;
    *code.6934 = 80;
    offset = offset + 4;
    <D.47041>:
    <D.47039>:
    D.47037 = tree->dreg;
    if (D.47037 != 1) goto <D.47043>; else goto <D.47044>;
    <D.47043>:
    if (sreg != 1) goto <D.47045>; else goto <D.47046>;
    <D.47045>:
    code.6935 = code;
    code = code.6935 + 1;
    *code.6935 = 81;
    offset = offset + 4;
    <D.47046>:
    <D.47044>:
    D.47037 = tree->dreg;
    if (D.47037 != 7) goto <D.47048>; else goto <D.47049>;
    <D.47048>:
    if (sreg != 7) goto <D.47050>; else goto <D.47051>;
    <D.47050>:
    code.6936 = code;
    code = code.6936 + 1;
    *code.6936 = 87;
    offset = offset + 4;
    <D.47051>:
    <D.47049>:
    if (0 != 0) goto <D.47053>; else goto <D.47054>;
    <D.47053>:
    code.6937 = code;
    code = code.6937 + 1;
    *code.6937 = 209;
    code.6938 = code;
    code = code.6938 + 1;
    D.46685 = (signed char) sreg;
    D.46686 = D.46685 & 7;
    D.46848 = D.46686 | -24;
    D.46849 = (unsigned char) D.46848;
    *code.6938 = D.46849;
    goto <D.47057>;
    <D.47054>:
    code.6939 = code;
    code = code.6939 + 1;
    *code.6939 = 193;
    code.6940 = code;
    code = code.6940 + 1;
    D.46685 = (signed char) sreg;
    D.46686 = D.46685 & 7;
    D.46848 = D.46686 | -24;
    D.46849 = (unsigned char) D.46848;
    *code.6940 = D.46849;
    *code = 2;
    code = code + 1;
    <D.47057>:
    if (sreg != 1) goto <D.47060>; else goto <D.47061>;
    <D.47060>:
    switch (4) <default: <D.24542>, case 1: <D.24538>, case 2: <D.24540>, case 4: <D.24541>>
    <D.24538>:
    code.6941 = code;
    code = code.6941 + 1;
    *code.6941 = 138;
    goto <D.24539>;
    <D.24540>:
    code.6942 = code;
    code = code.6942 + 1;
    *code.6942 = 102;
    <D.24541>:
    code.6943 = code;
    code = code.6943 + 1;
    *code.6943 = 139;
    goto <D.24539>;
    <D.24542>:
    __assert_fail ("0", "mini-x86.c", 2271, &__PRETTY_FUNCTION__);
    <D.24539>:
    code.6944 = code;
    code = code.6944 + 1;
    D.46685 = (signed char) sreg;
    D.46686 = D.46685 & 7;
    D.47066 = D.46686 | -56;
    D.47067 = (unsigned char) D.47066;
    *code.6944 = D.47067;
    <D.47061>:
    code.6945 = code;
    code = code.6945 + 1;
    *code.6945 = 51;
    code.6946 = code;
    code = code.6946 + 1;
    *code.6946 = 192;
    code.6947 = code;
    code = code.6947 + 1;
    *code.6947 = 141;
    if (1 != 0) goto <D.47071>; else goto <D.47072>;
    <D.47071>:
    if (offset == 0) goto <D.47073>; else goto <D.47074>;
    <D.47073>:
    code.6948 = code;
    code = code.6948 + 1;
    *code.6948 = 60;
    code.6949 = code;
    code = code.6949 + 1;
    *code.6949 = 36;
    goto <D.47077>;
    <D.47074>:
    offset.6950 = (unsigned int) offset;
    D.47079 = offset.6950 + 128;
    if (D.47079 <= 255) goto <D.47080>; else goto <D.47081>;
    <D.47080>:
    code.6951 = code;
    code = code.6951 + 1;
    *code.6951 = 124;
    code.6952 = code;
    code = code.6952 + 1;
    *code.6952 = 36;
    D.47084 = (unsigned char) offset;
    *code = D.47084;
    code = code + 1;
    goto <D.47085>;
    <D.47081>:
    code.6953 = code;
    code = code.6953 + 1;
    *code.6953 = 188;
    code.6954 = code;
    code = code.6954 + 1;
    *code.6954 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.6955 = code;
          code = code.6955 + 1;
          D.47089 = imb.b[0];
          *code.6955 = D.47089;
          code.6956 = code;
          code = code.6956 + 1;
          D.47091 = imb.b[1];
          *code.6956 = D.47091;
          code.6957 = code;
          code = code.6957 + 1;
          D.47093 = imb.b[2];
          *code.6957 = D.47093;
          code.6958 = code;
          code = code.6958 + 1;
          D.47095 = imb.b[3];
          *code.6958 = D.47095;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47085>:
    <D.47077>:
    goto <D.24544>;
    <D.47072>:
    if (offset == 0) goto <D.47096>; else goto <D.47097>;
    <D.47096>:
    code.6959 = code;
    code = code.6959 + 1;
    *code.6959 = 60;
    goto <D.24544>;
    <D.47097>:
    offset.6950 = (unsigned int) offset;
    D.47079 = offset.6950 + 128;
    if (D.47079 <= 255) goto <D.47099>; else goto <D.47100>;
    <D.47099>:
    code.6960 = code;
    code = code.6960 + 1;
    *code.6960 = 124;
    D.47084 = (unsigned char) offset;
    *code = D.47084;
    code = code + 1;
    goto <D.47102>;
    <D.47100>:
    code.6961 = code;
    code = code.6961 + 1;
    *code.6961 = 188;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.6962 = code;
          code = code.6962 + 1;
          D.47105 = imb.b[0];
          *code.6962 = D.47105;
          code.6963 = code;
          code = code.6963 + 1;
          D.47107 = imb.b[1];
          *code.6963 = D.47107;
          code.6964 = code;
          code = code.6964 + 1;
          D.47109 = imb.b[2];
          *code.6964 = D.47109;
          code.6965 = code;
          code = code.6965 + 1;
          D.47111 = imb.b[3];
          *code.6965 = D.47111;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47102>:
    <D.24544>:
    code.6966 = code;
    code = code.6966 + 1;
    *code.6966 = 252;
    code.6967 = code;
    code = code.6967 + 1;
    *code.6967 = 243;
    code.6968 = code;
    code = code.6968 + 1;
    *code.6968 = 171;
    D.47037 = tree->dreg;
    if (D.47037 != 7) goto <D.47115>; else goto <D.47116>;
    <D.47115>:
    if (sreg != 7) goto <D.47117>; else goto <D.47118>;
    <D.47117>:
    code.6969 = code;
    code = code.6969 + 1;
    *code.6969 = 95;
    <D.47118>:
    <D.47116>:
    D.47037 = tree->dreg;
    if (D.47037 != 1) goto <D.47120>; else goto <D.47121>;
    <D.47120>:
    if (sreg != 1) goto <D.47122>; else goto <D.47123>;
    <D.47122>:
    code.6970 = code;
    code = code.6970 + 1;
    *code.6970 = 89;
    <D.47123>:
    <D.47121>:
    D.47037 = tree->dreg;
    if (D.47037 != 0) goto <D.47125>; else goto <D.47126>;
    <D.47125>:
    if (sreg != 0) goto <D.47127>; else goto <D.47128>;
    <D.47127>:
    code.6971 = code;
    code = code.6971 + 1;
    *code.6971 = 88;
    <D.47128>:
    <D.47126>:
  }
  <D.47036>:
  D.47130 = code;
  return D.47130;
}


emit_call (struct MonoCompile * cfg, guint8 * code, guint32 patch_type, const void * data)
{
  struct GHashTable * D.47136;
  <unnamed type> D.47141;
  unsigned char D.47144;
  unsigned char D.47145;
  guint8 * D.47148;
  int D.47149;
  unsigned char * D.47150;
  int D.47151;
  int D.47152;
  unsigned int D.47153;
  _Bool D.47154;
  _Bool D.47155;
  _Bool D.47156;
  unsigned int D.47159;
  guint8 * code.6972;
  guint8 * code.6973;
  guint8 * code.6974;
  guint8 * code.6975;
  guint8 * code.6976;
  guint8 * code.6977;
  guint8 * code.6978;
  guint8 * code.6979;
  guint8 * code.6980;
  guint8 * code.6981;
  guint8 * code.6982;
  guint8 * code.6983;
  guint8 * code.6984;
  guint8 * code.6985;
  guint8 * code.6986;
  guint8 * code.6987;
  guint8 * code.6988;
  guint8 * code.6989;
  guint8 * code.6990;
  guint8 * code.6991;
  guint8 * code.6992;
  guint8 * code.6993;
  guint8 * code.6994;
  guint8 * code.6995;
  guint8 * code.6996;
  guint8 * code.6997;
  guint8 * code.6998;
  guint8 * code.6999;
  int code.7000;
  int D.47189;
  int code.7001;
  guint8 * code.7002;
  guint8 * code.7003;
  unsigned char D.47193;
  guint8 * code.7004;
  unsigned char D.47195;
  guint8 * code.7005;
  unsigned char D.47197;
  guint8 * code.7006;
  unsigned char D.47199;
  guint8 * D.47200;
  gboolean needs_paddings;
  guint32 pad_size;
  struct MonoJumpInfo * jinfo;
  static const char __PRETTY_FUNCTION__[10] = "emit_call";

  needs_paddings = 1;
  jinfo = 0B;
  D.47136 = cfg->abs_patches;
  if (D.47136 != 0B) goto <D.47137>; else goto <D.47138>;
  <D.47137>:
  D.47136 = cfg->abs_patches;
  jinfo = monoeg_g_hash_table_lookup (D.47136, data);
  if (jinfo != 0B) goto <D.47139>; else goto <D.47140>;
  <D.47139>:
  D.47141 = jinfo->type;
  if (D.47141 == 32) goto <D.47142>; else goto <D.47143>;
  <D.47142>:
  needs_paddings = 0;
  <D.47143>:
  <D.47140>:
  <D.47138>:
  D.47144 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.47145 = D.47144 & 64;
  if (D.47145 != 0) goto <D.47146>; else goto <D.47147>;
  <D.47146>:
  needs_paddings = 0;
  <D.47147>:
  D.47148 = code + 1;
  D.47149 = (int) D.47148;
  D.47150 = cfg->native_code;
  D.47151 = (int) D.47150;
  D.47152 = D.47149 - D.47151;
  D.47153 = (unsigned int) D.47152;
  pad_size = D.47153 & 3;
  D.47154 = needs_paddings != 0;
  D.47155 = pad_size != 0;
  D.47156 = D.47154 & D.47155;
  if (D.47156 != 0) goto <D.47157>; else goto <D.47158>;
  <D.47157>:
  D.47159 = 4 - pad_size;
  switch (D.47159) <default: <D.24263>, case 1: <D.24255>, case 2: <D.24257>, case 3: <D.24258>, case 4: <D.24259>, case 5: <D.24260>, case 6: <D.24261>, case 7: <D.24262>>
  <D.24255>:
  code.6972 = code;
  code = code.6972 + 1;
  *code.6972 = 144;
  goto <D.24256>;
  <D.24257>:
  code.6973 = code;
  code = code.6973 + 1;
  *code.6973 = 139;
  code.6974 = code;
  code = code.6974 + 1;
  *code.6974 = 192;
  goto <D.24256>;
  <D.24258>:
  code.6975 = code;
  code = code.6975 + 1;
  *code.6975 = 141;
  code.6976 = code;
  code = code.6976 + 1;
  *code.6976 = 109;
  code.6977 = code;
  code = code.6977 + 1;
  *code.6977 = 0;
  goto <D.24256>;
  <D.24259>:
  code.6978 = code;
  code = code.6978 + 1;
  *code.6978 = 141;
  code.6979 = code;
  code = code.6979 + 1;
  *code.6979 = 100;
  code.6980 = code;
  code = code.6980 + 1;
  *code.6980 = 36;
  code.6981 = code;
  code = code.6981 + 1;
  *code.6981 = 0;
  goto <D.24256>;
  <D.24260>:
  code.6982 = code;
  code = code.6982 + 1;
  *code.6982 = 141;
  code.6983 = code;
  code = code.6983 + 1;
  *code.6983 = 100;
  code.6984 = code;
  code = code.6984 + 1;
  *code.6984 = 36;
  code.6985 = code;
  code = code.6985 + 1;
  *code.6985 = 0;
  code.6986 = code;
  code = code.6986 + 1;
  *code.6986 = 144;
  goto <D.24256>;
  <D.24261>:
  code.6987 = code;
  code = code.6987 + 1;
  *code.6987 = 141;
  code.6988 = code;
  code = code.6988 + 1;
  *code.6988 = 173;
  code.6989 = code;
  code = code.6989 + 1;
  *code.6989 = 0;
  code.6990 = code;
  code = code.6990 + 1;
  *code.6990 = 0;
  code.6991 = code;
  code = code.6991 + 1;
  *code.6991 = 0;
  code.6992 = code;
  code = code.6992 + 1;
  *code.6992 = 0;
  goto <D.24256>;
  <D.24262>:
  code.6993 = code;
  code = code.6993 + 1;
  *code.6993 = 141;
  code.6994 = code;
  code = code.6994 + 1;
  *code.6994 = 164;
  code.6995 = code;
  code = code.6995 + 1;
  *code.6995 = 36;
  code.6996 = code;
  code = code.6996 + 1;
  *code.6996 = 0;
  code.6997 = code;
  code = code.6997 + 1;
  *code.6997 = 0;
  code.6998 = code;
  code = code.6998 + 1;
  *code.6998 = 0;
  code.6999 = code;
  code = code.6999 + 1;
  *code.6999 = 0;
  goto <D.24256>;
  <D.24263>:
  __assert_fail ("0", "mini-x86.c", 1930, &__PRETTY_FUNCTION__);
  <D.24256>:
  <D.47158>:
  code.7000 = (int) code;
  D.47150 = cfg->native_code;
  D.47151 = (int) D.47150;
  D.47189 = code.7000 - D.47151;
  mono_add_patch_info (cfg, D.47189, patch_type, data);
  {
    int _x86_offset;

    code.7001 = (int) code;
    _x86_offset = -code.7001;
    _x86_offset = _x86_offset + -5;
    code.7002 = code;
    code = code.7002 + 1;
    *code.7002 = 232;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _x86_offset;
          code.7003 = code;
          code = code.7003 + 1;
          D.47193 = imb.b[0];
          *code.7003 = D.47193;
          code.7004 = code;
          code = code.7004 + 1;
          D.47195 = imb.b[1];
          *code.7004 = D.47195;
          code.7005 = code;
          code = code.7005 + 1;
          D.47197 = imb.b[2];
          *code.7005 = D.47197;
          code.7006 = code;
          code = code.7006 + 1;
          D.47199 = imb.b[3];
          *code.7006 = D.47199;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
  }
  D.47200 = code;
  return D.47200;
}


__signbit (double __x)
{
  int D.47202;
  int D.47203;
  _Bool D.47204;
  typedef union 
{
  double __d;
  int __i[2];
} unionunion 
{
  double __d;
  int __i[2];
};
  union 
{
  double __d;
  int __i[2];
} __u;

  try
    {
      __u.__d = __x;
      D.47203 = __u.__i[1];
      D.47204 = D.47203 < 0;
      D.47202 = (int) D.47204;
      return D.47202;
    }
  finally
    {
      __u = {CLOBBER};
    }
}


__signbitf (float __x)
{
  int D.47207;
  int D.47208;
  _Bool D.47209;
  typedef union 
{
  float __f;
  int __i;
} unionunion 
{
  float __f;
  int __i;
};
  union 
{
  float __f;
  int __i;
} __u;

  try
    {
      __u.__f = __x;
      D.47208 = __u.__i;
      D.47209 = D.47208 < 0;
      D.47207 = (int) D.47209;
      return D.47207;
    }
  finally
    {
      __u = {CLOBBER};
    }
}


emit_float_to_int (struct MonoCompile * cfg, guchar * code, int dreg, int size, gboolean is_signed)
{
  unsigned int D.47212;
  unsigned int D.47213;
  unsigned int D.47218;
  guchar * code.7007;
  guchar * code.7008;
  unsigned char D.47225;
  guchar * code.7009;
  unsigned char D.47227;
  guchar * code.7010;
  unsigned char D.47229;
  guchar * code.7011;
  unsigned char D.47231;
  guchar * code.7012;
  guchar * code.7013;
  guchar * code.7014;
  guchar * code.7015;
  guchar * code.7016;
  unsigned char D.47240;
  guchar * code.7017;
  unsigned char D.47242;
  guchar * code.7018;
  unsigned char D.47244;
  guchar * code.7019;
  unsigned char D.47246;
  guchar * code.7020;
  guchar * code.7021;
  guchar * code.7022;
  guchar * code.7023;
  guchar * code.7024;
  guchar * code.7025;
  guchar * code.7026;
  guchar * code.7027;
  unsigned char D.47263;
  guchar * code.7028;
  unsigned char D.47265;
  guchar * code.7029;
  unsigned char D.47267;
  guchar * code.7030;
  unsigned char D.47269;
  guchar * code.7031;
  guchar * code.7032;
  guchar * code.7033;
  guchar * code.7034;
  unsigned char D.47279;
  guchar * code.7035;
  unsigned char D.47281;
  guchar * code.7036;
  unsigned char D.47283;
  guchar * code.7037;
  unsigned char D.47285;
  guchar * code.7038;
  guchar * code.7039;
  guchar * code.7040;
  guchar * code.7041;
  guchar * code.7042;
  guchar * code.7043;
  guchar * code.7044;
  guchar * code.7045;
  guchar * code.7046;
  guchar * code.7047;
  unsigned char D.47304;
  guchar * code.7048;
  unsigned char D.47306;
  guchar * code.7049;
  unsigned char D.47308;
  guchar * code.7050;
  unsigned char D.47310;
  guchar * code.7051;
  guchar * code.7052;
  guchar * code.7053;
  guchar * code.7054;
  unsigned char D.47320;
  guchar * code.7055;
  unsigned char D.47322;
  guchar * code.7056;
  unsigned char D.47324;
  guchar * code.7057;
  unsigned char D.47326;
  guchar * code.7058;
  guchar * code.7059;
  guchar * code.7060;
  guchar * code.7061;
  int D.47331;
  int D.47332;
  signed char D.47333;
  signed char D.47334;
  unsigned char D.47335;
  guchar * code.7062;
  guchar * code.7063;
  unsigned char D.47340;
  guchar * code.7064;
  unsigned char D.47342;
  guchar * code.7065;
  unsigned char D.47344;
  guchar * code.7066;
  unsigned char D.47346;
  guchar * code.7067;
  guchar * code.7068;
  guchar * code.7069;
  guchar * code.7070;
  guchar * code.7071;
  unsigned char D.47355;
  guchar * code.7072;
  unsigned char D.47357;
  guchar * code.7073;
  unsigned char D.47359;
  guchar * code.7074;
  unsigned char D.47361;
  _Bool D.47364;
  long int D.47365;
  long int D.47366;
  guchar * code.7075;
  guchar * code.7076;
  guchar * code.7077;
  signed char D.47376;
  signed char D.47377;
  signed char D.47378;
  unsigned char D.47379;
  guchar * code.7078;
  guchar * code.7079;
  guchar * code.7080;
  unsigned char * D.47392;
  guchar * code.7081;
  guchar * code.7082;
  unsigned char D.47397;
  guchar * code.7083;
  unsigned char D.47399;
  guchar * code.7084;
  unsigned char D.47401;
  guchar * code.7085;
  unsigned char D.47403;
  guchar * code.7086;
  guchar * code.7087;
  guchar * code.7088;
  guchar * code.7089;
  guchar * code.7090;
  unsigned char D.47412;
  guchar * code.7091;
  unsigned char D.47414;
  guchar * code.7092;
  unsigned char D.47416;
  guchar * code.7093;
  unsigned char D.47418;
  guchar * code.7094;
  guchar * code.7095;
  guchar * code.7096;
  guchar * code.7097;
  guchar * code.7098;
  guchar * code.7099;
  guchar * code.7100;
  guchar * code.7101;
  unsigned char D.47435;
  guchar * code.7102;
  unsigned char D.47437;
  guchar * code.7103;
  unsigned char D.47439;
  guchar * code.7104;
  unsigned char D.47441;
  guchar * code.7105;
  guchar * code.7106;
  guchar * code.7107;
  guchar * code.7108;
  unsigned char D.47451;
  guchar * code.7109;
  unsigned char D.47453;
  guchar * code.7110;
  unsigned char D.47455;
  guchar * code.7111;
  unsigned char D.47457;
  guchar * code.7112;
  guchar * code.7113;
  guchar * code.7114;
  guchar * code.7115;
  signed char D.47466;
  unsigned char D.47467;
  guchar * code.7116;
  guchar * code.7117;
  signed char D.47473;
  unsigned char D.47474;
  guchar * code.7118;
  guchar * code.7119;
  signed char D.47478;
  unsigned char D.47479;
  guchar * code.7120;
  guchar * code.7121;
  unsigned char D.47482;
  guchar * code.7122;
  unsigned char D.47484;
  guchar * code.7123;
  unsigned char D.47486;
  guchar * code.7124;
  unsigned char D.47488;
  guchar * code.7125;
  guchar * code.7126;
  guchar * code.7127;
  guchar * code.7128;
  unsigned char D.47498;
  guchar * code.7129;
  unsigned char D.47500;
  guchar * code.7130;
  unsigned char D.47502;
  guchar * code.7131;
  unsigned char D.47504;
  guchar * code.7132;
  guchar * code.7133;
  unsigned char D.47509;
  guchar * code.7134;
  unsigned char D.47511;
  guchar * code.7135;
  unsigned char D.47513;
  guchar * code.7136;
  unsigned char D.47515;
  guchar * code.7137;
  guchar * code.7138;
  signed char D.47520;
  unsigned char D.47521;
  guchar * code.7139;
  guchar * code.7140;
  guchar * code.7141;
  unsigned char D.47526;
  guchar * code.7142;
  unsigned char D.47528;
  guchar * code.7143;
  unsigned char D.47530;
  guchar * code.7144;
  unsigned char D.47532;
  guchar * code.7145;
  guchar * code.7146;
  guchar * code.7147;
  guchar * code.7148;
  guchar * code.7149;
  guchar * code.7150;
  guchar * code.7151;
  guchar * code.7152;
  guchar * code.7153;
  guchar * code.7154;
  unsigned char D.47551;
  guchar * code.7155;
  unsigned char D.47553;
  guchar * code.7156;
  unsigned char D.47555;
  guchar * code.7157;
  unsigned char D.47557;
  guchar * code.7158;
  guchar * code.7159;
  guchar * code.7160;
  guchar * code.7161;
  unsigned char D.47567;
  guchar * code.7162;
  unsigned char D.47569;
  guchar * code.7163;
  unsigned char D.47571;
  guchar * code.7164;
  unsigned char D.47573;
  guchar * code.7165;
  guchar * code.7166;
  guchar * code.7167;
  guchar * code.7168;
  guchar * code.7169;
  guchar * code.7170;
  guchar * code.7171;
  guchar * code.7172;
  unsigned char D.47590;
  guchar * code.7173;
  unsigned char D.47592;
  guchar * code.7174;
  unsigned char D.47594;
  guchar * code.7175;
  unsigned char D.47596;
  guchar * code.7176;
  guchar * code.7177;
  guchar * code.7178;
  guchar * code.7179;
  unsigned char D.47606;
  guchar * code.7180;
  unsigned char D.47608;
  guchar * code.7181;
  unsigned char D.47610;
  guchar * code.7182;
  unsigned char D.47612;
  guchar * code.7183;
  guchar * code.7184;
  unsigned char D.47619;
  guchar * code.7185;
  unsigned char D.47621;
  guchar * code.7186;
  unsigned char D.47623;
  guchar * code.7187;
  unsigned char D.47625;
  guchar * code.7188;
  guchar * code.7189;
  guchar * code.7190;
  guchar * code.7191;
  guchar * code.7192;
  unsigned char D.47634;
  guchar * code.7193;
  unsigned char D.47636;
  guchar * code.7194;
  unsigned char D.47638;
  guchar * code.7195;
  unsigned char D.47640;
  guchar * code.7196;
  guchar * code.7197;
  guchar * code.7198;
  guchar * code.7199;
  guchar * code.7200;
  guchar * code.7201;
  guchar * code.7202;
  guchar * code.7203;
  unsigned char D.47659;
  guchar * code.7204;
  unsigned char D.47661;
  guchar * code.7205;
  unsigned char D.47663;
  guchar * code.7206;
  unsigned char D.47665;
  guchar * code.7207;
  guchar * code.7208;
  guchar * code.7209;
  guchar * code.7210;
  unsigned char D.47675;
  guchar * code.7211;
  unsigned char D.47677;
  guchar * code.7212;
  unsigned char D.47679;
  guchar * code.7213;
  unsigned char D.47681;
  guchar * code.7214;
  guchar * code.7215;
  guchar * code.7216;
  guchar * code.7217;
  guchar * code.7218;
  guchar * code.7219;
  guchar * code.7220;
  guchar * code.7221;
  unsigned char D.47699;
  guchar * code.7222;
  unsigned char D.47701;
  guchar * code.7223;
  unsigned char D.47703;
  guchar * code.7224;
  unsigned char D.47705;
  guchar * code.7225;
  guchar * code.7226;
  guchar * code.7227;
  guchar * code.7228;
  unsigned char D.47715;
  guchar * code.7229;
  unsigned char D.47717;
  guchar * code.7230;
  unsigned char D.47719;
  guchar * code.7231;
  unsigned char D.47721;
  guchar * code.7232;
  unsigned char D.47723;
  unsigned char D.47724;
  guchar * code.7233;
  guchar * code.7234;
  guchar * code.7235;
  guchar * code.7236;
  guchar * code.7237;
  guchar * code.7238;
  guchar * code.7239;
  guchar * code.7240;
  guchar * code.7241;
  unsigned char D.47745;
  guchar * code.7242;
  unsigned char D.47747;
  guchar * code.7243;
  unsigned char D.47749;
  guchar * code.7244;
  unsigned char D.47751;
  guchar * code.7245;
  guchar * code.7246;
  guchar * code.7247;
  guchar * code.7248;
  unsigned char D.47761;
  guchar * code.7249;
  unsigned char D.47763;
  guchar * code.7250;
  unsigned char D.47765;
  guchar * code.7251;
  unsigned char D.47767;
  guchar * code.7252;
  guchar * code.7253;
  guchar * code.7254;
  guchar * code.7255;
  guchar * code.7256;
  guchar * code.7257;
  guchar * code.7258;
  guchar * code.7259;
  unsigned char D.47785;
  guchar * code.7260;
  unsigned char D.47787;
  guchar * code.7261;
  unsigned char D.47789;
  guchar * code.7262;
  unsigned char D.47791;
  guchar * code.7263;
  guchar * code.7264;
  guchar * code.7265;
  guchar * code.7266;
  unsigned char D.47801;
  guchar * code.7267;
  unsigned char D.47803;
  guchar * code.7268;
  unsigned char D.47805;
  guchar * code.7269;
  unsigned char D.47807;
  guchar * code.7270;
  guchar * code.7271;
  guchar * code.7272;
  guchar * code.7273;
  guchar * code.7274;
  guchar * code.7275;
  guchar * code.7276;
  guchar * code.7277;
  guchar * code.7278;
  unsigned char D.47825;
  guchar * code.7279;
  unsigned char D.47827;
  guchar * code.7280;
  unsigned char D.47829;
  guchar * code.7281;
  unsigned char D.47831;
  guchar * code.7282;
  guchar * code.7283;
  guchar * code.7284;
  guchar * code.7285;
  unsigned char D.47841;
  guchar * code.7286;
  unsigned char D.47843;
  guchar * code.7287;
  unsigned char D.47845;
  guchar * code.7288;
  unsigned char D.47847;
  guchar * code.7289;
  guchar * code.7290;
  unsigned char D.47852;
  guchar * code.7291;
  unsigned char D.47854;
  guchar * code.7292;
  unsigned char D.47856;
  guchar * code.7293;
  unsigned char D.47858;
  guchar * code.7294;
  guchar * code.7295;
  guchar * code.7296;
  guchar * code.7297;
  guchar * code.7298;
  unsigned char D.47867;
  guchar * code.7299;
  unsigned char D.47869;
  guchar * code.7300;
  unsigned char D.47871;
  guchar * code.7301;
  unsigned char D.47873;
  guchar * code.7302;
  guchar * code.7303;
  guchar * code.7304;
  guchar * code.7305;
  guchar * code.7306;
  guchar * code.7307;
  static const char __PRETTY_FUNCTION__[18] = "emit_float_to_int";

  D.47212 = cfg->opt;
  D.47213 = D.47212 & 8388608;
  if (D.47213 != 0) goto <D.47214>; else goto <D.47215>;
  <D.47214>:
  if (size <= 7) goto <D.47216>; else goto <D.47217>;
  <D.47216>:
  D.47212 = cfg->opt;
  D.47218 = D.47212 & 67108864;
  if (D.47218 == 0) goto <D.47219>; else goto <D.47220>;
  <D.47219>:
  if (0 != 0) goto <D.47221>; else goto <D.47222>;
  <D.47221>:
  code.7007 = code;
  code = code.7007 + 1;
  *code.7007 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.7008 = code;
        code = code.7008 + 1;
        D.47225 = imb.b[0];
        *code.7008 = D.47225;
        code.7009 = code;
        code = code.7009 + 1;
        D.47227 = imb.b[1];
        *code.7009 = D.47227;
        code.7010 = code;
        code = code.7010 + 1;
        D.47229 = imb.b[2];
        *code.7010 = D.47229;
        code.7011 = code;
        code = code.7011 + 1;
        D.47231 = imb.b[3];
        *code.7011 = D.47231;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24331>;
  <D.47222>:
  if (1 != 0) goto <D.47232>; else goto <D.47233>;
  <D.47232>:
  code.7012 = code;
  code = code.7012 + 1;
  *code.7012 = 131;
  code.7013 = code;
  code = code.7013 + 1;
  *code.7013 = 236;
  *code = 8;
  code = code + 1;
  goto <D.47236>;
  <D.47233>:
  code.7014 = code;
  code = code.7014 + 1;
  *code.7014 = 129;
  code.7015 = code;
  code = code.7015 + 1;
  *code.7015 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.7016 = code;
        code = code.7016 + 1;
        D.47240 = imb.b[0];
        *code.7016 = D.47240;
        code.7017 = code;
        code = code.7017 + 1;
        D.47242 = imb.b[1];
        *code.7017 = D.47242;
        code.7018 = code;
        code = code.7018 + 1;
        D.47244 = imb.b[2];
        *code.7018 = D.47244;
        code.7019 = code;
        code = code.7019 + 1;
        D.47246 = imb.b[3];
        *code.7019 = D.47246;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47236>:
  <D.24331>:
  code.7020 = code;
  code = code.7020 + 1;
  *code.7020 = 221;
  if (1 != 0) goto <D.47248>; else goto <D.47249>;
  <D.47248>:
  if (1 != 0) goto <D.47250>; else goto <D.47251>;
  <D.47250>:
  code.7021 = code;
  code = code.7021 + 1;
  *code.7021 = 28;
  code.7022 = code;
  code = code.7022 + 1;
  *code.7022 = 36;
  goto <D.47254>;
  <D.47251>:
  if (1 != 0) goto <D.47255>; else goto <D.47256>;
  <D.47255>:
  code.7023 = code;
  code = code.7023 + 1;
  *code.7023 = 92;
  code.7024 = code;
  code = code.7024 + 1;
  *code.7024 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47259>;
  <D.47256>:
  code.7025 = code;
  code = code.7025 + 1;
  *code.7025 = 156;
  code.7026 = code;
  code = code.7026 + 1;
  *code.7026 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7027 = code;
        code = code.7027 + 1;
        D.47263 = imb.b[0];
        *code.7027 = D.47263;
        code.7028 = code;
        code = code.7028 + 1;
        D.47265 = imb.b[1];
        *code.7028 = D.47265;
        code.7029 = code;
        code = code.7029 + 1;
        D.47267 = imb.b[2];
        *code.7029 = D.47267;
        code.7030 = code;
        code = code.7030 + 1;
        D.47269 = imb.b[3];
        *code.7030 = D.47269;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47259>:
  <D.47254>:
  goto <D.24334>;
  <D.47249>:
  if (1 != 0) goto <D.47270>; else goto <D.47271>;
  <D.47270>:
  code.7031 = code;
  code = code.7031 + 1;
  *code.7031 = 28;
  goto <D.24334>;
  <D.47271>:
  if (1 != 0) goto <D.47273>; else goto <D.47274>;
  <D.47273>:
  code.7032 = code;
  code = code.7032 + 1;
  *code.7032 = 92;
  *code = 0;
  code = code + 1;
  goto <D.47276>;
  <D.47274>:
  code.7033 = code;
  code = code.7033 + 1;
  *code.7033 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7034 = code;
        code = code.7034 + 1;
        D.47279 = imb.b[0];
        *code.7034 = D.47279;
        code.7035 = code;
        code = code.7035 + 1;
        D.47281 = imb.b[1];
        *code.7035 = D.47281;
        code.7036 = code;
        code = code.7036 + 1;
        D.47283 = imb.b[2];
        *code.7036 = D.47283;
        code.7037 = code;
        code = code.7037 + 1;
        D.47285 = imb.b[3];
        *code.7037 = D.47285;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47276>:
  <D.24334>:
  code.7038 = code;
  code = code.7038 + 1;
  *code.7038 = 242;
  code.7039 = code;
  code = code.7039 + 1;
  *code.7039 = 15;
  code.7040 = code;
  code = code.7040 + 1;
  *code.7040 = 16;
  if (1 != 0) goto <D.47289>; else goto <D.47290>;
  <D.47289>:
  if (1 != 0) goto <D.47291>; else goto <D.47292>;
  <D.47291>:
  code.7041 = code;
  code = code.7041 + 1;
  *code.7041 = 4;
  code.7042 = code;
  code = code.7042 + 1;
  *code.7042 = 36;
  goto <D.47295>;
  <D.47292>:
  if (1 != 0) goto <D.47296>; else goto <D.47297>;
  <D.47296>:
  code.7043 = code;
  code = code.7043 + 1;
  *code.7043 = 68;
  code.7044 = code;
  code = code.7044 + 1;
  *code.7044 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47300>;
  <D.47297>:
  code.7045 = code;
  code = code.7045 + 1;
  *code.7045 = 132;
  code.7046 = code;
  code = code.7046 + 1;
  *code.7046 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7047 = code;
        code = code.7047 + 1;
        D.47304 = imb.b[0];
        *code.7047 = D.47304;
        code.7048 = code;
        code = code.7048 + 1;
        D.47306 = imb.b[1];
        *code.7048 = D.47306;
        code.7049 = code;
        code = code.7049 + 1;
        D.47308 = imb.b[2];
        *code.7049 = D.47308;
        code.7050 = code;
        code = code.7050 + 1;
        D.47310 = imb.b[3];
        *code.7050 = D.47310;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47300>:
  <D.47295>:
  goto <D.24337>;
  <D.47290>:
  if (1 != 0) goto <D.47311>; else goto <D.47312>;
  <D.47311>:
  code.7051 = code;
  code = code.7051 + 1;
  *code.7051 = 4;
  goto <D.24337>;
  <D.47312>:
  if (1 != 0) goto <D.47314>; else goto <D.47315>;
  <D.47314>:
  code.7052 = code;
  code = code.7052 + 1;
  *code.7052 = 68;
  *code = 0;
  code = code + 1;
  goto <D.47317>;
  <D.47315>:
  code.7053 = code;
  code = code.7053 + 1;
  *code.7053 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7054 = code;
        code = code.7054 + 1;
        D.47320 = imb.b[0];
        *code.7054 = D.47320;
        code.7055 = code;
        code = code.7055 + 1;
        D.47322 = imb.b[1];
        *code.7055 = D.47322;
        code.7056 = code;
        code = code.7056 + 1;
        D.47324 = imb.b[2];
        *code.7056 = D.47324;
        code.7057 = code;
        code = code.7057 + 1;
        D.47326 = imb.b[3];
        *code.7057 = D.47326;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47317>:
  <D.24337>:
  code.7058 = code;
  code = code.7058 + 1;
  *code.7058 = 242;
  code.7059 = code;
  code = code.7059 + 1;
  *code.7059 = 15;
  code.7060 = code;
  code = code.7060 + 1;
  *code.7060 = 44;
  code.7061 = code;
  code = code.7061 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47334 = D.47333 | -64;
  D.47335 = (unsigned char) D.47334;
  *code.7061 = D.47335;
  if (0 != 0) goto <D.47336>; else goto <D.47337>;
  <D.47336>:
  code.7062 = code;
  code = code.7062 + 1;
  *code.7062 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.7063 = code;
        code = code.7063 + 1;
        D.47340 = imb.b[0];
        *code.7063 = D.47340;
        code.7064 = code;
        code = code.7064 + 1;
        D.47342 = imb.b[1];
        *code.7064 = D.47342;
        code.7065 = code;
        code = code.7065 + 1;
        D.47344 = imb.b[2];
        *code.7065 = D.47344;
        code.7066 = code;
        code = code.7066 + 1;
        D.47346 = imb.b[3];
        *code.7066 = D.47346;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24340>;
  <D.47337>:
  if (1 != 0) goto <D.47347>; else goto <D.47348>;
  <D.47347>:
  code.7067 = code;
  code = code.7067 + 1;
  *code.7067 = 131;
  code.7068 = code;
  code = code.7068 + 1;
  *code.7068 = 196;
  *code = 8;
  code = code + 1;
  goto <D.47351>;
  <D.47348>:
  code.7069 = code;
  code = code.7069 + 1;
  *code.7069 = 129;
  code.7070 = code;
  code = code.7070 + 1;
  *code.7070 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.7071 = code;
        code = code.7071 + 1;
        D.47355 = imb.b[0];
        *code.7071 = D.47355;
        code.7072 = code;
        code = code.7072 + 1;
        D.47357 = imb.b[1];
        *code.7072 = D.47357;
        code.7073 = code;
        code = code.7073 + 1;
        D.47359 = imb.b[2];
        *code.7073 = D.47359;
        code.7074 = code;
        code = code.7074 + 1;
        D.47361 = imb.b[3];
        *code.7074 = D.47361;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47351>:
  <D.24340>:
  if (size == 1) goto <D.47362>; else goto <D.47363>;
  <D.47362>:
  {
    unsigned char op;

    op = 182;
    D.47364 = dreg > 3;
    D.47365 = (long int) D.47364;
    D.47366 = __builtin_expect (D.47365, 0);
    if (D.47366 != 0) goto <D.47367>; else goto <D.47368>;
    <D.47367>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2149, "0 || X86_IS_BYTE_REG (dreg)");
    <D.47368>:
    code.7075 = code;
    code = code.7075 + 1;
    *code.7075 = 15;
    if (is_signed != 0) goto <D.47370>; else goto <D.47371>;
    <D.47370>:
    op = op + 8;
    <D.47371>:
    if (0 != 0) goto <D.47372>; else goto <D.47373>;
    <D.47372>:
    op = op + 1;
    <D.47373>:
    code.7076 = code;
    code = code.7076 + 1;
    *code.7076 = op;
    code.7077 = code;
    code = code.7077 + 1;
    D.47331 = dreg & 7;
    D.47332 = D.47331 << 3;
    D.47333 = (signed char) D.47332;
    D.47334 = D.47333 | -64;
    D.47376 = (signed char) dreg;
    D.47377 = D.47376 & 7;
    D.47378 = D.47334 | D.47377;
    D.47379 = (unsigned char) D.47378;
    *code.7077 = D.47379;
  }
  goto <D.47380>;
  <D.47363>:
  if (size == 2) goto <D.47381>; else goto <D.47382>;
  <D.47381>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.47383>; else goto <D.47384>;
    <D.47383>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2151, "1 || X86_IS_BYTE_REG (dreg)");
    <D.47384>:
    code.7078 = code;
    code = code.7078 + 1;
    *code.7078 = 15;
    if (is_signed != 0) goto <D.47386>; else goto <D.47387>;
    <D.47386>:
    op = op + 8;
    <D.47387>:
    if (1 != 0) goto <D.47388>; else goto <D.47389>;
    <D.47388>:
    op = op + 1;
    <D.47389>:
    code.7079 = code;
    code = code.7079 + 1;
    *code.7079 = op;
    code.7080 = code;
    code = code.7080 + 1;
    D.47331 = dreg & 7;
    D.47332 = D.47331 << 3;
    D.47333 = (signed char) D.47332;
    D.47334 = D.47333 | -64;
    D.47376 = (signed char) dreg;
    D.47377 = D.47376 & 7;
    D.47378 = D.47334 | D.47377;
    D.47379 = (unsigned char) D.47378;
    *code.7080 = D.47379;
  }
  <D.47382>:
  <D.47380>:
  D.47392 = code;
  return D.47392;
  <D.47220>:
  <D.47217>:
  <D.47215>:
  if (0 != 0) goto <D.47393>; else goto <D.47394>;
  <D.47393>:
  code.7081 = code;
  code = code.7081 + 1;
  *code.7081 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.7082 = code;
        code = code.7082 + 1;
        D.47397 = imb.b[0];
        *code.7082 = D.47397;
        code.7083 = code;
        code = code.7083 + 1;
        D.47399 = imb.b[1];
        *code.7083 = D.47399;
        code.7084 = code;
        code = code.7084 + 1;
        D.47401 = imb.b[2];
        *code.7084 = D.47401;
        code.7085 = code;
        code = code.7085 + 1;
        D.47403 = imb.b[3];
        *code.7085 = D.47403;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24345>;
  <D.47394>:
  if (1 != 0) goto <D.47404>; else goto <D.47405>;
  <D.47404>:
  code.7086 = code;
  code = code.7086 + 1;
  *code.7086 = 131;
  code.7087 = code;
  code = code.7087 + 1;
  *code.7087 = 236;
  *code = 4;
  code = code + 1;
  goto <D.47408>;
  <D.47405>:
  code.7088 = code;
  code = code.7088 + 1;
  *code.7088 = 129;
  code.7089 = code;
  code = code.7089 + 1;
  *code.7089 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.7090 = code;
        code = code.7090 + 1;
        D.47412 = imb.b[0];
        *code.7090 = D.47412;
        code.7091 = code;
        code = code.7091 + 1;
        D.47414 = imb.b[1];
        *code.7091 = D.47414;
        code.7092 = code;
        code = code.7092 + 1;
        D.47416 = imb.b[2];
        *code.7092 = D.47416;
        code.7093 = code;
        code = code.7093 + 1;
        D.47418 = imb.b[3];
        *code.7093 = D.47418;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47408>:
  <D.24345>:
  code.7094 = code;
  code = code.7094 + 1;
  *code.7094 = 217;
  if (1 != 0) goto <D.47420>; else goto <D.47421>;
  <D.47420>:
  if (1 != 0) goto <D.47422>; else goto <D.47423>;
  <D.47422>:
  code.7095 = code;
  code = code.7095 + 1;
  *code.7095 = 60;
  code.7096 = code;
  code = code.7096 + 1;
  *code.7096 = 36;
  goto <D.47426>;
  <D.47423>:
  if (1 != 0) goto <D.47427>; else goto <D.47428>;
  <D.47427>:
  code.7097 = code;
  code = code.7097 + 1;
  *code.7097 = 124;
  code.7098 = code;
  code = code.7098 + 1;
  *code.7098 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47431>;
  <D.47428>:
  code.7099 = code;
  code = code.7099 + 1;
  *code.7099 = 188;
  code.7100 = code;
  code = code.7100 + 1;
  *code.7100 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7101 = code;
        code = code.7101 + 1;
        D.47435 = imb.b[0];
        *code.7101 = D.47435;
        code.7102 = code;
        code = code.7102 + 1;
        D.47437 = imb.b[1];
        *code.7102 = D.47437;
        code.7103 = code;
        code = code.7103 + 1;
        D.47439 = imb.b[2];
        *code.7103 = D.47439;
        code.7104 = code;
        code = code.7104 + 1;
        D.47441 = imb.b[3];
        *code.7104 = D.47441;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47431>:
  <D.47426>:
  goto <D.24348>;
  <D.47421>:
  if (1 != 0) goto <D.47442>; else goto <D.47443>;
  <D.47442>:
  code.7105 = code;
  code = code.7105 + 1;
  *code.7105 = 60;
  goto <D.24348>;
  <D.47443>:
  if (1 != 0) goto <D.47445>; else goto <D.47446>;
  <D.47445>:
  code.7106 = code;
  code = code.7106 + 1;
  *code.7106 = 124;
  *code = 0;
  code = code + 1;
  goto <D.47448>;
  <D.47446>:
  code.7107 = code;
  code = code.7107 + 1;
  *code.7107 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7108 = code;
        code = code.7108 + 1;
        D.47451 = imb.b[0];
        *code.7108 = D.47451;
        code.7109 = code;
        code = code.7109 + 1;
        D.47453 = imb.b[1];
        *code.7109 = D.47453;
        code.7110 = code;
        code = code.7110 + 1;
        D.47455 = imb.b[2];
        *code.7110 = D.47455;
        code.7111 = code;
        code = code.7111 + 1;
        D.47457 = imb.b[3];
        *code.7111 = D.47457;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47448>:
  <D.24348>:
  switch (2) <default: <D.24354>, case 1: <D.24350>, case 2: <D.24352>, case 4: <D.24353>>
  <D.24350>:
  code.7112 = code;
  code = code.7112 + 1;
  *code.7112 = 138;
  goto <D.24351>;
  <D.24352>:
  code.7113 = code;
  code = code.7113 + 1;
  *code.7113 = 102;
  <D.24353>:
  code.7114 = code;
  code = code.7114 + 1;
  *code.7114 = 139;
  goto <D.24351>;
  <D.24354>:
  __assert_fail ("0", "mini-x86.c", 2156, &__PRETTY_FUNCTION__);
  <D.24351>:
  if (1 != 0) goto <D.47461>; else goto <D.47462>;
  <D.47461>:
  if (1 != 0) goto <D.47463>; else goto <D.47464>;
  <D.47463>:
  code.7115 = code;
  code = code.7115 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47466 = D.47333 | 4;
  D.47467 = (unsigned char) D.47466;
  *code.7115 = D.47467;
  code.7116 = code;
  code = code.7116 + 1;
  *code.7116 = 36;
  goto <D.47469>;
  <D.47464>:
  if (1 != 0) goto <D.47470>; else goto <D.47471>;
  <D.47470>:
  code.7117 = code;
  code = code.7117 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47473 = D.47333 | 68;
  D.47474 = (unsigned char) D.47473;
  *code.7117 = D.47474;
  code.7118 = code;
  code = code.7118 + 1;
  *code.7118 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47476>;
  <D.47471>:
  code.7119 = code;
  code = code.7119 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47478 = D.47333 | -124;
  D.47479 = (unsigned char) D.47478;
  *code.7119 = D.47479;
  code.7120 = code;
  code = code.7120 + 1;
  *code.7120 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7121 = code;
        code = code.7121 + 1;
        D.47482 = imb.b[0];
        *code.7121 = D.47482;
        code.7122 = code;
        code = code.7122 + 1;
        D.47484 = imb.b[1];
        *code.7122 = D.47484;
        code.7123 = code;
        code = code.7123 + 1;
        D.47486 = imb.b[2];
        *code.7123 = D.47486;
        code.7124 = code;
        code = code.7124 + 1;
        D.47488 = imb.b[3];
        *code.7124 = D.47488;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47476>:
  <D.47469>:
  goto <D.24357>;
  <D.47462>:
  if (1 != 0) goto <D.47489>; else goto <D.47490>;
  <D.47489>:
  code.7125 = code;
  code = code.7125 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47466 = D.47333 | 4;
  D.47467 = (unsigned char) D.47466;
  *code.7125 = D.47467;
  goto <D.24357>;
  <D.47490>:
  if (1 != 0) goto <D.47492>; else goto <D.47493>;
  <D.47492>:
  code.7126 = code;
  code = code.7126 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47473 = D.47333 | 68;
  D.47474 = (unsigned char) D.47473;
  *code.7126 = D.47474;
  *code = 0;
  code = code + 1;
  goto <D.47495>;
  <D.47493>:
  code.7127 = code;
  code = code.7127 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47478 = D.47333 | -124;
  D.47479 = (unsigned char) D.47478;
  *code.7127 = D.47479;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7128 = code;
        code = code.7128 + 1;
        D.47498 = imb.b[0];
        *code.7128 = D.47498;
        code.7129 = code;
        code = code.7129 + 1;
        D.47500 = imb.b[1];
        *code.7129 = D.47500;
        code.7130 = code;
        code = code.7130 + 1;
        D.47502 = imb.b[2];
        *code.7130 = D.47502;
        code.7131 = code;
        code = code.7131 + 1;
        D.47504 = imb.b[3];
        *code.7131 = D.47504;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47495>:
  <D.24357>:
  if (dreg == 0) goto <D.47505>; else goto <D.47506>;
  <D.47505>:
  code.7132 = code;
  code = code.7132 + 1;
  *code.7132 = 13;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 3072;
        code.7133 = code;
        code = code.7133 + 1;
        D.47509 = imb.b[0];
        *code.7133 = D.47509;
        code.7134 = code;
        code = code.7134 + 1;
        D.47511 = imb.b[1];
        *code.7134 = D.47511;
        code.7135 = code;
        code = code.7135 + 1;
        D.47513 = imb.b[2];
        *code.7135 = D.47513;
        code.7136 = code;
        code = code.7136 + 1;
        D.47515 = imb.b[3];
        *code.7136 = D.47515;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24360>;
  <D.47506>:
  if (0 != 0) goto <D.47516>; else goto <D.47517>;
  <D.47516>:
  code.7137 = code;
  code = code.7137 + 1;
  *code.7137 = 131;
  code.7138 = code;
  code = code.7138 + 1;
  D.47376 = (signed char) dreg;
  D.47377 = D.47376 & 7;
  D.47520 = D.47377 | -56;
  D.47521 = (unsigned char) D.47520;
  *code.7138 = D.47521;
  *code = 0;
  code = code + 1;
  goto <D.47522>;
  <D.47517>:
  code.7139 = code;
  code = code.7139 + 1;
  *code.7139 = 129;
  code.7140 = code;
  code = code.7140 + 1;
  D.47376 = (signed char) dreg;
  D.47377 = D.47376 & 7;
  D.47520 = D.47377 | -56;
  D.47521 = (unsigned char) D.47520;
  *code.7140 = D.47521;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 3072;
        code.7141 = code;
        code = code.7141 + 1;
        D.47526 = imb.b[0];
        *code.7141 = D.47526;
        code.7142 = code;
        code = code.7142 + 1;
        D.47528 = imb.b[1];
        *code.7142 = D.47528;
        code.7143 = code;
        code = code.7143 + 1;
        D.47530 = imb.b[2];
        *code.7143 = D.47530;
        code.7144 = code;
        code = code.7144 + 1;
        D.47532 = imb.b[3];
        *code.7144 = D.47532;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47522>:
  <D.24360>:
  switch (2) <default: <D.24366>, case 1: <D.24362>, case 2: <D.24364>, case 4: <D.24365>>
  <D.24362>:
  code.7145 = code;
  code = code.7145 + 1;
  *code.7145 = 136;
  goto <D.24363>;
  <D.24364>:
  code.7146 = code;
  code = code.7146 + 1;
  *code.7146 = 102;
  <D.24365>:
  code.7147 = code;
  code = code.7147 + 1;
  *code.7147 = 137;
  goto <D.24363>;
  <D.24366>:
  __assert_fail ("0", "mini-x86.c", 2158, &__PRETTY_FUNCTION__);
  <D.24363>:
  if (1 != 0) goto <D.47536>; else goto <D.47537>;
  <D.47536>:
  if (0 != 0) goto <D.47538>; else goto <D.47539>;
  <D.47538>:
  code.7148 = code;
  code = code.7148 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47466 = D.47333 | 4;
  D.47467 = (unsigned char) D.47466;
  *code.7148 = D.47467;
  code.7149 = code;
  code = code.7149 + 1;
  *code.7149 = 36;
  goto <D.47542>;
  <D.47539>:
  if (1 != 0) goto <D.47543>; else goto <D.47544>;
  <D.47543>:
  code.7150 = code;
  code = code.7150 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47473 = D.47333 | 68;
  D.47474 = (unsigned char) D.47473;
  *code.7150 = D.47474;
  code.7151 = code;
  code = code.7151 + 1;
  *code.7151 = 36;
  *code = 2;
  code = code + 1;
  goto <D.47547>;
  <D.47544>:
  code.7152 = code;
  code = code.7152 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47478 = D.47333 | -124;
  D.47479 = (unsigned char) D.47478;
  *code.7152 = D.47479;
  code.7153 = code;
  code = code.7153 + 1;
  *code.7153 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.7154 = code;
        code = code.7154 + 1;
        D.47551 = imb.b[0];
        *code.7154 = D.47551;
        code.7155 = code;
        code = code.7155 + 1;
        D.47553 = imb.b[1];
        *code.7155 = D.47553;
        code.7156 = code;
        code = code.7156 + 1;
        D.47555 = imb.b[2];
        *code.7156 = D.47555;
        code.7157 = code;
        code = code.7157 + 1;
        D.47557 = imb.b[3];
        *code.7157 = D.47557;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47547>:
  <D.47542>:
  goto <D.24368>;
  <D.47537>:
  if (0 != 0) goto <D.47558>; else goto <D.47559>;
  <D.47558>:
  code.7158 = code;
  code = code.7158 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47466 = D.47333 | 4;
  D.47467 = (unsigned char) D.47466;
  *code.7158 = D.47467;
  goto <D.24368>;
  <D.47559>:
  if (1 != 0) goto <D.47561>; else goto <D.47562>;
  <D.47561>:
  code.7159 = code;
  code = code.7159 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47473 = D.47333 | 68;
  D.47474 = (unsigned char) D.47473;
  *code.7159 = D.47474;
  *code = 2;
  code = code + 1;
  goto <D.47564>;
  <D.47562>:
  code.7160 = code;
  code = code.7160 + 1;
  D.47331 = dreg & 7;
  D.47332 = D.47331 << 3;
  D.47333 = (signed char) D.47332;
  D.47478 = D.47333 | -124;
  D.47479 = (unsigned char) D.47478;
  *code.7160 = D.47479;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.7161 = code;
        code = code.7161 + 1;
        D.47567 = imb.b[0];
        *code.7161 = D.47567;
        code.7162 = code;
        code = code.7162 + 1;
        D.47569 = imb.b[1];
        *code.7162 = D.47569;
        code.7163 = code;
        code = code.7163 + 1;
        D.47571 = imb.b[2];
        *code.7163 = D.47571;
        code.7164 = code;
        code = code.7164 + 1;
        D.47573 = imb.b[3];
        *code.7164 = D.47573;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47564>:
  <D.24368>:
  code.7165 = code;
  code = code.7165 + 1;
  *code.7165 = 217;
  if (1 != 0) goto <D.47575>; else goto <D.47576>;
  <D.47575>:
  if (0 != 0) goto <D.47577>; else goto <D.47578>;
  <D.47577>:
  code.7166 = code;
  code = code.7166 + 1;
  *code.7166 = 44;
  code.7167 = code;
  code = code.7167 + 1;
  *code.7167 = 36;
  goto <D.47581>;
  <D.47578>:
  if (1 != 0) goto <D.47582>; else goto <D.47583>;
  <D.47582>:
  code.7168 = code;
  code = code.7168 + 1;
  *code.7168 = 108;
  code.7169 = code;
  code = code.7169 + 1;
  *code.7169 = 36;
  *code = 2;
  code = code + 1;
  goto <D.47586>;
  <D.47583>:
  code.7170 = code;
  code = code.7170 + 1;
  *code.7170 = 172;
  code.7171 = code;
  code = code.7171 + 1;
  *code.7171 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.7172 = code;
        code = code.7172 + 1;
        D.47590 = imb.b[0];
        *code.7172 = D.47590;
        code.7173 = code;
        code = code.7173 + 1;
        D.47592 = imb.b[1];
        *code.7173 = D.47592;
        code.7174 = code;
        code = code.7174 + 1;
        D.47594 = imb.b[2];
        *code.7174 = D.47594;
        code.7175 = code;
        code = code.7175 + 1;
        D.47596 = imb.b[3];
        *code.7175 = D.47596;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47586>:
  <D.47581>:
  goto <D.24371>;
  <D.47576>:
  if (0 != 0) goto <D.47597>; else goto <D.47598>;
  <D.47597>:
  code.7176 = code;
  code = code.7176 + 1;
  *code.7176 = 44;
  goto <D.24371>;
  <D.47598>:
  if (1 != 0) goto <D.47600>; else goto <D.47601>;
  <D.47600>:
  code.7177 = code;
  code = code.7177 + 1;
  *code.7177 = 108;
  *code = 2;
  code = code + 1;
  goto <D.47603>;
  <D.47601>:
  code.7178 = code;
  code = code.7178 + 1;
  *code.7178 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2;
        code.7179 = code;
        code = code.7179 + 1;
        D.47606 = imb.b[0];
        *code.7179 = D.47606;
        code.7180 = code;
        code = code.7180 + 1;
        D.47608 = imb.b[1];
        *code.7180 = D.47608;
        code.7181 = code;
        code = code.7181 + 1;
        D.47610 = imb.b[2];
        *code.7181 = D.47610;
        code.7182 = code;
        code = code.7182 + 1;
        D.47612 = imb.b[3];
        *code.7182 = D.47612;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47603>:
  <D.24371>:
  if (size == 8) goto <D.47613>; else goto <D.47614>;
  <D.47613>:
  if (0 != 0) goto <D.47615>; else goto <D.47616>;
  <D.47615>:
  code.7183 = code;
  code = code.7183 + 1;
  *code.7183 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.7184 = code;
        code = code.7184 + 1;
        D.47619 = imb.b[0];
        *code.7184 = D.47619;
        code.7185 = code;
        code = code.7185 + 1;
        D.47621 = imb.b[1];
        *code.7185 = D.47621;
        code.7186 = code;
        code = code.7186 + 1;
        D.47623 = imb.b[2];
        *code.7186 = D.47623;
        code.7187 = code;
        code = code.7187 + 1;
        D.47625 = imb.b[3];
        *code.7187 = D.47625;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24374>;
  <D.47616>:
  if (1 != 0) goto <D.47626>; else goto <D.47627>;
  <D.47626>:
  code.7188 = code;
  code = code.7188 + 1;
  *code.7188 = 131;
  code.7189 = code;
  code = code.7189 + 1;
  *code.7189 = 236;
  *code = 8;
  code = code + 1;
  goto <D.47630>;
  <D.47627>:
  code.7190 = code;
  code = code.7190 + 1;
  *code.7190 = 129;
  code.7191 = code;
  code = code.7191 + 1;
  *code.7191 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.7192 = code;
        code = code.7192 + 1;
        D.47634 = imb.b[0];
        *code.7192 = D.47634;
        code.7193 = code;
        code = code.7193 + 1;
        D.47636 = imb.b[1];
        *code.7193 = D.47636;
        code.7194 = code;
        code = code.7194 + 1;
        D.47638 = imb.b[2];
        *code.7194 = D.47638;
        code.7195 = code;
        code = code.7195 + 1;
        D.47640 = imb.b[3];
        *code.7195 = D.47640;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47630>:
  <D.24374>:
  if (1 != 0) goto <D.47641>; else goto <D.47642>;
  <D.47641>:
  code.7196 = code;
  code = code.7196 + 1;
  *code.7196 = 223;
  if (1 != 0) goto <D.47644>; else goto <D.47645>;
  <D.47644>:
  if (1 != 0) goto <D.47646>; else goto <D.47647>;
  <D.47646>:
  code.7197 = code;
  code = code.7197 + 1;
  *code.7197 = 60;
  code.7198 = code;
  code = code.7198 + 1;
  *code.7198 = 36;
  goto <D.47650>;
  <D.47647>:
  if (1 != 0) goto <D.47651>; else goto <D.47652>;
  <D.47651>:
  code.7199 = code;
  code = code.7199 + 1;
  *code.7199 = 124;
  code.7200 = code;
  code = code.7200 + 1;
  *code.7200 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47655>;
  <D.47652>:
  code.7201 = code;
  code = code.7201 + 1;
  *code.7201 = 188;
  code.7202 = code;
  code = code.7202 + 1;
  *code.7202 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7203 = code;
        code = code.7203 + 1;
        D.47659 = imb.b[0];
        *code.7203 = D.47659;
        code.7204 = code;
        code = code.7204 + 1;
        D.47661 = imb.b[1];
        *code.7204 = D.47661;
        code.7205 = code;
        code = code.7205 + 1;
        D.47663 = imb.b[2];
        *code.7205 = D.47663;
        code.7206 = code;
        code = code.7206 + 1;
        D.47665 = imb.b[3];
        *code.7206 = D.47665;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47655>:
  <D.47650>:
  goto <D.24377>;
  <D.47645>:
  if (1 != 0) goto <D.47666>; else goto <D.47667>;
  <D.47666>:
  code.7207 = code;
  code = code.7207 + 1;
  *code.7207 = 60;
  goto <D.24377>;
  <D.47667>:
  if (1 != 0) goto <D.47669>; else goto <D.47670>;
  <D.47669>:
  code.7208 = code;
  code = code.7208 + 1;
  *code.7208 = 124;
  *code = 0;
  code = code + 1;
  goto <D.47672>;
  <D.47670>:
  code.7209 = code;
  code = code.7209 + 1;
  *code.7209 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7210 = code;
        code = code.7210 + 1;
        D.47675 = imb.b[0];
        *code.7210 = D.47675;
        code.7211 = code;
        code = code.7211 + 1;
        D.47677 = imb.b[1];
        *code.7211 = D.47677;
        code.7212 = code;
        code = code.7212 + 1;
        D.47679 = imb.b[2];
        *code.7212 = D.47679;
        code.7213 = code;
        code = code.7213 + 1;
        D.47681 = imb.b[3];
        *code.7213 = D.47681;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47672>:
  <D.24377>:
  goto <D.47682>;
  <D.47642>:
  code.7214 = code;
  code = code.7214 + 1;
  *code.7214 = 219;
  if (1 != 0) goto <D.47684>; else goto <D.47685>;
  <D.47684>:
  if (1 != 0) goto <D.47686>; else goto <D.47687>;
  <D.47686>:
  code.7215 = code;
  code = code.7215 + 1;
  *code.7215 = 28;
  code.7216 = code;
  code = code.7216 + 1;
  *code.7216 = 36;
  goto <D.47690>;
  <D.47687>:
  if (1 != 0) goto <D.47691>; else goto <D.47692>;
  <D.47691>:
  code.7217 = code;
  code = code.7217 + 1;
  *code.7217 = 92;
  code.7218 = code;
  code = code.7218 + 1;
  *code.7218 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47695>;
  <D.47692>:
  code.7219 = code;
  code = code.7219 + 1;
  *code.7219 = 156;
  code.7220 = code;
  code = code.7220 + 1;
  *code.7220 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7221 = code;
        code = code.7221 + 1;
        D.47699 = imb.b[0];
        *code.7221 = D.47699;
        code.7222 = code;
        code = code.7222 + 1;
        D.47701 = imb.b[1];
        *code.7222 = D.47701;
        code.7223 = code;
        code = code.7223 + 1;
        D.47703 = imb.b[2];
        *code.7223 = D.47703;
        code.7224 = code;
        code = code.7224 + 1;
        D.47705 = imb.b[3];
        *code.7224 = D.47705;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47695>:
  <D.47690>:
  goto <D.24380>;
  <D.47685>:
  if (1 != 0) goto <D.47706>; else goto <D.47707>;
  <D.47706>:
  code.7225 = code;
  code = code.7225 + 1;
  *code.7225 = 28;
  goto <D.24380>;
  <D.47707>:
  if (1 != 0) goto <D.47709>; else goto <D.47710>;
  <D.47709>:
  code.7226 = code;
  code = code.7226 + 1;
  *code.7226 = 92;
  *code = 0;
  code = code + 1;
  goto <D.47712>;
  <D.47710>:
  code.7227 = code;
  code = code.7227 + 1;
  *code.7227 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7228 = code;
        code = code.7228 + 1;
        D.47715 = imb.b[0];
        *code.7228 = D.47715;
        code.7229 = code;
        code = code.7229 + 1;
        D.47717 = imb.b[1];
        *code.7229 = D.47717;
        code.7230 = code;
        code = code.7230 + 1;
        D.47719 = imb.b[2];
        *code.7230 = D.47719;
        code.7231 = code;
        code = code.7231 + 1;
        D.47721 = imb.b[3];
        *code.7231 = D.47721;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47712>:
  <D.24380>:
  <D.47682>:
  code.7232 = code;
  code = code.7232 + 1;
  D.47723 = (unsigned char) dreg;
  D.47724 = D.47723 + 88;
  *code.7232 = D.47724;
  goto <D.47725>;
  <D.47614>:
  code.7233 = code;
  code = code.7233 + 1;
  *code.7233 = 80;
  if (0 != 0) goto <D.47727>; else goto <D.47728>;
  <D.47727>:
  code.7234 = code;
  code = code.7234 + 1;
  *code.7234 = 223;
  if (1 != 0) goto <D.47730>; else goto <D.47731>;
  <D.47730>:
  if (1 != 0) goto <D.47732>; else goto <D.47733>;
  <D.47732>:
  code.7235 = code;
  code = code.7235 + 1;
  *code.7235 = 60;
  code.7236 = code;
  code = code.7236 + 1;
  *code.7236 = 36;
  goto <D.47736>;
  <D.47733>:
  if (1 != 0) goto <D.47737>; else goto <D.47738>;
  <D.47737>:
  code.7237 = code;
  code = code.7237 + 1;
  *code.7237 = 124;
  code.7238 = code;
  code = code.7238 + 1;
  *code.7238 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47741>;
  <D.47738>:
  code.7239 = code;
  code = code.7239 + 1;
  *code.7239 = 188;
  code.7240 = code;
  code = code.7240 + 1;
  *code.7240 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7241 = code;
        code = code.7241 + 1;
        D.47745 = imb.b[0];
        *code.7241 = D.47745;
        code.7242 = code;
        code = code.7242 + 1;
        D.47747 = imb.b[1];
        *code.7242 = D.47747;
        code.7243 = code;
        code = code.7243 + 1;
        D.47749 = imb.b[2];
        *code.7243 = D.47749;
        code.7244 = code;
        code = code.7244 + 1;
        D.47751 = imb.b[3];
        *code.7244 = D.47751;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47741>:
  <D.47736>:
  goto <D.24383>;
  <D.47731>:
  if (1 != 0) goto <D.47752>; else goto <D.47753>;
  <D.47752>:
  code.7245 = code;
  code = code.7245 + 1;
  *code.7245 = 60;
  goto <D.24383>;
  <D.47753>:
  if (1 != 0) goto <D.47755>; else goto <D.47756>;
  <D.47755>:
  code.7246 = code;
  code = code.7246 + 1;
  *code.7246 = 124;
  *code = 0;
  code = code + 1;
  goto <D.47758>;
  <D.47756>:
  code.7247 = code;
  code = code.7247 + 1;
  *code.7247 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7248 = code;
        code = code.7248 + 1;
        D.47761 = imb.b[0];
        *code.7248 = D.47761;
        code.7249 = code;
        code = code.7249 + 1;
        D.47763 = imb.b[1];
        *code.7249 = D.47763;
        code.7250 = code;
        code = code.7250 + 1;
        D.47765 = imb.b[2];
        *code.7250 = D.47765;
        code.7251 = code;
        code = code.7251 + 1;
        D.47767 = imb.b[3];
        *code.7251 = D.47767;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47758>:
  <D.24383>:
  goto <D.47768>;
  <D.47728>:
  code.7252 = code;
  code = code.7252 + 1;
  *code.7252 = 219;
  if (1 != 0) goto <D.47770>; else goto <D.47771>;
  <D.47770>:
  if (1 != 0) goto <D.47772>; else goto <D.47773>;
  <D.47772>:
  code.7253 = code;
  code = code.7253 + 1;
  *code.7253 = 28;
  code.7254 = code;
  code = code.7254 + 1;
  *code.7254 = 36;
  goto <D.47776>;
  <D.47773>:
  if (1 != 0) goto <D.47777>; else goto <D.47778>;
  <D.47777>:
  code.7255 = code;
  code = code.7255 + 1;
  *code.7255 = 92;
  code.7256 = code;
  code = code.7256 + 1;
  *code.7256 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47781>;
  <D.47778>:
  code.7257 = code;
  code = code.7257 + 1;
  *code.7257 = 156;
  code.7258 = code;
  code = code.7258 + 1;
  *code.7258 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7259 = code;
        code = code.7259 + 1;
        D.47785 = imb.b[0];
        *code.7259 = D.47785;
        code.7260 = code;
        code = code.7260 + 1;
        D.47787 = imb.b[1];
        *code.7260 = D.47787;
        code.7261 = code;
        code = code.7261 + 1;
        D.47789 = imb.b[2];
        *code.7261 = D.47789;
        code.7262 = code;
        code = code.7262 + 1;
        D.47791 = imb.b[3];
        *code.7262 = D.47791;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47781>:
  <D.47776>:
  goto <D.24386>;
  <D.47771>:
  if (1 != 0) goto <D.47792>; else goto <D.47793>;
  <D.47792>:
  code.7263 = code;
  code = code.7263 + 1;
  *code.7263 = 28;
  goto <D.24386>;
  <D.47793>:
  if (1 != 0) goto <D.47795>; else goto <D.47796>;
  <D.47795>:
  code.7264 = code;
  code = code.7264 + 1;
  *code.7264 = 92;
  *code = 0;
  code = code + 1;
  goto <D.47798>;
  <D.47796>:
  code.7265 = code;
  code = code.7265 + 1;
  *code.7265 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7266 = code;
        code = code.7266 + 1;
        D.47801 = imb.b[0];
        *code.7266 = D.47801;
        code.7267 = code;
        code = code.7267 + 1;
        D.47803 = imb.b[1];
        *code.7267 = D.47803;
        code.7268 = code;
        code = code.7268 + 1;
        D.47805 = imb.b[2];
        *code.7268 = D.47805;
        code.7269 = code;
        code = code.7269 + 1;
        D.47807 = imb.b[3];
        *code.7269 = D.47807;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47798>:
  <D.24386>:
  <D.47768>:
  code.7270 = code;
  code = code.7270 + 1;
  D.47723 = (unsigned char) dreg;
  D.47724 = D.47723 + 88;
  *code.7270 = D.47724;
  <D.47725>:
  code.7271 = code;
  code = code.7271 + 1;
  *code.7271 = 217;
  if (1 != 0) goto <D.47810>; else goto <D.47811>;
  <D.47810>:
  if (1 != 0) goto <D.47812>; else goto <D.47813>;
  <D.47812>:
  code.7272 = code;
  code = code.7272 + 1;
  *code.7272 = 44;
  code.7273 = code;
  code = code.7273 + 1;
  *code.7273 = 36;
  goto <D.47816>;
  <D.47813>:
  if (1 != 0) goto <D.47817>; else goto <D.47818>;
  <D.47817>:
  code.7274 = code;
  code = code.7274 + 1;
  *code.7274 = 108;
  code.7275 = code;
  code = code.7275 + 1;
  *code.7275 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47821>;
  <D.47818>:
  code.7276 = code;
  code = code.7276 + 1;
  *code.7276 = 172;
  code.7277 = code;
  code = code.7277 + 1;
  *code.7277 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7278 = code;
        code = code.7278 + 1;
        D.47825 = imb.b[0];
        *code.7278 = D.47825;
        code.7279 = code;
        code = code.7279 + 1;
        D.47827 = imb.b[1];
        *code.7279 = D.47827;
        code.7280 = code;
        code = code.7280 + 1;
        D.47829 = imb.b[2];
        *code.7280 = D.47829;
        code.7281 = code;
        code = code.7281 + 1;
        D.47831 = imb.b[3];
        *code.7281 = D.47831;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47821>:
  <D.47816>:
  goto <D.24389>;
  <D.47811>:
  if (1 != 0) goto <D.47832>; else goto <D.47833>;
  <D.47832>:
  code.7282 = code;
  code = code.7282 + 1;
  *code.7282 = 44;
  goto <D.24389>;
  <D.47833>:
  if (1 != 0) goto <D.47835>; else goto <D.47836>;
  <D.47835>:
  code.7283 = code;
  code = code.7283 + 1;
  *code.7283 = 108;
  *code = 0;
  code = code + 1;
  goto <D.47838>;
  <D.47836>:
  code.7284 = code;
  code = code.7284 + 1;
  *code.7284 = 172;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7285 = code;
        code = code.7285 + 1;
        D.47841 = imb.b[0];
        *code.7285 = D.47841;
        code.7286 = code;
        code = code.7286 + 1;
        D.47843 = imb.b[1];
        *code.7286 = D.47843;
        code.7287 = code;
        code = code.7287 + 1;
        D.47845 = imb.b[2];
        *code.7287 = D.47845;
        code.7288 = code;
        code = code.7288 + 1;
        D.47847 = imb.b[3];
        *code.7288 = D.47847;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47838>:
  <D.24389>:
  if (0 != 0) goto <D.47848>; else goto <D.47849>;
  <D.47848>:
  code.7289 = code;
  code = code.7289 + 1;
  *code.7289 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.7290 = code;
        code = code.7290 + 1;
        D.47852 = imb.b[0];
        *code.7290 = D.47852;
        code.7291 = code;
        code = code.7291 + 1;
        D.47854 = imb.b[1];
        *code.7291 = D.47854;
        code.7292 = code;
        code = code.7292 + 1;
        D.47856 = imb.b[2];
        *code.7292 = D.47856;
        code.7293 = code;
        code = code.7293 + 1;
        D.47858 = imb.b[3];
        *code.7293 = D.47858;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.24392>;
  <D.47849>:
  if (1 != 0) goto <D.47859>; else goto <D.47860>;
  <D.47859>:
  code.7294 = code;
  code = code.7294 + 1;
  *code.7294 = 131;
  code.7295 = code;
  code = code.7295 + 1;
  *code.7295 = 196;
  *code = 4;
  code = code + 1;
  goto <D.47863>;
  <D.47860>:
  code.7296 = code;
  code = code.7296 + 1;
  *code.7296 = 129;
  code.7297 = code;
  code = code.7297 + 1;
  *code.7297 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.7298 = code;
        code = code.7298 + 1;
        D.47867 = imb.b[0];
        *code.7298 = D.47867;
        code.7299 = code;
        code = code.7299 + 1;
        D.47869 = imb.b[1];
        *code.7299 = D.47869;
        code.7300 = code;
        code = code.7300 + 1;
        D.47871 = imb.b[2];
        *code.7300 = D.47871;
        code.7301 = code;
        code = code.7301 + 1;
        D.47873 = imb.b[3];
        *code.7301 = D.47873;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47863>:
  <D.24392>:
  if (size == 1) goto <D.47874>; else goto <D.47875>;
  <D.47874>:
  {
    unsigned char op;

    op = 182;
    D.47364 = dreg > 3;
    D.47365 = (long int) D.47364;
    D.47366 = __builtin_expect (D.47365, 0);
    if (D.47366 != 0) goto <D.47876>; else goto <D.47877>;
    <D.47876>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2176, "0 || X86_IS_BYTE_REG (dreg)");
    <D.47877>:
    code.7302 = code;
    code = code.7302 + 1;
    *code.7302 = 15;
    if (is_signed != 0) goto <D.47879>; else goto <D.47880>;
    <D.47879>:
    op = op + 8;
    <D.47880>:
    if (0 != 0) goto <D.47881>; else goto <D.47882>;
    <D.47881>:
    op = op + 1;
    <D.47882>:
    code.7303 = code;
    code = code.7303 + 1;
    *code.7303 = op;
    code.7304 = code;
    code = code.7304 + 1;
    D.47331 = dreg & 7;
    D.47332 = D.47331 << 3;
    D.47333 = (signed char) D.47332;
    D.47334 = D.47333 | -64;
    D.47376 = (signed char) dreg;
    D.47377 = D.47376 & 7;
    D.47378 = D.47334 | D.47377;
    D.47379 = (unsigned char) D.47378;
    *code.7304 = D.47379;
  }
  goto <D.47885>;
  <D.47875>:
  if (size == 2) goto <D.47886>; else goto <D.47887>;
  <D.47886>:
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.47888>; else goto <D.47889>;
    <D.47888>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 2178, "1 || X86_IS_BYTE_REG (dreg)");
    <D.47889>:
    code.7305 = code;
    code = code.7305 + 1;
    *code.7305 = 15;
    if (is_signed != 0) goto <D.47891>; else goto <D.47892>;
    <D.47891>:
    op = op + 8;
    <D.47892>:
    if (1 != 0) goto <D.47893>; else goto <D.47894>;
    <D.47893>:
    op = op + 1;
    <D.47894>:
    code.7306 = code;
    code = code.7306 + 1;
    *code.7306 = op;
    code.7307 = code;
    code = code.7307 + 1;
    D.47331 = dreg & 7;
    D.47332 = D.47331 << 3;
    D.47333 = (signed char) D.47332;
    D.47334 = D.47333 | -64;
    D.47376 = (signed char) dreg;
    D.47377 = D.47376 & 7;
    D.47378 = D.47334 | D.47377;
    D.47379 = (unsigned char) D.47378;
    *code.7307 = D.47379;
  }
  <D.47887>:
  <D.47885>:
  D.47392 = code;
  return D.47392;
}


mono_x86_emit_tls_set (guint8 * code, int sreg, int tls_offset)
{
  guint8 * code.7308;
  guint8 * code.7309;
  guint8 * code.7310;
  guint8 * code.7311;
  guint8 * code.7312;
  int D.47903;
  int D.47904;
  signed char D.47905;
  signed char D.47906;
  unsigned char D.47907;
  guint8 * code.7313;
  unsigned char D.47909;
  guint8 * code.7314;
  unsigned char D.47911;
  guint8 * code.7315;
  unsigned char D.47913;
  guint8 * code.7316;
  unsigned char D.47915;
  guint8 * D.47916;
  static const char __PRETTY_FUNCTION__[22] = "mono_x86_emit_tls_set";

  code.7308 = code;
  code = code.7308 + 1;
  *code.7308 = 101;
  switch (4) <default: <D.24574>, case 1: <D.24570>, case 2: <D.24572>, case 4: <D.24573>>
  <D.24570>:
  code.7309 = code;
  code = code.7309 + 1;
  *code.7309 = 136;
  goto <D.24571>;
  <D.24572>:
  code.7310 = code;
  code = code.7310 + 1;
  *code.7310 = 102;
  <D.24573>:
  code.7311 = code;
  code = code.7311 + 1;
  *code.7311 = 137;
  goto <D.24571>;
  <D.24574>:
  __assert_fail ("0", "mini-x86.c", 2353, &__PRETTY_FUNCTION__);
  <D.24571>:
  code.7312 = code;
  code = code.7312 + 1;
  D.47903 = sreg & 7;
  D.47904 = D.47903 << 3;
  D.47905 = (signed char) D.47904;
  D.47906 = D.47905 | 5;
  D.47907 = (unsigned char) D.47906;
  *code.7312 = D.47907;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.7313 = code;
        code = code.7313 + 1;
        D.47909 = imb.b[0];
        *code.7313 = D.47909;
        code.7314 = code;
        code = code.7314 + 1;
        D.47911 = imb.b[1];
        *code.7314 = D.47911;
        code.7315 = code;
        code = code.7315 + 1;
        D.47913 = imb.b[2];
        *code.7315 = D.47913;
        code.7316 = code;
        code = code.7316 + 1;
        D.47915 = imb.b[3];
        *code.7316 = D.47915;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.47916 = code;
  return D.47916;
}


emit_tls_set_reg (guint8 * code, int sreg, int offset_reg)
{
  guint8 * code.7317;
  guint8 * code.7318;
  guint8 * code.7319;
  guint8 * code.7320;
  guint8 * code.7321;
  int D.47927;
  int D.47928;
  signed char D.47929;
  signed char D.47930;
  unsigned char D.47931;
  guint8 * code.7322;
  guint8 * code.7323;
  signed char D.47937;
  unsigned char D.47938;
  guint8 * code.7324;
  guint8 * code.7325;
  signed char D.47942;
  unsigned char D.47943;
  guint8 * code.7326;
  guint8 * code.7327;
  unsigned char D.47946;
  guint8 * code.7328;
  unsigned char D.47948;
  guint8 * code.7329;
  unsigned char D.47950;
  guint8 * code.7330;
  unsigned char D.47952;
  guint8 * code.7331;
  signed char D.47956;
  signed char D.47957;
  signed char D.47958;
  unsigned char D.47959;
  guint8 * code.7332;
  signed char D.47963;
  signed char D.47964;
  unsigned char D.47965;
  guint8 * code.7333;
  signed char D.47968;
  signed char D.47969;
  unsigned char D.47970;
  guint8 * code.7334;
  unsigned char D.47972;
  guint8 * code.7335;
  unsigned char D.47974;
  guint8 * code.7336;
  unsigned char D.47976;
  guint8 * code.7337;
  unsigned char D.47978;
  guint8 * D.47979;
  static const char __PRETTY_FUNCTION__[17] = "emit_tls_set_reg";

  code.7317 = code;
  code = code.7317 + 1;
  *code.7317 = 101;
  switch (4) <default: <D.24636>, case 1: <D.24632>, case 2: <D.24634>, case 4: <D.24635>>
  <D.24632>:
  code.7318 = code;
  code = code.7318 + 1;
  *code.7318 = 136;
  goto <D.24633>;
  <D.24634>:
  code.7319 = code;
  code = code.7319 + 1;
  *code.7319 = 102;
  <D.24635>:
  code.7320 = code;
  code = code.7320 + 1;
  *code.7320 = 137;
  goto <D.24633>;
  <D.24636>:
  __assert_fail ("0", "mini-x86.c", 2429, &__PRETTY_FUNCTION__);
  <D.24633>:
  if (offset_reg == 4) goto <D.47922>; else goto <D.47923>;
  <D.47922>:
  if (1 != 0) goto <D.47924>; else goto <D.47925>;
  <D.47924>:
  code.7321 = code;
  code = code.7321 + 1;
  D.47927 = sreg & 7;
  D.47928 = D.47927 << 3;
  D.47929 = (signed char) D.47928;
  D.47930 = D.47929 | 4;
  D.47931 = (unsigned char) D.47930;
  *code.7321 = D.47931;
  code.7322 = code;
  code = code.7322 + 1;
  *code.7322 = 36;
  goto <D.47933>;
  <D.47925>:
  if (1 != 0) goto <D.47934>; else goto <D.47935>;
  <D.47934>:
  code.7323 = code;
  code = code.7323 + 1;
  D.47927 = sreg & 7;
  D.47928 = D.47927 << 3;
  D.47929 = (signed char) D.47928;
  D.47937 = D.47929 | 68;
  D.47938 = (unsigned char) D.47937;
  *code.7323 = D.47938;
  code.7324 = code;
  code = code.7324 + 1;
  *code.7324 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47940>;
  <D.47935>:
  code.7325 = code;
  code = code.7325 + 1;
  D.47927 = sreg & 7;
  D.47928 = D.47927 << 3;
  D.47929 = (signed char) D.47928;
  D.47942 = D.47929 | -124;
  D.47943 = (unsigned char) D.47942;
  *code.7325 = D.47943;
  code.7326 = code;
  code = code.7326 + 1;
  *code.7326 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7327 = code;
        code = code.7327 + 1;
        D.47946 = imb.b[0];
        *code.7327 = D.47946;
        code.7328 = code;
        code = code.7328 + 1;
        D.47948 = imb.b[1];
        *code.7328 = D.47948;
        code.7329 = code;
        code = code.7329 + 1;
        D.47950 = imb.b[2];
        *code.7329 = D.47950;
        code.7330 = code;
        code = code.7330 + 1;
        D.47952 = imb.b[3];
        *code.7330 = D.47952;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47940>:
  <D.47933>:
  goto <D.24639>;
  <D.47923>:
  if (offset_reg != 5) goto <D.47953>; else goto <D.47954>;
  <D.47953>:
  code.7331 = code;
  code = code.7331 + 1;
  D.47927 = sreg & 7;
  D.47928 = D.47927 << 3;
  D.47929 = (signed char) D.47928;
  D.47956 = (signed char) offset_reg;
  D.47957 = D.47956 & 7;
  D.47958 = D.47929 | D.47957;
  D.47959 = (unsigned char) D.47958;
  *code.7331 = D.47959;
  goto <D.24639>;
  <D.47954>:
  if (1 != 0) goto <D.47960>; else goto <D.47961>;
  <D.47960>:
  code.7332 = code;
  code = code.7332 + 1;
  D.47927 = sreg & 7;
  D.47928 = D.47927 << 3;
  D.47929 = (signed char) D.47928;
  D.47963 = D.47929 | 64;
  D.47956 = (signed char) offset_reg;
  D.47957 = D.47956 & 7;
  D.47964 = D.47963 | D.47957;
  D.47965 = (unsigned char) D.47964;
  *code.7332 = D.47965;
  *code = 0;
  code = code + 1;
  goto <D.47966>;
  <D.47961>:
  code.7333 = code;
  code = code.7333 + 1;
  D.47927 = sreg & 7;
  D.47928 = D.47927 << 3;
  D.47929 = (signed char) D.47928;
  D.47968 = D.47929 | -128;
  D.47956 = (signed char) offset_reg;
  D.47957 = D.47956 & 7;
  D.47969 = D.47968 | D.47957;
  D.47970 = (unsigned char) D.47969;
  *code.7333 = D.47970;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7334 = code;
        code = code.7334 + 1;
        D.47972 = imb.b[0];
        *code.7334 = D.47972;
        code.7335 = code;
        code = code.7335 + 1;
        D.47974 = imb.b[1];
        *code.7335 = D.47974;
        code.7336 = code;
        code = code.7336 + 1;
        D.47976 = imb.b[2];
        *code.7336 = D.47976;
        code.7337 = code;
        code = code.7337 + 1;
        D.47978 = imb.b[3];
        *code.7337 = D.47978;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47966>:
  <D.24639>:
  D.47979 = code;
  return D.47979;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.47981;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 8);
  new_list->data = data;
  new_list->next = list;
  D.47981 = new_list;
  return D.47981;
}


mono_arch_register_lowlevel_calls ()
{

}


mono_arch_patch_code (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * ji, struct MonoCodeManager * dyn_code_mp, gboolean run_cctors)
{
  _Bool D.47983;
  int D.47984;
  sizetype D.47985;
  <unnamed type> D.47988;
  int code.7338;
  guint8 * code.7339;
  guint8 * code.7340;
  unsigned char D.47992;
  guint8 * code.7341;
  unsigned char D.47994;
  guint8 * code.7342;
  unsigned char D.47996;
  guint8 * code.7343;
  unsigned char D.47998;
  unsigned char D.47999;
  int D.48000;
  unsigned char D.48001;
  unsigned char D.48002;
  int target.7344;
  int pos.7345;
  int D.48009;
  unsigned char * pos.7346;
  unsigned char D.48011;
  unsigned char * pos.7347;
  unsigned char D.48013;
  unsigned char * pos.7348;
  unsigned char D.48015;
  unsigned char * pos.7349;
  unsigned char D.48017;
  unsigned int disp.7350;
  unsigned int D.48020;
  unsigned char D.48023;
  unsigned char D.48024;
  unsigned char D.48026;
  unsigned char D.48027;
  int pos.7351;
  int D.48033;
  unsigned char * pos.7352;
  unsigned char D.48035;
  unsigned char * pos.7353;
  unsigned char D.48037;
  unsigned char * pos.7354;
  unsigned char D.48039;
  unsigned char * pos.7355;
  unsigned char D.48041;
  unsigned int disp.7356;
  unsigned int D.48044;
  unsigned char D.48047;
  unsigned char D.48048;
  const void * * D.48050;
  const void * * D.48051;
  struct MonoJumpInfo * patch_info;
  gboolean compile_aot;
  static const char __PRETTY_FUNCTION__[21] = "mono_arch_patch_code";

  D.47983 = run_cctors == 0;
  compile_aot = (gboolean) D.47983;
  patch_info = ji;
  goto <D.28569>;
  <D.28568>:
  {
    unsigned char * ip;
    const unsigned char * target;

    D.47984 = patch_info->ip.i;
    D.47985 = (sizetype) D.47984;
    ip = code + D.47985;
    if (compile_aot != 0) goto <D.47986>; else goto <D.47987>;
    <D.47986>:
    D.47988 = patch_info->type;
    switch (D.47988) <default: <D.28484>, case 0: <D.28481>, case 2: <D.28482>>
    <D.28481>:
    <D.28482>:
    goto <D.28483>;
    <D.28484>:
    // predicted unlikely by continue predictor.
    goto <D.28485>;
    <D.28483>:
    <D.47987>:
    target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
    D.47988 = patch_info->type;
    switch (D.47988) <default: <D.28566>, case 0: <D.28526>, case 1: <D.28522>, case 2: <D.28527>, case 3: <D.28523>, case 4: <D.28524>, case 7: <D.28525>, case 15: <D.28488>, case 20: <D.28563>, case 21: <D.28564>, case 22: <D.28486>, case 32: <D.28532>, case 35: <D.28528>, case 36: <D.28529>, case 37: <D.28530>, case 38: <D.28531>, case 51: <D.28562>>
    <D.28486>:
    MEM[(const void * *)ip] = target;
    goto <D.28487>;
    <D.28488>:
    {
      guint8 * code;

      code = ip;
      {
        int _x86_offset;

        code.7338 = (int) code;
        _x86_offset = -code.7338;
        _x86_offset = _x86_offset + -5;
        code.7339 = code;
        code = code.7339 + 1;
        *code.7339 = 232;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = _x86_offset;
              code.7340 = code;
              code = code.7340 + 1;
              D.47992 = imb.b[0];
              *code.7340 = D.47992;
              code.7341 = code;
              code = code.7341 + 1;
              D.47994 = imb.b[1];
              *code.7341 = D.47994;
              code.7342 = code;
              code = code.7342 + 1;
              D.47996 = imb.b[2];
              *code.7342 = D.47996;
              code.7343 = code;
              code = code.7343 + 1;
              D.47998 = imb.b[3];
              *code.7343 = D.47998;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
      }
      {
        unsigned char * pos;
        int disp;
        int size;

        pos = ip + 1;
        size = 0;
        D.47999 = *ip;
        D.48000 = (int) D.47999;
        switch (D.48000) <default: <D.28520>, case 15: <D.28498>, case 112: <D.28504>, case 113: <D.28505>, case 114: <D.28506>, case 115: <D.28507>, case 116: <D.28508>, case 117: <D.28509>, case 118: <D.28510>, case 119: <D.28511>, case 120: <D.28512>, case 121: <D.28513>, case 122: <D.28514>, case 123: <D.28515>, case 124: <D.28516>, case 125: <D.28517>, case 126: <D.28518>, case 127: <D.28519>, case 224: <D.28500>, case 225: <D.28501>, case 226: <D.28502>, case 232: <D.28495>, case 233: <D.28496>, case 235: <D.28503>>
        <D.28495>:
        <D.28496>:
        size = size + 1;
        goto <D.28497>;
        <D.28498>:
        D.48001 = *pos;
        D.48002 = D.48001 + 144;
        if (D.48002 > 31) goto <D.48003>; else goto <D.48004>;
        <D.48003>:
        __assert_fail ("0", "mini-x86.c", 5185, &__PRETTY_FUNCTION__);
        <D.48004>:
        size = size + 1;
        pos = pos + 1;
        goto <D.28497>;
        <D.28500>:
        <D.28501>:
        <D.28502>:
        <D.28503>:
        <D.28504>:
        <D.28505>:
        <D.28506>:
        <D.28507>:
        <D.28508>:
        <D.28509>:
        <D.28510>:
        <D.28511>:
        <D.28512>:
        <D.28513>:
        <D.28514>:
        <D.28515>:
        <D.28516>:
        <D.28517>:
        <D.28518>:
        <D.28519>:
        goto <D.28497>;
        <D.28520>:
        __assert_fail ("0", "mini-x86.c", 5185, &__PRETTY_FUNCTION__);
        <D.28497>:
        target.7344 = (int) target;
        pos.7345 = (int) pos;
        disp = target.7344 - pos.7345;
        if (size != 0) goto <D.48007>; else goto <D.48008>;
        <D.48007>:
        {
          union x86_imm_buf imb;

          try
            {
              D.48009 = disp + -4;
              imb.val = D.48009;
              pos.7346 = pos;
              pos = pos.7346 + 1;
              D.48011 = imb.b[0];
              *pos.7346 = D.48011;
              pos.7347 = pos;
              pos = pos.7347 + 1;
              D.48013 = imb.b[1];
              *pos.7347 = D.48013;
              pos.7348 = pos;
              pos = pos.7348 + 1;
              D.48015 = imb.b[2];
              *pos.7348 = D.48015;
              pos.7349 = pos;
              pos = pos.7349 + 1;
              D.48017 = imb.b[3];
              *pos.7349 = D.48017;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.48018>;
        <D.48008>:
        disp.7350 = (unsigned int) disp;
        D.48020 = disp.7350 + 127;
        if (D.48020 <= 255) goto <D.48021>; else goto <D.48022>;
        <D.48021>:
        D.48023 = (unsigned char) disp;
        D.48024 = D.48023 + 255;
        *pos = D.48024;
        pos = pos + 1;
        goto <D.48025>;
        <D.48022>:
        __assert_fail ("0", "mini-x86.c", 5185, &__PRETTY_FUNCTION__);
        <D.48025>:
        <D.48018>:
      }
      goto <D.28487>;
    }
    <D.28522>:
    <D.28523>:
    <D.28524>:
    <D.28525>:
    <D.28526>:
    <D.28527>:
    <D.28528>:
    <D.28529>:
    <D.28530>:
    <D.28531>:
    <D.28532>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = ip + 1;
      size = 0;
      D.47999 = *ip;
      D.48000 = (int) D.47999;
      switch (D.48000) <default: <D.28560>, case 15: <D.28539>, case 112: <D.28544>, case 113: <D.28545>, case 114: <D.28546>, case 115: <D.28547>, case 116: <D.28548>, case 117: <D.28549>, case 118: <D.28550>, case 119: <D.28551>, case 120: <D.28552>, case 121: <D.28553>, case 122: <D.28554>, case 123: <D.28555>, case 124: <D.28556>, case 125: <D.28557>, case 126: <D.28558>, case 127: <D.28559>, case 224: <D.28540>, case 225: <D.28541>, case 226: <D.28542>, case 232: <D.28536>, case 233: <D.28537>, case 235: <D.28543>>
      <D.28536>:
      <D.28537>:
      size = size + 1;
      goto <D.28538>;
      <D.28539>:
      D.48026 = *pos;
      D.48027 = D.48026 + 144;
      if (D.48027 > 31) goto <D.48028>; else goto <D.48029>;
      <D.48028>:
      __assert_fail ("0", "mini-x86.c", 5221, &__PRETTY_FUNCTION__);
      <D.48029>:
      size = size + 1;
      pos = pos + 1;
      goto <D.28538>;
      <D.28540>:
      <D.28541>:
      <D.28542>:
      <D.28543>:
      <D.28544>:
      <D.28545>:
      <D.28546>:
      <D.28547>:
      <D.28548>:
      <D.28549>:
      <D.28550>:
      <D.28551>:
      <D.28552>:
      <D.28553>:
      <D.28554>:
      <D.28555>:
      <D.28556>:
      <D.28557>:
      <D.28558>:
      <D.28559>:
      goto <D.28538>;
      <D.28560>:
      __assert_fail ("0", "mini-x86.c", 5221, &__PRETTY_FUNCTION__);
      <D.28538>:
      target.7344 = (int) target;
      pos.7351 = (int) pos;
      disp = target.7344 - pos.7351;
      if (size != 0) goto <D.48031>; else goto <D.48032>;
      <D.48031>:
      {
        union x86_imm_buf imb;

        try
          {
            D.48033 = disp + -4;
            imb.val = D.48033;
            pos.7352 = pos;
            pos = pos.7352 + 1;
            D.48035 = imb.b[0];
            *pos.7352 = D.48035;
            pos.7353 = pos;
            pos = pos.7353 + 1;
            D.48037 = imb.b[1];
            *pos.7353 = D.48037;
            pos.7354 = pos;
            pos = pos.7354 + 1;
            D.48039 = imb.b[2];
            *pos.7354 = D.48039;
            pos.7355 = pos;
            pos = pos.7355 + 1;
            D.48041 = imb.b[3];
            *pos.7355 = D.48041;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.48042>;
      <D.48032>:
      disp.7356 = (unsigned int) disp;
      D.48044 = disp.7356 + 127;
      if (D.48044 <= 255) goto <D.48045>; else goto <D.48046>;
      <D.48045>:
      D.48047 = (unsigned char) disp;
      D.48048 = D.48047 + 255;
      *pos = D.48048;
      pos = pos + 1;
      goto <D.48049>;
      <D.48046>:
      __assert_fail ("0", "mini-x86.c", 5221, &__PRETTY_FUNCTION__);
      <D.48049>:
      <D.48042>:
    }
    goto <D.28487>;
    <D.28562>:
    goto <D.28487>;
    <D.28563>:
    <D.28564>:
    {
      guint32 offset;

      offset = mono_arch_get_patch_offset (ip);
      D.48050 = ip + offset;
      *D.48050 = target;
      goto <D.28487>;
    }
    <D.28566>:
    {
      guint32 offset;

      offset = mono_arch_get_patch_offset (ip);
      D.48051 = ip + offset;
      *D.48051 = target;
      goto <D.28487>;
    }
    <D.28487>:
  }
  <D.28485>:
  patch_info = patch_info->next;
  <D.28569>:
  if (patch_info != 0B) goto <D.28568>; else goto <D.28570>;
  <D.28570>:
}


mono_arch_emit_prolog (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.48056;
  unsigned int D.48057;
  unsigned int D.48058;
  unsigned int D.48059;
  unsigned int D.48060;
  unsigned int D.48061;
  unsigned int D.48064;
  unsigned int D.48065;
  void * D.48066;
  int code.7357;
  unsigned char * D.48068;
  int D.48069;
  int D.48070;
  int D.48071;
  guint8 * code.7358;
  unsigned int cfa_offset.7359;
  unsigned int D.48076;
  guint8 * code.7360;
  guint8 * code.7361;
  guint8 * code.7362;
  guint8 * code.7363;
  unsigned char D.48082;
  unsigned char D.48083;
  unsigned int D.48086;
  unsigned int D.48087;
  guint8 * code.7364;
  unsigned int D.48091;
  guint8 * code.7365;
  unsigned int D.48095;
  guint8 * code.7366;
  int mono_do_x86_stack_align.7367;
  int D.48104;
  int D.48109;
  int D.48110;
  unsigned int i.7368;
  unsigned int D.48112;
  guint8 * code.7369;
  guint8 * code.7370;
  unsigned char D.48119;
  guint8 * code.7371;
  unsigned char D.48121;
  guint8 * code.7372;
  unsigned char D.48123;
  guint8 * code.7373;
  unsigned char D.48125;
  unsigned int alloc_size.7374;
  unsigned int D.48127;
  guint8 * code.7375;
  guint8 * code.7376;
  unsigned char D.48132;
  guint8 * code.7377;
  guint8 * code.7378;
  guint8 * code.7379;
  unsigned char D.48137;
  guint8 * code.7380;
  unsigned char D.48139;
  guint8 * code.7381;
  unsigned char D.48141;
  guint8 * code.7382;
  unsigned char D.48143;
  _Bool D.48144;
  long int D.48145;
  long int D.48146;
  struct MonoMethod * D.48149;
  unsigned char D.48150;
  unsigned char D.48151;
  _Bool D.48152;
  _Bool D.48153;
  _Bool D.48154;
  guint8 * code.7383;
  guint8 * code.7384;
  unsigned char D.48161;
  guint8 * code.7385;
  unsigned char D.48163;
  guint8 * code.7386;
  unsigned char D.48165;
  guint8 * code.7387;
  unsigned char D.48167;
  guint8 * code.7388;
  guint8 * code.7389;
  guint8 * code.7390;
  guint8 * code.7391;
  guint8 * code.7392;
  unsigned char D.48176;
  guint8 * code.7393;
  unsigned char D.48178;
  guint8 * code.7394;
  unsigned char D.48180;
  guint8 * code.7395;
  unsigned char D.48182;
  unsigned int D.48183;
  unsigned int D.48184;
  unsigned int D.48187;
  unsigned int D.48190;
  signed char D.48193;
  signed char D.48196;
  short unsigned int D.48199;
  int D.48202;
  int D.48203;
  short unsigned int D.48204;
  sizetype D.48205;
  sizetype D.48206;
  guint8 * D.48207;
  unsigned char D.48208;
  int D.48209;
  struct MonoInst * D.48210;
  int iftmp.7396;
  short unsigned int D.48217;
  int D.48219;
  _Bool D.48220;
  long int D.48221;
  long int D.48222;
  guint8 * code.7397;
  guint8 * code.7398;
  guint8 * code.7399;
  int D.48230;
  guint8 * code.7400;
  guint8 * code.7401;
  unsigned int D.48236;
  unsigned int D.48237;
  guint8 * code.7402;
  guint8 * code.7403;
  unsigned char D.48242;
  guint8 * code.7404;
  guint8 * code.7405;
  guint8 * code.7406;
  unsigned char D.48247;
  guint8 * code.7407;
  unsigned char D.48249;
  guint8 * code.7408;
  unsigned char D.48251;
  guint8 * code.7409;
  unsigned char D.48253;
  guint8 * code.7410;
  guint8 * code.7411;
  guint8 * code.7412;
  guint8 * code.7413;
  unsigned char D.48263;
  guint8 * code.7414;
  unsigned char D.48265;
  guint8 * code.7415;
  unsigned char D.48267;
  guint8 * code.7416;
  unsigned char D.48269;
  struct MonoInst * D.48272;
  int D.48273;
  unsigned char D.48274;
  unsigned char D.48275;
  struct MonoTraceSpec * mono_jit_trace_calls.7417;
  int D.48281;
  struct MonoInst * * D.48284;
  unsigned int pos.7418;
  unsigned int D.48286;
  struct MonoInst * * D.48287;
  short unsigned int D.48288;
  guint8 * code.7419;
  guint8 * code.7420;
  guint8 * code.7421;
  int D.48298;
  guint8 * code.7422;
  int D.48302;
  int D.48303;
  int D.48304;
  signed char D.48305;
  signed char D.48306;
  unsigned char D.48307;
  guint8 * code.7423;
  unsigned int D.48310;
  unsigned int D.48311;
  guint8 * code.7424;
  signed char D.48315;
  unsigned char D.48316;
  guint8 * code.7425;
  unsigned char D.48318;
  guint8 * code.7426;
  signed char D.48321;
  unsigned char D.48322;
  guint8 * code.7427;
  guint8 * code.7428;
  unsigned char D.48325;
  guint8 * code.7429;
  unsigned char D.48327;
  guint8 * code.7430;
  unsigned char D.48329;
  guint8 * code.7431;
  unsigned char D.48331;
  guint8 * code.7432;
  signed char D.48335;
  unsigned char D.48336;
  guint8 * code.7433;
  signed char D.48340;
  unsigned char D.48341;
  guint8 * code.7434;
  signed char D.48344;
  unsigned char D.48345;
  guint8 * code.7435;
  unsigned char D.48347;
  guint8 * code.7436;
  unsigned char D.48349;
  guint8 * code.7437;
  unsigned char D.48351;
  guint8 * code.7438;
  unsigned char D.48353;
  unsigned int D.48354;
  const char * D.48357;
  short unsigned int D.48358;
  int D.48359;
  <unnamed-unsigned:1> D.48360;
  int D.48361;
  int D.48362;
  unsigned int D.48363;
  unsigned int D.48364;
  _Bool D.48365;
  long int D.48366;
  long int D.48367;
  guint8 * D.48370;
  struct MonoMethod * method;
  struct MonoBasicBlock * bb;
  struct MonoMethodSignature * sig;
  struct MonoInst * inst;
  int alloc_size;
  int pos;
  int max_offset;
  int i;
  int cfa_offset;
  guint8 * code;
  gboolean need_stack_frame;
  static const char __PRETTY_FUNCTION__[22] = "mono_arch_emit_prolog";

  method = cfg->method;
  D.48056 = cfg->header;
  D.48057 = D.48056->code_size;
  D.48058 = D.48057 * 4;
  D.48059 = MAX_EXPR <D.48058, 10240>;
  cfg->code_size = D.48059;
  D.48060 = cfg->prof_options;
  D.48061 = D.48060 & 4096;
  if (D.48061 != 0) goto <D.48062>; else goto <D.48063>;
  <D.48062>:
  D.48064 = cfg->code_size;
  D.48065 = D.48064 + 512;
  cfg->code_size = D.48065;
  <D.48063>:
  D.48064 = cfg->code_size;
  D.48066 = monoeg_malloc (D.48064);
  cfg->native_code = D.48066;
  code = cfg->native_code;
  cfa_offset = 0;
  cfa_offset = 4;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 12, 4, 4);
  cfg->cfa_reg = 4;
  cfg->cfa_offset = 4;
  D.48071 = -cfa_offset;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 128, 8, D.48071);
  D.48071 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.48071, 0);
  need_stack_frame = needs_stack_frame (cfg);
  if (need_stack_frame != 0) goto <D.48072>; else goto <D.48073>;
  <D.48072>:
  code.7358 = code;
  code = code.7358 + 1;
  *code.7358 = 85;
  cfa_offset.7359 = (unsigned int) cfa_offset;
  D.48076 = cfa_offset.7359 + 4;
  cfa_offset = (int) D.48076;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 14, 0, cfa_offset);
  cfg->cfa_offset = cfa_offset;
  D.48071 = -cfa_offset;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 128, 5, D.48071);
  switch (4) <default: <D.28593>, case 1: <D.28589>, case 2: <D.28591>, case 4: <D.28592>>
  <D.28589>:
  code.7360 = code;
  code = code.7360 + 1;
  *code.7360 = 138;
  goto <D.28590>;
  <D.28591>:
  code.7361 = code;
  code = code.7361 + 1;
  *code.7361 = 102;
  <D.28592>:
  code.7362 = code;
  code = code.7362 + 1;
  *code.7362 = 139;
  goto <D.28590>;
  <D.28593>:
  __assert_fail ("0", "mini-x86.c", 5324, &__PRETTY_FUNCTION__);
  <D.28590>:
  code.7363 = code;
  code = code.7363 + 1;
  *code.7363 = 236;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 13, 5, 0);
  cfg->cfa_reg = 5;
  D.48071 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.48071, 0);
  goto <D.48081>;
  <D.48073>:
  cfg->frame_reg = 4;
  <D.48081>:
  alloc_size = cfg->stack_offset;
  pos = 0;
  D.48082 = BIT_FIELD_REF <*method, 8, 168>;
  D.48083 = D.48082 & 1;
  if (D.48083 == 0) goto <D.48084>; else goto <D.48085>;
  <D.48084>:
  D.48086 = cfg->used_int_regs;
  D.48087 = D.48086 & 8;
  if (D.48087 != 0) goto <D.48088>; else goto <D.48089>;
  <D.48088>:
  code.7364 = code;
  code = code.7364 + 1;
  *code.7364 = 83;
  pos = pos + 4;
  cfa_offset.7359 = (unsigned int) cfa_offset;
  D.48076 = cfa_offset.7359 + 4;
  cfa_offset = (int) D.48076;
  D.48071 = -cfa_offset;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 128, 3, D.48071);
  D.48071 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.48071, 0);
  <D.48089>:
  D.48086 = cfg->used_int_regs;
  D.48091 = D.48086 & 128;
  if (D.48091 != 0) goto <D.48092>; else goto <D.48093>;
  <D.48092>:
  code.7365 = code;
  code = code.7365 + 1;
  *code.7365 = 87;
  pos = pos + 4;
  cfa_offset.7359 = (unsigned int) cfa_offset;
  D.48076 = cfa_offset.7359 + 4;
  cfa_offset = (int) D.48076;
  D.48071 = -cfa_offset;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 128, 7, D.48071);
  D.48071 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.48071, 0);
  <D.48093>:
  D.48086 = cfg->used_int_regs;
  D.48095 = D.48086 & 64;
  if (D.48095 != 0) goto <D.48096>; else goto <D.48097>;
  <D.48096>:
  code.7366 = code;
  code = code.7366 + 1;
  *code.7366 = 86;
  pos = pos + 4;
  cfa_offset.7359 = (unsigned int) cfa_offset;
  D.48076 = cfa_offset.7359 + 4;
  cfa_offset = (int) D.48076;
  D.48071 = -cfa_offset;
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  mono_emit_unwind_op (cfg, D.48070, 128, 6, D.48071);
  D.48071 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.48071, 0);
  <D.48097>:
  <D.48085>:
  alloc_size = alloc_size - pos;
  mono_do_x86_stack_align.7367 = mono_do_x86_stack_align;
  if (mono_do_x86_stack_align.7367 != 0) goto <D.48100>; else goto <D.48101>;
  <D.48100>:
  if (need_stack_frame != 0) goto <D.48102>; else goto <D.48103>;
  <D.48102>:
  {
    int tot;

    D.48104 = alloc_size + pos;
    tot = D.48104 + 4;
    if (need_stack_frame != 0) goto <D.48105>; else goto <D.48106>;
    <D.48105>:
    tot = tot + 4;
    <D.48106>:
    tot = tot & 15;
    if (tot != 0) goto <D.48107>; else goto <D.48108>;
    <D.48107>:
    D.48109 = 16 - tot;
    alloc_size = D.48109 + alloc_size;
    i = 0;
    goto <D.28597>;
    <D.28596>:
    D.48104 = alloc_size + pos;
    D.48110 = i - D.48104;
    mini_gc_set_slot_type_from_fp (cfg, D.48110, 0);
    i.7368 = (unsigned int) i;
    D.48112 = i.7368 + 4;
    i = (int) D.48112;
    <D.28597>:
    D.48109 = 16 - tot;
    if (D.48109 > i) goto <D.28596>; else goto <D.28598>;
    <D.28598>:
    <D.48108>:
  }
  <D.48103>:
  <D.48101>:
  D.48104 = alloc_size + pos;
  cfg->arch.sp_fp_offset = D.48104;
  if (alloc_size != 0) goto <D.48113>; else goto <D.48114>;
  <D.48113>:
  if (0 != 0) goto <D.48115>; else goto <D.48116>;
  <D.48115>:
  code.7369 = code;
  code = code.7369 + 1;
  *code.7369 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = alloc_size;
        code.7370 = code;
        code = code.7370 + 1;
        D.48119 = imb.b[0];
        *code.7370 = D.48119;
        code.7371 = code;
        code = code.7371 + 1;
        D.48121 = imb.b[1];
        *code.7371 = D.48121;
        code.7372 = code;
        code = code.7372 + 1;
        D.48123 = imb.b[2];
        *code.7372 = D.48123;
        code.7373 = code;
        code = code.7373 + 1;
        D.48125 = imb.b[3];
        *code.7373 = D.48125;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.28600>;
  <D.48116>:
  alloc_size.7374 = (unsigned int) alloc_size;
  D.48127 = alloc_size.7374 + 128;
  if (D.48127 <= 255) goto <D.48128>; else goto <D.48129>;
  <D.48128>:
  code.7375 = code;
  code = code.7375 + 1;
  *code.7375 = 131;
  code.7376 = code;
  code = code.7376 + 1;
  *code.7376 = 236;
  D.48132 = (unsigned char) alloc_size;
  *code = D.48132;
  code = code + 1;
  goto <D.48133>;
  <D.48129>:
  code.7377 = code;
  code = code.7377 + 1;
  *code.7377 = 129;
  code.7378 = code;
  code = code.7378 + 1;
  *code.7378 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = alloc_size;
        code.7379 = code;
        code = code.7379 + 1;
        D.48137 = imb.b[0];
        *code.7379 = D.48137;
        code.7380 = code;
        code = code.7380 + 1;
        D.48139 = imb.b[1];
        *code.7380 = D.48139;
        code.7381 = code;
        code = code.7381 + 1;
        D.48141 = imb.b[2];
        *code.7381 = D.48141;
        code.7382 = code;
        code = code.7382 + 1;
        D.48143 = imb.b[3];
        *code.7382 = D.48143;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48133>:
  <D.28600>:
  D.48144 = need_stack_frame == 0;
  D.48145 = (long int) D.48144;
  D.48146 = __builtin_expect (D.48145, 0);
  if (D.48146 != 0) goto <D.48147>; else goto <D.48148>;
  <D.48147>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5404, "need_stack_frame");
  <D.48148>:
  <D.48114>:
  D.48149 = cfg->method;
  D.48150 = BIT_FIELD_REF <*D.48149, 8, 160>;
  D.48151 = D.48150 & 124;
  D.48152 = D.48151 == 20;
  D.48153 = D.48151 == 16;
  D.48154 = D.48152 | D.48153;
  if (D.48154 != 0) goto <D.48155>; else goto <D.48156>;
  <D.48155>:
  if (0 != 0) goto <D.48157>; else goto <D.48158>;
  <D.48157>:
  code.7383 = code;
  code = code.7383 + 1;
  *code.7383 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.7384 = code;
        code = code.7384 + 1;
        D.48161 = imb.b[0];
        *code.7384 = D.48161;
        code.7385 = code;
        code = code.7385 + 1;
        D.48163 = imb.b[1];
        *code.7385 = D.48163;
        code.7386 = code;
        code = code.7386 + 1;
        D.48165 = imb.b[2];
        *code.7386 = D.48165;
        code.7387 = code;
        code = code.7387 + 1;
        D.48167 = imb.b[3];
        *code.7387 = D.48167;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.28603>;
  <D.48158>:
  if (1 != 0) goto <D.48168>; else goto <D.48169>;
  <D.48168>:
  code.7388 = code;
  code = code.7388 + 1;
  *code.7388 = 131;
  code.7389 = code;
  code = code.7389 + 1;
  *code.7389 = 228;
  *code = 240;
  code = code + 1;
  goto <D.48172>;
  <D.48169>:
  code.7390 = code;
  code = code.7390 + 1;
  *code.7390 = 129;
  code.7391 = code;
  code = code.7391 + 1;
  *code.7391 = 228;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.7392 = code;
        code = code.7392 + 1;
        D.48176 = imb.b[0];
        *code.7392 = D.48176;
        code.7393 = code;
        code = code.7393 + 1;
        D.48178 = imb.b[1];
        *code.7393 = D.48178;
        code.7394 = code;
        code = code.7394 + 1;
        D.48180 = imb.b[2];
        *code.7394 = D.48180;
        code.7395 = code;
        code = code.7395 + 1;
        D.48182 = imb.b[3];
        *code.7395 = D.48182;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48172>:
  <D.28603>:
  <D.48156>:
  max_offset = 0;
  D.48183 = cfg->opt;
  D.48184 = D.48183 & 2;
  if (D.48184 != 0) goto <D.48185>; else goto <D.48186>;
  <D.48185>:
  bb = cfg->bb_entry;
  goto <D.28610>;
  <D.28609>:
  {
    struct MonoInst * ins;

    bb->max_offset = max_offset;
    D.48060 = cfg->prof_options;
    D.48187 = D.48060 & 8192;
    if (D.48187 != 0) goto <D.48188>; else goto <D.48189>;
    <D.48188>:
    max_offset = max_offset + 6;
    <D.48189>:
    D.48183 = cfg->opt;
    D.48190 = D.48183 & 8192;
    if (D.48190 != 0) goto <D.48191>; else goto <D.48192>;
    <D.48191>:
    D.48193 = bb->loop_body_start;
    if (D.48193 != 0) goto <D.48194>; else goto <D.48195>;
    <D.48194>:
    D.48196 = bb->nesting;
    if (D.48196 != 0) goto <D.48197>; else goto <D.48198>;
    <D.48197>:
    max_offset = max_offset + 8;
    <D.48198>:
    <D.48195>:
    <D.48192>:
    ins = bb->code;
    goto <D.28607>;
    <D.28606>:
    D.48199 = ins->opcode;
    if (D.48199 == 369) goto <D.48200>; else goto <D.48201>;
    <D.48200>:
    ins->data.op[1].const_val = max_offset;
    <D.48201>:
    D.48199 = ins->opcode;
    D.48202 = (int) D.48199;
    D.48203 = D.48202 + -313;
    D.48204 = x86_desc_idx[D.48203];
    D.48205 = (sizetype) D.48204;
    D.48206 = D.48205 + 4;
    D.48207 = &x86_desc + D.48206;
    D.48208 = *D.48207;
    D.48209 = (int) D.48208;
    max_offset = D.48209 + max_offset;
    ins = ins->next;
    <D.28607>:
    if (ins != 0B) goto <D.28606>; else goto <D.28608>;
    <D.28608>:
  }
  bb = bb->next_bb;
  <D.28610>:
  if (bb != 0B) goto <D.28609>; else goto <D.28611>;
  <D.28611>:
  <D.48186>:
  D.48210 = cfg->rgctx_var;
  if (D.48210 != 0B) goto <D.48211>; else goto <D.48212>;
  <D.48211>:
  D.48210 = cfg->rgctx_var;
  D.48217 = D.48210->opcode;
  if (D.48217 != 367) goto <D.48214>; else goto <D.48218>;
  <D.48218>:
  D.48210 = cfg->rgctx_var;
  D.48219 = D.48210->sreg1;
  if (D.48219 != 5) goto <D.48214>; else goto <D.48215>;
  <D.48214>:
  iftmp.7396 = 1;
  goto <D.48216>;
  <D.48215>:
  iftmp.7396 = 0;
  <D.48216>:
  D.48220 = iftmp.7396 != 0;
  D.48221 = (long int) D.48220;
  D.48222 = __builtin_expect (D.48221, 0);
  if (D.48222 != 0) goto <D.48223>; else goto <D.48224>;
  <D.48223>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5478, "cfg->rgctx_var->opcode == OP_REGOFFSET && cfg->rgctx_var->inst_basereg == X86_EBP");
  <D.48224>:
  switch (4) <default: <D.28616>, case 1: <D.28612>, case 2: <D.28614>, case 4: <D.28615>>
  <D.28612>:
  code.7397 = code;
  code = code.7397 + 1;
  *code.7397 = 136;
  goto <D.28613>;
  <D.28614>:
  code.7398 = code;
  code = code.7398 + 1;
  *code.7398 = 102;
  <D.28615>:
  code.7399 = code;
  code = code.7399 + 1;
  *code.7399 = 137;
  goto <D.28613>;
  <D.28616>:
  __assert_fail ("0", "mini-x86.c", 5480, &__PRETTY_FUNCTION__);
  <D.28613>:
  if (0 != 0) goto <D.48228>; else goto <D.48229>;
  <D.48228>:
  D.48210 = cfg->rgctx_var;
  D.48230 = D.48210->data.op[0].const_val;
  if (D.48230 == 0) goto <D.48231>; else goto <D.48232>;
  <D.48231>:
  code.7400 = code;
  code = code.7400 + 1;
  *code.7400 = 20;
  code.7401 = code;
  code = code.7401 + 1;
  *code.7401 = 36;
  goto <D.48235>;
  <D.48232>:
  D.48210 = cfg->rgctx_var;
  D.48230 = D.48210->data.op[0].const_val;
  D.48236 = (unsigned int) D.48230;
  D.48237 = D.48236 + 128;
  if (D.48237 <= 255) goto <D.48238>; else goto <D.48239>;
  <D.48238>:
  code.7402 = code;
  code = code.7402 + 1;
  *code.7402 = 84;
  code.7403 = code;
  code = code.7403 + 1;
  *code.7403 = 36;
  D.48210 = cfg->rgctx_var;
  D.48230 = D.48210->data.op[0].const_val;
  D.48242 = (unsigned char) D.48230;
  *code = D.48242;
  code = code + 1;
  goto <D.48243>;
  <D.48239>:
  code.7404 = code;
  code = code.7404 + 1;
  *code.7404 = 148;
  code.7405 = code;
  code = code.7405 + 1;
  *code.7405 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.48210 = cfg->rgctx_var;
        D.48230 = D.48210->data.op[0].const_val;
        imb.val = D.48230;
        code.7406 = code;
        code = code.7406 + 1;
        D.48247 = imb.b[0];
        *code.7406 = D.48247;
        code.7407 = code;
        code = code.7407 + 1;
        D.48249 = imb.b[1];
        *code.7407 = D.48249;
        code.7408 = code;
        code = code.7408 + 1;
        D.48251 = imb.b[2];
        *code.7408 = D.48251;
        code.7409 = code;
        code = code.7409 + 1;
        D.48253 = imb.b[3];
        *code.7409 = D.48253;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48243>:
  <D.48235>:
  goto <D.28618>;
  <D.48229>:
  if (0 != 0) goto <D.48254>; else goto <D.48255>;
  <D.48254>:
  code.7410 = code;
  code = code.7410 + 1;
  *code.7410 = 21;
  goto <D.28618>;
  <D.48255>:
  D.48210 = cfg->rgctx_var;
  D.48230 = D.48210->data.op[0].const_val;
  D.48236 = (unsigned int) D.48230;
  D.48237 = D.48236 + 128;
  if (D.48237 <= 255) goto <D.48257>; else goto <D.48258>;
  <D.48257>:
  code.7411 = code;
  code = code.7411 + 1;
  *code.7411 = 85;
  D.48210 = cfg->rgctx_var;
  D.48230 = D.48210->data.op[0].const_val;
  D.48242 = (unsigned char) D.48230;
  *code = D.48242;
  code = code + 1;
  goto <D.48260>;
  <D.48258>:
  code.7412 = code;
  code = code.7412 + 1;
  *code.7412 = 149;
  {
    union x86_imm_buf imb;

    try
      {
        D.48210 = cfg->rgctx_var;
        D.48230 = D.48210->data.op[0].const_val;
        imb.val = D.48230;
        code.7413 = code;
        code = code.7413 + 1;
        D.48263 = imb.b[0];
        *code.7413 = D.48263;
        code.7414 = code;
        code = code.7414 + 1;
        D.48265 = imb.b[1];
        *code.7414 = D.48265;
        code.7415 = code;
        code = code.7415 + 1;
        D.48267 = imb.b[2];
        *code.7415 = D.48267;
        code.7416 = code;
        code = code.7416 + 1;
        D.48269 = imb.b[3];
        *code.7416 = D.48269;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48260>:
  <D.28618>:
  <D.48212>:
  D.48082 = BIT_FIELD_REF <*method, 8, 168>;
  D.48083 = D.48082 & 1;
  if (D.48083 != 0) goto <D.48270>; else goto <D.48271>;
  <D.48270>:
  D.48272 = cfg->lmf_var;
  D.48273 = D.48272->data.op[0].const_val;
  code = emit_setup_lmf (cfg, code, D.48273, cfa_offset);
  D.48274 = BIT_FIELD_REF <*cfg, 8, 3416>;
  D.48275 = D.48274 & 4;
  if (D.48275 == 0) goto <D.48276>; else goto <D.48277>;
  <D.48276>:
  D.48272 = cfg->lmf_var;
  D.48273 = D.48272->data.op[0].const_val;
  code = emit_push_lmf (cfg, code, D.48273);
  <D.48277>:
  <D.48271>:
  mono_jit_trace_calls.7417 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.7417 != 0B) goto <D.48279>; else goto <D.48280>;
  <D.48279>:
  D.48281 = mono_trace_eval (method);
  if (D.48281 != 0) goto <D.48282>; else goto <D.48283>;
  <D.48282>:
  code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, 1);
  <D.48283>:
  <D.48280>:
  sig = mono_method_signature (method);
  pos = 0;
  i = 0;
  goto <D.28629>;
  <D.28628>:
  D.48284 = cfg->args;
  pos.7418 = (unsigned int) pos;
  D.48286 = pos.7418 * 4;
  D.48287 = D.48284 + D.48286;
  inst = *D.48287;
  D.48288 = inst->opcode;
  if (D.48288 == 366) goto <D.48289>; else goto <D.48290>;
  <D.48289>:
  D.48144 = need_stack_frame == 0;
  D.48145 = (long int) D.48144;
  D.48146 = __builtin_expect (D.48145, 0);
  if (D.48146 != 0) goto <D.48291>; else goto <D.48292>;
  <D.48291>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5499, "need_stack_frame");
  <D.48292>:
  switch (4) <default: <D.28624>, case 1: <D.28620>, case 2: <D.28622>, case 4: <D.28623>>
  <D.28620>:
  code.7419 = code;
  code = code.7419 + 1;
  *code.7419 = 138;
  goto <D.28621>;
  <D.28622>:
  code.7420 = code;
  code = code.7420 + 1;
  *code.7420 = 102;
  <D.28623>:
  code.7421 = code;
  code = code.7421 + 1;
  *code.7421 = 139;
  goto <D.28621>;
  <D.28624>:
  __assert_fail ("0", "mini-x86.c", 5500, &__PRETTY_FUNCTION__);
  <D.28621>:
  if (0 != 0) goto <D.48296>; else goto <D.48297>;
  <D.48296>:
  D.48298 = inst->data.op[0].const_val;
  if (D.48298 == 0) goto <D.48299>; else goto <D.48300>;
  <D.48299>:
  code.7422 = code;
  code = code.7422 + 1;
  D.48302 = inst->dreg;
  D.48303 = D.48302 & 7;
  D.48304 = D.48303 << 3;
  D.48305 = (signed char) D.48304;
  D.48306 = D.48305 | 4;
  D.48307 = (unsigned char) D.48306;
  *code.7422 = D.48307;
  code.7423 = code;
  code = code.7423 + 1;
  *code.7423 = 36;
  goto <D.48309>;
  <D.48300>:
  D.48298 = inst->data.op[0].const_val;
  D.48310 = (unsigned int) D.48298;
  D.48311 = D.48310 + 128;
  if (D.48311 <= 255) goto <D.48312>; else goto <D.48313>;
  <D.48312>:
  code.7424 = code;
  code = code.7424 + 1;
  D.48302 = inst->dreg;
  D.48303 = D.48302 & 7;
  D.48304 = D.48303 << 3;
  D.48305 = (signed char) D.48304;
  D.48315 = D.48305 | 68;
  D.48316 = (unsigned char) D.48315;
  *code.7424 = D.48316;
  code.7425 = code;
  code = code.7425 + 1;
  *code.7425 = 36;
  D.48298 = inst->data.op[0].const_val;
  D.48318 = (unsigned char) D.48298;
  *code = D.48318;
  code = code + 1;
  goto <D.48319>;
  <D.48313>:
  code.7426 = code;
  code = code.7426 + 1;
  D.48302 = inst->dreg;
  D.48303 = D.48302 & 7;
  D.48304 = D.48303 << 3;
  D.48305 = (signed char) D.48304;
  D.48321 = D.48305 | -124;
  D.48322 = (unsigned char) D.48321;
  *code.7426 = D.48322;
  code.7427 = code;
  code = code.7427 + 1;
  *code.7427 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.48298 = inst->data.op[0].const_val;
        imb.val = D.48298;
        code.7428 = code;
        code = code.7428 + 1;
        D.48325 = imb.b[0];
        *code.7428 = D.48325;
        code.7429 = code;
        code = code.7429 + 1;
        D.48327 = imb.b[1];
        *code.7429 = D.48327;
        code.7430 = code;
        code = code.7430 + 1;
        D.48329 = imb.b[2];
        *code.7430 = D.48329;
        code.7431 = code;
        code = code.7431 + 1;
        D.48331 = imb.b[3];
        *code.7431 = D.48331;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48319>:
  <D.48309>:
  goto <D.28626>;
  <D.48297>:
  if (0 != 0) goto <D.48332>; else goto <D.48333>;
  <D.48332>:
  code.7432 = code;
  code = code.7432 + 1;
  D.48302 = inst->dreg;
  D.48303 = D.48302 & 7;
  D.48304 = D.48303 << 3;
  D.48305 = (signed char) D.48304;
  D.48335 = D.48305 | 5;
  D.48336 = (unsigned char) D.48335;
  *code.7432 = D.48336;
  goto <D.28626>;
  <D.48333>:
  D.48298 = inst->data.op[0].const_val;
  D.48310 = (unsigned int) D.48298;
  D.48311 = D.48310 + 128;
  if (D.48311 <= 255) goto <D.48337>; else goto <D.48338>;
  <D.48337>:
  code.7433 = code;
  code = code.7433 + 1;
  D.48302 = inst->dreg;
  D.48303 = D.48302 & 7;
  D.48304 = D.48303 << 3;
  D.48305 = (signed char) D.48304;
  D.48340 = D.48305 | 69;
  D.48341 = (unsigned char) D.48340;
  *code.7433 = D.48341;
  D.48298 = inst->data.op[0].const_val;
  D.48318 = (unsigned char) D.48298;
  *code = D.48318;
  code = code + 1;
  goto <D.48342>;
  <D.48338>:
  code.7434 = code;
  code = code.7434 + 1;
  D.48302 = inst->dreg;
  D.48303 = D.48302 & 7;
  D.48304 = D.48303 << 3;
  D.48305 = (signed char) D.48304;
  D.48344 = D.48305 | -123;
  D.48345 = (unsigned char) D.48344;
  *code.7434 = D.48345;
  {
    union x86_imm_buf imb;

    try
      {
        D.48298 = inst->data.op[0].const_val;
        imb.val = D.48298;
        code.7435 = code;
        code = code.7435 + 1;
        D.48347 = imb.b[0];
        *code.7435 = D.48347;
        code.7436 = code;
        code = code.7436 + 1;
        D.48349 = imb.b[1];
        *code.7436 = D.48349;
        code.7437 = code;
        code = code.7437 + 1;
        D.48351 = imb.b[2];
        *code.7437 = D.48351;
        code.7438 = code;
        code = code.7438 + 1;
        D.48353 = imb.b[3];
        *code.7438 = D.48353;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48342>:
  <D.28626>:
  D.48354 = cfg->verbose_level;
  if (D.48354 > 2) goto <D.48355>; else goto <D.48356>;
  <D.48355>:
  D.48302 = inst->dreg;
  D.48357 = mono_arch_regname (D.48302);
  monoeg_g_print ("Argument %d assigned to register %s\n", pos, D.48357);
  <D.48356>:
  <D.48290>:
  pos = pos + 1;
  i = i + 1;
  <D.28629>:
  D.48358 = sig->param_count;
  D.48359 = (int) D.48358;
  D.48360 = sig->hasthis;
  D.48361 = (int) D.48360;
  D.48362 = D.48359 + D.48361;
  if (D.48362 > i) goto <D.28628>; else goto <D.28630>;
  <D.28630>:
  code.7357 = (int) code;
  D.48068 = cfg->native_code;
  D.48069 = (int) D.48068;
  D.48070 = code.7357 - D.48069;
  D.48363 = (unsigned int) D.48070;
  cfg->code_len = D.48363;
  D.48364 = cfg->code_len;
  D.48064 = cfg->code_size;
  D.48365 = D.48364 >= D.48064;
  D.48366 = (long int) D.48365;
  D.48367 = __builtin_expect (D.48366, 0);
  if (D.48367 != 0) goto <D.48368>; else goto <D.48369>;
  <D.48368>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5509, "cfg->code_len < cfg->code_size");
  <D.48369>:
  D.48370 = code;
  return D.48370;
}


needs_stack_frame (struct MonoCompile * cfg)
{
  int D.48372;
  gboolean D.48375;
  struct MonoMethod * D.48376;
  unsigned char D.48377;
  unsigned char D.48378;
  unsigned int D.48382;
  unsigned int D.48383;
  unsigned char D.48387;
  unsigned char D.48388;
  int D.48392;
  unsigned int D.48396;
  unsigned int D.48400;
  short unsigned int D.48404;
  short unsigned int D.48405;
  short unsigned int D.48409;
  int D.48410;
  <unnamed-unsigned:1> D.48411;
  int D.48412;
  int D.48413;
  short unsigned int D.48417;
  short unsigned int D.48418;
  struct MonoTraceSpec * mono_jit_trace_calls.7439;
  int D.48427;
  unsigned int D.48428;
  unsigned int D.48429;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  gboolean result;

  result = 0;
  D.48372 = cfg->arch.need_stack_frame_inited;
  if (D.48372 != 0) goto <D.48373>; else goto <D.48374>;
  <D.48373>:
  D.48375 = cfg->arch.need_stack_frame;
  return D.48375;
  <D.48374>:
  header = cfg->header;
  D.48376 = cfg->method;
  sig = mono_method_signature (D.48376);
  D.48377 = BIT_FIELD_REF <*cfg, 8, 3408>;
  D.48378 = D.48377 & 32;
  if (D.48378 != 0) goto <D.48379>; else goto <D.48380>;
  <D.48379>:
  result = 1;
  goto <D.48381>;
  <D.48380>:
  D.48382 = cfg->flags;
  D.48383 = D.48382 & 1;
  if (D.48383 != 0) goto <D.48384>; else goto <D.48385>;
  <D.48384>:
  result = 1;
  goto <D.48386>;
  <D.48385>:
  D.48376 = cfg->method;
  D.48387 = BIT_FIELD_REF <*D.48376, 8, 168>;
  D.48388 = D.48387 & 1;
  if (D.48388 != 0) goto <D.48389>; else goto <D.48390>;
  <D.48389>:
  result = 1;
  goto <D.48391>;
  <D.48390>:
  D.48392 = cfg->stack_offset;
  if (D.48392 != 0) goto <D.48393>; else goto <D.48394>;
  <D.48393>:
  result = 1;
  goto <D.48395>;
  <D.48394>:
  D.48396 = cfg->param_area;
  if (D.48396 != 0) goto <D.48397>; else goto <D.48398>;
  <D.48397>:
  result = 1;
  goto <D.48399>;
  <D.48398>:
  D.48382 = cfg->flags;
  D.48400 = D.48382 & 19;
  if (D.48400 != 0) goto <D.48401>; else goto <D.48402>;
  <D.48401>:
  result = 1;
  goto <D.48403>;
  <D.48402>:
  D.48404 = BIT_FIELD_REF <*header, 16, 80>;
  D.48405 = D.48404 & 32767;
  if (D.48405 != 0) goto <D.48406>; else goto <D.48407>;
  <D.48406>:
  result = 1;
  goto <D.48408>;
  <D.48407>:
  D.48409 = sig->param_count;
  D.48410 = (int) D.48409;
  D.48411 = sig->hasthis;
  D.48412 = (int) D.48411;
  D.48413 = D.48410 + D.48412;
  if (D.48413 != 0) goto <D.48414>; else goto <D.48415>;
  <D.48414>:
  result = 1;
  goto <D.48416>;
  <D.48415>:
  D.48417 = BIT_FIELD_REF <*sig, 16, 80>;
  D.48418 = D.48417 & 319;
  if (D.48418 == 5) goto <D.48419>; else goto <D.48420>;
  <D.48419>:
  result = 1;
  goto <D.48421>;
  <D.48420>:
  mono_jit_trace_calls.7439 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.7439 != 0B) goto <D.48426>; else goto <D.48422>;
  <D.48426>:
  D.48376 = cfg->method;
  D.48427 = mono_trace_eval (D.48376);
  if (D.48427 != 0) goto <D.48423>; else goto <D.48422>;
  <D.48422>:
  D.48428 = cfg->prof_options;
  D.48429 = D.48428 & 4096;
  if (D.48429 != 0) goto <D.48423>; else goto <D.48424>;
  <D.48423>:
  result = 1;
  <D.48424>:
  <D.48421>:
  <D.48416>:
  <D.48408>:
  <D.48403>:
  <D.48399>:
  <D.48395>:
  <D.48391>:
  <D.48386>:
  <D.48381>:
  set_needs_stack_frame (cfg, result);
  D.48375 = cfg->arch.need_stack_frame;
  return D.48375;
}


set_needs_stack_frame (struct MonoCompile * cfg, gboolean flag)
{
  int D.48431;
  int D.48434;
  _Bool D.48435;
  long int D.48436;
  long int D.48437;
  int inited.7440;
  int count.7441;
  int count.7442;
  static int inited = 0;
  static int count = 0;

  D.48431 = cfg->arch.need_stack_frame_inited;
  if (D.48431 != 0) goto <D.48432>; else goto <D.48433>;
  <D.48432>:
  D.48434 = cfg->arch.need_stack_frame;
  D.48435 = D.48434 != flag;
  D.48436 = (long int) D.48435;
  D.48437 = __builtin_expect (D.48436, 0);
  if (D.48437 != 0) goto <D.48438>; else goto <D.48439>;
  <D.48438>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 979, "cfg->arch.need_stack_frame == flag");
  <D.48439>:
  return;
  <D.48433>:
  cfg->arch.need_stack_frame = flag;
  cfg->arch.need_stack_frame_inited = 1;
  if (flag != 0) goto <D.48440>; else goto <D.48441>;
  <D.48440>:
  return;
  <D.48441>:
  inited.7440 = inited;
  if (inited.7440 == 0) goto <D.48443>; else goto <D.48444>;
  <D.48443>:
  mono_counters_register ("Could eliminate stack frame", 256, &count);
  inited = 1;
  <D.48444>:
  count.7441 = count;
  count.7442 = count.7441 + 1;
  count = count.7442;
}


emit_setup_lmf (struct MonoCompile * cfg, guint8 * code, gint32 lmf_offset, int cfa_offset)
{
  guint8 * code.7443;
  guint8 * code.7444;
  guint8 * code.7445;
  unsigned int D.48451;
  guint8 * code.7446;
  guint8 * code.7447;
  unsigned int lmf_offset.7448;
  unsigned int D.48462;
  int D.48463;
  guint8 * code.7449;
  guint8 * code.7450;
  unsigned char D.48468;
  unsigned char D.48469;
  guint8 * code.7451;
  guint8 * code.7452;
  guint8 * code.7453;
  unsigned char D.48473;
  guint8 * code.7454;
  unsigned char D.48475;
  guint8 * code.7455;
  unsigned char D.48477;
  guint8 * code.7456;
  unsigned char D.48479;
  guint8 * code.7457;
  unsigned char D.48485;
  unsigned char D.48486;
  unsigned char D.48487;
  guint8 * code.7458;
  unsigned char D.48493;
  guint8 * code.7459;
  unsigned char D.48495;
  guint8 * code.7460;
  unsigned char D.48497;
  guint8 * code.7461;
  unsigned char D.48499;
  guint8 * code.7462;
  unsigned char D.48501;
  guint8 * code.7463;
  unsigned char D.48503;
  int D.48504;
  unsigned int D.48505;
  unsigned int D.48506;
  int D.48507;
  int code.7464;
  unsigned char * D.48509;
  int D.48510;
  int D.48511;
  guint8 * code.7465;
  guint8 * code.7466;
  guint8 * code.7467;
  guint8 * code.7468;
  guint8 * code.7469;
  unsigned int D.48524;
  int D.48525;
  guint8 * code.7470;
  guint8 * code.7471;
  unsigned char D.48530;
  guint8 * code.7472;
  guint8 * code.7473;
  guint8 * code.7474;
  unsigned char D.48534;
  guint8 * code.7475;
  unsigned char D.48536;
  guint8 * code.7476;
  unsigned char D.48538;
  guint8 * code.7477;
  unsigned char D.48540;
  guint8 * code.7478;
  unsigned char D.48546;
  guint8 * code.7479;
  unsigned char D.48552;
  guint8 * code.7480;
  unsigned char D.48554;
  guint8 * code.7481;
  unsigned char D.48556;
  guint8 * code.7482;
  unsigned char D.48558;
  guint8 * code.7483;
  unsigned char D.48560;
  guint8 * code.7484;
  unsigned char D.48562;
  unsigned int D.48563;
  int D.48564;
  guint8 * code.7485;
  guint8 * code.7486;
  guint8 * code.7487;
  guint8 * code.7488;
  guint8 * code.7489;
  unsigned int D.48577;
  int D.48578;
  guint8 * code.7490;
  guint8 * code.7491;
  unsigned char D.48583;
  guint8 * code.7492;
  guint8 * code.7493;
  guint8 * code.7494;
  unsigned char D.48587;
  guint8 * code.7495;
  unsigned char D.48589;
  guint8 * code.7496;
  unsigned char D.48591;
  guint8 * code.7497;
  unsigned char D.48593;
  guint8 * code.7498;
  unsigned char D.48599;
  guint8 * code.7499;
  unsigned char D.48605;
  guint8 * code.7500;
  unsigned char D.48607;
  guint8 * code.7501;
  unsigned char D.48609;
  guint8 * code.7502;
  unsigned char D.48611;
  guint8 * code.7503;
  unsigned char D.48613;
  guint8 * code.7504;
  unsigned char D.48615;
  unsigned int D.48616;
  int D.48617;
  guint8 * code.7505;
  guint8 * code.7506;
  guint8 * code.7507;
  guint8 * code.7508;
  guint8 * code.7509;
  unsigned int D.48630;
  int D.48631;
  guint8 * code.7510;
  guint8 * code.7511;
  unsigned char D.48636;
  guint8 * code.7512;
  guint8 * code.7513;
  guint8 * code.7514;
  unsigned char D.48640;
  guint8 * code.7515;
  unsigned char D.48642;
  guint8 * code.7516;
  unsigned char D.48644;
  guint8 * code.7517;
  unsigned char D.48646;
  guint8 * code.7518;
  unsigned char D.48652;
  guint8 * code.7519;
  unsigned char D.48658;
  guint8 * code.7520;
  unsigned char D.48660;
  guint8 * code.7521;
  unsigned char D.48662;
  guint8 * code.7522;
  unsigned char D.48664;
  guint8 * code.7523;
  unsigned char D.48666;
  guint8 * code.7524;
  unsigned char D.48668;
  unsigned char D.48669;
  unsigned char D.48670;
  guint8 * code.7525;
  guint8 * code.7526;
  unsigned char D.48675;
  guint8 * code.7527;
  unsigned char D.48677;
  guint8 * code.7528;
  unsigned char D.48679;
  guint8 * code.7529;
  unsigned char D.48681;
  guint8 * code.7530;
  guint8 * D.48684;
  int D.48685;
  int D.48686;
  guint8 * code.7531;
  guint8 * code.7532;
  unsigned char D.48689;
  guint8 * code.7533;
  unsigned char D.48691;
  guint8 * code.7534;
  unsigned char D.48693;
  guint8 * code.7535;
  unsigned char D.48695;
  guint8 * code.7536;
  guint8 * code.7537;
  guint8 * code.7538;
  guint8 * code.7539;
  guint8 * code.7540;
  unsigned int D.48708;
  int D.48709;
  guint8 * code.7541;
  guint8 * code.7542;
  unsigned char D.48714;
  guint8 * code.7543;
  guint8 * code.7544;
  guint8 * code.7545;
  unsigned char D.48718;
  guint8 * code.7546;
  unsigned char D.48720;
  guint8 * code.7547;
  unsigned char D.48722;
  guint8 * code.7548;
  unsigned char D.48724;
  guint8 * code.7549;
  guint8 * code.7550;
  unsigned char D.48735;
  guint8 * code.7551;
  unsigned char D.48737;
  guint8 * code.7552;
  unsigned char D.48739;
  guint8 * code.7553;
  unsigned char D.48741;
  guint8 * code.7554;
  unsigned char D.48743;
  guint8 * code.7555;
  unsigned char D.48745;
  unsigned int D.48746;
  int D.48747;
  unsigned int D.48748;
  int D.48749;
  unsigned int D.48750;
  int D.48751;
  unsigned int D.48752;
  int D.48753;
  unsigned int D.48754;
  int D.48755;
  guint8 * D.48756;
  static const char __PRETTY_FUNCTION__[15] = "emit_setup_lmf";

  switch (4) <default: <D.24654>, case 1: <D.24650>, case 2: <D.24652>, case 4: <D.24653>>
  <D.24650>:
  code.7443 = code;
  code = code.7443 + 1;
  *code.7443 = 136;
  goto <D.24651>;
  <D.24652>:
  code.7444 = code;
  code = code.7444 + 1;
  *code.7444 = 102;
  <D.24653>:
  code.7445 = code;
  code = code.7445 + 1;
  *code.7445 = 137;
  goto <D.24651>;
  <D.24654>:
  __assert_fail ("0", "mini-x86.c", 2460, &__PRETTY_FUNCTION__);
  <D.24651>:
  D.48451 = cfg->frame_reg;
  if (D.48451 == 4) goto <D.48452>; else goto <D.48453>;
  <D.48452>:
  if (lmf_offset == -16) goto <D.48454>; else goto <D.48455>;
  <D.48454>:
  code.7446 = code;
  code = code.7446 + 1;
  *code.7446 = 28;
  code.7447 = code;
  code = code.7447 + 1;
  *code.7447 = 36;
  goto <D.48458>;
  <D.48455>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48462 = lmf_offset.7448 + 16;
  D.48463 = (int) D.48462;
  if (D.48463 >= -128) goto <D.48464>; else goto <D.48459>;
  <D.48464>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48462 = lmf_offset.7448 + 16;
  D.48463 = (int) D.48462;
  if (D.48463 <= 127) goto <D.48465>; else goto <D.48459>;
  <D.48465>:
  code.7449 = code;
  code = code.7449 + 1;
  *code.7449 = 92;
  code.7450 = code;
  code = code.7450 + 1;
  *code.7450 = 36;
  D.48468 = (unsigned char) lmf_offset;
  D.48469 = D.48468 + 16;
  *code = D.48469;
  code = code + 1;
  goto <D.48460>;
  <D.48459>:
  code.7451 = code;
  code = code.7451 + 1;
  *code.7451 = 156;
  code.7452 = code;
  code = code.7452 + 1;
  *code.7452 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48462 = lmf_offset.7448 + 16;
        D.48463 = (int) D.48462;
        imb.val = D.48463;
        code.7453 = code;
        code = code.7453 + 1;
        D.48473 = imb.b[0];
        *code.7453 = D.48473;
        code.7454 = code;
        code = code.7454 + 1;
        D.48475 = imb.b[1];
        *code.7454 = D.48475;
        code.7455 = code;
        code = code.7455 + 1;
        D.48477 = imb.b[2];
        *code.7455 = D.48477;
        code.7456 = code;
        code = code.7456 + 1;
        D.48479 = imb.b[3];
        *code.7456 = D.48479;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48460>:
  <D.48458>:
  goto <D.24657>;
  <D.48453>:
  if (lmf_offset == -16) goto <D.48480>; else goto <D.48481>;
  <D.48480>:
  D.48451 = cfg->frame_reg;
  if (D.48451 != 5) goto <D.48482>; else goto <D.48483>;
  <D.48482>:
  code.7457 = code;
  code = code.7457 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48487 = D.48486 | 24;
  *code.7457 = D.48487;
  goto <D.24657>;
  <D.48483>:
  <D.48481>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48462 = lmf_offset.7448 + 16;
  D.48463 = (int) D.48462;
  if (D.48463 >= -128) goto <D.48490>; else goto <D.48488>;
  <D.48490>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48462 = lmf_offset.7448 + 16;
  D.48463 = (int) D.48462;
  if (D.48463 <= 127) goto <D.48491>; else goto <D.48488>;
  <D.48491>:
  code.7458 = code;
  code = code.7458 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48493 = D.48486 | 88;
  *code.7458 = D.48493;
  D.48468 = (unsigned char) lmf_offset;
  D.48469 = D.48468 + 16;
  *code = D.48469;
  code = code + 1;
  goto <D.48489>;
  <D.48488>:
  code.7459 = code;
  code = code.7459 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48495 = D.48486 | 152;
  *code.7459 = D.48495;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48462 = lmf_offset.7448 + 16;
        D.48463 = (int) D.48462;
        imb.val = D.48463;
        code.7460 = code;
        code = code.7460 + 1;
        D.48497 = imb.b[0];
        *code.7460 = D.48497;
        code.7461 = code;
        code = code.7461 + 1;
        D.48499 = imb.b[1];
        *code.7461 = D.48499;
        code.7462 = code;
        code = code.7462 + 1;
        D.48501 = imb.b[2];
        *code.7462 = D.48501;
        code.7463 = code;
        code = code.7463 + 1;
        D.48503 = imb.b[3];
        *code.7463 = D.48503;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48489>:
  <D.24657>:
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48506 = D.48505 + 16;
  D.48507 = (int) D.48506;
  code.7464 = (int) code;
  D.48509 = cfg->native_code;
  D.48510 = (int) D.48509;
  D.48511 = code.7464 - D.48510;
  mono_emit_unwind_op (cfg, D.48511, 128, 3, D.48507);
  switch (4) <default: <D.24663>, case 1: <D.24659>, case 2: <D.24661>, case 4: <D.24662>>
  <D.24659>:
  code.7465 = code;
  code = code.7465 + 1;
  *code.7465 = 136;
  goto <D.24660>;
  <D.24661>:
  code.7466 = code;
  code = code.7466 + 1;
  *code.7466 = 102;
  <D.24662>:
  code.7467 = code;
  code = code.7467 + 1;
  *code.7467 = 137;
  goto <D.24660>;
  <D.24663>:
  __assert_fail ("0", "mini-x86.c", 2462, &__PRETTY_FUNCTION__);
  <D.24660>:
  D.48451 = cfg->frame_reg;
  if (D.48451 == 4) goto <D.48515>; else goto <D.48516>;
  <D.48515>:
  if (lmf_offset == -20) goto <D.48517>; else goto <D.48518>;
  <D.48517>:
  code.7468 = code;
  code = code.7468 + 1;
  *code.7468 = 60;
  code.7469 = code;
  code = code.7469 + 1;
  *code.7469 = 36;
  goto <D.48521>;
  <D.48518>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48524 = lmf_offset.7448 + 20;
  D.48525 = (int) D.48524;
  if (D.48525 >= -128) goto <D.48526>; else goto <D.48522>;
  <D.48526>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48524 = lmf_offset.7448 + 20;
  D.48525 = (int) D.48524;
  if (D.48525 <= 127) goto <D.48527>; else goto <D.48522>;
  <D.48527>:
  code.7470 = code;
  code = code.7470 + 1;
  *code.7470 = 124;
  code.7471 = code;
  code = code.7471 + 1;
  *code.7471 = 36;
  D.48468 = (unsigned char) lmf_offset;
  D.48530 = D.48468 + 20;
  *code = D.48530;
  code = code + 1;
  goto <D.48523>;
  <D.48522>:
  code.7472 = code;
  code = code.7472 + 1;
  *code.7472 = 188;
  code.7473 = code;
  code = code.7473 + 1;
  *code.7473 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48524 = lmf_offset.7448 + 20;
        D.48525 = (int) D.48524;
        imb.val = D.48525;
        code.7474 = code;
        code = code.7474 + 1;
        D.48534 = imb.b[0];
        *code.7474 = D.48534;
        code.7475 = code;
        code = code.7475 + 1;
        D.48536 = imb.b[1];
        *code.7475 = D.48536;
        code.7476 = code;
        code = code.7476 + 1;
        D.48538 = imb.b[2];
        *code.7476 = D.48538;
        code.7477 = code;
        code = code.7477 + 1;
        D.48540 = imb.b[3];
        *code.7477 = D.48540;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48523>:
  <D.48521>:
  goto <D.24665>;
  <D.48516>:
  if (lmf_offset == -20) goto <D.48541>; else goto <D.48542>;
  <D.48541>:
  D.48451 = cfg->frame_reg;
  if (D.48451 != 5) goto <D.48543>; else goto <D.48544>;
  <D.48543>:
  code.7478 = code;
  code = code.7478 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48546 = D.48486 | 56;
  *code.7478 = D.48546;
  goto <D.24665>;
  <D.48544>:
  <D.48542>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48524 = lmf_offset.7448 + 20;
  D.48525 = (int) D.48524;
  if (D.48525 >= -128) goto <D.48549>; else goto <D.48547>;
  <D.48549>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48524 = lmf_offset.7448 + 20;
  D.48525 = (int) D.48524;
  if (D.48525 <= 127) goto <D.48550>; else goto <D.48547>;
  <D.48550>:
  code.7479 = code;
  code = code.7479 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48552 = D.48486 | 120;
  *code.7479 = D.48552;
  D.48468 = (unsigned char) lmf_offset;
  D.48530 = D.48468 + 20;
  *code = D.48530;
  code = code + 1;
  goto <D.48548>;
  <D.48547>:
  code.7480 = code;
  code = code.7480 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48554 = D.48486 | 184;
  *code.7480 = D.48554;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48524 = lmf_offset.7448 + 20;
        D.48525 = (int) D.48524;
        imb.val = D.48525;
        code.7481 = code;
        code = code.7481 + 1;
        D.48556 = imb.b[0];
        *code.7481 = D.48556;
        code.7482 = code;
        code = code.7482 + 1;
        D.48558 = imb.b[1];
        *code.7482 = D.48558;
        code.7483 = code;
        code = code.7483 + 1;
        D.48560 = imb.b[2];
        *code.7483 = D.48560;
        code.7484 = code;
        code = code.7484 + 1;
        D.48562 = imb.b[3];
        *code.7484 = D.48562;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48548>:
  <D.24665>:
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48563 = D.48505 + 20;
  D.48564 = (int) D.48563;
  code.7464 = (int) code;
  D.48509 = cfg->native_code;
  D.48510 = (int) D.48509;
  D.48511 = code.7464 - D.48510;
  mono_emit_unwind_op (cfg, D.48511, 128, 7, D.48564);
  switch (4) <default: <D.24671>, case 1: <D.24667>, case 2: <D.24669>, case 4: <D.24670>>
  <D.24667>:
  code.7485 = code;
  code = code.7485 + 1;
  *code.7485 = 136;
  goto <D.24668>;
  <D.24669>:
  code.7486 = code;
  code = code.7486 + 1;
  *code.7486 = 102;
  <D.24670>:
  code.7487 = code;
  code = code.7487 + 1;
  *code.7487 = 137;
  goto <D.24668>;
  <D.24671>:
  __assert_fail ("0", "mini-x86.c", 2464, &__PRETTY_FUNCTION__);
  <D.24668>:
  D.48451 = cfg->frame_reg;
  if (D.48451 == 4) goto <D.48568>; else goto <D.48569>;
  <D.48568>:
  if (lmf_offset == -24) goto <D.48570>; else goto <D.48571>;
  <D.48570>:
  code.7488 = code;
  code = code.7488 + 1;
  *code.7488 = 52;
  code.7489 = code;
  code = code.7489 + 1;
  *code.7489 = 36;
  goto <D.48574>;
  <D.48571>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48577 = lmf_offset.7448 + 24;
  D.48578 = (int) D.48577;
  if (D.48578 >= -128) goto <D.48579>; else goto <D.48575>;
  <D.48579>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48577 = lmf_offset.7448 + 24;
  D.48578 = (int) D.48577;
  if (D.48578 <= 127) goto <D.48580>; else goto <D.48575>;
  <D.48580>:
  code.7490 = code;
  code = code.7490 + 1;
  *code.7490 = 116;
  code.7491 = code;
  code = code.7491 + 1;
  *code.7491 = 36;
  D.48468 = (unsigned char) lmf_offset;
  D.48583 = D.48468 + 24;
  *code = D.48583;
  code = code + 1;
  goto <D.48576>;
  <D.48575>:
  code.7492 = code;
  code = code.7492 + 1;
  *code.7492 = 180;
  code.7493 = code;
  code = code.7493 + 1;
  *code.7493 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48577 = lmf_offset.7448 + 24;
        D.48578 = (int) D.48577;
        imb.val = D.48578;
        code.7494 = code;
        code = code.7494 + 1;
        D.48587 = imb.b[0];
        *code.7494 = D.48587;
        code.7495 = code;
        code = code.7495 + 1;
        D.48589 = imb.b[1];
        *code.7495 = D.48589;
        code.7496 = code;
        code = code.7496 + 1;
        D.48591 = imb.b[2];
        *code.7496 = D.48591;
        code.7497 = code;
        code = code.7497 + 1;
        D.48593 = imb.b[3];
        *code.7497 = D.48593;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48576>:
  <D.48574>:
  goto <D.24673>;
  <D.48569>:
  if (lmf_offset == -24) goto <D.48594>; else goto <D.48595>;
  <D.48594>:
  D.48451 = cfg->frame_reg;
  if (D.48451 != 5) goto <D.48596>; else goto <D.48597>;
  <D.48596>:
  code.7498 = code;
  code = code.7498 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48599 = D.48486 | 48;
  *code.7498 = D.48599;
  goto <D.24673>;
  <D.48597>:
  <D.48595>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48577 = lmf_offset.7448 + 24;
  D.48578 = (int) D.48577;
  if (D.48578 >= -128) goto <D.48602>; else goto <D.48600>;
  <D.48602>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48577 = lmf_offset.7448 + 24;
  D.48578 = (int) D.48577;
  if (D.48578 <= 127) goto <D.48603>; else goto <D.48600>;
  <D.48603>:
  code.7499 = code;
  code = code.7499 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48605 = D.48486 | 112;
  *code.7499 = D.48605;
  D.48468 = (unsigned char) lmf_offset;
  D.48583 = D.48468 + 24;
  *code = D.48583;
  code = code + 1;
  goto <D.48601>;
  <D.48600>:
  code.7500 = code;
  code = code.7500 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48607 = D.48486 | 176;
  *code.7500 = D.48607;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48577 = lmf_offset.7448 + 24;
        D.48578 = (int) D.48577;
        imb.val = D.48578;
        code.7501 = code;
        code = code.7501 + 1;
        D.48609 = imb.b[0];
        *code.7501 = D.48609;
        code.7502 = code;
        code = code.7502 + 1;
        D.48611 = imb.b[1];
        *code.7502 = D.48611;
        code.7503 = code;
        code = code.7503 + 1;
        D.48613 = imb.b[2];
        *code.7503 = D.48613;
        code.7504 = code;
        code = code.7504 + 1;
        D.48615 = imb.b[3];
        *code.7504 = D.48615;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48601>:
  <D.24673>:
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48616 = D.48505 + 24;
  D.48617 = (int) D.48616;
  code.7464 = (int) code;
  D.48509 = cfg->native_code;
  D.48510 = (int) D.48509;
  D.48511 = code.7464 - D.48510;
  mono_emit_unwind_op (cfg, D.48511, 128, 6, D.48617);
  switch (4) <default: <D.24679>, case 1: <D.24675>, case 2: <D.24677>, case 4: <D.24678>>
  <D.24675>:
  code.7505 = code;
  code = code.7505 + 1;
  *code.7505 = 136;
  goto <D.24676>;
  <D.24677>:
  code.7506 = code;
  code = code.7506 + 1;
  *code.7506 = 102;
  <D.24678>:
  code.7507 = code;
  code = code.7507 + 1;
  *code.7507 = 137;
  goto <D.24676>;
  <D.24679>:
  __assert_fail ("0", "mini-x86.c", 2466, &__PRETTY_FUNCTION__);
  <D.24676>:
  D.48451 = cfg->frame_reg;
  if (D.48451 == 4) goto <D.48621>; else goto <D.48622>;
  <D.48621>:
  if (lmf_offset == -28) goto <D.48623>; else goto <D.48624>;
  <D.48623>:
  code.7508 = code;
  code = code.7508 + 1;
  *code.7508 = 44;
  code.7509 = code;
  code = code.7509 + 1;
  *code.7509 = 36;
  goto <D.48627>;
  <D.48624>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48630 = lmf_offset.7448 + 28;
  D.48631 = (int) D.48630;
  if (D.48631 >= -128) goto <D.48632>; else goto <D.48628>;
  <D.48632>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48630 = lmf_offset.7448 + 28;
  D.48631 = (int) D.48630;
  if (D.48631 <= 127) goto <D.48633>; else goto <D.48628>;
  <D.48633>:
  code.7510 = code;
  code = code.7510 + 1;
  *code.7510 = 108;
  code.7511 = code;
  code = code.7511 + 1;
  *code.7511 = 36;
  D.48468 = (unsigned char) lmf_offset;
  D.48636 = D.48468 + 28;
  *code = D.48636;
  code = code + 1;
  goto <D.48629>;
  <D.48628>:
  code.7512 = code;
  code = code.7512 + 1;
  *code.7512 = 172;
  code.7513 = code;
  code = code.7513 + 1;
  *code.7513 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48630 = lmf_offset.7448 + 28;
        D.48631 = (int) D.48630;
        imb.val = D.48631;
        code.7514 = code;
        code = code.7514 + 1;
        D.48640 = imb.b[0];
        *code.7514 = D.48640;
        code.7515 = code;
        code = code.7515 + 1;
        D.48642 = imb.b[1];
        *code.7515 = D.48642;
        code.7516 = code;
        code = code.7516 + 1;
        D.48644 = imb.b[2];
        *code.7516 = D.48644;
        code.7517 = code;
        code = code.7517 + 1;
        D.48646 = imb.b[3];
        *code.7517 = D.48646;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48629>:
  <D.48627>:
  goto <D.24681>;
  <D.48622>:
  if (lmf_offset == -28) goto <D.48647>; else goto <D.48648>;
  <D.48647>:
  D.48451 = cfg->frame_reg;
  if (D.48451 != 5) goto <D.48649>; else goto <D.48650>;
  <D.48649>:
  code.7518 = code;
  code = code.7518 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48652 = D.48486 | 40;
  *code.7518 = D.48652;
  goto <D.24681>;
  <D.48650>:
  <D.48648>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48630 = lmf_offset.7448 + 28;
  D.48631 = (int) D.48630;
  if (D.48631 >= -128) goto <D.48655>; else goto <D.48653>;
  <D.48655>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48630 = lmf_offset.7448 + 28;
  D.48631 = (int) D.48630;
  if (D.48631 <= 127) goto <D.48656>; else goto <D.48653>;
  <D.48656>:
  code.7519 = code;
  code = code.7519 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48658 = D.48486 | 104;
  *code.7519 = D.48658;
  D.48468 = (unsigned char) lmf_offset;
  D.48636 = D.48468 + 28;
  *code = D.48636;
  code = code + 1;
  goto <D.48654>;
  <D.48653>:
  code.7520 = code;
  code = code.7520 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48660 = D.48486 | 168;
  *code.7520 = D.48660;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48630 = lmf_offset.7448 + 28;
        D.48631 = (int) D.48630;
        imb.val = D.48631;
        code.7521 = code;
        code = code.7521 + 1;
        D.48662 = imb.b[0];
        *code.7521 = D.48662;
        code.7522 = code;
        code = code.7522 + 1;
        D.48664 = imb.b[1];
        *code.7522 = D.48664;
        code.7523 = code;
        code = code.7523 + 1;
        D.48666 = imb.b[2];
        *code.7523 = D.48666;
        code.7524 = code;
        code = code.7524 + 1;
        D.48668 = imb.b[3];
        *code.7524 = D.48668;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48654>:
  <D.24681>:
  D.48669 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.48670 = D.48669 & 64;
  if (D.48670 != 0) goto <D.48671>; else goto <D.48672>;
  <D.48671>:
  code.7525 = code;
  code = code.7525 + 1;
  *code.7525 = 232;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7526 = code;
        code = code.7526 + 1;
        D.48675 = imb.b[0];
        *code.7526 = D.48675;
        code.7527 = code;
        code = code.7527 + 1;
        D.48677 = imb.b[1];
        *code.7527 = D.48677;
        code.7528 = code;
        code = code.7528 + 1;
        D.48679 = imb.b[2];
        *code.7528 = D.48679;
        code.7529 = code;
        code = code.7529 + 1;
        D.48681 = imb.b[3];
        *code.7529 = D.48681;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  code.7530 = code;
  code = code.7530 + 1;
  *code.7530 = 88;
  goto <D.48683>;
  <D.48672>:
  D.48684 = code + 1;
  D.48685 = (int) D.48684;
  D.48509 = cfg->native_code;
  D.48510 = (int) D.48509;
  D.48686 = D.48685 - D.48510;
  mono_add_patch_info (cfg, D.48686, 22, 0B);
  code.7531 = code;
  code = code.7531 + 1;
  *code.7531 = 184;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7532 = code;
        code = code.7532 + 1;
        D.48689 = imb.b[0];
        *code.7532 = D.48689;
        code.7533 = code;
        code = code.7533 + 1;
        D.48691 = imb.b[1];
        *code.7533 = D.48691;
        code.7534 = code;
        code = code.7534 + 1;
        D.48693 = imb.b[2];
        *code.7534 = D.48693;
        code.7535 = code;
        code = code.7535 + 1;
        D.48695 = imb.b[3];
        *code.7535 = D.48695;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48683>:
  switch (4) <default: <D.24689>, case 1: <D.24685>, case 2: <D.24687>, case 4: <D.24688>>
  <D.24685>:
  code.7536 = code;
  code = code.7536 + 1;
  *code.7536 = 136;
  goto <D.24686>;
  <D.24687>:
  code.7537 = code;
  code = code.7537 + 1;
  *code.7537 = 102;
  <D.24688>:
  code.7538 = code;
  code = code.7538 + 1;
  *code.7538 = 137;
  goto <D.24686>;
  <D.24689>:
  __assert_fail ("0", "mini-x86.c", 2477, &__PRETTY_FUNCTION__);
  <D.24686>:
  D.48451 = cfg->frame_reg;
  if (D.48451 == 4) goto <D.48699>; else goto <D.48700>;
  <D.48699>:
  if (lmf_offset == -32) goto <D.48701>; else goto <D.48702>;
  <D.48701>:
  code.7539 = code;
  code = code.7539 + 1;
  *code.7539 = 4;
  code.7540 = code;
  code = code.7540 + 1;
  *code.7540 = 36;
  goto <D.48705>;
  <D.48702>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48708 = lmf_offset.7448 + 32;
  D.48709 = (int) D.48708;
  if (D.48709 >= -128) goto <D.48710>; else goto <D.48706>;
  <D.48710>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48708 = lmf_offset.7448 + 32;
  D.48709 = (int) D.48708;
  if (D.48709 <= 127) goto <D.48711>; else goto <D.48706>;
  <D.48711>:
  code.7541 = code;
  code = code.7541 + 1;
  *code.7541 = 68;
  code.7542 = code;
  code = code.7542 + 1;
  *code.7542 = 36;
  D.48468 = (unsigned char) lmf_offset;
  D.48714 = D.48468 + 32;
  *code = D.48714;
  code = code + 1;
  goto <D.48707>;
  <D.48706>:
  code.7543 = code;
  code = code.7543 + 1;
  *code.7543 = 132;
  code.7544 = code;
  code = code.7544 + 1;
  *code.7544 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48708 = lmf_offset.7448 + 32;
        D.48709 = (int) D.48708;
        imb.val = D.48709;
        code.7545 = code;
        code = code.7545 + 1;
        D.48718 = imb.b[0];
        *code.7545 = D.48718;
        code.7546 = code;
        code = code.7546 + 1;
        D.48720 = imb.b[1];
        *code.7546 = D.48720;
        code.7547 = code;
        code = code.7547 + 1;
        D.48722 = imb.b[2];
        *code.7547 = D.48722;
        code.7548 = code;
        code = code.7548 + 1;
        D.48724 = imb.b[3];
        *code.7548 = D.48724;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48707>:
  <D.48705>:
  goto <D.24691>;
  <D.48700>:
  if (lmf_offset == -32) goto <D.48725>; else goto <D.48726>;
  <D.48725>:
  D.48451 = cfg->frame_reg;
  if (D.48451 != 5) goto <D.48727>; else goto <D.48728>;
  <D.48727>:
  code.7549 = code;
  code = code.7549 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  *code.7549 = D.48486;
  goto <D.24691>;
  <D.48728>:
  <D.48726>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48708 = lmf_offset.7448 + 32;
  D.48709 = (int) D.48708;
  if (D.48709 >= -128) goto <D.48732>; else goto <D.48730>;
  <D.48732>:
  lmf_offset.7448 = (unsigned int) lmf_offset;
  D.48708 = lmf_offset.7448 + 32;
  D.48709 = (int) D.48708;
  if (D.48709 <= 127) goto <D.48733>; else goto <D.48730>;
  <D.48733>:
  code.7550 = code;
  code = code.7550 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48735 = D.48486 | 64;
  *code.7550 = D.48735;
  D.48468 = (unsigned char) lmf_offset;
  D.48714 = D.48468 + 32;
  *code = D.48714;
  code = code + 1;
  goto <D.48731>;
  <D.48730>:
  code.7551 = code;
  code = code.7551 + 1;
  D.48451 = cfg->frame_reg;
  D.48485 = (unsigned char) D.48451;
  D.48486 = D.48485 & 7;
  D.48737 = D.48486 | 128;
  *code.7551 = D.48737;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7448 = (unsigned int) lmf_offset;
        D.48708 = lmf_offset.7448 + 32;
        D.48709 = (int) D.48708;
        imb.val = D.48709;
        code.7552 = code;
        code = code.7552 + 1;
        D.48739 = imb.b[0];
        *code.7552 = D.48739;
        code.7553 = code;
        code = code.7553 + 1;
        D.48741 = imb.b[1];
        *code.7553 = D.48741;
        code.7554 = code;
        code = code.7554 + 1;
        D.48743 = imb.b[2];
        *code.7554 = D.48743;
        code.7555 = code;
        code = code.7555 + 1;
        D.48745 = imb.b[3];
        *code.7555 = D.48745;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48731>:
  <D.24691>:
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48746 = D.48505 + 32;
  D.48747 = (int) D.48746;
  mini_gc_set_slot_type_from_cfa (cfg, D.48747, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48748 = D.48505 + 28;
  D.48749 = (int) D.48748;
  mini_gc_set_slot_type_from_cfa (cfg, D.48749, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48616 = D.48505 + 24;
  D.48617 = (int) D.48616;
  mini_gc_set_slot_type_from_cfa (cfg, D.48617, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48563 = D.48505 + 20;
  D.48564 = (int) D.48563;
  mini_gc_set_slot_type_from_cfa (cfg, D.48564, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48506 = D.48505 + 16;
  D.48507 = (int) D.48506;
  mini_gc_set_slot_type_from_cfa (cfg, D.48507, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48750 = D.48505 + 12;
  D.48751 = (int) D.48750;
  mini_gc_set_slot_type_from_cfa (cfg, D.48751, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48752 = D.48505 + 8;
  D.48753 = (int) D.48752;
  mini_gc_set_slot_type_from_cfa (cfg, D.48753, 0);
  D.48504 = lmf_offset - cfa_offset;
  D.48505 = (unsigned int) D.48504;
  D.48754 = D.48505 + 4;
  D.48755 = (int) D.48754;
  mini_gc_set_slot_type_from_cfa (cfg, D.48755, 0);
  D.48504 = lmf_offset - cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.48504, 0);
  D.48756 = code;
  return D.48756;
}


emit_push_lmf (struct MonoCompile * cfg, guint8 * code, gint32 lmf_offset)
{
  unsigned char D.48758;
  unsigned char D.48759;
  int lmf_addr_tls_offset.7556;
  unsigned char * D.48769;
  guint8 * code.7557;
  guint8 * code.7558;
  guint8 * code.7559;
  unsigned int D.48773;
  guint8 * code.7560;
  guint8 * code.7561;
  unsigned int lmf_offset.7562;
  unsigned int D.48784;
  int D.48785;
  guint8 * code.7563;
  guint8 * code.7564;
  unsigned char D.48790;
  unsigned char D.48791;
  guint8 * code.7565;
  guint8 * code.7566;
  guint8 * code.7567;
  unsigned char D.48795;
  guint8 * code.7568;
  unsigned char D.48797;
  guint8 * code.7569;
  unsigned char D.48799;
  guint8 * code.7570;
  unsigned char D.48801;
  guint8 * code.7571;
  unsigned char D.48807;
  unsigned char D.48808;
  guint8 * code.7572;
  unsigned char D.48814;
  guint8 * code.7573;
  unsigned char D.48816;
  guint8 * code.7574;
  unsigned char D.48818;
  guint8 * code.7575;
  unsigned char D.48820;
  guint8 * code.7576;
  unsigned char D.48822;
  guint8 * code.7577;
  unsigned char D.48824;
  guint8 * code.7578;
  guint8 * code.7579;
  guint8 * code.7580;
  guint8 * code.7581;
  guint8 * code.7582;
  guint8 * code.7583;
  guint8 * code.7584;
  guint8 * code.7585;
  guint8 * code.7586;
  guint8 * code.7587;
  unsigned char D.48843;
  guint8 * code.7588;
  unsigned char D.48845;
  guint8 * code.7589;
  unsigned char D.48847;
  guint8 * code.7590;
  unsigned char D.48849;
  guint8 * code.7591;
  guint8 * code.7592;
  guint8 * code.7593;
  guint8 * code.7594;
  unsigned char D.48859;
  guint8 * code.7595;
  unsigned char D.48861;
  guint8 * code.7596;
  unsigned char D.48863;
  guint8 * code.7597;
  unsigned char D.48865;
  guint8 * code.7598;
  guint8 * code.7599;
  guint8 * code.7600;
  guint8 * code.7601;
  guint8 * code.7602;
  unsigned int lmf_offset.7603;
  unsigned int D.48877;
  guint8 * code.7604;
  guint8 * code.7605;
  guint8 * code.7606;
  guint8 * code.7607;
  guint8 * code.7608;
  unsigned char D.48886;
  guint8 * code.7609;
  unsigned char D.48888;
  guint8 * code.7610;
  unsigned char D.48890;
  guint8 * code.7611;
  unsigned char D.48892;
  guint8 * code.7612;
  unsigned char D.48898;
  guint8 * code.7613;
  unsigned char D.48902;
  guint8 * code.7614;
  unsigned char D.48905;
  guint8 * code.7615;
  unsigned char D.48907;
  guint8 * code.7616;
  unsigned char D.48909;
  guint8 * code.7617;
  unsigned char D.48911;
  guint8 * code.7618;
  unsigned char D.48913;
  guint8 * code.7619;
  guint8 * code.7620;
  guint8 * code.7621;
  guint8 * code.7622;
  guint8 * code.7623;
  unsigned char D.48926;
  guint8 * code.7624;
  guint8 * code.7625;
  guint8 * code.7626;
  unsigned char D.48931;
  guint8 * code.7627;
  unsigned char D.48933;
  guint8 * code.7628;
  unsigned char D.48935;
  guint8 * code.7629;
  unsigned char D.48937;
  guint8 * code.7630;
  guint8 * code.7631;
  guint8 * code.7632;
  guint8 * code.7633;
  unsigned char D.48949;
  guint8 * code.7634;
  unsigned char D.48951;
  guint8 * code.7635;
  unsigned char D.48953;
  guint8 * code.7636;
  unsigned char D.48955;
  guint8 * code.7637;
  guint8 * code.7638;
  guint8 * code.7639;
  guint8 * code.7640;
  guint8 * code.7641;
  guint8 * code.7642;
  guint8 * code.7643;
  guint8 * code.7644;
  guint8 * code.7645;
  guint8 * code.7646;
  unsigned char D.48974;
  guint8 * code.7647;
  unsigned char D.48976;
  guint8 * code.7648;
  unsigned char D.48978;
  guint8 * code.7649;
  unsigned char D.48980;
  guint8 * code.7650;
  guint8 * code.7651;
  guint8 * code.7652;
  guint8 * code.7653;
  unsigned char D.48990;
  guint8 * code.7654;
  unsigned char D.48992;
  guint8 * code.7655;
  unsigned char D.48994;
  guint8 * code.7656;
  unsigned char D.48996;
  guint8 * D.48997;
  gboolean have_fastpath;
  static const char __PRETTY_FUNCTION__[14] = "emit_push_lmf";

  have_fastpath = 0;
  D.48758 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.48759 = D.48758 & 64;
  if (D.48759 == 0) goto <D.48760>; else goto <D.48761>;
  <D.48760>:
  lmf_addr_tls_offset.7556 = lmf_addr_tls_offset;
  if (lmf_addr_tls_offset.7556 != -1) goto <D.48763>; else goto <D.48764>;
  <D.48763>:
  lmf_addr_tls_offset.7556 = lmf_addr_tls_offset;
  code = mono_x86_emit_tls_get (code, 0, lmf_addr_tls_offset.7556);
  have_fastpath = 1;
  <D.48764>:
  <D.48761>:
  if (have_fastpath == 0) goto <D.48765>; else goto <D.48766>;
  <D.48765>:
  D.48758 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.48759 = D.48758 & 64;
  if (D.48759 != 0) goto <D.48767>; else goto <D.48768>;
  <D.48767>:
  D.48769 = cfg->native_code;
  code = mono_arch_emit_load_got_addr (D.48769, code, cfg, 0B);
  <D.48768>:
  code = emit_call (cfg, code, 7, "mono_get_lmf_addr");
  <D.48766>:
  switch (4) <default: <D.24703>, case 1: <D.24699>, case 2: <D.24701>, case 4: <D.24702>>
  <D.24699>:
  code.7557 = code;
  code = code.7557 + 1;
  *code.7557 = 136;
  goto <D.24700>;
  <D.24701>:
  code.7558 = code;
  code = code.7558 + 1;
  *code.7558 = 102;
  <D.24702>:
  code.7559 = code;
  code = code.7559 + 1;
  *code.7559 = 137;
  goto <D.24700>;
  <D.24703>:
  __assert_fail ("0", "mini-x86.c", 2526, &__PRETTY_FUNCTION__);
  <D.24700>:
  D.48773 = cfg->frame_reg;
  if (D.48773 == 4) goto <D.48774>; else goto <D.48775>;
  <D.48774>:
  if (lmf_offset == -4) goto <D.48776>; else goto <D.48777>;
  <D.48776>:
  code.7560 = code;
  code = code.7560 + 1;
  *code.7560 = 4;
  code.7561 = code;
  code = code.7561 + 1;
  *code.7561 = 36;
  goto <D.48780>;
  <D.48777>:
  lmf_offset.7562 = (unsigned int) lmf_offset;
  D.48784 = lmf_offset.7562 + 4;
  D.48785 = (int) D.48784;
  if (D.48785 >= -128) goto <D.48786>; else goto <D.48781>;
  <D.48786>:
  lmf_offset.7562 = (unsigned int) lmf_offset;
  D.48784 = lmf_offset.7562 + 4;
  D.48785 = (int) D.48784;
  if (D.48785 <= 127) goto <D.48787>; else goto <D.48781>;
  <D.48787>:
  code.7563 = code;
  code = code.7563 + 1;
  *code.7563 = 68;
  code.7564 = code;
  code = code.7564 + 1;
  *code.7564 = 36;
  D.48790 = (unsigned char) lmf_offset;
  D.48791 = D.48790 + 4;
  *code = D.48791;
  code = code + 1;
  goto <D.48782>;
  <D.48781>:
  code.7565 = code;
  code = code.7565 + 1;
  *code.7565 = 132;
  code.7566 = code;
  code = code.7566 + 1;
  *code.7566 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7562 = (unsigned int) lmf_offset;
        D.48784 = lmf_offset.7562 + 4;
        D.48785 = (int) D.48784;
        imb.val = D.48785;
        code.7567 = code;
        code = code.7567 + 1;
        D.48795 = imb.b[0];
        *code.7567 = D.48795;
        code.7568 = code;
        code = code.7568 + 1;
        D.48797 = imb.b[1];
        *code.7568 = D.48797;
        code.7569 = code;
        code = code.7569 + 1;
        D.48799 = imb.b[2];
        *code.7569 = D.48799;
        code.7570 = code;
        code = code.7570 + 1;
        D.48801 = imb.b[3];
        *code.7570 = D.48801;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48782>:
  <D.48780>:
  goto <D.24706>;
  <D.48775>:
  if (lmf_offset == -4) goto <D.48802>; else goto <D.48803>;
  <D.48802>:
  D.48773 = cfg->frame_reg;
  if (D.48773 != 5) goto <D.48804>; else goto <D.48805>;
  <D.48804>:
  code.7571 = code;
  code = code.7571 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  *code.7571 = D.48808;
  goto <D.24706>;
  <D.48805>:
  <D.48803>:
  lmf_offset.7562 = (unsigned int) lmf_offset;
  D.48784 = lmf_offset.7562 + 4;
  D.48785 = (int) D.48784;
  if (D.48785 >= -128) goto <D.48811>; else goto <D.48809>;
  <D.48811>:
  lmf_offset.7562 = (unsigned int) lmf_offset;
  D.48784 = lmf_offset.7562 + 4;
  D.48785 = (int) D.48784;
  if (D.48785 <= 127) goto <D.48812>; else goto <D.48809>;
  <D.48812>:
  code.7572 = code;
  code = code.7572 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48814 = D.48808 | 64;
  *code.7572 = D.48814;
  D.48790 = (unsigned char) lmf_offset;
  D.48791 = D.48790 + 4;
  *code = D.48791;
  code = code + 1;
  goto <D.48810>;
  <D.48809>:
  code.7573 = code;
  code = code.7573 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48816 = D.48808 | 128;
  *code.7573 = D.48816;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7562 = (unsigned int) lmf_offset;
        D.48784 = lmf_offset.7562 + 4;
        D.48785 = (int) D.48784;
        imb.val = D.48785;
        code.7574 = code;
        code = code.7574 + 1;
        D.48818 = imb.b[0];
        *code.7574 = D.48818;
        code.7575 = code;
        code = code.7575 + 1;
        D.48820 = imb.b[1];
        *code.7575 = D.48820;
        code.7576 = code;
        code = code.7576 + 1;
        D.48822 = imb.b[2];
        *code.7576 = D.48822;
        code.7577 = code;
        code = code.7577 + 1;
        D.48824 = imb.b[3];
        *code.7577 = D.48824;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48810>:
  <D.24706>:
  switch (4) <default: <D.24712>, case 1: <D.24708>, case 2: <D.24710>, case 4: <D.24711>>
  <D.24708>:
  code.7578 = code;
  code = code.7578 + 1;
  *code.7578 = 138;
  goto <D.24709>;
  <D.24710>:
  code.7579 = code;
  code = code.7579 + 1;
  *code.7579 = 102;
  <D.24711>:
  code.7580 = code;
  code = code.7580 + 1;
  *code.7580 = 139;
  goto <D.24709>;
  <D.24712>:
  __assert_fail ("0", "mini-x86.c", 2528, &__PRETTY_FUNCTION__);
  <D.24709>:
  if (0 != 0) goto <D.48828>; else goto <D.48829>;
  <D.48828>:
  if (1 != 0) goto <D.48830>; else goto <D.48831>;
  <D.48830>:
  code.7581 = code;
  code = code.7581 + 1;
  *code.7581 = 12;
  code.7582 = code;
  code = code.7582 + 1;
  *code.7582 = 36;
  goto <D.48834>;
  <D.48831>:
  if (1 != 0) goto <D.48835>; else goto <D.48836>;
  <D.48835>:
  code.7583 = code;
  code = code.7583 + 1;
  *code.7583 = 76;
  code.7584 = code;
  code = code.7584 + 1;
  *code.7584 = 36;
  *code = 0;
  code = code + 1;
  goto <D.48839>;
  <D.48836>:
  code.7585 = code;
  code = code.7585 + 1;
  *code.7585 = 140;
  code.7586 = code;
  code = code.7586 + 1;
  *code.7586 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7587 = code;
        code = code.7587 + 1;
        D.48843 = imb.b[0];
        *code.7587 = D.48843;
        code.7588 = code;
        code = code.7588 + 1;
        D.48845 = imb.b[1];
        *code.7588 = D.48845;
        code.7589 = code;
        code = code.7589 + 1;
        D.48847 = imb.b[2];
        *code.7589 = D.48847;
        code.7590 = code;
        code = code.7590 + 1;
        D.48849 = imb.b[3];
        *code.7590 = D.48849;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48839>:
  <D.48834>:
  goto <D.24714>;
  <D.48829>:
  if (1 != 0) goto <D.48850>; else goto <D.48851>;
  <D.48850>:
  code.7591 = code;
  code = code.7591 + 1;
  *code.7591 = 8;
  goto <D.24714>;
  <D.48851>:
  if (1 != 0) goto <D.48853>; else goto <D.48854>;
  <D.48853>:
  code.7592 = code;
  code = code.7592 + 1;
  *code.7592 = 72;
  *code = 0;
  code = code + 1;
  goto <D.48856>;
  <D.48854>:
  code.7593 = code;
  code = code.7593 + 1;
  *code.7593 = 136;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7594 = code;
        code = code.7594 + 1;
        D.48859 = imb.b[0];
        *code.7594 = D.48859;
        code.7595 = code;
        code = code.7595 + 1;
        D.48861 = imb.b[1];
        *code.7595 = D.48861;
        code.7596 = code;
        code = code.7596 + 1;
        D.48863 = imb.b[2];
        *code.7596 = D.48863;
        code.7597 = code;
        code = code.7597 + 1;
        D.48865 = imb.b[3];
        *code.7597 = D.48865;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48856>:
  <D.24714>:
  switch (4) <default: <D.24720>, case 1: <D.24716>, case 2: <D.24718>, case 4: <D.24719>>
  <D.24716>:
  code.7598 = code;
  code = code.7598 + 1;
  *code.7598 = 136;
  goto <D.24717>;
  <D.24718>:
  code.7599 = code;
  code = code.7599 + 1;
  *code.7599 = 102;
  <D.24719>:
  code.7600 = code;
  code = code.7600 + 1;
  *code.7600 = 137;
  goto <D.24717>;
  <D.24720>:
  __assert_fail ("0", "mini-x86.c", 2529, &__PRETTY_FUNCTION__);
  <D.24717>:
  D.48773 = cfg->frame_reg;
  if (D.48773 == 4) goto <D.48869>; else goto <D.48870>;
  <D.48869>:
  if (lmf_offset == 0) goto <D.48871>; else goto <D.48872>;
  <D.48871>:
  code.7601 = code;
  code = code.7601 + 1;
  *code.7601 = 12;
  code.7602 = code;
  code = code.7602 + 1;
  *code.7602 = 36;
  goto <D.48875>;
  <D.48872>:
  lmf_offset.7603 = (unsigned int) lmf_offset;
  D.48877 = lmf_offset.7603 + 128;
  if (D.48877 <= 255) goto <D.48878>; else goto <D.48879>;
  <D.48878>:
  code.7604 = code;
  code = code.7604 + 1;
  *code.7604 = 76;
  code.7605 = code;
  code = code.7605 + 1;
  *code.7605 = 36;
  D.48790 = (unsigned char) lmf_offset;
  *code = D.48790;
  code = code + 1;
  goto <D.48882>;
  <D.48879>:
  code.7606 = code;
  code = code.7606 + 1;
  *code.7606 = 140;
  code.7607 = code;
  code = code.7607 + 1;
  *code.7607 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = lmf_offset;
        code.7608 = code;
        code = code.7608 + 1;
        D.48886 = imb.b[0];
        *code.7608 = D.48886;
        code.7609 = code;
        code = code.7609 + 1;
        D.48888 = imb.b[1];
        *code.7609 = D.48888;
        code.7610 = code;
        code = code.7610 + 1;
        D.48890 = imb.b[2];
        *code.7610 = D.48890;
        code.7611 = code;
        code = code.7611 + 1;
        D.48892 = imb.b[3];
        *code.7611 = D.48892;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48882>:
  <D.48875>:
  goto <D.24722>;
  <D.48870>:
  if (lmf_offset == 0) goto <D.48893>; else goto <D.48894>;
  <D.48893>:
  D.48773 = cfg->frame_reg;
  if (D.48773 != 5) goto <D.48895>; else goto <D.48896>;
  <D.48895>:
  code.7612 = code;
  code = code.7612 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48898 = D.48808 | 8;
  *code.7612 = D.48898;
  goto <D.24722>;
  <D.48896>:
  <D.48894>:
  lmf_offset.7603 = (unsigned int) lmf_offset;
  D.48877 = lmf_offset.7603 + 128;
  if (D.48877 <= 255) goto <D.48899>; else goto <D.48900>;
  <D.48899>:
  code.7613 = code;
  code = code.7613 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48902 = D.48808 | 72;
  *code.7613 = D.48902;
  D.48790 = (unsigned char) lmf_offset;
  *code = D.48790;
  code = code + 1;
  goto <D.48903>;
  <D.48900>:
  code.7614 = code;
  code = code.7614 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48905 = D.48808 | 136;
  *code.7614 = D.48905;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = lmf_offset;
        code.7615 = code;
        code = code.7615 + 1;
        D.48907 = imb.b[0];
        *code.7615 = D.48907;
        code.7616 = code;
        code = code.7616 + 1;
        D.48909 = imb.b[1];
        *code.7616 = D.48909;
        code.7617 = code;
        code = code.7617 + 1;
        D.48911 = imb.b[2];
        *code.7617 = D.48911;
        code.7618 = code;
        code = code.7618 + 1;
        D.48913 = imb.b[3];
        *code.7618 = D.48913;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48903>:
  <D.24722>:
  code.7619 = code;
  code = code.7619 + 1;
  *code.7619 = 141;
  D.48773 = cfg->frame_reg;
  if (D.48773 == 4) goto <D.48915>; else goto <D.48916>;
  <D.48915>:
  if (lmf_offset == 0) goto <D.48917>; else goto <D.48918>;
  <D.48917>:
  code.7620 = code;
  code = code.7620 + 1;
  *code.7620 = 12;
  code.7621 = code;
  code = code.7621 + 1;
  *code.7621 = 36;
  goto <D.48921>;
  <D.48918>:
  lmf_offset.7603 = (unsigned int) lmf_offset;
  D.48877 = lmf_offset.7603 + 128;
  if (D.48877 <= 255) goto <D.48922>; else goto <D.48923>;
  <D.48922>:
  code.7622 = code;
  code = code.7622 + 1;
  *code.7622 = 76;
  code.7623 = code;
  code = code.7623 + 1;
  *code.7623 = 36;
  D.48926 = (unsigned char) lmf_offset;
  *code = D.48926;
  code = code + 1;
  goto <D.48927>;
  <D.48923>:
  code.7624 = code;
  code = code.7624 + 1;
  *code.7624 = 140;
  code.7625 = code;
  code = code.7625 + 1;
  *code.7625 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = lmf_offset;
        code.7626 = code;
        code = code.7626 + 1;
        D.48931 = imb.b[0];
        *code.7626 = D.48931;
        code.7627 = code;
        code = code.7627 + 1;
        D.48933 = imb.b[1];
        *code.7627 = D.48933;
        code.7628 = code;
        code = code.7628 + 1;
        D.48935 = imb.b[2];
        *code.7628 = D.48935;
        code.7629 = code;
        code = code.7629 + 1;
        D.48937 = imb.b[3];
        *code.7629 = D.48937;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48927>:
  <D.48921>:
  goto <D.24725>;
  <D.48916>:
  if (lmf_offset == 0) goto <D.48938>; else goto <D.48939>;
  <D.48938>:
  D.48773 = cfg->frame_reg;
  if (D.48773 != 5) goto <D.48940>; else goto <D.48941>;
  <D.48940>:
  code.7630 = code;
  code = code.7630 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48898 = D.48808 | 8;
  *code.7630 = D.48898;
  goto <D.24725>;
  <D.48941>:
  <D.48939>:
  lmf_offset.7603 = (unsigned int) lmf_offset;
  D.48877 = lmf_offset.7603 + 128;
  if (D.48877 <= 255) goto <D.48943>; else goto <D.48944>;
  <D.48943>:
  code.7631 = code;
  code = code.7631 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48902 = D.48808 | 72;
  *code.7631 = D.48902;
  D.48926 = (unsigned char) lmf_offset;
  *code = D.48926;
  code = code + 1;
  goto <D.48946>;
  <D.48944>:
  code.7632 = code;
  code = code.7632 + 1;
  D.48773 = cfg->frame_reg;
  D.48807 = (unsigned char) D.48773;
  D.48808 = D.48807 & 7;
  D.48905 = D.48808 | 136;
  *code.7632 = D.48905;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = lmf_offset;
        code.7633 = code;
        code = code.7633 + 1;
        D.48949 = imb.b[0];
        *code.7633 = D.48949;
        code.7634 = code;
        code = code.7634 + 1;
        D.48951 = imb.b[1];
        *code.7634 = D.48951;
        code.7635 = code;
        code = code.7635 + 1;
        D.48953 = imb.b[2];
        *code.7635 = D.48953;
        code.7636 = code;
        code = code.7636 + 1;
        D.48955 = imb.b[3];
        *code.7636 = D.48955;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48946>:
  <D.24725>:
  switch (4) <default: <D.24731>, case 1: <D.24727>, case 2: <D.24729>, case 4: <D.24730>>
  <D.24727>:
  code.7637 = code;
  code = code.7637 + 1;
  *code.7637 = 136;
  goto <D.24728>;
  <D.24729>:
  code.7638 = code;
  code = code.7638 + 1;
  *code.7638 = 102;
  <D.24730>:
  code.7639 = code;
  code = code.7639 + 1;
  *code.7639 = 137;
  goto <D.24728>;
  <D.24731>:
  __assert_fail ("0", "mini-x86.c", 2532, &__PRETTY_FUNCTION__);
  <D.24728>:
  if (0 != 0) goto <D.48959>; else goto <D.48960>;
  <D.48959>:
  if (1 != 0) goto <D.48961>; else goto <D.48962>;
  <D.48961>:
  code.7640 = code;
  code = code.7640 + 1;
  *code.7640 = 12;
  code.7641 = code;
  code = code.7641 + 1;
  *code.7641 = 36;
  goto <D.48965>;
  <D.48962>:
  if (1 != 0) goto <D.48966>; else goto <D.48967>;
  <D.48966>:
  code.7642 = code;
  code = code.7642 + 1;
  *code.7642 = 76;
  code.7643 = code;
  code = code.7643 + 1;
  *code.7643 = 36;
  *code = 0;
  code = code + 1;
  goto <D.48970>;
  <D.48967>:
  code.7644 = code;
  code = code.7644 + 1;
  *code.7644 = 140;
  code.7645 = code;
  code = code.7645 + 1;
  *code.7645 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7646 = code;
        code = code.7646 + 1;
        D.48974 = imb.b[0];
        *code.7646 = D.48974;
        code.7647 = code;
        code = code.7647 + 1;
        D.48976 = imb.b[1];
        *code.7647 = D.48976;
        code.7648 = code;
        code = code.7648 + 1;
        D.48978 = imb.b[2];
        *code.7648 = D.48978;
        code.7649 = code;
        code = code.7649 + 1;
        D.48980 = imb.b[3];
        *code.7649 = D.48980;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48970>:
  <D.48965>:
  goto <D.24733>;
  <D.48960>:
  if (1 != 0) goto <D.48981>; else goto <D.48982>;
  <D.48981>:
  code.7650 = code;
  code = code.7650 + 1;
  *code.7650 = 8;
  goto <D.24733>;
  <D.48982>:
  if (1 != 0) goto <D.48984>; else goto <D.48985>;
  <D.48984>:
  code.7651 = code;
  code = code.7651 + 1;
  *code.7651 = 72;
  *code = 0;
  code = code + 1;
  goto <D.48987>;
  <D.48985>:
  code.7652 = code;
  code = code.7652 + 1;
  *code.7652 = 136;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7653 = code;
        code = code.7653 + 1;
        D.48990 = imb.b[0];
        *code.7653 = D.48990;
        code.7654 = code;
        code = code.7654 + 1;
        D.48992 = imb.b[1];
        *code.7654 = D.48992;
        code.7655 = code;
        code = code.7655 + 1;
        D.48994 = imb.b[2];
        *code.7655 = D.48994;
        code.7656 = code;
        code = code.7656 + 1;
        D.48996 = imb.b[3];
        *code.7656 = D.48996;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.48987>:
  <D.24733>:
  D.48997 = code;
  return D.48997;
}


mono_arch_emit_epilog (struct MonoCompile * cfg)
{
  struct MonoMethod * D.48999;
  unsigned char D.49000;
  unsigned char D.49001;
  unsigned int D.49004;
  unsigned int D.49005;
  void * D.49006;
  int D.49007;
  int D.49008;
  unsigned int D.49009;
  unsigned int max_epilog_size.7657;
  unsigned int D.49011;
  unsigned int D.49012;
  unsigned char * D.49013;
  struct MonoTraceSpec * mono_jit_trace_calls.7658;
  int D.49017;
  unsigned char D.49020;
  unsigned char D.49021;
  struct MonoInst * D.49024;
  unsigned char D.49025;
  unsigned char D.49026;
  int D.49030;
  int D.49038;
  guint8 * code.7659;
  guint8 * code.7660;
  guint8 * code.7661;
  guint8 * code.7662;
  guint8 * code.7663;
  guint8 * code.7664;
  guint8 * code.7665;
  guint8 * code.7666;
  guint8 * code.7667;
  guint8 * code.7668;
  unsigned char D.49057;
  guint8 * code.7669;
  unsigned char D.49059;
  guint8 * code.7670;
  unsigned char D.49061;
  guint8 * code.7671;
  unsigned char D.49063;
  guint8 * code.7672;
  guint8 * code.7673;
  guint8 * code.7674;
  guint8 * code.7675;
  unsigned char D.49073;
  guint8 * code.7676;
  unsigned char D.49075;
  guint8 * code.7677;
  unsigned char D.49077;
  guint8 * code.7678;
  unsigned char D.49079;
  guint8 * code.7679;
  guint8 * code.7680;
  unsigned char D.49084;
  guint8 * code.7681;
  unsigned char D.49086;
  guint8 * code.7682;
  unsigned char D.49088;
  guint8 * code.7683;
  unsigned char D.49090;
  guint8 * code.7684;
  guint8 * code.7685;
  guint8 * code.7686;
  guint8 * code.7687;
  guint8 * code.7688;
  unsigned char D.49099;
  guint8 * code.7689;
  unsigned char D.49101;
  guint8 * code.7690;
  unsigned char D.49103;
  guint8 * code.7691;
  unsigned char D.49105;
  guint8 * code.7692;
  unsigned char D.49109;
  guint8 * code.7693;
  unsigned char D.49112;
  guint8 * code.7694;
  guint8 * code.7695;
  unsigned char D.49115;
  int D.49116;
  unsigned char D.49117;
  unsigned char D.49118;
  int code.7696;
  int pos.7697;
  int D.49125;
  unsigned char * pos.7698;
  unsigned char D.49127;
  unsigned char * pos.7699;
  unsigned char D.49129;
  unsigned char * pos.7700;
  unsigned char D.49131;
  unsigned char * pos.7701;
  unsigned char D.49133;
  unsigned int disp.7702;
  unsigned int D.49136;
  unsigned char D.49139;
  unsigned char D.49140;
  unsigned char D.49143;
  unsigned char D.49144;
  unsigned int D.49147;
  unsigned int D.49148;
  guint8 * code.7703;
  guint8 * code.7704;
  guint8 * code.7705;
  unsigned int D.49154;
  guint8 * code.7706;
  guint8 * code.7707;
  unsigned int lmf_offset.7708;
  unsigned int D.49165;
  int D.49166;
  guint8 * code.7709;
  guint8 * code.7710;
  unsigned char D.49171;
  unsigned char D.49172;
  guint8 * code.7711;
  guint8 * code.7712;
  guint8 * code.7713;
  unsigned char D.49176;
  guint8 * code.7714;
  unsigned char D.49178;
  guint8 * code.7715;
  unsigned char D.49180;
  guint8 * code.7716;
  unsigned char D.49182;
  guint8 * code.7717;
  unsigned char D.49188;
  unsigned char D.49189;
  unsigned char D.49190;
  guint8 * code.7718;
  unsigned char D.49196;
  guint8 * code.7719;
  unsigned char D.49198;
  guint8 * code.7720;
  unsigned char D.49200;
  guint8 * code.7721;
  unsigned char D.49202;
  guint8 * code.7722;
  unsigned char D.49204;
  guint8 * code.7723;
  unsigned char D.49206;
  unsigned int D.49207;
  guint8 * code.7724;
  guint8 * code.7725;
  guint8 * code.7726;
  guint8 * code.7727;
  guint8 * code.7728;
  unsigned int D.49222;
  int D.49223;
  guint8 * code.7729;
  guint8 * code.7730;
  unsigned char D.49228;
  guint8 * code.7731;
  guint8 * code.7732;
  guint8 * code.7733;
  unsigned char D.49232;
  guint8 * code.7734;
  unsigned char D.49234;
  guint8 * code.7735;
  unsigned char D.49236;
  guint8 * code.7736;
  unsigned char D.49238;
  guint8 * code.7737;
  unsigned char D.49244;
  guint8 * code.7738;
  unsigned char D.49250;
  guint8 * code.7739;
  unsigned char D.49252;
  guint8 * code.7740;
  unsigned char D.49254;
  guint8 * code.7741;
  unsigned char D.49256;
  guint8 * code.7742;
  unsigned char D.49258;
  guint8 * code.7743;
  unsigned char D.49260;
  unsigned int D.49261;
  guint8 * code.7744;
  guint8 * code.7745;
  guint8 * code.7746;
  guint8 * code.7747;
  guint8 * code.7748;
  unsigned int D.49276;
  int D.49277;
  guint8 * code.7749;
  guint8 * code.7750;
  unsigned char D.49282;
  guint8 * code.7751;
  guint8 * code.7752;
  guint8 * code.7753;
  unsigned char D.49286;
  guint8 * code.7754;
  unsigned char D.49288;
  guint8 * code.7755;
  unsigned char D.49290;
  guint8 * code.7756;
  unsigned char D.49292;
  guint8 * code.7757;
  unsigned char D.49298;
  guint8 * code.7758;
  unsigned char D.49304;
  guint8 * code.7759;
  unsigned char D.49306;
  guint8 * code.7760;
  unsigned char D.49308;
  guint8 * code.7761;
  unsigned char D.49310;
  guint8 * code.7762;
  unsigned char D.49312;
  guint8 * code.7763;
  unsigned char D.49314;
  int D.49316;
  unsigned int D.49317;
  unsigned int D.49318;
  unsigned int D.49319;
  _Bool D.49326;
  long int D.49327;
  long int D.49328;
  guint8 * code.7764;
  guint8 * code.7765;
  guint8 * code.7766;
  unsigned int pos.7767;
  unsigned int D.49340;
  guint8 * code.7768;
  guint8 * code.7769;
  unsigned char D.49345;
  guint8 * code.7770;
  guint8 * code.7771;
  guint8 * code.7772;
  unsigned char D.49350;
  guint8 * code.7773;
  unsigned char D.49352;
  guint8 * code.7774;
  unsigned char D.49354;
  guint8 * code.7775;
  unsigned char D.49356;
  guint8 * code.7776;
  guint8 * code.7777;
  guint8 * code.7778;
  guint8 * code.7779;
  unsigned char D.49366;
  guint8 * code.7780;
  unsigned char D.49368;
  guint8 * code.7781;
  unsigned char D.49370;
  guint8 * code.7782;
  unsigned char D.49372;
  guint8 * code.7783;
  guint8 * code.7784;
  guint8 * code.7785;
  guint8 * code.7786;
  guint8 * code.7787;
  guint8 * code.7788;
  guint8 * code.7789;
  guint8 * code.7790;
  unsigned char D.49393;
  guint8 * code.7791;
  unsigned char D.49395;
  guint8 * code.7792;
  unsigned char D.49397;
  guint8 * code.7793;
  unsigned char D.49399;
  guint8 * code.7794;
  guint8 * code.7795;
  guint8 * code.7796;
  guint8 * code.7797;
  unsigned char D.49409;
  guint8 * code.7798;
  unsigned char D.49411;
  guint8 * code.7799;
  unsigned char D.49413;
  guint8 * code.7800;
  unsigned char D.49415;
  guint8 * code.7801;
  guint8 * code.7802;
  guint8 * code.7803;
  struct MonoMemPool * D.49425;
  struct MonoGenericSharingContext * D.49426;
  <unnamed type> D.49427;
  <unnamed type> D.49430;
  guint8 * code.7804;
  guint8 * code.7805;
  guint8 * code.7806;
  struct MonoInst * D.49434;
  int D.49435;
  int D.49438;
  unsigned int D.49439;
  unsigned int quad.7807;
  unsigned int D.49441;
  unsigned int D.49442;
  guint8 * code.7808;
  signed char D.49446;
  int D.49447;
  int D.49448;
  int D.49449;
  signed char D.49450;
  signed char D.49451;
  unsigned char D.49452;
  guint8 * code.7809;
  int D.49457;
  guint8 * code.7810;
  signed char D.49461;
  unsigned char D.49462;
  guint8 * code.7811;
  unsigned char D.49464;
  unsigned char D.49465;
  unsigned char D.49466;
  unsigned char D.49467;
  guint8 * code.7812;
  signed char D.49469;
  unsigned char D.49470;
  guint8 * code.7813;
  guint8 * code.7814;
  unsigned char D.49473;
  guint8 * code.7815;
  unsigned char D.49475;
  guint8 * code.7816;
  unsigned char D.49477;
  guint8 * code.7817;
  unsigned char D.49479;
  guint8 * code.7818;
  signed char D.49485;
  signed char D.49486;
  signed char D.49487;
  unsigned char D.49488;
  guint8 * code.7819;
  signed char D.49494;
  signed char D.49495;
  unsigned char D.49496;
  guint8 * code.7820;
  signed char D.49498;
  signed char D.49499;
  unsigned char D.49500;
  guint8 * code.7821;
  unsigned char D.49502;
  guint8 * code.7822;
  unsigned char D.49504;
  guint8 * code.7823;
  unsigned char D.49506;
  guint8 * code.7824;
  unsigned char D.49508;
  guint8 * code.7825;
  guint8 * code.7826;
  guint8 * code.7827;
  guint8 * code.7828;
  guint8 * code.7829;
  guint8 * code.7830;
  guint8 * code.7831;
  guint8 * code.7832;
  unsigned char D.49526;
  guint8 * code.7833;
  unsigned char D.49528;
  guint8 * code.7834;
  unsigned char D.49530;
  guint8 * code.7835;
  unsigned char D.49532;
  guint8 * code.7836;
  unsigned char D.49538;
  unsigned char D.49539;
  guint8 * code.7837;
  signed char D.49545;
  unsigned char D.49546;
  guint8 * code.7838;
  signed char D.49548;
  unsigned char D.49549;
  guint8 * code.7839;
  unsigned char D.49551;
  guint8 * code.7840;
  unsigned char D.49553;
  guint8 * code.7841;
  unsigned char D.49555;
  guint8 * code.7842;
  unsigned char D.49557;
  guint8 * code.7843;
  guint8 * code.7844;
  guint8 * code.7845;
  guint8 * code.7846;
  guint8 * code.7847;
  guint8 * code.7848;
  guint8 * code.7849;
  guint8 * code.7850;
  unsigned char D.49575;
  guint8 * code.7851;
  unsigned char D.49577;
  guint8 * code.7852;
  unsigned char D.49579;
  guint8 * code.7853;
  unsigned char D.49581;
  guint8 * code.7854;
  guint8 * code.7855;
  guint8 * code.7856;
  guint8 * code.7857;
  unsigned char D.49594;
  guint8 * code.7858;
  unsigned char D.49596;
  guint8 * code.7859;
  unsigned char D.49598;
  guint8 * code.7860;
  unsigned char D.49600;
  guint8 * code.7861;
  unsigned char D.49607;
  unsigned char D.49608;
  short unsigned int D.49610;
  short unsigned int D.49611;
  short unsigned int D.49612;
  int D.49613;
  int D.49614;
  unsigned int D.49615;
  unsigned int D.49616;
  int D.49617;
  int D.49618;
  guint8 * code.7862;
  guint8 * code.7863;
  short int D.49631;
  guint8 * code.7864;
  int D.49634;
  int D.49635;
  unsigned int D.49636;
  _Bool D.49637;
  long int D.49638;
  long int D.49639;
  struct MonoMethod * method;
  struct MonoMethodSignature * sig;
  int i;
  int quad;
  int pos;
  guint32 stack_to_pop;
  guint8 * code;
  int max_epilog_size;
  struct CallInfo * cinfo;
  gboolean need_stack_frame;
  static const char __PRETTY_FUNCTION__[22] = "mono_arch_emit_epilog";

  method = cfg->method;
  sig = mono_method_signature (method);
  max_epilog_size = 16;
  need_stack_frame = needs_stack_frame (cfg);
  D.48999 = cfg->method;
  D.49000 = BIT_FIELD_REF <*D.48999, 8, 168>;
  D.49001 = D.49000 & 1;
  if (D.49001 != 0) goto <D.49002>; else goto <D.49003>;
  <D.49002>:
  max_epilog_size = max_epilog_size + 128;
  <D.49003>:
  goto <D.28645>;
  <D.28644>:
  D.49004 = cfg->code_size;
  D.49005 = D.49004 * 2;
  cfg->code_size = D.49005;
  D.49006 = mono_realloc_native_code (cfg);
  cfg->native_code = D.49006;
  D.49007 = cfg->stat_code_reallocs;
  D.49008 = D.49007 + 1;
  cfg->stat_code_reallocs = D.49008;
  <D.28645>:
  D.49009 = cfg->code_len;
  max_epilog_size.7657 = (unsigned int) max_epilog_size;
  D.49011 = D.49009 + max_epilog_size.7657;
  D.49004 = cfg->code_size;
  D.49012 = D.49004 + 4294967280;
  if (D.49011 > D.49012) goto <D.28644>; else goto <D.28646>;
  <D.28646>:
  D.49013 = cfg->native_code;
  D.49009 = cfg->code_len;
  code = D.49013 + D.49009;
  mono_jit_trace_calls.7658 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.7658 != 0B) goto <D.49015>; else goto <D.49016>;
  <D.49015>:
  D.49017 = mono_trace_eval (method);
  if (D.49017 != 0) goto <D.49018>; else goto <D.49019>;
  <D.49018>:
  code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, 1);
  <D.49019>:
  <D.49016>:
  pos = 0;
  D.49020 = BIT_FIELD_REF <*method, 8, 168>;
  D.49021 = D.49020 & 1;
  if (D.49021 != 0) goto <D.49022>; else goto <D.49023>;
  <D.49022>:
  {
    gint32 lmf_offset;
    guint8 * patch;
    gboolean supported;

    D.49024 = cfg->lmf_var;
    lmf_offset = D.49024->data.op[0].const_val;
    supported = 0;
    D.49025 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.49026 = D.49025 & 64;
    if (D.49026 != 0) goto <D.49027>; else goto <D.49028>;
    <D.49027>:
    supported = 1;
    goto <D.49029>;
    <D.49028>:
    D.49030 = mono_get_jit_tls_offset ();
    if (D.49030 != -1) goto <D.49031>; else goto <D.49032>;
    <D.49031>:
    supported = 1;
    <D.49032>:
    <D.49029>:
    if (supported != 0) goto <D.49033>; else goto <D.49034>;
    <D.49033>:
    D.49025 = BIT_FIELD_REF <*cfg, 8, 3392>;
    D.49026 = D.49025 & 64;
    if (D.49026 != 0) goto <D.49035>; else goto <D.49036>;
    <D.49035>:
    code = emit_load_aotconst (0B, code, cfg, 0B, 1, 48, 1B);
    code = emit_tls_get_reg (code, 1, 1);
    goto <D.49037>;
    <D.49036>:
    D.49038 = mono_get_jit_tls_offset ();
    code = mono_x86_emit_tls_get (code, 1, D.49038);
    <D.49037>:
    switch (4) <default: <D.28654>, case 1: <D.28650>, case 2: <D.28652>, case 4: <D.28653>>
    <D.28650>:
    code.7659 = code;
    code = code.7659 + 1;
    *code.7659 = 138;
    goto <D.28651>;
    <D.28652>:
    code.7660 = code;
    code = code.7660 + 1;
    *code.7660 = 102;
    <D.28653>:
    code.7661 = code;
    code = code.7661 + 1;
    *code.7661 = 139;
    goto <D.28651>;
    <D.28654>:
    __assert_fail ("0", "mini-x86.c", 5569, &__PRETTY_FUNCTION__);
    <D.28651>:
    if (0 != 0) goto <D.49042>; else goto <D.49043>;
    <D.49042>:
    if (0 != 0) goto <D.49044>; else goto <D.49045>;
    <D.49044>:
    code.7662 = code;
    code = code.7662 + 1;
    *code.7662 = 12;
    code.7663 = code;
    code = code.7663 + 1;
    *code.7663 = 36;
    goto <D.49048>;
    <D.49045>:
    if (1 != 0) goto <D.49049>; else goto <D.49050>;
    <D.49049>:
    code.7664 = code;
    code = code.7664 + 1;
    *code.7664 = 76;
    code.7665 = code;
    code = code.7665 + 1;
    *code.7665 = 36;
    *code = 12;
    code = code + 1;
    goto <D.49053>;
    <D.49050>:
    code.7666 = code;
    code = code.7666 + 1;
    *code.7666 = 140;
    code.7667 = code;
    code = code.7667 + 1;
    *code.7667 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 12;
          code.7668 = code;
          code = code.7668 + 1;
          D.49057 = imb.b[0];
          *code.7668 = D.49057;
          code.7669 = code;
          code = code.7669 + 1;
          D.49059 = imb.b[1];
          *code.7669 = D.49059;
          code.7670 = code;
          code = code.7670 + 1;
          D.49061 = imb.b[2];
          *code.7670 = D.49061;
          code.7671 = code;
          code = code.7671 + 1;
          D.49063 = imb.b[3];
          *code.7671 = D.49063;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49053>:
    <D.49048>:
    goto <D.28657>;
    <D.49043>:
    if (0 != 0) goto <D.49064>; else goto <D.49065>;
    <D.49064>:
    code.7672 = code;
    code = code.7672 + 1;
    *code.7672 = 9;
    goto <D.28657>;
    <D.49065>:
    if (1 != 0) goto <D.49067>; else goto <D.49068>;
    <D.49067>:
    code.7673 = code;
    code = code.7673 + 1;
    *code.7673 = 73;
    *code = 12;
    code = code + 1;
    goto <D.49070>;
    <D.49068>:
    code.7674 = code;
    code = code.7674 + 1;
    *code.7674 = 137;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 12;
          code.7675 = code;
          code = code.7675 + 1;
          D.49073 = imb.b[0];
          *code.7675 = D.49073;
          code.7676 = code;
          code = code.7676 + 1;
          D.49075 = imb.b[1];
          *code.7676 = D.49075;
          code.7677 = code;
          code = code.7677 + 1;
          D.49077 = imb.b[2];
          *code.7677 = D.49077;
          code.7678 = code;
          code = code.7678 + 1;
          D.49079 = imb.b[3];
          *code.7678 = D.49079;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49070>:
    <D.28657>:
    if (0 != 0) goto <D.49080>; else goto <D.49081>;
    <D.49080>:
    code.7679 = code;
    code = code.7679 + 1;
    *code.7679 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.7680 = code;
          code = code.7680 + 1;
          D.49084 = imb.b[0];
          *code.7680 = D.49084;
          code.7681 = code;
          code = code.7681 + 1;
          D.49086 = imb.b[1];
          *code.7681 = D.49086;
          code.7682 = code;
          code = code.7682 + 1;
          D.49088 = imb.b[2];
          *code.7682 = D.49088;
          code.7683 = code;
          code = code.7683 + 1;
          D.49090 = imb.b[3];
          *code.7683 = D.49090;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.28660>;
    <D.49081>:
    if (1 != 0) goto <D.49091>; else goto <D.49092>;
    <D.49091>:
    code.7684 = code;
    code = code.7684 + 1;
    *code.7684 = 131;
    code.7685 = code;
    code = code.7685 + 1;
    *code.7685 = 249;
    *code = 0;
    code = code + 1;
    goto <D.49095>;
    <D.49092>:
    code.7686 = code;
    code = code.7686 + 1;
    *code.7686 = 129;
    code.7687 = code;
    code = code.7687 + 1;
    *code.7687 = 249;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.7688 = code;
          code = code.7688 + 1;
          D.49099 = imb.b[0];
          *code.7688 = D.49099;
          code.7689 = code;
          code = code.7689 + 1;
          D.49101 = imb.b[1];
          *code.7689 = D.49101;
          code.7690 = code;
          code = code.7690 + 1;
          D.49103 = imb.b[2];
          *code.7690 = D.49103;
          code.7691 = code;
          code = code.7691 + 1;
          D.49105 = imb.b[3];
          *code.7691 = D.49105;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49095>:
    <D.28660>:
    patch = code;
    if (0 != 0) goto <D.49106>; else goto <D.49107>;
    <D.49106>:
    code.7692 = code;
    code = code.7692 + 1;
    D.49109 = 116;
    *code.7692 = D.49109;
    goto <D.49110>;
    <D.49107>:
    code.7693 = code;
    code = code.7693 + 1;
    D.49112 = 116;
    *code.7693 = D.49112;
    <D.49110>:
    *code = 0;
    code = code + 1;
    code.7694 = code;
    code = code.7694 + 1;
    *code.7694 = 255;
    code.7695 = code;
    code = code.7695 + 1;
    *code.7695 = 209;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = patch + 1;
      size = 0;
      D.49115 = MEM[(unsigned char *)patch];
      D.49116 = (int) D.49115;
      switch (D.49116) <default: <D.28689>, case 15: <D.28668>, case 112: <D.28673>, case 113: <D.28674>, case 114: <D.28675>, case 115: <D.28676>, case 116: <D.28677>, case 117: <D.28678>, case 118: <D.28679>, case 119: <D.28680>, case 120: <D.28681>, case 121: <D.28682>, case 122: <D.28683>, case 123: <D.28684>, case 124: <D.28685>, case 125: <D.28686>, case 126: <D.28687>, case 127: <D.28688>, case 224: <D.28669>, case 225: <D.28670>, case 226: <D.28671>, case 232: <D.28665>, case 233: <D.28666>, case 235: <D.28672>>
      <D.28665>:
      <D.28666>:
      size = size + 1;
      goto <D.28667>;
      <D.28668>:
      D.49117 = *pos;
      D.49118 = D.49117 + 144;
      if (D.49118 > 31) goto <D.49119>; else goto <D.49120>;
      <D.49119>:
      __assert_fail ("0", "mini-x86.c", 5575, &__PRETTY_FUNCTION__);
      <D.49120>:
      size = size + 1;
      pos = pos + 1;
      goto <D.28667>;
      <D.28669>:
      <D.28670>:
      <D.28671>:
      <D.28672>:
      <D.28673>:
      <D.28674>:
      <D.28675>:
      <D.28676>:
      <D.28677>:
      <D.28678>:
      <D.28679>:
      <D.28680>:
      <D.28681>:
      <D.28682>:
      <D.28683>:
      <D.28684>:
      <D.28685>:
      <D.28686>:
      <D.28687>:
      <D.28688>:
      goto <D.28667>;
      <D.28689>:
      __assert_fail ("0", "mini-x86.c", 5575, &__PRETTY_FUNCTION__);
      <D.28667>:
      code.7696 = (int) code;
      pos.7697 = (int) pos;
      disp = code.7696 - pos.7697;
      if (size != 0) goto <D.49123>; else goto <D.49124>;
      <D.49123>:
      {
        union x86_imm_buf imb;

        try
          {
            D.49125 = disp + -4;
            imb.val = D.49125;
            pos.7698 = pos;
            pos = pos.7698 + 1;
            D.49127 = imb.b[0];
            *pos.7698 = D.49127;
            pos.7699 = pos;
            pos = pos.7699 + 1;
            D.49129 = imb.b[1];
            *pos.7699 = D.49129;
            pos.7700 = pos;
            pos = pos.7700 + 1;
            D.49131 = imb.b[2];
            *pos.7700 = D.49131;
            pos.7701 = pos;
            pos = pos.7701 + 1;
            D.49133 = imb.b[3];
            *pos.7701 = D.49133;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.49134>;
      <D.49124>:
      disp.7702 = (unsigned int) disp;
      D.49136 = disp.7702 + 127;
      if (D.49136 <= 255) goto <D.49137>; else goto <D.49138>;
      <D.49137>:
      D.49139 = (unsigned char) disp;
      D.49140 = D.49139 + 255;
      *pos = D.49140;
      pos = pos + 1;
      goto <D.49141>;
      <D.49138>:
      __assert_fail ("0", "mini-x86.c", 5575, &__PRETTY_FUNCTION__);
      <D.49141>:
      <D.49134>:
    }
    goto <D.49142>;
    <D.49034>:
    <D.49142>:
    D.49143 = BIT_FIELD_REF <*cfg, 8, 3416>;
    D.49144 = D.49143 & 4;
    if (D.49144 == 0) goto <D.49145>; else goto <D.49146>;
    <D.49145>:
    code = emit_pop_lmf (cfg, code, lmf_offset);
    <D.49146>:
    D.49147 = cfg->used_int_regs;
    D.49148 = D.49147 & 8;
    if (D.49148 != 0) goto <D.49149>; else goto <D.49150>;
    <D.49149>:
    switch (4) <default: <D.28695>, case 1: <D.28691>, case 2: <D.28693>, case 4: <D.28694>>
    <D.28691>:
    code.7703 = code;
    code = code.7703 + 1;
    *code.7703 = 138;
    goto <D.28692>;
    <D.28693>:
    code.7704 = code;
    code = code.7704 + 1;
    *code.7704 = 102;
    <D.28694>:
    code.7705 = code;
    code = code.7705 + 1;
    *code.7705 = 139;
    goto <D.28692>;
    <D.28695>:
    __assert_fail ("0", "mini-x86.c", 5585, &__PRETTY_FUNCTION__);
    <D.28692>:
    D.49154 = cfg->frame_reg;
    if (D.49154 == 4) goto <D.49155>; else goto <D.49156>;
    <D.49155>:
    if (lmf_offset == -16) goto <D.49157>; else goto <D.49158>;
    <D.49157>:
    code.7706 = code;
    code = code.7706 + 1;
    *code.7706 = 28;
    code.7707 = code;
    code = code.7707 + 1;
    *code.7707 = 36;
    goto <D.49161>;
    <D.49158>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49165 = lmf_offset.7708 + 16;
    D.49166 = (int) D.49165;
    if (D.49166 >= -128) goto <D.49167>; else goto <D.49162>;
    <D.49167>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49165 = lmf_offset.7708 + 16;
    D.49166 = (int) D.49165;
    if (D.49166 <= 127) goto <D.49168>; else goto <D.49162>;
    <D.49168>:
    code.7709 = code;
    code = code.7709 + 1;
    *code.7709 = 92;
    code.7710 = code;
    code = code.7710 + 1;
    *code.7710 = 36;
    D.49171 = (unsigned char) lmf_offset;
    D.49172 = D.49171 + 16;
    *code = D.49172;
    code = code + 1;
    goto <D.49163>;
    <D.49162>:
    code.7711 = code;
    code = code.7711 + 1;
    *code.7711 = 156;
    code.7712 = code;
    code = code.7712 + 1;
    *code.7712 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          lmf_offset.7708 = (unsigned int) lmf_offset;
          D.49165 = lmf_offset.7708 + 16;
          D.49166 = (int) D.49165;
          imb.val = D.49166;
          code.7713 = code;
          code = code.7713 + 1;
          D.49176 = imb.b[0];
          *code.7713 = D.49176;
          code.7714 = code;
          code = code.7714 + 1;
          D.49178 = imb.b[1];
          *code.7714 = D.49178;
          code.7715 = code;
          code = code.7715 + 1;
          D.49180 = imb.b[2];
          *code.7715 = D.49180;
          code.7716 = code;
          code = code.7716 + 1;
          D.49182 = imb.b[3];
          *code.7716 = D.49182;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49163>:
    <D.49161>:
    goto <D.28697>;
    <D.49156>:
    if (lmf_offset == -16) goto <D.49183>; else goto <D.49184>;
    <D.49183>:
    D.49154 = cfg->frame_reg;
    if (D.49154 != 5) goto <D.49185>; else goto <D.49186>;
    <D.49185>:
    code.7717 = code;
    code = code.7717 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49190 = D.49189 | 24;
    *code.7717 = D.49190;
    goto <D.28697>;
    <D.49186>:
    <D.49184>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49165 = lmf_offset.7708 + 16;
    D.49166 = (int) D.49165;
    if (D.49166 >= -128) goto <D.49193>; else goto <D.49191>;
    <D.49193>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49165 = lmf_offset.7708 + 16;
    D.49166 = (int) D.49165;
    if (D.49166 <= 127) goto <D.49194>; else goto <D.49191>;
    <D.49194>:
    code.7718 = code;
    code = code.7718 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49196 = D.49189 | 88;
    *code.7718 = D.49196;
    D.49171 = (unsigned char) lmf_offset;
    D.49172 = D.49171 + 16;
    *code = D.49172;
    code = code + 1;
    goto <D.49192>;
    <D.49191>:
    code.7719 = code;
    code = code.7719 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49198 = D.49189 | 152;
    *code.7719 = D.49198;
    {
      union x86_imm_buf imb;

      try
        {
          lmf_offset.7708 = (unsigned int) lmf_offset;
          D.49165 = lmf_offset.7708 + 16;
          D.49166 = (int) D.49165;
          imb.val = D.49166;
          code.7720 = code;
          code = code.7720 + 1;
          D.49200 = imb.b[0];
          *code.7720 = D.49200;
          code.7721 = code;
          code = code.7721 + 1;
          D.49202 = imb.b[1];
          *code.7721 = D.49202;
          code.7722 = code;
          code = code.7722 + 1;
          D.49204 = imb.b[2];
          *code.7722 = D.49204;
          code.7723 = code;
          code = code.7723 + 1;
          D.49206 = imb.b[3];
          *code.7723 = D.49206;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49192>:
    <D.28697>:
    <D.49150>:
    D.49147 = cfg->used_int_regs;
    D.49207 = D.49147 & 128;
    if (D.49207 != 0) goto <D.49208>; else goto <D.49209>;
    <D.49208>:
    switch (4) <default: <D.28703>, case 1: <D.28699>, case 2: <D.28701>, case 4: <D.28702>>
    <D.28699>:
    code.7724 = code;
    code = code.7724 + 1;
    *code.7724 = 138;
    goto <D.28700>;
    <D.28701>:
    code.7725 = code;
    code = code.7725 + 1;
    *code.7725 = 102;
    <D.28702>:
    code.7726 = code;
    code = code.7726 + 1;
    *code.7726 = 139;
    goto <D.28700>;
    <D.28703>:
    __assert_fail ("0", "mini-x86.c", 5589, &__PRETTY_FUNCTION__);
    <D.28700>:
    D.49154 = cfg->frame_reg;
    if (D.49154 == 4) goto <D.49213>; else goto <D.49214>;
    <D.49213>:
    if (lmf_offset == -20) goto <D.49215>; else goto <D.49216>;
    <D.49215>:
    code.7727 = code;
    code = code.7727 + 1;
    *code.7727 = 60;
    code.7728 = code;
    code = code.7728 + 1;
    *code.7728 = 36;
    goto <D.49219>;
    <D.49216>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49222 = lmf_offset.7708 + 20;
    D.49223 = (int) D.49222;
    if (D.49223 >= -128) goto <D.49224>; else goto <D.49220>;
    <D.49224>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49222 = lmf_offset.7708 + 20;
    D.49223 = (int) D.49222;
    if (D.49223 <= 127) goto <D.49225>; else goto <D.49220>;
    <D.49225>:
    code.7729 = code;
    code = code.7729 + 1;
    *code.7729 = 124;
    code.7730 = code;
    code = code.7730 + 1;
    *code.7730 = 36;
    D.49171 = (unsigned char) lmf_offset;
    D.49228 = D.49171 + 20;
    *code = D.49228;
    code = code + 1;
    goto <D.49221>;
    <D.49220>:
    code.7731 = code;
    code = code.7731 + 1;
    *code.7731 = 188;
    code.7732 = code;
    code = code.7732 + 1;
    *code.7732 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          lmf_offset.7708 = (unsigned int) lmf_offset;
          D.49222 = lmf_offset.7708 + 20;
          D.49223 = (int) D.49222;
          imb.val = D.49223;
          code.7733 = code;
          code = code.7733 + 1;
          D.49232 = imb.b[0];
          *code.7733 = D.49232;
          code.7734 = code;
          code = code.7734 + 1;
          D.49234 = imb.b[1];
          *code.7734 = D.49234;
          code.7735 = code;
          code = code.7735 + 1;
          D.49236 = imb.b[2];
          *code.7735 = D.49236;
          code.7736 = code;
          code = code.7736 + 1;
          D.49238 = imb.b[3];
          *code.7736 = D.49238;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49221>:
    <D.49219>:
    goto <D.28705>;
    <D.49214>:
    if (lmf_offset == -20) goto <D.49239>; else goto <D.49240>;
    <D.49239>:
    D.49154 = cfg->frame_reg;
    if (D.49154 != 5) goto <D.49241>; else goto <D.49242>;
    <D.49241>:
    code.7737 = code;
    code = code.7737 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49244 = D.49189 | 56;
    *code.7737 = D.49244;
    goto <D.28705>;
    <D.49242>:
    <D.49240>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49222 = lmf_offset.7708 + 20;
    D.49223 = (int) D.49222;
    if (D.49223 >= -128) goto <D.49247>; else goto <D.49245>;
    <D.49247>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49222 = lmf_offset.7708 + 20;
    D.49223 = (int) D.49222;
    if (D.49223 <= 127) goto <D.49248>; else goto <D.49245>;
    <D.49248>:
    code.7738 = code;
    code = code.7738 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49250 = D.49189 | 120;
    *code.7738 = D.49250;
    D.49171 = (unsigned char) lmf_offset;
    D.49228 = D.49171 + 20;
    *code = D.49228;
    code = code + 1;
    goto <D.49246>;
    <D.49245>:
    code.7739 = code;
    code = code.7739 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49252 = D.49189 | 184;
    *code.7739 = D.49252;
    {
      union x86_imm_buf imb;

      try
        {
          lmf_offset.7708 = (unsigned int) lmf_offset;
          D.49222 = lmf_offset.7708 + 20;
          D.49223 = (int) D.49222;
          imb.val = D.49223;
          code.7740 = code;
          code = code.7740 + 1;
          D.49254 = imb.b[0];
          *code.7740 = D.49254;
          code.7741 = code;
          code = code.7741 + 1;
          D.49256 = imb.b[1];
          *code.7741 = D.49256;
          code.7742 = code;
          code = code.7742 + 1;
          D.49258 = imb.b[2];
          *code.7742 = D.49258;
          code.7743 = code;
          code = code.7743 + 1;
          D.49260 = imb.b[3];
          *code.7743 = D.49260;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49246>:
    <D.28705>:
    <D.49209>:
    D.49147 = cfg->used_int_regs;
    D.49261 = D.49147 & 64;
    if (D.49261 != 0) goto <D.49262>; else goto <D.49263>;
    <D.49262>:
    switch (4) <default: <D.28711>, case 1: <D.28707>, case 2: <D.28709>, case 4: <D.28710>>
    <D.28707>:
    code.7744 = code;
    code = code.7744 + 1;
    *code.7744 = 138;
    goto <D.28708>;
    <D.28709>:
    code.7745 = code;
    code = code.7745 + 1;
    *code.7745 = 102;
    <D.28710>:
    code.7746 = code;
    code = code.7746 + 1;
    *code.7746 = 139;
    goto <D.28708>;
    <D.28711>:
    __assert_fail ("0", "mini-x86.c", 5592, &__PRETTY_FUNCTION__);
    <D.28708>:
    D.49154 = cfg->frame_reg;
    if (D.49154 == 4) goto <D.49267>; else goto <D.49268>;
    <D.49267>:
    if (lmf_offset == -24) goto <D.49269>; else goto <D.49270>;
    <D.49269>:
    code.7747 = code;
    code = code.7747 + 1;
    *code.7747 = 52;
    code.7748 = code;
    code = code.7748 + 1;
    *code.7748 = 36;
    goto <D.49273>;
    <D.49270>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49276 = lmf_offset.7708 + 24;
    D.49277 = (int) D.49276;
    if (D.49277 >= -128) goto <D.49278>; else goto <D.49274>;
    <D.49278>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49276 = lmf_offset.7708 + 24;
    D.49277 = (int) D.49276;
    if (D.49277 <= 127) goto <D.49279>; else goto <D.49274>;
    <D.49279>:
    code.7749 = code;
    code = code.7749 + 1;
    *code.7749 = 116;
    code.7750 = code;
    code = code.7750 + 1;
    *code.7750 = 36;
    D.49171 = (unsigned char) lmf_offset;
    D.49282 = D.49171 + 24;
    *code = D.49282;
    code = code + 1;
    goto <D.49275>;
    <D.49274>:
    code.7751 = code;
    code = code.7751 + 1;
    *code.7751 = 180;
    code.7752 = code;
    code = code.7752 + 1;
    *code.7752 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          lmf_offset.7708 = (unsigned int) lmf_offset;
          D.49276 = lmf_offset.7708 + 24;
          D.49277 = (int) D.49276;
          imb.val = D.49277;
          code.7753 = code;
          code = code.7753 + 1;
          D.49286 = imb.b[0];
          *code.7753 = D.49286;
          code.7754 = code;
          code = code.7754 + 1;
          D.49288 = imb.b[1];
          *code.7754 = D.49288;
          code.7755 = code;
          code = code.7755 + 1;
          D.49290 = imb.b[2];
          *code.7755 = D.49290;
          code.7756 = code;
          code = code.7756 + 1;
          D.49292 = imb.b[3];
          *code.7756 = D.49292;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49275>:
    <D.49273>:
    goto <D.28713>;
    <D.49268>:
    if (lmf_offset == -24) goto <D.49293>; else goto <D.49294>;
    <D.49293>:
    D.49154 = cfg->frame_reg;
    if (D.49154 != 5) goto <D.49295>; else goto <D.49296>;
    <D.49295>:
    code.7757 = code;
    code = code.7757 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49298 = D.49189 | 48;
    *code.7757 = D.49298;
    goto <D.28713>;
    <D.49296>:
    <D.49294>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49276 = lmf_offset.7708 + 24;
    D.49277 = (int) D.49276;
    if (D.49277 >= -128) goto <D.49301>; else goto <D.49299>;
    <D.49301>:
    lmf_offset.7708 = (unsigned int) lmf_offset;
    D.49276 = lmf_offset.7708 + 24;
    D.49277 = (int) D.49276;
    if (D.49277 <= 127) goto <D.49302>; else goto <D.49299>;
    <D.49302>:
    code.7758 = code;
    code = code.7758 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49304 = D.49189 | 112;
    *code.7758 = D.49304;
    D.49171 = (unsigned char) lmf_offset;
    D.49282 = D.49171 + 24;
    *code = D.49282;
    code = code + 1;
    goto <D.49300>;
    <D.49299>:
    code.7759 = code;
    code = code.7759 + 1;
    D.49154 = cfg->frame_reg;
    D.49188 = (unsigned char) D.49154;
    D.49189 = D.49188 & 7;
    D.49306 = D.49189 | 176;
    *code.7759 = D.49306;
    {
      union x86_imm_buf imb;

      try
        {
          lmf_offset.7708 = (unsigned int) lmf_offset;
          D.49276 = lmf_offset.7708 + 24;
          D.49277 = (int) D.49276;
          imb.val = D.49277;
          code.7760 = code;
          code = code.7760 + 1;
          D.49308 = imb.b[0];
          *code.7760 = D.49308;
          code.7761 = code;
          code = code.7761 + 1;
          D.49310 = imb.b[1];
          *code.7761 = D.49310;
          code.7762 = code;
          code = code.7762 + 1;
          D.49312 = imb.b[2];
          *code.7762 = D.49312;
          code.7763 = code;
          code = code.7763 + 1;
          D.49314 = imb.b[3];
          *code.7763 = D.49314;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.49300>:
    <D.28713>:
    <D.49263>:
  }
  goto <D.49315>;
  <D.49023>:
  i = 0;
  goto <D.28716>;
  <D.28715>:
  D.49147 = cfg->used_int_regs;
  D.49316 = 1 << i;
  D.49317 = (unsigned int) D.49316;
  D.49318 = D.49147 & D.49317;
  D.49319 = D.49318 & 232;
  if (D.49319 != 0) goto <D.49320>; else goto <D.49321>;
  <D.49320>:
  if (i != 5) goto <D.49322>; else goto <D.49323>;
  <D.49322>:
  pos = pos + -4;
  <D.49323>:
  <D.49321>:
  i = i + 1;
  <D.28716>:
  if (i <= 7) goto <D.28715>; else goto <D.28717>;
  <D.28717>:
  if (pos != 0) goto <D.49324>; else goto <D.49325>;
  <D.49324>:
  D.49326 = need_stack_frame == 0;
  D.49327 = (long int) D.49326;
  D.49328 = __builtin_expect (D.49327, 0);
  if (D.49328 != 0) goto <D.49329>; else goto <D.49330>;
  <D.49329>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5604, "need_stack_frame");
  <D.49330>:
  code.7764 = code;
  code = code.7764 + 1;
  *code.7764 = 141;
  if (0 != 0) goto <D.49332>; else goto <D.49333>;
  <D.49332>:
  if (pos == 0) goto <D.49334>; else goto <D.49335>;
  <D.49334>:
  code.7765 = code;
  code = code.7765 + 1;
  *code.7765 = 36;
  code.7766 = code;
  code = code.7766 + 1;
  *code.7766 = 36;
  goto <D.49338>;
  <D.49335>:
  pos.7767 = (unsigned int) pos;
  D.49340 = pos.7767 + 128;
  if (D.49340 <= 255) goto <D.49341>; else goto <D.49342>;
  <D.49341>:
  code.7768 = code;
  code = code.7768 + 1;
  *code.7768 = 100;
  code.7769 = code;
  code = code.7769 + 1;
  *code.7769 = 36;
  D.49345 = (unsigned char) pos;
  *code = D.49345;
  code = code + 1;
  goto <D.49346>;
  <D.49342>:
  code.7770 = code;
  code = code.7770 + 1;
  *code.7770 = 164;
  code.7771 = code;
  code = code.7771 + 1;
  *code.7771 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = pos;
        code.7772 = code;
        code = code.7772 + 1;
        D.49350 = imb.b[0];
        *code.7772 = D.49350;
        code.7773 = code;
        code = code.7773 + 1;
        D.49352 = imb.b[1];
        *code.7773 = D.49352;
        code.7774 = code;
        code = code.7774 + 1;
        D.49354 = imb.b[2];
        *code.7774 = D.49354;
        code.7775 = code;
        code = code.7775 + 1;
        D.49356 = imb.b[3];
        *code.7775 = D.49356;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49346>:
  <D.49338>:
  goto <D.28719>;
  <D.49333>:
  if (0 != 0) goto <D.49357>; else goto <D.49358>;
  <D.49357>:
  code.7776 = code;
  code = code.7776 + 1;
  *code.7776 = 37;
  goto <D.28719>;
  <D.49358>:
  pos.7767 = (unsigned int) pos;
  D.49340 = pos.7767 + 128;
  if (D.49340 <= 255) goto <D.49360>; else goto <D.49361>;
  <D.49360>:
  code.7777 = code;
  code = code.7777 + 1;
  *code.7777 = 101;
  D.49345 = (unsigned char) pos;
  *code = D.49345;
  code = code + 1;
  goto <D.49363>;
  <D.49361>:
  code.7778 = code;
  code = code.7778 + 1;
  *code.7778 = 165;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = pos;
        code.7779 = code;
        code = code.7779 + 1;
        D.49366 = imb.b[0];
        *code.7779 = D.49366;
        code.7780 = code;
        code = code.7780 + 1;
        D.49368 = imb.b[1];
        *code.7780 = D.49368;
        code.7781 = code;
        code = code.7781 + 1;
        D.49370 = imb.b[2];
        *code.7781 = D.49370;
        code.7782 = code;
        code = code.7782 + 1;
        D.49372 = imb.b[3];
        *code.7782 = D.49372;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49363>:
  <D.28719>:
  <D.49325>:
  if (pos != 0) goto <D.49373>; else goto <D.49374>;
  <D.49373>:
  D.49326 = need_stack_frame == 0;
  D.49327 = (long int) D.49326;
  D.49328 = __builtin_expect (D.49327, 0);
  if (D.49328 != 0) goto <D.49375>; else goto <D.49376>;
  <D.49375>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5609, "need_stack_frame");
  <D.49376>:
  code.7783 = code;
  code = code.7783 + 1;
  *code.7783 = 141;
  if (0 != 0) goto <D.49378>; else goto <D.49379>;
  <D.49378>:
  if (pos == 0) goto <D.49380>; else goto <D.49381>;
  <D.49380>:
  code.7784 = code;
  code = code.7784 + 1;
  *code.7784 = 36;
  code.7785 = code;
  code = code.7785 + 1;
  *code.7785 = 36;
  goto <D.49384>;
  <D.49381>:
  pos.7767 = (unsigned int) pos;
  D.49340 = pos.7767 + 128;
  if (D.49340 <= 255) goto <D.49385>; else goto <D.49386>;
  <D.49385>:
  code.7786 = code;
  code = code.7786 + 1;
  *code.7786 = 100;
  code.7787 = code;
  code = code.7787 + 1;
  *code.7787 = 36;
  D.49345 = (unsigned char) pos;
  *code = D.49345;
  code = code + 1;
  goto <D.49389>;
  <D.49386>:
  code.7788 = code;
  code = code.7788 + 1;
  *code.7788 = 164;
  code.7789 = code;
  code = code.7789 + 1;
  *code.7789 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = pos;
        code.7790 = code;
        code = code.7790 + 1;
        D.49393 = imb.b[0];
        *code.7790 = D.49393;
        code.7791 = code;
        code = code.7791 + 1;
        D.49395 = imb.b[1];
        *code.7791 = D.49395;
        code.7792 = code;
        code = code.7792 + 1;
        D.49397 = imb.b[2];
        *code.7792 = D.49397;
        code.7793 = code;
        code = code.7793 + 1;
        D.49399 = imb.b[3];
        *code.7793 = D.49399;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49389>:
  <D.49384>:
  goto <D.28722>;
  <D.49379>:
  if (0 != 0) goto <D.49400>; else goto <D.49401>;
  <D.49400>:
  code.7794 = code;
  code = code.7794 + 1;
  *code.7794 = 37;
  goto <D.28722>;
  <D.49401>:
  pos.7767 = (unsigned int) pos;
  D.49340 = pos.7767 + 128;
  if (D.49340 <= 255) goto <D.49403>; else goto <D.49404>;
  <D.49403>:
  code.7795 = code;
  code = code.7795 + 1;
  *code.7795 = 101;
  D.49345 = (unsigned char) pos;
  *code = D.49345;
  code = code + 1;
  goto <D.49406>;
  <D.49404>:
  code.7796 = code;
  code = code.7796 + 1;
  *code.7796 = 165;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = pos;
        code.7797 = code;
        code = code.7797 + 1;
        D.49409 = imb.b[0];
        *code.7797 = D.49409;
        code.7798 = code;
        code = code.7798 + 1;
        D.49411 = imb.b[1];
        *code.7798 = D.49411;
        code.7799 = code;
        code = code.7799 + 1;
        D.49413 = imb.b[2];
        *code.7799 = D.49413;
        code.7800 = code;
        code = code.7800 + 1;
        D.49415 = imb.b[3];
        *code.7800 = D.49415;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49406>:
  <D.28722>:
  <D.49374>:
  D.49147 = cfg->used_int_regs;
  D.49261 = D.49147 & 64;
  if (D.49261 != 0) goto <D.49416>; else goto <D.49417>;
  <D.49416>:
  code.7801 = code;
  code = code.7801 + 1;
  *code.7801 = 94;
  <D.49417>:
  D.49147 = cfg->used_int_regs;
  D.49207 = D.49147 & 128;
  if (D.49207 != 0) goto <D.49419>; else goto <D.49420>;
  <D.49419>:
  code.7802 = code;
  code = code.7802 + 1;
  *code.7802 = 95;
  <D.49420>:
  D.49147 = cfg->used_int_regs;
  D.49148 = D.49147 & 8;
  if (D.49148 != 0) goto <D.49422>; else goto <D.49423>;
  <D.49422>:
  code.7803 = code;
  code = code.7803 + 1;
  *code.7803 = 91;
  <D.49423>:
  <D.49315>:
  D.49425 = cfg->mempool;
  D.49426 = cfg->generic_sharing_context;
  cinfo = get_call_info (D.49426, D.49425, sig);
  D.49427 = cinfo->ret.storage;
  if (D.49427 == 4) goto <D.49428>; else goto <D.49429>;
  <D.49428>:
  quad = 0;
  goto <D.28745>;
  <D.28744>:
  D.49430 = cinfo->ret.pair_storage[quad];
  switch (D.49430) <default: <D.28743>, case 0: <D.28724>, case 5: <D.28734>, case 6: <D.28738>, case 8: <D.28742>>
  <D.28724>:
  switch (4) <default: <D.28729>, case 1: <D.28725>, case 2: <D.28727>, case 4: <D.28728>>
  <D.28725>:
  code.7804 = code;
  code = code.7804 + 1;
  *code.7804 = 138;
  goto <D.28726>;
  <D.28727>:
  code.7805 = code;
  code = code.7805 + 1;
  *code.7805 = 102;
  <D.28728>:
  code.7806 = code;
  code = code.7806 + 1;
  *code.7806 = 139;
  goto <D.28726>;
  <D.28729>:
  __assert_fail ("0", "mini-x86.c", 5630, &__PRETTY_FUNCTION__);
  <D.28726>:
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  if (D.49435 == 4) goto <D.49436>; else goto <D.49437>;
  <D.49436>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  if (D.49442 == 0) goto <D.49443>; else goto <D.49444>;
  <D.49443>:
  code.7808 = code;
  code = code.7808 + 1;
  D.49446 = cinfo->ret.pair_regs[quad];
  D.49447 = (int) D.49446;
  D.49448 = D.49447 & 7;
  D.49449 = D.49448 << 3;
  D.49450 = (signed char) D.49449;
  D.49451 = D.49450 | 4;
  D.49452 = (unsigned char) D.49451;
  *code.7808 = D.49452;
  code.7809 = code;
  code = code.7809 + 1;
  *code.7809 = 36;
  goto <D.49454>;
  <D.49444>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 >= -128) goto <D.49458>; else goto <D.49455>;
  <D.49458>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 <= 127) goto <D.49459>; else goto <D.49455>;
  <D.49459>:
  code.7810 = code;
  code = code.7810 + 1;
  D.49446 = cinfo->ret.pair_regs[quad];
  D.49447 = (int) D.49446;
  D.49448 = D.49447 & 7;
  D.49449 = D.49448 << 3;
  D.49450 = (signed char) D.49449;
  D.49461 = D.49450 | 68;
  D.49462 = (unsigned char) D.49461;
  *code.7810 = D.49462;
  code.7811 = code;
  code = code.7811 + 1;
  *code.7811 = 36;
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49464 = (unsigned char) D.49438;
  D.49465 = (unsigned char) quad;
  D.49466 = D.49465 * 4;
  D.49467 = D.49464 + D.49466;
  *code = D.49467;
  code = code + 1;
  goto <D.49456>;
  <D.49455>:
  code.7812 = code;
  code = code.7812 + 1;
  D.49446 = cinfo->ret.pair_regs[quad];
  D.49447 = (int) D.49446;
  D.49448 = D.49447 & 7;
  D.49449 = D.49448 << 3;
  D.49450 = (signed char) D.49449;
  D.49469 = D.49450 | -124;
  D.49470 = (unsigned char) D.49469;
  *code.7812 = D.49470;
  code.7813 = code;
  code = code.7813 + 1;
  *code.7813 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.49434 = cfg->ret;
        D.49438 = D.49434->data.op[0].const_val;
        D.49439 = (unsigned int) D.49438;
        quad.7807 = (unsigned int) quad;
        D.49441 = quad.7807 * 4;
        D.49442 = D.49439 + D.49441;
        D.49457 = (int) D.49442;
        imb.val = D.49457;
        code.7814 = code;
        code = code.7814 + 1;
        D.49473 = imb.b[0];
        *code.7814 = D.49473;
        code.7815 = code;
        code = code.7815 + 1;
        D.49475 = imb.b[1];
        *code.7815 = D.49475;
        code.7816 = code;
        code = code.7816 + 1;
        D.49477 = imb.b[2];
        *code.7816 = D.49477;
        code.7817 = code;
        code = code.7817 + 1;
        D.49479 = imb.b[3];
        *code.7817 = D.49479;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49456>:
  <D.49454>:
  goto <D.28731>;
  <D.49437>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  if (D.49442 == 0) goto <D.49480>; else goto <D.49481>;
  <D.49480>:
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  if (D.49435 != 5) goto <D.49482>; else goto <D.49483>;
  <D.49482>:
  code.7818 = code;
  code = code.7818 + 1;
  D.49446 = cinfo->ret.pair_regs[quad];
  D.49447 = (int) D.49446;
  D.49448 = D.49447 & 7;
  D.49449 = D.49448 << 3;
  D.49450 = (signed char) D.49449;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49487 = D.49450 | D.49486;
  D.49488 = (unsigned char) D.49487;
  *code.7818 = D.49488;
  goto <D.28731>;
  <D.49483>:
  <D.49481>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 >= -128) goto <D.49491>; else goto <D.49489>;
  <D.49491>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 <= 127) goto <D.49492>; else goto <D.49489>;
  <D.49492>:
  code.7819 = code;
  code = code.7819 + 1;
  D.49446 = cinfo->ret.pair_regs[quad];
  D.49447 = (int) D.49446;
  D.49448 = D.49447 & 7;
  D.49449 = D.49448 << 3;
  D.49450 = (signed char) D.49449;
  D.49494 = D.49450 | 64;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49495 = D.49494 | D.49486;
  D.49496 = (unsigned char) D.49495;
  *code.7819 = D.49496;
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49464 = (unsigned char) D.49438;
  D.49465 = (unsigned char) quad;
  D.49466 = D.49465 * 4;
  D.49467 = D.49464 + D.49466;
  *code = D.49467;
  code = code + 1;
  goto <D.49490>;
  <D.49489>:
  code.7820 = code;
  code = code.7820 + 1;
  D.49446 = cinfo->ret.pair_regs[quad];
  D.49447 = (int) D.49446;
  D.49448 = D.49447 & 7;
  D.49449 = D.49448 << 3;
  D.49450 = (signed char) D.49449;
  D.49498 = D.49450 | -128;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49499 = D.49498 | D.49486;
  D.49500 = (unsigned char) D.49499;
  *code.7820 = D.49500;
  {
    union x86_imm_buf imb;

    try
      {
        D.49434 = cfg->ret;
        D.49438 = D.49434->data.op[0].const_val;
        D.49439 = (unsigned int) D.49438;
        quad.7807 = (unsigned int) quad;
        D.49441 = quad.7807 * 4;
        D.49442 = D.49439 + D.49441;
        D.49457 = (int) D.49442;
        imb.val = D.49457;
        code.7821 = code;
        code = code.7821 + 1;
        D.49502 = imb.b[0];
        *code.7821 = D.49502;
        code.7822 = code;
        code = code.7822 + 1;
        D.49504 = imb.b[1];
        *code.7822 = D.49504;
        code.7823 = code;
        code = code.7823 + 1;
        D.49506 = imb.b[2];
        *code.7823 = D.49506;
        code.7824 = code;
        code = code.7824 + 1;
        D.49508 = imb.b[3];
        *code.7824 = D.49508;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49490>:
  <D.28731>:
  goto <D.28733>;
  <D.28734>:
  code.7825 = code;
  code = code.7825 + 1;
  *code.7825 = 217;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  if (D.49435 == 4) goto <D.49510>; else goto <D.49511>;
  <D.49510>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  if (D.49442 == 0) goto <D.49512>; else goto <D.49513>;
  <D.49512>:
  code.7826 = code;
  code = code.7826 + 1;
  *code.7826 = 4;
  code.7827 = code;
  code = code.7827 + 1;
  *code.7827 = 36;
  goto <D.49516>;
  <D.49513>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 >= -128) goto <D.49519>; else goto <D.49517>;
  <D.49519>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 <= 127) goto <D.49520>; else goto <D.49517>;
  <D.49520>:
  code.7828 = code;
  code = code.7828 + 1;
  *code.7828 = 68;
  code.7829 = code;
  code = code.7829 + 1;
  *code.7829 = 36;
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49464 = (unsigned char) D.49438;
  D.49465 = (unsigned char) quad;
  D.49466 = D.49465 * 4;
  D.49467 = D.49464 + D.49466;
  *code = D.49467;
  code = code + 1;
  goto <D.49518>;
  <D.49517>:
  code.7830 = code;
  code = code.7830 + 1;
  *code.7830 = 132;
  code.7831 = code;
  code = code.7831 + 1;
  *code.7831 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.49434 = cfg->ret;
        D.49438 = D.49434->data.op[0].const_val;
        D.49439 = (unsigned int) D.49438;
        quad.7807 = (unsigned int) quad;
        D.49441 = quad.7807 * 4;
        D.49442 = D.49439 + D.49441;
        D.49457 = (int) D.49442;
        imb.val = D.49457;
        code.7832 = code;
        code = code.7832 + 1;
        D.49526 = imb.b[0];
        *code.7832 = D.49526;
        code.7833 = code;
        code = code.7833 + 1;
        D.49528 = imb.b[1];
        *code.7833 = D.49528;
        code.7834 = code;
        code = code.7834 + 1;
        D.49530 = imb.b[2];
        *code.7834 = D.49530;
        code.7835 = code;
        code = code.7835 + 1;
        D.49532 = imb.b[3];
        *code.7835 = D.49532;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49518>:
  <D.49516>:
  goto <D.28736>;
  <D.49511>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  if (D.49442 == 0) goto <D.49533>; else goto <D.49534>;
  <D.49533>:
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  if (D.49435 != 5) goto <D.49535>; else goto <D.49536>;
  <D.49535>:
  code.7836 = code;
  code = code.7836 + 1;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49538 = (unsigned char) D.49435;
  D.49539 = D.49538 & 7;
  *code.7836 = D.49539;
  goto <D.28736>;
  <D.49536>:
  <D.49534>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 >= -128) goto <D.49542>; else goto <D.49540>;
  <D.49542>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 <= 127) goto <D.49543>; else goto <D.49540>;
  <D.49543>:
  code.7837 = code;
  code = code.7837 + 1;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49545 = D.49486 | 64;
  D.49546 = (unsigned char) D.49545;
  *code.7837 = D.49546;
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49464 = (unsigned char) D.49438;
  D.49465 = (unsigned char) quad;
  D.49466 = D.49465 * 4;
  D.49467 = D.49464 + D.49466;
  *code = D.49467;
  code = code + 1;
  goto <D.49541>;
  <D.49540>:
  code.7838 = code;
  code = code.7838 + 1;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49548 = D.49486 | -128;
  D.49549 = (unsigned char) D.49548;
  *code.7838 = D.49549;
  {
    union x86_imm_buf imb;

    try
      {
        D.49434 = cfg->ret;
        D.49438 = D.49434->data.op[0].const_val;
        D.49439 = (unsigned int) D.49438;
        quad.7807 = (unsigned int) quad;
        D.49441 = quad.7807 * 4;
        D.49442 = D.49439 + D.49441;
        D.49457 = (int) D.49442;
        imb.val = D.49457;
        code.7839 = code;
        code = code.7839 + 1;
        D.49551 = imb.b[0];
        *code.7839 = D.49551;
        code.7840 = code;
        code = code.7840 + 1;
        D.49553 = imb.b[1];
        *code.7840 = D.49553;
        code.7841 = code;
        code = code.7841 + 1;
        D.49555 = imb.b[2];
        *code.7841 = D.49555;
        code.7842 = code;
        code = code.7842 + 1;
        D.49557 = imb.b[3];
        *code.7842 = D.49557;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49541>:
  <D.28736>:
  goto <D.28733>;
  <D.28738>:
  code.7843 = code;
  code = code.7843 + 1;
  *code.7843 = 221;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  if (D.49435 == 4) goto <D.49559>; else goto <D.49560>;
  <D.49559>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  if (D.49442 == 0) goto <D.49561>; else goto <D.49562>;
  <D.49561>:
  code.7844 = code;
  code = code.7844 + 1;
  *code.7844 = 4;
  code.7845 = code;
  code = code.7845 + 1;
  *code.7845 = 36;
  goto <D.49565>;
  <D.49562>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 >= -128) goto <D.49568>; else goto <D.49566>;
  <D.49568>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 <= 127) goto <D.49569>; else goto <D.49566>;
  <D.49569>:
  code.7846 = code;
  code = code.7846 + 1;
  *code.7846 = 68;
  code.7847 = code;
  code = code.7847 + 1;
  *code.7847 = 36;
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49464 = (unsigned char) D.49438;
  D.49465 = (unsigned char) quad;
  D.49466 = D.49465 * 4;
  D.49467 = D.49464 + D.49466;
  *code = D.49467;
  code = code + 1;
  goto <D.49567>;
  <D.49566>:
  code.7848 = code;
  code = code.7848 + 1;
  *code.7848 = 132;
  code.7849 = code;
  code = code.7849 + 1;
  *code.7849 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.49434 = cfg->ret;
        D.49438 = D.49434->data.op[0].const_val;
        D.49439 = (unsigned int) D.49438;
        quad.7807 = (unsigned int) quad;
        D.49441 = quad.7807 * 4;
        D.49442 = D.49439 + D.49441;
        D.49457 = (int) D.49442;
        imb.val = D.49457;
        code.7850 = code;
        code = code.7850 + 1;
        D.49575 = imb.b[0];
        *code.7850 = D.49575;
        code.7851 = code;
        code = code.7851 + 1;
        D.49577 = imb.b[1];
        *code.7851 = D.49577;
        code.7852 = code;
        code = code.7852 + 1;
        D.49579 = imb.b[2];
        *code.7852 = D.49579;
        code.7853 = code;
        code = code.7853 + 1;
        D.49581 = imb.b[3];
        *code.7853 = D.49581;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49567>:
  <D.49565>:
  goto <D.28740>;
  <D.49560>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  if (D.49442 == 0) goto <D.49582>; else goto <D.49583>;
  <D.49582>:
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  if (D.49435 != 5) goto <D.49584>; else goto <D.49585>;
  <D.49584>:
  code.7854 = code;
  code = code.7854 + 1;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49538 = (unsigned char) D.49435;
  D.49539 = D.49538 & 7;
  *code.7854 = D.49539;
  goto <D.28740>;
  <D.49585>:
  <D.49583>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 >= -128) goto <D.49589>; else goto <D.49587>;
  <D.49589>:
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49439 = (unsigned int) D.49438;
  quad.7807 = (unsigned int) quad;
  D.49441 = quad.7807 * 4;
  D.49442 = D.49439 + D.49441;
  D.49457 = (int) D.49442;
  if (D.49457 <= 127) goto <D.49590>; else goto <D.49587>;
  <D.49590>:
  code.7855 = code;
  code = code.7855 + 1;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49545 = D.49486 | 64;
  D.49546 = (unsigned char) D.49545;
  *code.7855 = D.49546;
  D.49434 = cfg->ret;
  D.49438 = D.49434->data.op[0].const_val;
  D.49464 = (unsigned char) D.49438;
  D.49465 = (unsigned char) quad;
  D.49466 = D.49465 * 4;
  D.49467 = D.49464 + D.49466;
  *code = D.49467;
  code = code + 1;
  goto <D.49588>;
  <D.49587>:
  code.7856 = code;
  code = code.7856 + 1;
  D.49434 = cfg->ret;
  D.49435 = D.49434->sreg1;
  D.49485 = (signed char) D.49435;
  D.49486 = D.49485 & 7;
  D.49548 = D.49486 | -128;
  D.49549 = (unsigned char) D.49548;
  *code.7856 = D.49549;
  {
    union x86_imm_buf imb;

    try
      {
        D.49434 = cfg->ret;
        D.49438 = D.49434->data.op[0].const_val;
        D.49439 = (unsigned int) D.49438;
        quad.7807 = (unsigned int) quad;
        D.49441 = quad.7807 * 4;
        D.49442 = D.49439 + D.49441;
        D.49457 = (int) D.49442;
        imb.val = D.49457;
        code.7857 = code;
        code = code.7857 + 1;
        D.49594 = imb.b[0];
        *code.7857 = D.49594;
        code.7858 = code;
        code = code.7858 + 1;
        D.49596 = imb.b[1];
        *code.7858 = D.49596;
        code.7859 = code;
        code = code.7859 + 1;
        D.49598 = imb.b[2];
        *code.7859 = D.49598;
        code.7860 = code;
        code = code.7860 + 1;
        D.49600 = imb.b[3];
        *code.7860 = D.49600;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49588>:
  <D.28740>:
  goto <D.28733>;
  <D.28742>:
  goto <D.28733>;
  <D.28743>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 5641);
  <D.28733>:
  quad = quad + 1;
  <D.28745>:
  if (quad <= 1) goto <D.28744>; else goto <D.28746>;
  <D.28746>:
  <D.49429>:
  if (need_stack_frame != 0) goto <D.49601>; else goto <D.49602>;
  <D.49601>:
  code.7861 = code;
  code = code.7861 + 1;
  *code.7861 = 201;
  <D.49602>:
  D.49607 = BIT_FIELD_REF <*sig, 8, 80>;
  D.49608 = D.49607 & 63;
  if (D.49608 == 2) goto <D.49604>; else goto <D.49609>;
  <D.49609>:
  D.49610 = BIT_FIELD_REF <*sig, 16, 80>;
  D.49611 = D.49610 & 319;
  if (D.49611 == 259) goto <D.49604>; else goto <D.49605>;
  <D.49604>:
  {
    struct MonoJitArgumentInfo * arg_info;

    D.49612 = sig->param_count;
    D.49613 = (int) D.49612;
    D.49614 = D.49613 + 1;
    D.49615 = (unsigned int) D.49614;
    D.49616 = D.49615 * 6;
    arg_info = __builtin_alloca (D.49616);
    D.49612 = sig->param_count;
    D.49613 = (int) D.49612;
    D.49617 = mono_arch_get_argument_info (0B, sig, D.49613, arg_info);
    stack_to_pop = (guint32) D.49617;
  }
  goto <D.49606>;
  <D.49605>:
  D.49618 = cinfo->vtype_retaddr;
  if (D.49618 != 0) goto <D.49619>; else goto <D.49620>;
  <D.49619>:
  stack_to_pop = 4;
  goto <D.49621>;
  <D.49620>:
  stack_to_pop = 0;
  <D.49621>:
  <D.49606>:
  if (stack_to_pop != 0) goto <D.49622>; else goto <D.49623>;
  <D.49622>:
  D.49326 = need_stack_frame == 0;
  D.49327 = (long int) D.49326;
  D.49328 = __builtin_expect (D.49327, 0);
  if (D.49328 != 0) goto <D.49624>; else goto <D.49625>;
  <D.49624>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5659, "need_stack_frame");
  <D.49625>:
  if (stack_to_pop == 0) goto <D.49626>; else goto <D.49627>;
  <D.49626>:
  code.7862 = code;
  code = code.7862 + 1;
  *code.7862 = 195;
  goto <D.49629>;
  <D.49627>:
  code.7863 = code;
  code = code.7863 + 1;
  *code.7863 = 194;
  D.49631 = (short int) stack_to_pop;
  MEM[(short int *)code] = D.49631;
  code = code + 2;
  <D.49629>:
  goto <D.49632>;
  <D.49623>:
  code.7864 = code;
  code = code.7864 + 1;
  *code.7864 = 195;
  <D.49632>:
  code.7696 = (int) code;
  D.49013 = cfg->native_code;
  D.49634 = (int) D.49013;
  D.49635 = code.7696 - D.49634;
  D.49636 = (unsigned int) D.49635;
  cfg->code_len = D.49636;
  D.49009 = cfg->code_len;
  D.49004 = cfg->code_size;
  D.49637 = D.49009 >= D.49004;
  D.49638 = (long int) D.49637;
  D.49639 = __builtin_expect (D.49638, 0);
  if (D.49639 != 0) goto <D.49640>; else goto <D.49641>;
  <D.49640>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5667, "cfg->code_len < cfg->code_size");
  <D.49641>:
}


emit_load_aotconst (guint8 * start, guint8 * code, struct MonoCompile * cfg, struct MonoJumpInfo * * ji, int dreg, int tramp_type, const void * target)
{
  <unnamed type> tramp_type.7865;
  int code.7866;
  unsigned char * D.49648;
  int D.49649;
  int D.49650;
  guint8 * code.7867;
  guint8 * code.7868;
  guint8 * code.7869;
  guint8 * code.7870;
  int D.49660;
  int D.49661;
  signed char D.49662;
  signed char D.49663;
  unsigned char D.49664;
  guint8 * code.7871;
  guint8 * code.7872;
  signed char D.49670;
  unsigned char D.49671;
  guint8 * code.7873;
  guint8 * code.7874;
  signed char D.49675;
  unsigned char D.49676;
  guint8 * code.7875;
  guint8 * code.7876;
  unsigned char D.49679;
  guint8 * code.7877;
  unsigned char D.49681;
  guint8 * code.7878;
  unsigned char D.49683;
  guint8 * code.7879;
  unsigned char D.49685;
  guint8 * code.7880;
  signed char D.49689;
  unsigned char D.49690;
  guint8 * code.7881;
  signed char D.49694;
  unsigned char D.49695;
  guint8 * code.7882;
  signed char D.49698;
  unsigned char D.49699;
  guint8 * code.7883;
  unsigned char D.49701;
  guint8 * code.7884;
  unsigned char D.49703;
  guint8 * code.7885;
  unsigned char D.49705;
  guint8 * code.7886;
  unsigned char D.49707;
  guint8 * D.49708;
  static const char __PRETTY_FUNCTION__[19] = "emit_load_aotconst";

  if (cfg != 0B) goto <D.49644>; else goto <D.49645>;
  <D.49644>:
  tramp_type.7865 = (<unnamed type>) tramp_type;
  code.7866 = (int) code;
  D.49648 = cfg->native_code;
  D.49649 = (int) D.49648;
  D.49650 = code.7866 - D.49649;
  mono_add_patch_info (cfg, D.49650, tramp_type.7865, target);
  goto <D.49651>;
  <D.49645>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 6656);
  <D.49651>:
  switch (4) <default: <D.29280>, case 1: <D.29276>, case 2: <D.29278>, case 4: <D.29279>>
  <D.29276>:
  code.7867 = code;
  code = code.7867 + 1;
  *code.7867 = 138;
  goto <D.29277>;
  <D.29278>:
  code.7868 = code;
  code = code.7868 + 1;
  *code.7868 = 102;
  <D.29279>:
  code.7869 = code;
  code = code.7869 + 1;
  *code.7869 = 139;
  goto <D.29277>;
  <D.29280>:
  __assert_fail ("0", "mini-x86.c", 6657, &__PRETTY_FUNCTION__);
  <D.29277>:
  if (0 != 0) goto <D.49655>; else goto <D.49656>;
  <D.49655>:
  if (0 != 0) goto <D.49657>; else goto <D.49658>;
  <D.49657>:
  code.7870 = code;
  code = code.7870 + 1;
  D.49660 = dreg & 7;
  D.49661 = D.49660 << 3;
  D.49662 = (signed char) D.49661;
  D.49663 = D.49662 | 4;
  D.49664 = (unsigned char) D.49663;
  *code.7870 = D.49664;
  code.7871 = code;
  code = code.7871 + 1;
  *code.7871 = 36;
  goto <D.49666>;
  <D.49658>:
  if (0 != 0) goto <D.49667>; else goto <D.49668>;
  <D.49667>:
  code.7872 = code;
  code = code.7872 + 1;
  D.49660 = dreg & 7;
  D.49661 = D.49660 << 3;
  D.49662 = (signed char) D.49661;
  D.49670 = D.49662 | 68;
  D.49671 = (unsigned char) D.49670;
  *code.7872 = D.49671;
  code.7873 = code;
  code = code.7873 + 1;
  *code.7873 = 36;
  *code = 240;
  code = code + 1;
  goto <D.49673>;
  <D.49668>:
  code.7874 = code;
  code = code.7874 + 1;
  D.49660 = dreg & 7;
  D.49661 = D.49660 << 3;
  D.49662 = (signed char) D.49661;
  D.49675 = D.49662 | -124;
  D.49676 = (unsigned char) D.49675;
  *code.7874 = D.49676;
  code.7875 = code;
  code = code.7875 + 1;
  *code.7875 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.7876 = code;
        code = code.7876 + 1;
        D.49679 = imb.b[0];
        *code.7876 = D.49679;
        code.7877 = code;
        code = code.7877 + 1;
        D.49681 = imb.b[1];
        *code.7877 = D.49681;
        code.7878 = code;
        code = code.7878 + 1;
        D.49683 = imb.b[2];
        *code.7878 = D.49683;
        code.7879 = code;
        code = code.7879 + 1;
        D.49685 = imb.b[3];
        *code.7879 = D.49685;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49673>:
  <D.49666>:
  goto <D.29283>;
  <D.49656>:
  if (0 != 0) goto <D.49686>; else goto <D.49687>;
  <D.49686>:
  code.7880 = code;
  code = code.7880 + 1;
  D.49660 = dreg & 7;
  D.49661 = D.49660 << 3;
  D.49662 = (signed char) D.49661;
  D.49689 = D.49662 | 3;
  D.49690 = (unsigned char) D.49689;
  *code.7880 = D.49690;
  goto <D.29283>;
  <D.49687>:
  if (0 != 0) goto <D.49691>; else goto <D.49692>;
  <D.49691>:
  code.7881 = code;
  code = code.7881 + 1;
  D.49660 = dreg & 7;
  D.49661 = D.49660 << 3;
  D.49662 = (signed char) D.49661;
  D.49694 = D.49662 | 67;
  D.49695 = (unsigned char) D.49694;
  *code.7881 = D.49695;
  *code = 240;
  code = code + 1;
  goto <D.49696>;
  <D.49692>:
  code.7882 = code;
  code = code.7882 + 1;
  D.49660 = dreg & 7;
  D.49661 = D.49660 << 3;
  D.49662 = (signed char) D.49661;
  D.49698 = D.49662 | -125;
  D.49699 = (unsigned char) D.49698;
  *code.7882 = D.49699;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.7883 = code;
        code = code.7883 + 1;
        D.49701 = imb.b[0];
        *code.7883 = D.49701;
        code.7884 = code;
        code = code.7884 + 1;
        D.49703 = imb.b[1];
        *code.7884 = D.49703;
        code.7885 = code;
        code = code.7885 + 1;
        D.49705 = imb.b[2];
        *code.7885 = D.49705;
        code.7886 = code;
        code = code.7886 + 1;
        D.49707 = imb.b[3];
        *code.7886 = D.49707;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49696>:
  <D.29283>:
  D.49708 = code;
  return D.49708;
}


emit_pop_lmf (struct MonoCompile * cfg, guint8 * code, gint32 lmf_offset)
{
  struct MonoMethod * D.49710;
  struct MonoType * D.49711;
  struct MonoGenericSharingContext * D.49712;
  struct MonoType * D.49713;
  unsigned char D.49714;
  int D.49715;
  unsigned int D.49716;
  unsigned int D.49717;
  guint8 * code.7887;
  guint8 * code.7888;
  guint8 * code.7889;
  unsigned int D.49721;
  guint8 * code.7890;
  int D.49727;
  int D.49728;
  signed char D.49729;
  signed char D.49730;
  unsigned char D.49731;
  guint8 * code.7891;
  unsigned int lmf_offset.7892;
  unsigned int D.49735;
  guint8 * code.7893;
  signed char D.49739;
  unsigned char D.49740;
  guint8 * code.7894;
  unsigned char D.49742;
  guint8 * code.7895;
  signed char D.49745;
  unsigned char D.49746;
  guint8 * code.7896;
  guint8 * code.7897;
  unsigned char D.49749;
  guint8 * code.7898;
  unsigned char D.49751;
  guint8 * code.7899;
  unsigned char D.49753;
  guint8 * code.7900;
  unsigned char D.49755;
  guint8 * code.7901;
  unsigned char D.49761;
  unsigned char D.49762;
  unsigned char D.49763;
  unsigned char D.49764;
  unsigned char D.49765;
  unsigned char D.49766;
  guint8 * code.7902;
  unsigned char D.49770;
  guint8 * code.7903;
  unsigned char D.49773;
  guint8 * code.7904;
  unsigned char D.49775;
  guint8 * code.7905;
  unsigned char D.49777;
  guint8 * code.7906;
  unsigned char D.49779;
  guint8 * code.7907;
  unsigned char D.49781;
  guint8 * code.7908;
  guint8 * code.7909;
  guint8 * code.7910;
  guint8 * code.7911;
  guint8 * code.7912;
  unsigned int lmf_offset.7913;
  unsigned int D.49795;
  int D.49796;
  guint8 * code.7914;
  guint8 * code.7915;
  unsigned char D.49801;
  guint8 * code.7916;
  guint8 * code.7917;
  guint8 * code.7918;
  unsigned char D.49805;
  guint8 * code.7919;
  unsigned char D.49807;
  guint8 * code.7920;
  unsigned char D.49809;
  guint8 * code.7921;
  unsigned char D.49811;
  guint8 * code.7922;
  unsigned char D.49817;
  guint8 * code.7923;
  unsigned char D.49823;
  guint8 * code.7924;
  unsigned char D.49825;
  guint8 * code.7925;
  unsigned char D.49827;
  guint8 * code.7926;
  unsigned char D.49829;
  guint8 * code.7927;
  unsigned char D.49831;
  guint8 * code.7928;
  unsigned char D.49833;
  guint8 * code.7929;
  guint8 * code.7930;
  guint8 * code.7931;
  guint8 * code.7932;
  guint8 * code.7933;
  guint8 * code.7934;
  guint8 * code.7935;
  guint8 * code.7936;
  guint8 * code.7937;
  guint8 * code.7938;
  unsigned char D.49852;
  guint8 * code.7939;
  unsigned char D.49854;
  guint8 * code.7940;
  unsigned char D.49856;
  guint8 * code.7941;
  unsigned char D.49858;
  guint8 * code.7942;
  signed char D.49862;
  unsigned char D.49863;
  guint8 * code.7943;
  signed char D.49867;
  unsigned char D.49868;
  guint8 * code.7944;
  signed char D.49871;
  unsigned char D.49872;
  guint8 * code.7945;
  unsigned char D.49874;
  guint8 * code.7946;
  unsigned char D.49876;
  guint8 * code.7947;
  unsigned char D.49878;
  guint8 * code.7948;
  unsigned char D.49880;
  guint8 * D.49881;
  struct MonoMethodSignature * sig;
  int prev_lmf_reg;
  static const char __PRETTY_FUNCTION__[13] = "emit_pop_lmf";

  D.49710 = cfg->method;
  sig = mono_method_signature (D.49710);
  D.49711 = sig->ret;
  D.49712 = cfg->generic_sharing_context;
  D.49713 = mini_type_get_underlying_type (D.49712, D.49711);
  D.49714 = D.49713->type;
  D.49715 = (int) D.49714;
  switch (D.49715) <default: <D.24745>, case 10: <D.24742>, case 11: <D.24743>>
  <D.24742>:
  <D.24743>:
  prev_lmf_reg = 7;
  D.49716 = cfg->used_int_regs;
  D.49717 = D.49716 | 128;
  cfg->used_int_regs = D.49717;
  goto <D.24744>;
  <D.24745>:
  prev_lmf_reg = 2;
  goto <D.24744>;
  <D.24744>:
  switch (4) <default: <D.24750>, case 1: <D.24746>, case 2: <D.24748>, case 4: <D.24749>>
  <D.24746>:
  code.7887 = code;
  code = code.7887 + 1;
  *code.7887 = 138;
  goto <D.24747>;
  <D.24748>:
  code.7888 = code;
  code = code.7888 + 1;
  *code.7888 = 102;
  <D.24749>:
  code.7889 = code;
  code = code.7889 + 1;
  *code.7889 = 139;
  goto <D.24747>;
  <D.24750>:
  __assert_fail ("0", "mini-x86.c", 2562, &__PRETTY_FUNCTION__);
  <D.24747>:
  D.49721 = cfg->frame_reg;
  if (D.49721 == 4) goto <D.49722>; else goto <D.49723>;
  <D.49722>:
  if (lmf_offset == 0) goto <D.49724>; else goto <D.49725>;
  <D.49724>:
  code.7890 = code;
  code = code.7890 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49730 = D.49729 | 4;
  D.49731 = (unsigned char) D.49730;
  *code.7890 = D.49731;
  code.7891 = code;
  code = code.7891 + 1;
  *code.7891 = 36;
  goto <D.49733>;
  <D.49725>:
  lmf_offset.7892 = (unsigned int) lmf_offset;
  D.49735 = lmf_offset.7892 + 128;
  if (D.49735 <= 255) goto <D.49736>; else goto <D.49737>;
  <D.49736>:
  code.7893 = code;
  code = code.7893 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49739 = D.49729 | 68;
  D.49740 = (unsigned char) D.49739;
  *code.7893 = D.49740;
  code.7894 = code;
  code = code.7894 + 1;
  *code.7894 = 36;
  D.49742 = (unsigned char) lmf_offset;
  *code = D.49742;
  code = code + 1;
  goto <D.49743>;
  <D.49737>:
  code.7895 = code;
  code = code.7895 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49745 = D.49729 | -124;
  D.49746 = (unsigned char) D.49745;
  *code.7895 = D.49746;
  code.7896 = code;
  code = code.7896 + 1;
  *code.7896 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = lmf_offset;
        code.7897 = code;
        code = code.7897 + 1;
        D.49749 = imb.b[0];
        *code.7897 = D.49749;
        code.7898 = code;
        code = code.7898 + 1;
        D.49751 = imb.b[1];
        *code.7898 = D.49751;
        code.7899 = code;
        code = code.7899 + 1;
        D.49753 = imb.b[2];
        *code.7899 = D.49753;
        code.7900 = code;
        code = code.7900 + 1;
        D.49755 = imb.b[3];
        *code.7900 = D.49755;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49743>:
  <D.49733>:
  goto <D.24753>;
  <D.49723>:
  if (lmf_offset == 0) goto <D.49756>; else goto <D.49757>;
  <D.49756>:
  D.49721 = cfg->frame_reg;
  if (D.49721 != 5) goto <D.49758>; else goto <D.49759>;
  <D.49758>:
  code.7901 = code;
  code = code.7901 + 1;
  D.49761 = (unsigned char) prev_lmf_reg;
  D.49762 = D.49761 & 7;
  D.49763 = D.49762 << 3;
  D.49721 = cfg->frame_reg;
  D.49764 = (unsigned char) D.49721;
  D.49765 = D.49764 & 7;
  D.49766 = D.49763 | D.49765;
  *code.7901 = D.49766;
  goto <D.24753>;
  <D.49759>:
  <D.49757>:
  lmf_offset.7892 = (unsigned int) lmf_offset;
  D.49735 = lmf_offset.7892 + 128;
  if (D.49735 <= 255) goto <D.49767>; else goto <D.49768>;
  <D.49767>:
  code.7902 = code;
  code = code.7902 + 1;
  D.49761 = (unsigned char) prev_lmf_reg;
  D.49762 = D.49761 & 7;
  D.49763 = D.49762 << 3;
  D.49721 = cfg->frame_reg;
  D.49764 = (unsigned char) D.49721;
  D.49765 = D.49764 & 7;
  D.49766 = D.49763 | D.49765;
  D.49770 = D.49766 | 64;
  *code.7902 = D.49770;
  D.49742 = (unsigned char) lmf_offset;
  *code = D.49742;
  code = code + 1;
  goto <D.49771>;
  <D.49768>:
  code.7903 = code;
  code = code.7903 + 1;
  D.49761 = (unsigned char) prev_lmf_reg;
  D.49762 = D.49761 & 7;
  D.49763 = D.49762 << 3;
  D.49721 = cfg->frame_reg;
  D.49764 = (unsigned char) D.49721;
  D.49765 = D.49764 & 7;
  D.49766 = D.49763 | D.49765;
  D.49773 = D.49766 | 128;
  *code.7903 = D.49773;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = lmf_offset;
        code.7904 = code;
        code = code.7904 + 1;
        D.49775 = imb.b[0];
        *code.7904 = D.49775;
        code.7905 = code;
        code = code.7905 + 1;
        D.49777 = imb.b[1];
        *code.7905 = D.49777;
        code.7906 = code;
        code = code.7906 + 1;
        D.49779 = imb.b[2];
        *code.7906 = D.49779;
        code.7907 = code;
        code = code.7907 + 1;
        D.49781 = imb.b[3];
        *code.7907 = D.49781;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49771>:
  <D.24753>:
  switch (4) <default: <D.24759>, case 1: <D.24755>, case 2: <D.24757>, case 4: <D.24758>>
  <D.24755>:
  code.7908 = code;
  code = code.7908 + 1;
  *code.7908 = 138;
  goto <D.24756>;
  <D.24757>:
  code.7909 = code;
  code = code.7909 + 1;
  *code.7909 = 102;
  <D.24758>:
  code.7910 = code;
  code = code.7910 + 1;
  *code.7910 = 139;
  goto <D.24756>;
  <D.24759>:
  __assert_fail ("0", "mini-x86.c", 2565, &__PRETTY_FUNCTION__);
  <D.24756>:
  D.49721 = cfg->frame_reg;
  if (D.49721 == 4) goto <D.49785>; else goto <D.49786>;
  <D.49785>:
  if (lmf_offset == -4) goto <D.49787>; else goto <D.49788>;
  <D.49787>:
  code.7911 = code;
  code = code.7911 + 1;
  *code.7911 = 12;
  code.7912 = code;
  code = code.7912 + 1;
  *code.7912 = 36;
  goto <D.49791>;
  <D.49788>:
  lmf_offset.7913 = (unsigned int) lmf_offset;
  D.49795 = lmf_offset.7913 + 4;
  D.49796 = (int) D.49795;
  if (D.49796 >= -128) goto <D.49797>; else goto <D.49792>;
  <D.49797>:
  lmf_offset.7913 = (unsigned int) lmf_offset;
  D.49795 = lmf_offset.7913 + 4;
  D.49796 = (int) D.49795;
  if (D.49796 <= 127) goto <D.49798>; else goto <D.49792>;
  <D.49798>:
  code.7914 = code;
  code = code.7914 + 1;
  *code.7914 = 76;
  code.7915 = code;
  code = code.7915 + 1;
  *code.7915 = 36;
  D.49742 = (unsigned char) lmf_offset;
  D.49801 = D.49742 + 4;
  *code = D.49801;
  code = code + 1;
  goto <D.49793>;
  <D.49792>:
  code.7916 = code;
  code = code.7916 + 1;
  *code.7916 = 140;
  code.7917 = code;
  code = code.7917 + 1;
  *code.7917 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7913 = (unsigned int) lmf_offset;
        D.49795 = lmf_offset.7913 + 4;
        D.49796 = (int) D.49795;
        imb.val = D.49796;
        code.7918 = code;
        code = code.7918 + 1;
        D.49805 = imb.b[0];
        *code.7918 = D.49805;
        code.7919 = code;
        code = code.7919 + 1;
        D.49807 = imb.b[1];
        *code.7919 = D.49807;
        code.7920 = code;
        code = code.7920 + 1;
        D.49809 = imb.b[2];
        *code.7920 = D.49809;
        code.7921 = code;
        code = code.7921 + 1;
        D.49811 = imb.b[3];
        *code.7921 = D.49811;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49793>:
  <D.49791>:
  goto <D.24761>;
  <D.49786>:
  if (lmf_offset == -4) goto <D.49812>; else goto <D.49813>;
  <D.49812>:
  D.49721 = cfg->frame_reg;
  if (D.49721 != 5) goto <D.49814>; else goto <D.49815>;
  <D.49814>:
  code.7922 = code;
  code = code.7922 + 1;
  D.49721 = cfg->frame_reg;
  D.49764 = (unsigned char) D.49721;
  D.49765 = D.49764 & 7;
  D.49817 = D.49765 | 8;
  *code.7922 = D.49817;
  goto <D.24761>;
  <D.49815>:
  <D.49813>:
  lmf_offset.7913 = (unsigned int) lmf_offset;
  D.49795 = lmf_offset.7913 + 4;
  D.49796 = (int) D.49795;
  if (D.49796 >= -128) goto <D.49820>; else goto <D.49818>;
  <D.49820>:
  lmf_offset.7913 = (unsigned int) lmf_offset;
  D.49795 = lmf_offset.7913 + 4;
  D.49796 = (int) D.49795;
  if (D.49796 <= 127) goto <D.49821>; else goto <D.49818>;
  <D.49821>:
  code.7923 = code;
  code = code.7923 + 1;
  D.49721 = cfg->frame_reg;
  D.49764 = (unsigned char) D.49721;
  D.49765 = D.49764 & 7;
  D.49823 = D.49765 | 72;
  *code.7923 = D.49823;
  D.49742 = (unsigned char) lmf_offset;
  D.49801 = D.49742 + 4;
  *code = D.49801;
  code = code + 1;
  goto <D.49819>;
  <D.49818>:
  code.7924 = code;
  code = code.7924 + 1;
  D.49721 = cfg->frame_reg;
  D.49764 = (unsigned char) D.49721;
  D.49765 = D.49764 & 7;
  D.49825 = D.49765 | 136;
  *code.7924 = D.49825;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.7913 = (unsigned int) lmf_offset;
        D.49795 = lmf_offset.7913 + 4;
        D.49796 = (int) D.49795;
        imb.val = D.49796;
        code.7925 = code;
        code = code.7925 + 1;
        D.49827 = imb.b[0];
        *code.7925 = D.49827;
        code.7926 = code;
        code = code.7926 + 1;
        D.49829 = imb.b[1];
        *code.7926 = D.49829;
        code.7927 = code;
        code = code.7927 + 1;
        D.49831 = imb.b[2];
        *code.7927 = D.49831;
        code.7928 = code;
        code = code.7928 + 1;
        D.49833 = imb.b[3];
        *code.7928 = D.49833;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49819>:
  <D.24761>:
  switch (4) <default: <D.24767>, case 1: <D.24763>, case 2: <D.24765>, case 4: <D.24766>>
  <D.24763>:
  code.7929 = code;
  code = code.7929 + 1;
  *code.7929 = 136;
  goto <D.24764>;
  <D.24765>:
  code.7930 = code;
  code = code.7930 + 1;
  *code.7930 = 102;
  <D.24766>:
  code.7931 = code;
  code = code.7931 + 1;
  *code.7931 = 137;
  goto <D.24764>;
  <D.24767>:
  __assert_fail ("0", "mini-x86.c", 2568, &__PRETTY_FUNCTION__);
  <D.24764>:
  if (0 != 0) goto <D.49837>; else goto <D.49838>;
  <D.49837>:
  if (1 != 0) goto <D.49839>; else goto <D.49840>;
  <D.49839>:
  code.7932 = code;
  code = code.7932 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49730 = D.49729 | 4;
  D.49731 = (unsigned char) D.49730;
  *code.7932 = D.49731;
  code.7933 = code;
  code = code.7933 + 1;
  *code.7933 = 36;
  goto <D.49843>;
  <D.49840>:
  if (1 != 0) goto <D.49844>; else goto <D.49845>;
  <D.49844>:
  code.7934 = code;
  code = code.7934 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49739 = D.49729 | 68;
  D.49740 = (unsigned char) D.49739;
  *code.7934 = D.49740;
  code.7935 = code;
  code = code.7935 + 1;
  *code.7935 = 36;
  *code = 0;
  code = code + 1;
  goto <D.49848>;
  <D.49845>:
  code.7936 = code;
  code = code.7936 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49745 = D.49729 | -124;
  D.49746 = (unsigned char) D.49745;
  *code.7936 = D.49746;
  code.7937 = code;
  code = code.7937 + 1;
  *code.7937 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7938 = code;
        code = code.7938 + 1;
        D.49852 = imb.b[0];
        *code.7938 = D.49852;
        code.7939 = code;
        code = code.7939 + 1;
        D.49854 = imb.b[1];
        *code.7939 = D.49854;
        code.7940 = code;
        code = code.7940 + 1;
        D.49856 = imb.b[2];
        *code.7940 = D.49856;
        code.7941 = code;
        code = code.7941 + 1;
        D.49858 = imb.b[3];
        *code.7941 = D.49858;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49848>:
  <D.49843>:
  goto <D.24769>;
  <D.49838>:
  if (1 != 0) goto <D.49859>; else goto <D.49860>;
  <D.49859>:
  code.7942 = code;
  code = code.7942 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49862 = D.49729 | 1;
  D.49863 = (unsigned char) D.49862;
  *code.7942 = D.49863;
  goto <D.24769>;
  <D.49860>:
  if (1 != 0) goto <D.49864>; else goto <D.49865>;
  <D.49864>:
  code.7943 = code;
  code = code.7943 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49867 = D.49729 | 65;
  D.49868 = (unsigned char) D.49867;
  *code.7943 = D.49868;
  *code = 0;
  code = code + 1;
  goto <D.49869>;
  <D.49865>:
  code.7944 = code;
  code = code.7944 + 1;
  D.49727 = prev_lmf_reg & 7;
  D.49728 = D.49727 << 3;
  D.49729 = (signed char) D.49728;
  D.49871 = D.49729 | -127;
  D.49872 = (unsigned char) D.49871;
  *code.7944 = D.49872;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.7945 = code;
        code = code.7945 + 1;
        D.49874 = imb.b[0];
        *code.7945 = D.49874;
        code.7946 = code;
        code = code.7946 + 1;
        D.49876 = imb.b[1];
        *code.7946 = D.49876;
        code.7947 = code;
        code = code.7947 + 1;
        D.49878 = imb.b[2];
        *code.7947 = D.49878;
        code.7948 = code;
        code = code.7948 + 1;
        D.49880 = imb.b[3];
        *code.7948 = D.49880;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.49869>:
  <D.24769>:
  D.49881 = code;
  return D.49881;
}


mono_arch_emit_exceptions (struct MonoCompile * cfg)
{
  <unnamed type> D.49883;
  unsigned char D.49886;
  unsigned char D.49887;
  int D.49890;
  int D.49892;
  unsigned int D.49893;
  unsigned int D.49894;
  void * D.49895;
  int D.49896;
  int D.49897;
  unsigned int D.49898;
  unsigned int D.49899;
  unsigned int D.49900;
  unsigned char * D.49901;
  int D.49902;
  sizetype D.49903;
  sizetype D.49904;
  unsigned char * D.49905;
  unsigned char D.49906;
  int D.49907;
  unsigned char D.49908;
  unsigned char D.49909;
  int code.7949;
  int pos.7950;
  int D.49916;
  unsigned char * pos.7951;
  unsigned char D.49918;
  unsigned char * pos.7952;
  unsigned char D.49920;
  unsigned char * pos.7953;
  unsigned char D.49922;
  unsigned char * pos.7954;
  unsigned char D.49924;
  unsigned int disp.7955;
  unsigned int D.49927;
  unsigned char D.49930;
  unsigned char D.49931;
  const char * D.49933;
  struct MonoImage * D.49934;
  _Bool D.49935;
  long int D.49936;
  long int D.49937;
  struct MonoClass * D.49940;
  guint8 * D.49944;
  int D.49945;
  int D.49946;
  int D.49947;
  unsigned int D.49948;
  unsigned int D.49949;
  unsigned int _imm.7956;
  unsigned int D.49951;
  guint8 * code.7957;
  unsigned char D.49955;
  guint8 * code.7958;
  guint8 * code.7959;
  unsigned char D.49959;
  guint8 * code.7960;
  unsigned char D.49961;
  guint8 * code.7961;
  unsigned char D.49963;
  guint8 * code.7962;
  unsigned char D.49965;
  guint8 * D.49966;
  int D.49967;
  int D.49968;
  unsigned int t.7963;
  unsigned int D.49970;
  guint8 * code.7964;
  unsigned char D.49974;
  guint8 * code.7965;
  guint8 * code.7966;
  unsigned char D.49978;
  guint8 * code.7967;
  unsigned char D.49980;
  guint8 * code.7968;
  unsigned char D.49982;
  guint8 * code.7969;
  unsigned char D.49984;
  int D.49986;
  unsigned int D.49987;
  unsigned int D.49988;
  unsigned int D.49989;
  unsigned int _imm.7970;
  unsigned int D.49993;
  guint8 * code.7971;
  unsigned char D.49997;
  guint8 * code.7972;
  guint8 * code.7973;
  unsigned char D.50001;
  guint8 * code.7974;
  unsigned char D.50003;
  guint8 * code.7975;
  unsigned char D.50005;
  guint8 * code.7976;
  unsigned char D.50007;
  unsigned int _imm.7977;
  unsigned int D.50010;
  guint8 * code.7978;
  unsigned char D.50014;
  guint8 * code.7979;
  guint8 * code.7980;
  unsigned char D.50018;
  guint8 * code.7981;
  unsigned char D.50020;
  guint8 * code.7982;
  unsigned char D.50022;
  guint8 * code.7983;
  unsigned char D.50024;
  unsigned int D.50027;
  unsigned int D.50028;
  unsigned int _imm.7984;
  unsigned int D.50030;
  guint8 * code.7985;
  unsigned char D.50034;
  guint8 * code.7986;
  guint8 * code.7987;
  unsigned char D.50038;
  guint8 * code.7988;
  unsigned char D.50040;
  guint8 * code.7989;
  unsigned char D.50042;
  guint8 * code.7990;
  unsigned char D.50044;
  int code.7991;
  guint8 * code.7992;
  guint8 * code.7993;
  unsigned char D.50048;
  guint8 * code.7994;
  unsigned char D.50050;
  guint8 * code.7995;
  unsigned char D.50052;
  guint8 * code.7996;
  unsigned char D.50054;
  unsigned int _imm.7997;
  unsigned int D.50056;
  guint8 * buf.7998;
  unsigned char D.50060;
  guint8 * buf.7999;
  guint8 * buf.8000;
  unsigned char D.50064;
  guint8 * buf.8001;
  unsigned char D.50066;
  guint8 * buf.8002;
  unsigned char D.50068;
  guint8 * buf.8003;
  unsigned char D.50070;
  guint8 * buf.8004;
  unsigned int D.50074;
  _Bool D.50075;
  long int D.50076;
  long int D.50077;
  struct MonoJumpInfo * patch_info;
  int nthrows;
  int i;
  guint8 * code;
  struct MonoClass * exc_classes[16];
  guint8 * exc_throw_start[16];
  guint8 * exc_throw_end[16];
  guint32 code_size;
  int exc_count;
  static const char __PRETTY_FUNCTION__[26] = "mono_arch_emit_exceptions";

  try
    {
      exc_count = 0;
      patch_info = cfg->patch_info;
      goto <D.28761>;
      <D.28760>:
      D.49883 = patch_info->type;
      if (D.49883 == 9) goto <D.49884>; else goto <D.49885>;
      <D.49884>:
      exc_count = exc_count + 1;
      <D.49885>:
      patch_info = patch_info->next;
      <D.28761>:
      if (patch_info != 0B) goto <D.28760>; else goto <D.28762>;
      <D.28762>:
      D.49886 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.49887 = D.49886 & 64;
      if (D.49887 != 0) goto <D.49888>; else goto <D.49889>;
      <D.49888>:
      D.49890 = exc_count * 32;
      code_size = (guint32) D.49890;
      goto <D.49891>;
      <D.49889>:
      D.49892 = exc_count * 16;
      code_size = (guint32) D.49892;
      <D.49891>:
      goto <D.28764>;
      <D.28763>:
      D.49893 = cfg->code_size;
      D.49894 = D.49893 * 2;
      cfg->code_size = D.49894;
      D.49895 = mono_realloc_native_code (cfg);
      cfg->native_code = D.49895;
      D.49896 = cfg->stat_code_reallocs;
      D.49897 = D.49896 + 1;
      cfg->stat_code_reallocs = D.49897;
      <D.28764>:
      D.49898 = cfg->code_len;
      D.49899 = D.49898 + code_size;
      D.49893 = cfg->code_size;
      D.49900 = D.49893 + 4294967280;
      if (D.49899 > D.49900) goto <D.28763>; else goto <D.28765>;
      <D.28765>:
      D.49901 = cfg->native_code;
      D.49898 = cfg->code_len;
      code = D.49901 + D.49898;
      nthrows = 0;
      patch_info = cfg->patch_info;
      goto <D.28825>;
      <D.28824>:
      D.49883 = patch_info->type;
      switch (D.49883) <default: <D.28823>, case 9: <D.28766>>
      <D.28766>:
      {
        struct MonoClass * exc_class;
        guint8 * buf;
        guint8 * buf2;
        guint32 throw_ip;

        {
          unsigned char * pos;
          int disp;
          int size;

          D.49901 = cfg->native_code;
          D.49902 = patch_info->ip.i;
          D.49903 = (sizetype) D.49902;
          D.49904 = D.49903 + 1;
          pos = D.49901 + D.49904;
          size = 0;
          D.49901 = cfg->native_code;
          D.49902 = patch_info->ip.i;
          D.49903 = (sizetype) D.49902;
          D.49905 = D.49901 + D.49903;
          D.49906 = *D.49905;
          D.49907 = (int) D.49906;
          switch (D.49907) <default: <D.28799>, case 15: <D.28777>, case 112: <D.28783>, case 113: <D.28784>, case 114: <D.28785>, case 115: <D.28786>, case 116: <D.28787>, case 117: <D.28788>, case 118: <D.28789>, case 119: <D.28790>, case 120: <D.28791>, case 121: <D.28792>, case 122: <D.28793>, case 123: <D.28794>, case 124: <D.28795>, case 125: <D.28796>, case 126: <D.28797>, case 127: <D.28798>, case 224: <D.28779>, case 225: <D.28780>, case 226: <D.28781>, case 232: <D.28774>, case 233: <D.28775>, case 235: <D.28782>>
          <D.28774>:
          <D.28775>:
          size = size + 1;
          goto <D.28776>;
          <D.28777>:
          D.49908 = *pos;
          D.49909 = D.49908 + 144;
          if (D.49909 > 31) goto <D.49910>; else goto <D.49911>;
          <D.49910>:
          __assert_fail ("0", "mini-x86.c", 5712, &__PRETTY_FUNCTION__);
          <D.49911>:
          size = size + 1;
          pos = pos + 1;
          goto <D.28776>;
          <D.28779>:
          <D.28780>:
          <D.28781>:
          <D.28782>:
          <D.28783>:
          <D.28784>:
          <D.28785>:
          <D.28786>:
          <D.28787>:
          <D.28788>:
          <D.28789>:
          <D.28790>:
          <D.28791>:
          <D.28792>:
          <D.28793>:
          <D.28794>:
          <D.28795>:
          <D.28796>:
          <D.28797>:
          <D.28798>:
          goto <D.28776>;
          <D.28799>:
          __assert_fail ("0", "mini-x86.c", 5712, &__PRETTY_FUNCTION__);
          <D.28776>:
          code.7949 = (int) code;
          pos.7950 = (int) pos;
          disp = code.7949 - pos.7950;
          if (size != 0) goto <D.49914>; else goto <D.49915>;
          <D.49914>:
          {
            union x86_imm_buf imb;

            try
              {
                D.49916 = disp + -4;
                imb.val = D.49916;
                pos.7951 = pos;
                pos = pos.7951 + 1;
                D.49918 = imb.b[0];
                *pos.7951 = D.49918;
                pos.7952 = pos;
                pos = pos.7952 + 1;
                D.49920 = imb.b[1];
                *pos.7952 = D.49920;
                pos.7953 = pos;
                pos = pos.7953 + 1;
                D.49922 = imb.b[2];
                *pos.7953 = D.49922;
                pos.7954 = pos;
                pos = pos.7954 + 1;
                D.49924 = imb.b[3];
                *pos.7954 = D.49924;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.49925>;
          <D.49915>:
          disp.7955 = (unsigned int) disp;
          D.49927 = disp.7955 + 127;
          if (D.49927 <= 255) goto <D.49928>; else goto <D.49929>;
          <D.49928>:
          D.49930 = (unsigned char) disp;
          D.49931 = D.49930 + 255;
          *pos = D.49931;
          pos = pos + 1;
          goto <D.49932>;
          <D.49929>:
          __assert_fail ("0", "mini-x86.c", 5712, &__PRETTY_FUNCTION__);
          <D.49932>:
          <D.49925>:
        }
        D.49933 = patch_info->data.name;
        D.49934 = mono_defaults.corlib;
        exc_class = mono_class_from_name (D.49934, "System", D.49933);
        D.49935 = exc_class == 0B;
        D.49936 = (long int) D.49935;
        D.49937 = __builtin_expect (D.49936, 0);
        if (D.49937 != 0) goto <D.49938>; else goto <D.49939>;
        <D.49938>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5715, "exc_class");
        <D.49939>:
        D.49902 = patch_info->ip.i;
        throw_ip = (guint32) D.49902;
        i = 0;
        goto <D.28803>;
        <D.28802>:
        D.49940 = exc_classes[i];
        if (D.49940 == exc_class) goto <D.28801>; else goto <D.49941>;
        <D.49941>:
        i = i + 1;
        <D.28803>:
        if (i < nthrows) goto <D.28802>; else goto <D.28801>;
        <D.28801>:
        if (i < nthrows) goto <D.49942>; else goto <D.49943>;
        <D.49942>:
        {
          int _imm;

          D.49944 = exc_throw_end[i];
          D.49945 = (int) D.49944;
          D.49901 = cfg->native_code;
          D.49946 = (int) D.49901;
          D.49947 = D.49945 - D.49946;
          D.49948 = (unsigned int) D.49947;
          D.49949 = D.49948 - throw_ip;
          _imm = (int) D.49949;
          _imm.7956 = (unsigned int) _imm;
          D.49951 = _imm.7956 + 128;
          if (D.49951 <= 255) goto <D.49952>; else goto <D.49953>;
          <D.49952>:
          code.7957 = code;
          code = code.7957 + 1;
          *code.7957 = 106;
          D.49955 = (unsigned char) _imm;
          *code = D.49955;
          code = code + 1;
          goto <D.49956>;
          <D.49953>:
          code.7958 = code;
          code = code.7958 + 1;
          *code.7958 = 104;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = _imm;
                code.7959 = code;
                code = code.7959 + 1;
                D.49959 = imb.b[0];
                *code.7959 = D.49959;
                code.7960 = code;
                code = code.7960 + 1;
                D.49961 = imb.b[1];
                *code.7960 = D.49961;
                code.7961 = code;
                code = code.7961 + 1;
                D.49963 = imb.b[2];
                *code.7961 = D.49963;
                code.7962 = code;
                code = code.7962 + 1;
                D.49965 = imb.b[3];
                *code.7962 = D.49965;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.49956>:
        }
        {
          int t;

          D.49966 = exc_throw_start[i];
          D.49967 = (int) D.49966;
          code.7949 = (int) code;
          D.49968 = D.49967 - code.7949;
          t = D.49968 + -2;
          t.7963 = (unsigned int) t;
          D.49970 = t.7963 + 128;
          if (D.49970 <= 255) goto <D.49971>; else goto <D.49972>;
          <D.49971>:
          code.7964 = code;
          code = code.7964 + 1;
          *code.7964 = 235;
          D.49974 = (unsigned char) t;
          *code = D.49974;
          code = code + 1;
          goto <D.49975>;
          <D.49972>:
          D.49966 = exc_throw_start[i];
          D.49967 = (int) D.49966;
          code.7949 = (int) code;
          D.49968 = D.49967 - code.7949;
          t = D.49968 + -5;
          code.7965 = code;
          code = code.7965 + 1;
          *code.7965 = 233;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = t;
                code.7966 = code;
                code = code.7966 + 1;
                D.49978 = imb.b[0];
                *code.7966 = D.49978;
                code.7967 = code;
                code = code.7967 + 1;
                D.49980 = imb.b[1];
                *code.7967 = D.49980;
                code.7968 = code;
                code = code.7968 + 1;
                D.49982 = imb.b[2];
                *code.7968 = D.49982;
                code.7969 = code;
                code = code.7969 + 1;
                D.49984 = imb.b[3];
                *code.7969 = D.49984;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.49975>:
        }
        patch_info->type = 51;
        goto <D.49985>;
        <D.49943>:
        {
          guint32 size;

          size = 10;
          code.7949 = (int) code;
          D.49901 = cfg->native_code;
          D.49946 = (int) D.49901;
          D.49986 = code.7949 - D.49946;
          D.49987 = (unsigned int) D.49986;
          D.49988 = D.49987 - throw_ip;
          D.49989 = 126 - size;
          if (D.49988 < D.49989) goto <D.49990>; else goto <D.49991>;
          <D.49990>:
          buf2 = code;
          buf = buf2;
          {
            int _imm;

            _imm = 0;
            _imm.7970 = (unsigned int) _imm;
            D.49993 = _imm.7970 + 128;
            if (D.49993 <= 255) goto <D.49994>; else goto <D.49995>;
            <D.49994>:
            code.7971 = code;
            code = code.7971 + 1;
            *code.7971 = 106;
            D.49997 = (unsigned char) _imm;
            *code = D.49997;
            code = code + 1;
            goto <D.49998>;
            <D.49995>:
            code.7972 = code;
            code = code.7972 + 1;
            *code.7972 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  code.7973 = code;
                  code = code.7973 + 1;
                  D.50001 = imb.b[0];
                  *code.7973 = D.50001;
                  code.7974 = code;
                  code = code.7974 + 1;
                  D.50003 = imb.b[1];
                  *code.7974 = D.50003;
                  code.7975 = code;
                  code = code.7975 + 1;
                  D.50005 = imb.b[2];
                  *code.7975 = D.50005;
                  code.7976 = code;
                  code = code.7976 + 1;
                  D.50007 = imb.b[3];
                  *code.7976 = D.50007;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.49998>:
          }
          goto <D.50008>;
          <D.49991>:
          buf = code;
          {
            int _imm;

            _imm = -252645136;
            _imm.7977 = (unsigned int) _imm;
            D.50010 = _imm.7977 + 128;
            if (D.50010 <= 255) goto <D.50011>; else goto <D.50012>;
            <D.50011>:
            code.7978 = code;
            code = code.7978 + 1;
            *code.7978 = 106;
            D.50014 = (unsigned char) _imm;
            *code = D.50014;
            code = code + 1;
            goto <D.50015>;
            <D.50012>:
            code.7979 = code;
            code = code.7979 + 1;
            *code.7979 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  code.7980 = code;
                  code = code.7980 + 1;
                  D.50018 = imb.b[0];
                  *code.7980 = D.50018;
                  code.7981 = code;
                  code = code.7981 + 1;
                  D.50020 = imb.b[1];
                  *code.7981 = D.50020;
                  code.7982 = code;
                  code = code.7982 + 1;
                  D.50022 = imb.b[2];
                  *code.7982 = D.50022;
                  code.7983 = code;
                  code = code.7983 + 1;
                  D.50024 = imb.b[3];
                  *code.7983 = D.50024;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.50015>:
          }
          buf2 = code;
          <D.50008>:
          if (nthrows <= 15) goto <D.50025>; else goto <D.50026>;
          <D.50025>:
          exc_classes[nthrows] = exc_class;
          exc_throw_start[nthrows] = code;
          <D.50026>:
          {
            int _imm;

            D.50027 = exc_class->type_token;
            D.50028 = D.50027 + 4261412864;
            _imm = (int) D.50028;
            _imm.7984 = (unsigned int) _imm;
            D.50030 = _imm.7984 + 128;
            if (D.50030 <= 255) goto <D.50031>; else goto <D.50032>;
            <D.50031>:
            code.7985 = code;
            code = code.7985 + 1;
            *code.7985 = 106;
            D.50034 = (unsigned char) _imm;
            *code = D.50034;
            code = code + 1;
            goto <D.50035>;
            <D.50032>:
            code.7986 = code;
            code = code.7986 + 1;
            *code.7986 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  code.7987 = code;
                  code = code.7987 + 1;
                  D.50038 = imb.b[0];
                  *code.7987 = D.50038;
                  code.7988 = code;
                  code = code.7988 + 1;
                  D.50040 = imb.b[1];
                  *code.7988 = D.50040;
                  code.7989 = code;
                  code = code.7989 + 1;
                  D.50042 = imb.b[2];
                  *code.7989 = D.50042;
                  code.7990 = code;
                  code = code.7990 + 1;
                  D.50044 = imb.b[3];
                  *code.7990 = D.50044;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.50035>:
          }
          patch_info->data.name = "mono_arch_throw_corlib_exception";
          patch_info->type = 7;
          code.7949 = (int) code;
          D.49901 = cfg->native_code;
          D.49946 = (int) D.49901;
          D.49986 = code.7949 - D.49946;
          patch_info->ip.i = D.49986;
          {
            int _x86_offset;

            code.7991 = (int) code;
            _x86_offset = -code.7991;
            _x86_offset = _x86_offset + -5;
            code.7992 = code;
            code = code.7992 + 1;
            *code.7992 = 232;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _x86_offset;
                  code.7993 = code;
                  code = code.7993 + 1;
                  D.50048 = imb.b[0];
                  *code.7993 = D.50048;
                  code.7994 = code;
                  code = code.7994 + 1;
                  D.50050 = imb.b[1];
                  *code.7994 = D.50050;
                  code.7995 = code;
                  code = code.7995 + 1;
                  D.50052 = imb.b[2];
                  *code.7995 = D.50052;
                  code.7996 = code;
                  code = code.7996 + 1;
                  D.50054 = imb.b[3];
                  *code.7996 = D.50054;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
          }
          {
            int _imm;

            code.7949 = (int) code;
            D.49901 = cfg->native_code;
            D.49946 = (int) D.49901;
            D.49986 = code.7949 - D.49946;
            D.49987 = (unsigned int) D.49986;
            D.49988 = D.49987 - throw_ip;
            _imm = (int) D.49988;
            _imm.7997 = (unsigned int) _imm;
            D.50056 = _imm.7997 + 128;
            if (D.50056 <= 255) goto <D.50057>; else goto <D.50058>;
            <D.50057>:
            buf.7998 = buf;
            buf = buf.7998 + 1;
            *buf.7998 = 106;
            D.50060 = (unsigned char) _imm;
            *buf = D.50060;
            buf = buf + 1;
            goto <D.50061>;
            <D.50058>:
            buf.7999 = buf;
            buf = buf.7999 + 1;
            *buf.7999 = 104;
            {
              union x86_imm_buf imb;

              try
                {
                  imb.val = _imm;
                  buf.8000 = buf;
                  buf = buf.8000 + 1;
                  D.50064 = imb.b[0];
                  *buf.8000 = D.50064;
                  buf.8001 = buf;
                  buf = buf.8001 + 1;
                  D.50066 = imb.b[1];
                  *buf.8001 = D.50066;
                  buf.8002 = buf;
                  buf = buf.8002 + 1;
                  D.50068 = imb.b[2];
                  *buf.8002 = D.50068;
                  buf.8003 = buf;
                  buf = buf.8003 + 1;
                  D.50070 = imb.b[3];
                  *buf.8003 = D.50070;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.50061>:
          }
          goto <D.28820>;
          <D.28819>:
          buf.8004 = buf;
          buf = buf.8004 + 1;
          *buf.8004 = 144;
          <D.28820>:
          if (buf < buf2) goto <D.28819>; else goto <D.28821>;
          <D.28821>:
          if (nthrows <= 15) goto <D.50072>; else goto <D.50073>;
          <D.50072>:
          exc_throw_end[nthrows] = code;
          nthrows = nthrows + 1;
          <D.50073>:
        }
        <D.49985>:
        goto <D.28822>;
      }
      <D.28823>:
      goto <D.28822>;
      <D.28822>:
      patch_info = patch_info->next;
      <D.28825>:
      if (patch_info != 0B) goto <D.28824>; else goto <D.28826>;
      <D.28826>:
      code.7949 = (int) code;
      D.49901 = cfg->native_code;
      D.49946 = (int) D.49901;
      D.49986 = code.7949 - D.49946;
      D.50074 = (unsigned int) D.49986;
      cfg->code_len = D.50074;
      D.49898 = cfg->code_len;
      D.49893 = cfg->code_size;
      D.50075 = D.49898 >= D.49893;
      D.50076 = (long int) D.50075;
      D.50077 = __builtin_expect (D.50076, 0);
      if (D.50077 != 0) goto <D.50078>; else goto <D.50079>;
      <D.50078>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5779, "cfg->code_len < cfg->code_size");
      <D.50079>:
    }
  finally
    {
      exc_classes = {CLOBBER};
      exc_throw_start = {CLOBBER};
      exc_throw_end = {CLOBBER};
    }
}


mono_arch_flush_icache (guint8 * code, gint size)
{

}


mono_arch_flush_register_windows ()
{

}


mono_arch_is_inst_imm (gint64 imm)
{
  gboolean D.50082;

  D.50082 = 1;
  return D.50082;
}


mono_arch_finish_init ()
{
  const gchar * D.50084;
  int D.50087;
  _Bool D.50088;
  int optimize_for_xen.8005;
  int lmf_addr_tls_offset.8006;

  D.50084 = monoeg_g_getenv ("MONO_NO_TLS");
  if (D.50084 == 0B) goto <D.50085>; else goto <D.50086>;
  <D.50085>:
  D.50087 = access ("/proc/xen", 0);
  D.50088 = D.50087 == 0;
  optimize_for_xen.8005 = (int) D.50088;
  optimize_for_xen = optimize_for_xen.8005;
  lmf_addr_tls_offset.8006 = mono_get_lmf_addr_tls_offset ();
  lmf_addr_tls_offset = lmf_addr_tls_offset.8006;
  <D.50086>:
}


mono_arch_free_jit_tls_data (struct MonoJitTlsData * tls)
{

}


mono_arch_build_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  unsigned int i.8007;
  unsigned int D.50092;
  struct MonoIMTCheckItem * * D.50093;
  unsigned char D.50094;
  int D.50097;
  unsigned char D.50100;
  unsigned char D.50103;
  unsigned char D.50104;
  unsigned char D.50105;
  unsigned char D.50109;
  unsigned char D.50112;
  unsigned int D.50113;
  unsigned int D.50114;
  struct MonoIMTCheckItem * * D.50115;
  struct MonoIMTCheckItem * D.50116;
  int D.50117;
  void * code.8008;
  void * code.8009;
  guint8 * code.8010;
  unsigned char D.50124;
  int D.50127;
  unsigned char D.50130;
  guint8 * code.8011;
  guint8 * code.8012;
  void * D.50137;
  int D.50138;
  guint8 * code.8013;
  guint8 * code.8014;
  unsigned char D.50141;
  guint8 * code.8015;
  guint8 * code.8016;
  unsigned char D.50144;
  guint8 * code.8017;
  guint8 * code.8018;
  unsigned char D.50147;
  guint8 * code.8019;
  guint8 * code.8020;
  unsigned char D.50150;
  unsigned int D.50151;
  unsigned int D.50152;
  guint8 * code.8021;
  guint8 * code.8022;
  guint8 * code.8023;
  guint8 * code.8024;
  int D.50159;
  unsigned char D.50160;
  guint8 * code.8025;
  guint8 * code.8026;
  guint8 * code.8027;
  guint8 * code.8028;
  guint8 * code.8029;
  guint8 * code.8030;
  guint8 * code.8031;
  unsigned char D.50169;
  guint8 * code.8032;
  guint8 * code.8033;
  unsigned char D.50172;
  guint8 * code.8034;
  guint8 * code.8035;
  unsigned char D.50175;
  guint8 * code.8036;
  guint8 * code.8037;
  unsigned char D.50178;
  guint8 * code.8038;
  guint8 * code.8039;
  unsigned char D.50183;
  guint8 * code.8040;
  guint8 * code.8041;
  unsigned char D.50187;
  unsigned char D.50188;
  void * D.50191;
  int D.50192;
  int code.8042;
  int D.50194;
  unsigned int t.8043;
  unsigned int D.50196;
  guint8 * code.8044;
  guint8 * code.8045;
  unsigned char D.50201;
  guint8 * code.8046;
  guint8 * code.8047;
  guint8 * code.8048;
  guint8 * code.8049;
  unsigned char D.50207;
  guint8 * code.8050;
  guint8 * code.8051;
  unsigned char D.50210;
  guint8 * code.8052;
  guint8 * code.8053;
  unsigned char D.50213;
  guint8 * code.8054;
  guint8 * code.8055;
  unsigned char D.50216;
  guint8 * code.8056;
  guint8 * code.8057;
  guint8 * code.8058;
  guint8 * code.8059;
  int D.50222;
  void * * D.50223;
  int D.50224;
  guint8 * code.8060;
  guint8 * code.8061;
  unsigned char D.50227;
  guint8 * code.8062;
  guint8 * code.8063;
  unsigned char D.50230;
  guint8 * code.8064;
  guint8 * code.8065;
  unsigned char D.50233;
  guint8 * code.8066;
  guint8 * code.8067;
  unsigned char D.50236;
  guint8 * code.8068;
  guint8 * code.8069;
  guint8 * code.8070;
  guint8 * code.8071;
  unsigned char D.50246;
  guint8 * code.8072;
  guint8 * code.8073;
  unsigned char D.50249;
  guint8 * code.8074;
  guint8 * code.8075;
  unsigned char D.50252;
  guint8 * code.8076;
  guint8 * code.8077;
  unsigned char D.50255;
  guint8 * code.8078;
  guint8 * code.8079;
  guint8 * code.8080;
  guint8 * code.8081;
  guint8 * code.8082;
  guint8 * code.8083;
  guint8 * code.8084;
  guint8 * code.8085;
  guint8 * code.8086;
  guint8 * code.8087;
  unsigned char D.50269;
  guint8 * code.8088;
  guint8 * code.8089;
  unsigned char D.50272;
  guint8 * code.8090;
  guint8 * code.8091;
  unsigned char D.50275;
  guint8 * code.8092;
  guint8 * code.8093;
  unsigned char D.50278;
  guint8 * code.8094;
  guint8 * code.8095;
  guint8 * code.8096;
  guint8 * code.8097;
  unsigned int t.8098;
  unsigned int D.50289;
  guint8 * code.8099;
  guint8 * code.8100;
  unsigned char D.50294;
  guint8 * code.8101;
  guint8 * code.8102;
  guint8 * code.8103;
  guint8 * code.8104;
  unsigned char D.50300;
  guint8 * code.8105;
  guint8 * code.8106;
  unsigned char D.50303;
  guint8 * code.8107;
  guint8 * code.8108;
  unsigned char D.50306;
  guint8 * code.8109;
  guint8 * code.8110;
  unsigned char D.50309;
  guint8 * code.8111;
  guint8 * code.8112;
  guint8 * code.8113;
  guint8 * code.8114;
  guint8 * code.8115;
  guint8 * code.8116;
  unsigned char D.50317;
  guint8 * code.8117;
  guint8 * code.8118;
  unsigned char D.50320;
  guint8 * code.8119;
  guint8 * code.8120;
  unsigned char D.50323;
  guint8 * code.8121;
  guint8 * code.8122;
  unsigned char D.50326;
  guint8 * D.50327;
  unsigned char D.50328;
  int D.50329;
  unsigned char D.50330;
  unsigned char D.50331;
  int pos.8123;
  int D.50337;
  unsigned char * pos.8124;
  unsigned char D.50339;
  unsigned char * pos.8125;
  unsigned char D.50341;
  unsigned char * pos.8126;
  unsigned char D.50343;
  unsigned char * pos.8127;
  unsigned char D.50345;
  unsigned int disp.8128;
  unsigned int D.50348;
  unsigned char D.50351;
  unsigned char D.50352;
  int fail_tramp.8129;
  int D.50355;
  unsigned int t.8130;
  unsigned int D.50357;
  guint8 * code.8131;
  guint8 * code.8132;
  unsigned char D.50362;
  guint8 * code.8133;
  guint8 * code.8134;
  guint8 * code.8135;
  guint8 * code.8136;
  unsigned char D.50368;
  guint8 * code.8137;
  guint8 * code.8138;
  unsigned char D.50371;
  guint8 * code.8139;
  guint8 * code.8140;
  unsigned char D.50374;
  guint8 * code.8141;
  guint8 * code.8142;
  unsigned char D.50377;
  unsigned int t.8143;
  unsigned int D.50382;
  guint8 * code.8144;
  guint8 * code.8145;
  unsigned char D.50387;
  guint8 * code.8146;
  guint8 * code.8147;
  guint8 * code.8148;
  guint8 * code.8149;
  unsigned char D.50393;
  guint8 * code.8150;
  guint8 * code.8151;
  unsigned char D.50396;
  guint8 * code.8152;
  guint8 * code.8153;
  unsigned char D.50399;
  guint8 * code.8154;
  guint8 * code.8155;
  unsigned char D.50402;
  guint8 * code.8156;
  guint8 * code.8157;
  guint8 * code.8158;
  guint8 * code.8159;
  guint8 * code.8160;
  guint8 * code.8161;
  unsigned char D.50410;
  guint8 * code.8162;
  guint8 * code.8163;
  unsigned char D.50413;
  guint8 * code.8164;
  guint8 * code.8165;
  unsigned char D.50416;
  guint8 * code.8166;
  guint8 * code.8167;
  unsigned char D.50419;
  guint8 * code.8168;
  guint8 * code.8169;
  guint8 * code.8170;
  guint8 * code.8171;
  unsigned char D.50427;
  guint8 * code.8172;
  guint8 * code.8173;
  unsigned char D.50430;
  guint8 * code.8174;
  guint8 * code.8175;
  unsigned char D.50433;
  guint8 * code.8176;
  guint8 * code.8177;
  unsigned char D.50436;
  guint8 * code.8178;
  guint8 * code.8179;
  guint8 * code.8180;
  guint8 * code.8181;
  guint8 * code.8182;
  guint8 * code.8183;
  guint8 * code.8184;
  guint8 * code.8185;
  guint8 * code.8186;
  guint8 * code.8187;
  unsigned char D.50450;
  guint8 * code.8188;
  guint8 * code.8189;
  unsigned char D.50453;
  guint8 * code.8190;
  guint8 * code.8191;
  unsigned char D.50456;
  guint8 * code.8192;
  guint8 * code.8193;
  unsigned char D.50459;
  int D.50462;
  int D.50464;
  guint8 * code.8194;
  guint8 * code.8195;
  unsigned char D.50470;
  guint8 * code.8196;
  guint8 * code.8197;
  unsigned char D.50474;
  guint8 * code.8198;
  guint8 * code.8199;
  guint8 * code.8200;
  guint8 * code.8201;
  unsigned char D.50481;
  guint8 * code.8202;
  guint8 * code.8203;
  unsigned char D.50485;
  guint8 * code.8204;
  guint8 * code.8205;
  unsigned char D.50488;
  guint8 * code.8206;
  guint8 * code.8207;
  unsigned char D.50491;
  guint8 * code.8208;
  guint8 * code.8209;
  unsigned char D.50494;
  guint8 * code.8210;
  guint8 * code.8211;
  unsigned char D.50497;
  guint8 * D.50498;
  int D.50501;
  unsigned char D.50504;
  int D.50505;
  unsigned char D.50506;
  unsigned char D.50507;
  unsigned int D.50510;
  unsigned int D.50511;
  struct MonoIMTCheckItem * * D.50512;
  struct MonoIMTCheckItem * D.50513;
  guint8 * D.50514;
  int D.50515;
  int pos.8212;
  int D.50519;
  unsigned char * pos.8213;
  unsigned char D.50521;
  unsigned char * pos.8214;
  unsigned char D.50523;
  unsigned char * pos.8215;
  unsigned char D.50525;
  unsigned char * pos.8216;
  unsigned char D.50527;
  unsigned int disp.8217;
  unsigned int D.50530;
  unsigned char D.50533;
  unsigned char D.50534;
  long unsigned int D.50538;
  guint8 * start.8218;
  int start.8219;
  int D.50541;
  long unsigned int D.50542;
  long unsigned int D.50543;
  _Bool D.50544;
  long int D.50545;
  long int D.50546;
  int D.50549;
  struct MonoClass * D.50554;
  const char * D.50555;
  const char * D.50556;
  void * D.50558;
  int i;
  int size;
  guint8 * code;
  guint8 * start;
  static const char __PRETTY_FUNCTION__[26] = "mono_arch_build_imt_thunk";

  try
    {
      size = 0;
      i = 0;
      goto <D.28866>;
      <D.28865>:
      {
        struct MonoIMTCheckItem * item;

        i.8007 = (unsigned int) i;
        D.50092 = i.8007 * 4;
        D.50093 = imt_entries + D.50092;
        item = *D.50093;
        D.50094 = item->is_equals;
        if (D.50094 != 0) goto <D.50095>; else goto <D.50096>;
        <D.50095>:
        D.50097 = item->check_target_idx;
        if (D.50097 != 0) goto <D.50098>; else goto <D.50099>;
        <D.50098>:
        D.50100 = item->compare_done;
        if (D.50100 == 0) goto <D.50101>; else goto <D.50102>;
        <D.50101>:
        D.50103 = item->chunk_size;
        D.50104 = D.50103 + 6;
        item->chunk_size = D.50104;
        <D.50102>:
        D.50103 = item->chunk_size;
        D.50105 = D.50103 + 8;
        item->chunk_size = D.50105;
        goto <D.50106>;
        <D.50099>:
        if (fail_tramp != 0B) goto <D.50107>; else goto <D.50108>;
        <D.50107>:
        D.50103 = item->chunk_size;
        D.50109 = D.50103 + 20;
        item->chunk_size = D.50109;
        goto <D.50110>;
        <D.50108>:
        D.50103 = item->chunk_size;
        D.50104 = D.50103 + 6;
        item->chunk_size = D.50104;
        <D.50110>:
        <D.50106>:
        goto <D.50111>;
        <D.50096>:
        D.50103 = item->chunk_size;
        D.50112 = D.50103 + 11;
        item->chunk_size = D.50112;
        D.50097 = item->check_target_idx;
        D.50113 = (unsigned int) D.50097;
        D.50114 = D.50113 * 4;
        D.50115 = imt_entries + D.50114;
        D.50116 = *D.50115;
        D.50116->compare_done = 1;
        <D.50111>:
        D.50103 = item->chunk_size;
        D.50117 = (int) D.50103;
        size = D.50117 + size;
      }
      i = i + 1;
      <D.28866>:
      if (i < count) goto <D.28865>; else goto <D.28867>;
      <D.28867>:
      if (fail_tramp != 0B) goto <D.50118>; else goto <D.50119>;
      <D.50118>:
      code.8008 = mono_method_alloc_generic_virtual_thunk (domain, size);
      code = code.8008;
      goto <D.50121>;
      <D.50119>:
      code.8009 = mono_domain_code_reserve (domain, size);
      code = code.8009;
      <D.50121>:
      code.8010 = code;
      start = code.8010;
      i = 0;
      goto <D.28921>;
      <D.28920>:
      {
        struct MonoIMTCheckItem * item;

        i.8007 = (unsigned int) i;
        D.50092 = i.8007 * 4;
        D.50093 = imt_entries + D.50092;
        item = *D.50093;
        code.8010 = code;
        item->code_target = code.8010;
        D.50124 = item->is_equals;
        if (D.50124 != 0) goto <D.50125>; else goto <D.50126>;
        <D.50125>:
        D.50127 = item->check_target_idx;
        if (D.50127 != 0) goto <D.50128>; else goto <D.50129>;
        <D.50128>:
        D.50130 = item->compare_done;
        if (D.50130 == 0) goto <D.50131>; else goto <D.50132>;
        <D.50131>:
        if (0 != 0) goto <D.50133>; else goto <D.50134>;
        <D.50133>:
        code.8010 = code;
        code.8011 = code.8010;
        code.8012 = code.8011 + 1;
        code = code.8012;
        *code.8011 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              D.50137 = item->key;
              D.50138 = (int) D.50137;
              imb.val = D.50138;
              code.8010 = code;
              code.8013 = code.8010;
              code.8014 = code.8013 + 1;
              code = code.8014;
              D.50141 = imb.b[0];
              *code.8013 = D.50141;
              code.8010 = code;
              code.8015 = code.8010;
              code.8016 = code.8015 + 1;
              code = code.8016;
              D.50144 = imb.b[1];
              *code.8015 = D.50144;
              code.8010 = code;
              code.8017 = code.8010;
              code.8018 = code.8017 + 1;
              code = code.8018;
              D.50147 = imb.b[2];
              *code.8017 = D.50147;
              code.8010 = code;
              code.8019 = code.8010;
              code.8020 = code.8019 + 1;
              code = code.8020;
              D.50150 = imb.b[3];
              *code.8019 = D.50150;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28870>;
        <D.50134>:
        D.50137 = item->key;
        D.50151 = (unsigned int) D.50137;
        D.50152 = D.50151 + 128;
        if (D.50152 <= 255) goto <D.50153>; else goto <D.50154>;
        <D.50153>:
        code.8010 = code;
        code.8021 = code.8010;
        code.8022 = code.8021 + 1;
        code = code.8022;
        *code.8021 = 131;
        code.8010 = code;
        code.8023 = code.8010;
        code.8024 = code.8023 + 1;
        code = code.8024;
        *code.8023 = 250;
        code.8010 = code;
        D.50137 = item->key;
        D.50159 = (int) D.50137;
        D.50160 = (unsigned char) D.50159;
        *code.8010 = D.50160;
        code.8010 = code;
        code.8025 = code.8010 + 1;
        code = code.8025;
        goto <D.50162>;
        <D.50154>:
        code.8010 = code;
        code.8026 = code.8010;
        code.8027 = code.8026 + 1;
        code = code.8027;
        *code.8026 = 129;
        code.8010 = code;
        code.8028 = code.8010;
        code.8029 = code.8028 + 1;
        code = code.8029;
        *code.8028 = 250;
        {
          union x86_imm_buf imb;

          try
            {
              D.50137 = item->key;
              D.50138 = (int) D.50137;
              imb.val = D.50138;
              code.8010 = code;
              code.8030 = code.8010;
              code.8031 = code.8030 + 1;
              code = code.8031;
              D.50169 = imb.b[0];
              *code.8030 = D.50169;
              code.8010 = code;
              code.8032 = code.8010;
              code.8033 = code.8032 + 1;
              code = code.8033;
              D.50172 = imb.b[1];
              *code.8032 = D.50172;
              code.8010 = code;
              code.8034 = code.8010;
              code.8035 = code.8034 + 1;
              code = code.8035;
              D.50175 = imb.b[2];
              *code.8034 = D.50175;
              code.8010 = code;
              code.8036 = code.8010;
              code.8037 = code.8036 + 1;
              code = code.8037;
              D.50178 = imb.b[3];
              *code.8036 = D.50178;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50162>:
        <D.28870>:
        <D.50132>:
        code.8010 = code;
        item->jmp_code = code.8010;
        if (0 != 0) goto <D.50179>; else goto <D.50180>;
        <D.50179>:
        code.8010 = code;
        code.8038 = code.8010;
        code.8039 = code.8038 + 1;
        code = code.8039;
        D.50183 = 117;
        *code.8038 = D.50183;
        goto <D.50184>;
        <D.50180>:
        code.8010 = code;
        code.8040 = code.8010;
        code.8041 = code.8040 + 1;
        code = code.8041;
        D.50187 = 117;
        *code.8040 = D.50187;
        <D.50184>:
        code.8010 = code;
        *code.8010 = 0;
        code.8010 = code;
        code.8025 = code.8010 + 1;
        code = code.8025;
        D.50188 = item->has_target_code;
        if (D.50188 != 0) goto <D.50189>; else goto <D.50190>;
        <D.50189>:
        {
          int t;

          D.50191 = item->value.target_code;
          D.50192 = (int) D.50191;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50194 = D.50192 - code.8042;
          t = D.50194 + -2;
          t.8043 = (unsigned int) t;
          D.50196 = t.8043 + 128;
          if (D.50196 <= 255) goto <D.50197>; else goto <D.50198>;
          <D.50197>:
          code.8010 = code;
          code.8044 = code.8010;
          code.8045 = code.8044 + 1;
          code = code.8045;
          *code.8044 = 235;
          code.8010 = code;
          D.50201 = (unsigned char) t;
          *code.8010 = D.50201;
          code.8010 = code;
          code.8025 = code.8010 + 1;
          code = code.8025;
          goto <D.50202>;
          <D.50198>:
          D.50191 = item->value.target_code;
          D.50192 = (int) D.50191;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50194 = D.50192 - code.8042;
          t = D.50194 + -5;
          code.8010 = code;
          code.8046 = code.8010;
          code.8047 = code.8046 + 1;
          code = code.8047;
          *code.8046 = 233;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = t;
                code.8010 = code;
                code.8048 = code.8010;
                code.8049 = code.8048 + 1;
                code = code.8049;
                D.50207 = imb.b[0];
                *code.8048 = D.50207;
                code.8010 = code;
                code.8050 = code.8010;
                code.8051 = code.8050 + 1;
                code = code.8051;
                D.50210 = imb.b[1];
                *code.8050 = D.50210;
                code.8010 = code;
                code.8052 = code.8010;
                code.8053 = code.8052 + 1;
                code = code.8053;
                D.50213 = imb.b[2];
                *code.8052 = D.50213;
                code.8010 = code;
                code.8054 = code.8010;
                code.8055 = code.8054 + 1;
                code = code.8055;
                D.50216 = imb.b[3];
                *code.8054 = D.50216;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.50202>:
        }
        goto <D.50217>;
        <D.50190>:
        code.8010 = code;
        code.8056 = code.8010;
        code.8057 = code.8056 + 1;
        code = code.8057;
        *code.8056 = 255;
        code.8010 = code;
        code.8058 = code.8010;
        code.8059 = code.8058 + 1;
        code = code.8059;
        *code.8058 = 37;
        {
          union x86_imm_buf imb;

          try
            {
              D.50222 = item->value.vtable_slot;
              D.50223 = &vtable->vtable[D.50222];
              D.50224 = (int) D.50223;
              imb.val = D.50224;
              code.8010 = code;
              code.8060 = code.8010;
              code.8061 = code.8060 + 1;
              code = code.8061;
              D.50227 = imb.b[0];
              *code.8060 = D.50227;
              code.8010 = code;
              code.8062 = code.8010;
              code.8063 = code.8062 + 1;
              code = code.8063;
              D.50230 = imb.b[1];
              *code.8062 = D.50230;
              code.8010 = code;
              code.8064 = code.8010;
              code.8065 = code.8064 + 1;
              code = code.8065;
              D.50233 = imb.b[2];
              *code.8064 = D.50233;
              code.8010 = code;
              code.8066 = code.8010;
              code.8067 = code.8066 + 1;
              code = code.8067;
              D.50236 = imb.b[3];
              *code.8066 = D.50236;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50217>:
        goto <D.50237>;
        <D.50129>:
        if (fail_tramp != 0B) goto <D.50238>; else goto <D.50239>;
        <D.50238>:
        if (0 != 0) goto <D.50240>; else goto <D.50241>;
        <D.50240>:
        code.8010 = code;
        code.8068 = code.8010;
        code.8069 = code.8068 + 1;
        code = code.8069;
        *code.8068 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              D.50137 = item->key;
              D.50138 = (int) D.50137;
              imb.val = D.50138;
              code.8010 = code;
              code.8070 = code.8010;
              code.8071 = code.8070 + 1;
              code = code.8071;
              D.50246 = imb.b[0];
              *code.8070 = D.50246;
              code.8010 = code;
              code.8072 = code.8010;
              code.8073 = code.8072 + 1;
              code = code.8073;
              D.50249 = imb.b[1];
              *code.8072 = D.50249;
              code.8010 = code;
              code.8074 = code.8010;
              code.8075 = code.8074 + 1;
              code = code.8075;
              D.50252 = imb.b[2];
              *code.8074 = D.50252;
              code.8010 = code;
              code.8076 = code.8010;
              code.8077 = code.8076 + 1;
              code = code.8077;
              D.50255 = imb.b[3];
              *code.8076 = D.50255;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28876>;
        <D.50241>:
        D.50137 = item->key;
        D.50151 = (unsigned int) D.50137;
        D.50152 = D.50151 + 128;
        if (D.50152 <= 255) goto <D.50256>; else goto <D.50257>;
        <D.50256>:
        code.8010 = code;
        code.8078 = code.8010;
        code.8079 = code.8078 + 1;
        code = code.8079;
        *code.8078 = 131;
        code.8010 = code;
        code.8080 = code.8010;
        code.8081 = code.8080 + 1;
        code = code.8081;
        *code.8080 = 250;
        code.8010 = code;
        D.50137 = item->key;
        D.50159 = (int) D.50137;
        D.50160 = (unsigned char) D.50159;
        *code.8010 = D.50160;
        code.8010 = code;
        code.8025 = code.8010 + 1;
        code = code.8025;
        goto <D.50262>;
        <D.50257>:
        code.8010 = code;
        code.8082 = code.8010;
        code.8083 = code.8082 + 1;
        code = code.8083;
        *code.8082 = 129;
        code.8010 = code;
        code.8084 = code.8010;
        code.8085 = code.8084 + 1;
        code = code.8085;
        *code.8084 = 250;
        {
          union x86_imm_buf imb;

          try
            {
              D.50137 = item->key;
              D.50138 = (int) D.50137;
              imb.val = D.50138;
              code.8010 = code;
              code.8086 = code.8010;
              code.8087 = code.8086 + 1;
              code = code.8087;
              D.50269 = imb.b[0];
              *code.8086 = D.50269;
              code.8010 = code;
              code.8088 = code.8010;
              code.8089 = code.8088 + 1;
              code = code.8089;
              D.50272 = imb.b[1];
              *code.8088 = D.50272;
              code.8010 = code;
              code.8090 = code.8010;
              code.8091 = code.8090 + 1;
              code = code.8091;
              D.50275 = imb.b[2];
              *code.8090 = D.50275;
              code.8010 = code;
              code.8092 = code.8010;
              code.8093 = code.8092 + 1;
              code = code.8093;
              D.50278 = imb.b[3];
              *code.8092 = D.50278;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50262>:
        <D.28876>:
        code.8010 = code;
        item->jmp_code = code.8010;
        if (0 != 0) goto <D.50279>; else goto <D.50280>;
        <D.50279>:
        code.8010 = code;
        code.8094 = code.8010;
        code.8095 = code.8094 + 1;
        code = code.8095;
        D.50183 = 117;
        *code.8094 = D.50183;
        goto <D.50283>;
        <D.50280>:
        code.8010 = code;
        code.8096 = code.8010;
        code.8097 = code.8096 + 1;
        code = code.8097;
        D.50187 = 117;
        *code.8096 = D.50187;
        <D.50283>:
        code.8010 = code;
        *code.8010 = 0;
        code.8010 = code;
        code.8025 = code.8010 + 1;
        code = code.8025;
        D.50188 = item->has_target_code;
        if (D.50188 != 0) goto <D.50286>; else goto <D.50287>;
        <D.50286>:
        {
          int t;

          D.50191 = item->value.target_code;
          D.50192 = (int) D.50191;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50194 = D.50192 - code.8042;
          t = D.50194 + -2;
          t.8098 = (unsigned int) t;
          D.50289 = t.8098 + 128;
          if (D.50289 <= 255) goto <D.50290>; else goto <D.50291>;
          <D.50290>:
          code.8010 = code;
          code.8099 = code.8010;
          code.8100 = code.8099 + 1;
          code = code.8100;
          *code.8099 = 235;
          code.8010 = code;
          D.50294 = (unsigned char) t;
          *code.8010 = D.50294;
          code.8010 = code;
          code.8025 = code.8010 + 1;
          code = code.8025;
          goto <D.50295>;
          <D.50291>:
          D.50191 = item->value.target_code;
          D.50192 = (int) D.50191;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50194 = D.50192 - code.8042;
          t = D.50194 + -5;
          code.8010 = code;
          code.8101 = code.8010;
          code.8102 = code.8101 + 1;
          code = code.8102;
          *code.8101 = 233;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = t;
                code.8010 = code;
                code.8103 = code.8010;
                code.8104 = code.8103 + 1;
                code = code.8104;
                D.50300 = imb.b[0];
                *code.8103 = D.50300;
                code.8010 = code;
                code.8105 = code.8010;
                code.8106 = code.8105 + 1;
                code = code.8106;
                D.50303 = imb.b[1];
                *code.8105 = D.50303;
                code.8010 = code;
                code.8107 = code.8010;
                code.8108 = code.8107 + 1;
                code = code.8108;
                D.50306 = imb.b[2];
                *code.8107 = D.50306;
                code.8010 = code;
                code.8109 = code.8010;
                code.8110 = code.8109 + 1;
                code = code.8110;
                D.50309 = imb.b[3];
                *code.8109 = D.50309;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.50295>:
        }
        goto <D.50310>;
        <D.50287>:
        code.8010 = code;
        code.8111 = code.8010;
        code.8112 = code.8111 + 1;
        code = code.8112;
        *code.8111 = 255;
        code.8010 = code;
        code.8113 = code.8010;
        code.8114 = code.8113 + 1;
        code = code.8114;
        *code.8113 = 37;
        {
          union x86_imm_buf imb;

          try
            {
              D.50222 = item->value.vtable_slot;
              D.50223 = &vtable->vtable[D.50222];
              D.50224 = (int) D.50223;
              imb.val = D.50224;
              code.8010 = code;
              code.8115 = code.8010;
              code.8116 = code.8115 + 1;
              code = code.8116;
              D.50317 = imb.b[0];
              *code.8115 = D.50317;
              code.8010 = code;
              code.8117 = code.8010;
              code.8118 = code.8117 + 1;
              code = code.8118;
              D.50320 = imb.b[1];
              *code.8117 = D.50320;
              code.8010 = code;
              code.8119 = code.8010;
              code.8120 = code.8119 + 1;
              code = code.8120;
              D.50323 = imb.b[2];
              *code.8119 = D.50323;
              code.8010 = code;
              code.8121 = code.8010;
              code.8122 = code.8121 + 1;
              code = code.8122;
              D.50326 = imb.b[3];
              *code.8121 = D.50326;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50310>:
        {
          unsigned char * pos;
          int disp;
          int size;

          D.50327 = item->jmp_code;
          pos = D.50327 + 1;
          size = 0;
          D.50327 = item->jmp_code;
          D.50328 = MEM[(unsigned char *)D.50327];
          D.50329 = (int) D.50328;
          switch (D.50329) <default: <D.28909>, case 15: <D.28887>, case 112: <D.28893>, case 113: <D.28894>, case 114: <D.28895>, case 115: <D.28896>, case 116: <D.28897>, case 117: <D.28898>, case 118: <D.28899>, case 119: <D.28900>, case 120: <D.28901>, case 121: <D.28902>, case 122: <D.28903>, case 123: <D.28904>, case 124: <D.28905>, case 125: <D.28906>, case 126: <D.28907>, case 127: <D.28908>, case 224: <D.28889>, case 225: <D.28890>, case 226: <D.28891>, case 232: <D.28884>, case 233: <D.28885>, case 235: <D.28892>>
          <D.28884>:
          <D.28885>:
          size = size + 1;
          goto <D.28886>;
          <D.28887>:
          D.50330 = *pos;
          D.50331 = D.50330 + 144;
          if (D.50331 > 31) goto <D.50332>; else goto <D.50333>;
          <D.50332>:
          __assert_fail ("0", "mini-x86.c", 5926, &__PRETTY_FUNCTION__);
          <D.50333>:
          size = size + 1;
          pos = pos + 1;
          goto <D.28886>;
          <D.28889>:
          <D.28890>:
          <D.28891>:
          <D.28892>:
          <D.28893>:
          <D.28894>:
          <D.28895>:
          <D.28896>:
          <D.28897>:
          <D.28898>:
          <D.28899>:
          <D.28900>:
          <D.28901>:
          <D.28902>:
          <D.28903>:
          <D.28904>:
          <D.28905>:
          <D.28906>:
          <D.28907>:
          <D.28908>:
          goto <D.28886>;
          <D.28909>:
          __assert_fail ("0", "mini-x86.c", 5926, &__PRETTY_FUNCTION__);
          <D.28886>:
          code.8010 = code;
          code.8042 = (int) code.8010;
          pos.8123 = (int) pos;
          disp = code.8042 - pos.8123;
          if (size != 0) goto <D.50335>; else goto <D.50336>;
          <D.50335>:
          {
            union x86_imm_buf imb;

            try
              {
                D.50337 = disp + -4;
                imb.val = D.50337;
                pos.8124 = pos;
                pos = pos.8124 + 1;
                D.50339 = imb.b[0];
                *pos.8124 = D.50339;
                pos.8125 = pos;
                pos = pos.8125 + 1;
                D.50341 = imb.b[1];
                *pos.8125 = D.50341;
                pos.8126 = pos;
                pos = pos.8126 + 1;
                D.50343 = imb.b[2];
                *pos.8126 = D.50343;
                pos.8127 = pos;
                pos = pos.8127 + 1;
                D.50345 = imb.b[3];
                *pos.8127 = D.50345;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.50346>;
          <D.50336>:
          disp.8128 = (unsigned int) disp;
          D.50348 = disp.8128 + 127;
          if (D.50348 <= 255) goto <D.50349>; else goto <D.50350>;
          <D.50349>:
          D.50351 = (unsigned char) disp;
          D.50352 = D.50351 + 255;
          *pos = D.50352;
          pos = pos + 1;
          goto <D.50353>;
          <D.50350>:
          __assert_fail ("0", "mini-x86.c", 5926, &__PRETTY_FUNCTION__);
          <D.50353>:
          <D.50346>:
        }
        {
          int t;

          fail_tramp.8129 = (int) fail_tramp;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50355 = fail_tramp.8129 - code.8042;
          t = D.50355 + -2;
          t.8130 = (unsigned int) t;
          D.50357 = t.8130 + 128;
          if (D.50357 <= 255) goto <D.50358>; else goto <D.50359>;
          <D.50358>:
          code.8010 = code;
          code.8131 = code.8010;
          code.8132 = code.8131 + 1;
          code = code.8132;
          *code.8131 = 235;
          code.8010 = code;
          D.50362 = (unsigned char) t;
          *code.8010 = D.50362;
          code.8010 = code;
          code.8025 = code.8010 + 1;
          code = code.8025;
          goto <D.50363>;
          <D.50359>:
          fail_tramp.8129 = (int) fail_tramp;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50355 = fail_tramp.8129 - code.8042;
          t = D.50355 + -5;
          code.8010 = code;
          code.8133 = code.8010;
          code.8134 = code.8133 + 1;
          code = code.8134;
          *code.8133 = 233;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = t;
                code.8010 = code;
                code.8135 = code.8010;
                code.8136 = code.8135 + 1;
                code = code.8136;
                D.50368 = imb.b[0];
                *code.8135 = D.50368;
                code.8010 = code;
                code.8137 = code.8010;
                code.8138 = code.8137 + 1;
                code = code.8138;
                D.50371 = imb.b[1];
                *code.8137 = D.50371;
                code.8010 = code;
                code.8139 = code.8010;
                code.8140 = code.8139 + 1;
                code = code.8140;
                D.50374 = imb.b[2];
                *code.8139 = D.50374;
                code.8010 = code;
                code.8141 = code.8010;
                code.8142 = code.8141 + 1;
                code = code.8142;
                D.50377 = imb.b[3];
                *code.8141 = D.50377;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.50363>:
        }
        item->jmp_code = 0B;
        goto <D.50378>;
        <D.50239>:
        D.50188 = item->has_target_code;
        if (D.50188 != 0) goto <D.50379>; else goto <D.50380>;
        <D.50379>:
        {
          int t;

          D.50191 = item->value.target_code;
          D.50192 = (int) D.50191;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50194 = D.50192 - code.8042;
          t = D.50194 + -2;
          t.8143 = (unsigned int) t;
          D.50382 = t.8143 + 128;
          if (D.50382 <= 255) goto <D.50383>; else goto <D.50384>;
          <D.50383>:
          code.8010 = code;
          code.8144 = code.8010;
          code.8145 = code.8144 + 1;
          code = code.8145;
          *code.8144 = 235;
          code.8010 = code;
          D.50387 = (unsigned char) t;
          *code.8010 = D.50387;
          code.8010 = code;
          code.8025 = code.8010 + 1;
          code = code.8025;
          goto <D.50388>;
          <D.50384>:
          D.50191 = item->value.target_code;
          D.50192 = (int) D.50191;
          code.8010 = code;
          code.8042 = (int) code.8010;
          D.50194 = D.50192 - code.8042;
          t = D.50194 + -5;
          code.8010 = code;
          code.8146 = code.8010;
          code.8147 = code.8146 + 1;
          code = code.8147;
          *code.8146 = 233;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = t;
                code.8010 = code;
                code.8148 = code.8010;
                code.8149 = code.8148 + 1;
                code = code.8149;
                D.50393 = imb.b[0];
                *code.8148 = D.50393;
                code.8010 = code;
                code.8150 = code.8010;
                code.8151 = code.8150 + 1;
                code = code.8151;
                D.50396 = imb.b[1];
                *code.8150 = D.50396;
                code.8010 = code;
                code.8152 = code.8010;
                code.8153 = code.8152 + 1;
                code = code.8153;
                D.50399 = imb.b[2];
                *code.8152 = D.50399;
                code.8010 = code;
                code.8154 = code.8010;
                code.8155 = code.8154 + 1;
                code = code.8155;
                D.50402 = imb.b[3];
                *code.8154 = D.50402;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.50388>:
        }
        goto <D.50403>;
        <D.50380>:
        code.8010 = code;
        code.8156 = code.8010;
        code.8157 = code.8156 + 1;
        code = code.8157;
        *code.8156 = 255;
        code.8010 = code;
        code.8158 = code.8010;
        code.8159 = code.8158 + 1;
        code = code.8159;
        *code.8158 = 37;
        {
          union x86_imm_buf imb;

          try
            {
              D.50222 = item->value.vtable_slot;
              D.50223 = &vtable->vtable[D.50222];
              D.50224 = (int) D.50223;
              imb.val = D.50224;
              code.8010 = code;
              code.8160 = code.8010;
              code.8161 = code.8160 + 1;
              code = code.8161;
              D.50410 = imb.b[0];
              *code.8160 = D.50410;
              code.8010 = code;
              code.8162 = code.8010;
              code.8163 = code.8162 + 1;
              code = code.8163;
              D.50413 = imb.b[1];
              *code.8162 = D.50413;
              code.8010 = code;
              code.8164 = code.8010;
              code.8165 = code.8164 + 1;
              code = code.8165;
              D.50416 = imb.b[2];
              *code.8164 = D.50416;
              code.8010 = code;
              code.8166 = code.8010;
              code.8167 = code.8166 + 1;
              code = code.8167;
              D.50419 = imb.b[3];
              *code.8166 = D.50419;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50403>:
        <D.50378>:
        <D.50237>:
        goto <D.50420>;
        <D.50126>:
        if (0 != 0) goto <D.50421>; else goto <D.50422>;
        <D.50421>:
        code.8010 = code;
        code.8168 = code.8010;
        code.8169 = code.8168 + 1;
        code = code.8169;
        *code.8168 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              D.50137 = item->key;
              D.50138 = (int) D.50137;
              imb.val = D.50138;
              code.8010 = code;
              code.8170 = code.8010;
              code.8171 = code.8170 + 1;
              code = code.8171;
              D.50427 = imb.b[0];
              *code.8170 = D.50427;
              code.8010 = code;
              code.8172 = code.8010;
              code.8173 = code.8172 + 1;
              code = code.8173;
              D.50430 = imb.b[1];
              *code.8172 = D.50430;
              code.8010 = code;
              code.8174 = code.8010;
              code.8175 = code.8174 + 1;
              code = code.8175;
              D.50433 = imb.b[2];
              *code.8174 = D.50433;
              code.8010 = code;
              code.8176 = code.8010;
              code.8177 = code.8176 + 1;
              code = code.8177;
              D.50436 = imb.b[3];
              *code.8176 = D.50436;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28917>;
        <D.50422>:
        D.50137 = item->key;
        D.50151 = (unsigned int) D.50137;
        D.50152 = D.50151 + 128;
        if (D.50152 <= 255) goto <D.50437>; else goto <D.50438>;
        <D.50437>:
        code.8010 = code;
        code.8178 = code.8010;
        code.8179 = code.8178 + 1;
        code = code.8179;
        *code.8178 = 131;
        code.8010 = code;
        code.8180 = code.8010;
        code.8181 = code.8180 + 1;
        code = code.8181;
        *code.8180 = 250;
        code.8010 = code;
        D.50137 = item->key;
        D.50159 = (int) D.50137;
        D.50160 = (unsigned char) D.50159;
        *code.8010 = D.50160;
        code.8010 = code;
        code.8025 = code.8010 + 1;
        code = code.8025;
        goto <D.50443>;
        <D.50438>:
        code.8010 = code;
        code.8182 = code.8010;
        code.8183 = code.8182 + 1;
        code = code.8183;
        *code.8182 = 129;
        code.8010 = code;
        code.8184 = code.8010;
        code.8185 = code.8184 + 1;
        code = code.8185;
        *code.8184 = 250;
        {
          union x86_imm_buf imb;

          try
            {
              D.50137 = item->key;
              D.50138 = (int) D.50137;
              imb.val = D.50138;
              code.8010 = code;
              code.8186 = code.8010;
              code.8187 = code.8186 + 1;
              code = code.8187;
              D.50450 = imb.b[0];
              *code.8186 = D.50450;
              code.8010 = code;
              code.8188 = code.8010;
              code.8189 = code.8188 + 1;
              code = code.8189;
              D.50453 = imb.b[1];
              *code.8188 = D.50453;
              code.8010 = code;
              code.8190 = code.8010;
              code.8191 = code.8190 + 1;
              code = code.8191;
              D.50456 = imb.b[2];
              *code.8190 = D.50456;
              code.8010 = code;
              code.8192 = code.8010;
              code.8193 = code.8192 + 1;
              code = code.8193;
              D.50459 = imb.b[3];
              *code.8192 = D.50459;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50443>:
        <D.28917>:
        code.8010 = code;
        item->jmp_code = code.8010;
        D.50127 = item->check_target_idx;
        D.50462 = imt_branch_distance (imt_entries, i, D.50127);
        if (D.50462 >= -128) goto <D.50463>; else goto <D.50460>;
        <D.50463>:
        D.50127 = item->check_target_idx;
        D.50464 = imt_branch_distance (imt_entries, i, D.50127);
        if (D.50464 <= 127) goto <D.50465>; else goto <D.50460>;
        <D.50465>:
        if (0 != 0) goto <D.50466>; else goto <D.50467>;
        <D.50466>:
        code.8010 = code;
        code.8194 = code.8010;
        code.8195 = code.8194 + 1;
        code = code.8195;
        D.50470 = 125;
        *code.8194 = D.50470;
        goto <D.50471>;
        <D.50467>:
        code.8010 = code;
        code.8196 = code.8010;
        code.8197 = code.8196 + 1;
        code = code.8197;
        D.50474 = 115;
        *code.8196 = D.50474;
        <D.50471>:
        code.8010 = code;
        *code.8010 = 0;
        code.8010 = code;
        code.8025 = code.8010 + 1;
        code = code.8025;
        goto <D.50461>;
        <D.50460>:
        code.8010 = code;
        code.8198 = code.8010;
        code.8199 = code.8198 + 1;
        code = code.8199;
        *code.8198 = 15;
        if (0 != 0) goto <D.50477>; else goto <D.50478>;
        <D.50477>:
        code.8010 = code;
        code.8200 = code.8010;
        code.8201 = code.8200 + 1;
        code = code.8201;
        D.50470 = 125;
        D.50481 = D.50470 + 16;
        *code.8200 = D.50481;
        goto <D.50482>;
        <D.50478>:
        code.8010 = code;
        code.8202 = code.8010;
        code.8203 = code.8202 + 1;
        code = code.8203;
        D.50474 = 115;
        D.50485 = D.50474 + 16;
        *code.8202 = D.50485;
        <D.50482>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.8010 = code;
              code.8204 = code.8010;
              code.8205 = code.8204 + 1;
              code = code.8205;
              D.50488 = imb.b[0];
              *code.8204 = D.50488;
              code.8010 = code;
              code.8206 = code.8010;
              code.8207 = code.8206 + 1;
              code = code.8207;
              D.50491 = imb.b[1];
              *code.8206 = D.50491;
              code.8010 = code;
              code.8208 = code.8010;
              code.8209 = code.8208 + 1;
              code = code.8209;
              D.50494 = imb.b[2];
              *code.8208 = D.50494;
              code.8010 = code;
              code.8210 = code.8010;
              code.8211 = code.8210 + 1;
              code = code.8211;
              D.50497 = imb.b[3];
              *code.8210 = D.50497;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.50461>:
        <D.50420>:
      }
      i = i + 1;
      <D.28921>:
      if (i < count) goto <D.28920>; else goto <D.28922>;
      <D.28922>:
      i = 0;
      goto <D.28954>;
      <D.28953>:
      {
        struct MonoIMTCheckItem * item;

        i.8007 = (unsigned int) i;
        D.50092 = i.8007 * 4;
        D.50093 = imt_entries + D.50092;
        item = *D.50093;
        D.50498 = item->jmp_code;
        if (D.50498 != 0B) goto <D.50499>; else goto <D.50500>;
        <D.50499>:
        D.50501 = item->check_target_idx;
        if (D.50501 != 0) goto <D.50502>; else goto <D.50503>;
        <D.50502>:
        {
          unsigned char * pos;
          int disp;
          int size;

          D.50498 = item->jmp_code;
          pos = D.50498 + 1;
          size = 0;
          D.50498 = item->jmp_code;
          D.50504 = MEM[(unsigned char *)D.50498];
          D.50505 = (int) D.50504;
          switch (D.50505) <default: <D.28951>, case 15: <D.28930>, case 112: <D.28935>, case 113: <D.28936>, case 114: <D.28937>, case 115: <D.28938>, case 116: <D.28939>, case 117: <D.28940>, case 118: <D.28941>, case 119: <D.28942>, case 120: <D.28943>, case 121: <D.28944>, case 122: <D.28945>, case 123: <D.28946>, case 124: <D.28947>, case 125: <D.28948>, case 126: <D.28949>, case 127: <D.28950>, case 224: <D.28931>, case 225: <D.28932>, case 226: <D.28933>, case 232: <D.28927>, case 233: <D.28928>, case 235: <D.28934>>
          <D.28927>:
          <D.28928>:
          size = size + 1;
          goto <D.28929>;
          <D.28930>:
          D.50506 = *pos;
          D.50507 = D.50506 + 144;
          if (D.50507 > 31) goto <D.50508>; else goto <D.50509>;
          <D.50508>:
          __assert_fail ("0", "mini-x86.c", 5961, &__PRETTY_FUNCTION__);
          <D.50509>:
          size = size + 1;
          pos = pos + 1;
          goto <D.28929>;
          <D.28931>:
          <D.28932>:
          <D.28933>:
          <D.28934>:
          <D.28935>:
          <D.28936>:
          <D.28937>:
          <D.28938>:
          <D.28939>:
          <D.28940>:
          <D.28941>:
          <D.28942>:
          <D.28943>:
          <D.28944>:
          <D.28945>:
          <D.28946>:
          <D.28947>:
          <D.28948>:
          <D.28949>:
          <D.28950>:
          goto <D.28929>;
          <D.28951>:
          __assert_fail ("0", "mini-x86.c", 5961, &__PRETTY_FUNCTION__);
          <D.28929>:
          D.50501 = item->check_target_idx;
          D.50510 = (unsigned int) D.50501;
          D.50511 = D.50510 * 4;
          D.50512 = imt_entries + D.50511;
          D.50513 = *D.50512;
          D.50514 = D.50513->code_target;
          D.50515 = (int) D.50514;
          pos.8212 = (int) pos;
          disp = D.50515 - pos.8212;
          if (size != 0) goto <D.50517>; else goto <D.50518>;
          <D.50517>:
          {
            union x86_imm_buf imb;

            try
              {
                D.50519 = disp + -4;
                imb.val = D.50519;
                pos.8213 = pos;
                pos = pos.8213 + 1;
                D.50521 = imb.b[0];
                *pos.8213 = D.50521;
                pos.8214 = pos;
                pos = pos.8214 + 1;
                D.50523 = imb.b[1];
                *pos.8214 = D.50523;
                pos.8215 = pos;
                pos = pos.8215 + 1;
                D.50525 = imb.b[2];
                *pos.8215 = D.50525;
                pos.8216 = pos;
                pos = pos.8216 + 1;
                D.50527 = imb.b[3];
                *pos.8216 = D.50527;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.50528>;
          <D.50518>:
          disp.8217 = (unsigned int) disp;
          D.50530 = disp.8217 + 127;
          if (D.50530 <= 255) goto <D.50531>; else goto <D.50532>;
          <D.50531>:
          D.50533 = (unsigned char) disp;
          D.50534 = D.50533 + 255;
          *pos = D.50534;
          pos = pos + 1;
          goto <D.50535>;
          <D.50532>:
          __assert_fail ("0", "mini-x86.c", 5961, &__PRETTY_FUNCTION__);
          <D.50535>:
          <D.50528>:
        }
        <D.50503>:
        <D.50500>:
      }
      i = i + 1;
      <D.28954>:
      if (i < count) goto <D.28953>; else goto <D.28955>;
      <D.28955>:
      if (fail_tramp == 0B) goto <D.50536>; else goto <D.50537>;
      <D.50536>:
      D.50538 = mono_stats.imt_thunks_size;
      code.8010 = code;
      code.8042 = (int) code.8010;
      start.8218 = start;
      start.8219 = (int) start.8218;
      D.50541 = code.8042 - start.8219;
      D.50542 = (long unsigned int) D.50541;
      D.50543 = D.50538 + D.50542;
      mono_stats.imt_thunks_size = D.50543;
      <D.50537>:
      code.8010 = code;
      code.8042 = (int) code.8010;
      start.8218 = start;
      start.8219 = (int) start.8218;
      D.50541 = code.8042 - start.8219;
      D.50544 = D.50541 > size;
      D.50545 = (long int) D.50544;
      D.50546 = __builtin_expect (D.50545, 0);
      if (D.50546 != 0) goto <D.50547>; else goto <D.50548>;
      <D.50547>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 5968, "code - start <= size");
      <D.50548>:
      D.50549 = mono_jit_map_is_enabled ();
      if (D.50549 != 0) goto <D.50550>; else goto <D.50551>;
      <D.50550>:
      {
        char * buff;

        if (vtable != 0B) goto <D.50552>; else goto <D.50553>;
        <D.50552>:
        D.50554 = vtable->klass;
        D.50555 = D.50554->name;
        D.50554 = vtable->klass;
        D.50556 = D.50554->name_space;
        buff = monoeg_g_strdup_printf ("imt_%s_%s_entries_%d", D.50556, D.50555, count);
        goto <D.50557>;
        <D.50553>:
        buff = monoeg_g_strdup_printf ("imt_thunk_entries_%d", count);
        <D.50557>:
        code.8010 = code;
        code.8042 = (int) code.8010;
        start.8218 = start;
        start.8219 = (int) start.8218;
        D.50541 = code.8042 - start.8219;
        start.8218 = start;
        mono_emit_jit_tramp (start.8218, D.50541, buff);
        monoeg_g_free (buff);
      }
      <D.50551>:
      nacl_domain_code_validate (domain, &start, size, &code);
      D.50558 = start;
      return D.50558;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


imt_branch_distance (struct MonoIMTCheckItem * * imt_entries, int start, int target)
{
  unsigned int i.8220;
  unsigned int D.50564;
  struct MonoIMTCheckItem * * D.50565;
  struct MonoIMTCheckItem * D.50566;
  unsigned char D.50567;
  int D.50568;
  int D.50569;
  int i;
  int distance;

  distance = 0;
  i = start;
  goto <D.28851>;
  <D.28850>:
  i.8220 = (unsigned int) i;
  D.50564 = i.8220 * 4;
  D.50565 = imt_entries + D.50564;
  D.50566 = *D.50565;
  D.50567 = D.50566->chunk_size;
  D.50568 = (int) D.50567;
  distance = D.50568 + distance;
  i = i + 1;
  <D.28851>:
  if (i < target) goto <D.28850>; else goto <D.28852>;
  <D.28852>:
  D.50569 = distance;
  return D.50569;
}


mono_arch_find_imt_method (mgreg_t * regs, guint8 * code)
{
  struct MonoMethod * D.50571;
  mgreg_t * D.50572;
  int D.50573;

  D.50572 = regs + 8;
  D.50573 = *D.50572;
  D.50571 = (struct MonoMethod *) D.50573;
  return D.50571;
}


mono_arch_find_static_call_vtable (mgreg_t * regs, guint8 * code)
{
  struct MonoVTable * D.50575;
  mgreg_t * D.50576;
  int D.50577;

  D.50576 = regs + 8;
  D.50577 = *D.50576;
  D.50575 = (struct MonoVTable *) D.50577;
  return D.50575;
}


mono_arch_get_cie_program ()
{
  struct MonoUnwindOp * D.50579;
  struct MonoUnwindOp * D.50580;
  struct GSList * D.50581;
  struct GSList * l;

  l = 0B;
  D.50579 = mono_create_unwind_op (0, 12, 4, 4);
  l = monoeg_g_slist_append (l, D.50579);
  D.50580 = mono_create_unwind_op (0, 128, 8, -4);
  l = monoeg_g_slist_append (l, D.50580);
  D.50581 = l;
  return D.50581;
}


mono_arch_emit_inst_for_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoClass * D.50583;
  struct MonoClass * D.50584;
  int D.28985;
  int iftmp.8221;
  int D.28984;
  const char[4] * D.50590;
  unsigned char D.50591;
  int D.50592;
  unsigned char D.50593;
  int D.50594;
  _Bool D.50595;
  _Bool D.50596;
  _Bool D.50597;
  const unsigned char * D.50600;
  unsigned char D.50601;
  int D.50602;
  const unsigned char * D.50603;
  unsigned char D.50604;
  int D.50605;
  _Bool D.50606;
  _Bool D.50607;
  const unsigned char * D.50610;
  unsigned char D.50611;
  int D.50612;
  const unsigned char * D.50613;
  unsigned char D.50614;
  int D.50615;
  _Bool D.50616;
  _Bool D.50617;
  const unsigned char * D.50620;
  unsigned char D.50621;
  int D.50622;
  const unsigned char * D.50623;
  unsigned char D.50624;
  int D.50625;
  const char * D.50627;
  int D.28994;
  int iftmp.8222;
  int D.28993;
  const char[4] * D.50634;
  unsigned char D.50635;
  int D.50636;
  unsigned char D.50637;
  int D.50638;
  _Bool D.50639;
  _Bool D.50640;
  _Bool D.50641;
  const unsigned char * D.50644;
  unsigned char D.50645;
  int D.50646;
  const unsigned char * D.50647;
  unsigned char D.50648;
  int D.50649;
  _Bool D.50650;
  _Bool D.50651;
  const unsigned char * D.50654;
  unsigned char D.50655;
  int D.50656;
  const unsigned char * D.50657;
  unsigned char D.50658;
  int D.50659;
  _Bool D.50660;
  _Bool D.50661;
  const unsigned char * D.50664;
  unsigned char D.50665;
  int D.50666;
  const unsigned char * D.50667;
  unsigned char D.50668;
  int D.50669;
  int D.29003;
  int iftmp.8223;
  int D.29002;
  const char[4] * D.50677;
  unsigned char D.50678;
  int D.50679;
  unsigned char D.50680;
  int D.50681;
  _Bool D.50682;
  _Bool D.50683;
  _Bool D.50684;
  const unsigned char * D.50687;
  unsigned char D.50688;
  int D.50689;
  const unsigned char * D.50690;
  unsigned char D.50691;
  int D.50692;
  _Bool D.50693;
  _Bool D.50694;
  const unsigned char * D.50697;
  unsigned char D.50698;
  int D.50699;
  const unsigned char * D.50700;
  unsigned char D.50701;
  int D.50702;
  _Bool D.50703;
  _Bool D.50704;
  const unsigned char * D.50707;
  unsigned char D.50708;
  int D.50709;
  const unsigned char * D.50710;
  unsigned char D.50711;
  int D.50712;
  int D.29012;
  int iftmp.8224;
  int D.29011;
  const char[5] * D.50720;
  unsigned char D.50721;
  int D.50722;
  unsigned char D.50723;
  int D.50724;
  _Bool D.50725;
  _Bool D.50726;
  _Bool D.50727;
  const unsigned char * D.50730;
  unsigned char D.50731;
  int D.50732;
  const unsigned char * D.50733;
  unsigned char D.50734;
  int D.50735;
  _Bool D.50736;
  _Bool D.50737;
  const unsigned char * D.50740;
  unsigned char D.50741;
  int D.50742;
  const unsigned char * D.50743;
  unsigned char D.50744;
  int D.50745;
  _Bool D.50746;
  _Bool D.50747;
  const unsigned char * D.50750;
  unsigned char D.50751;
  int D.50752;
  const unsigned char * D.50753;
  unsigned char D.50754;
  int D.50755;
  int D.29021;
  int iftmp.8225;
  int D.29020;
  const char[5] * D.50763;
  unsigned char D.50764;
  int D.50765;
  unsigned char D.50766;
  int D.50767;
  _Bool D.50768;
  _Bool D.50769;
  _Bool D.50770;
  const unsigned char * D.50773;
  unsigned char D.50774;
  int D.50775;
  const unsigned char * D.50776;
  unsigned char D.50777;
  int D.50778;
  _Bool D.50779;
  _Bool D.50780;
  const unsigned char * D.50783;
  unsigned char D.50784;
  int D.50785;
  const unsigned char * D.50786;
  unsigned char D.50787;
  int D.50788;
  _Bool D.50789;
  _Bool D.50790;
  const unsigned char * D.50793;
  unsigned char D.50794;
  int D.50795;
  const unsigned char * D.50796;
  unsigned char D.50797;
  int D.50798;
  int D.29030;
  int iftmp.8226;
  int D.29029;
  const char[4] * D.50808;
  unsigned char D.50809;
  int D.50810;
  unsigned char D.50811;
  int D.50812;
  _Bool D.50813;
  _Bool D.50814;
  _Bool D.50815;
  const unsigned char * D.50818;
  unsigned char D.50819;
  int D.50820;
  const unsigned char * D.50821;
  unsigned char D.50822;
  int D.50823;
  _Bool D.50824;
  _Bool D.50825;
  const unsigned char * D.50828;
  unsigned char D.50829;
  int D.50830;
  const unsigned char * D.50831;
  unsigned char D.50832;
  int D.50833;
  _Bool D.50834;
  _Bool D.50835;
  const unsigned char * D.50838;
  unsigned char D.50839;
  int D.50840;
  const unsigned char * D.50841;
  unsigned char D.50842;
  int D.50843;
  struct MonoType * D.50846;
  unsigned char D.50847;
  int D.29039;
  int iftmp.8227;
  int D.29038;
  const char[6] * D.50852;
  unsigned char D.50853;
  int D.50854;
  unsigned char D.50855;
  int D.50856;
  _Bool D.50857;
  _Bool D.50858;
  _Bool D.50859;
  const unsigned char * D.50862;
  unsigned char D.50863;
  int D.50864;
  const unsigned char * D.50865;
  unsigned char D.50866;
  int D.50867;
  _Bool D.50868;
  _Bool D.50869;
  const unsigned char * D.50872;
  unsigned char D.50873;
  int D.50874;
  const unsigned char * D.50875;
  unsigned char D.50876;
  int D.50877;
  _Bool D.50878;
  _Bool D.50879;
  const unsigned char * D.50882;
  unsigned char D.50883;
  int D.50884;
  const unsigned char * D.50885;
  unsigned char D.50886;
  int D.50887;
  short unsigned int D.50891;
  struct MonoMemPool * D.50898;
  int D.50899;
  struct MonoInst * D.50900;
  short unsigned int D.50901;
  int D.50902;
  int D.50903;
  const unsigned char * D.50904;
  unsigned int D.50905;
  int D.50906;
  struct MonoInst * D.50907;
  int D.50908;
  struct MonoBasicBlock * D.50909;
  struct MonoInst * D.50910;
  unsigned int D.50914;
  unsigned int D.50915;
  int D.29049;
  int iftmp.8228;
  int D.29048;
  const char[4] * D.50921;
  unsigned char D.50922;
  int D.50923;
  unsigned char D.50924;
  int D.50925;
  _Bool D.50926;
  _Bool D.50927;
  _Bool D.50928;
  const unsigned char * D.50931;
  unsigned char D.50932;
  int D.50933;
  const unsigned char * D.50934;
  unsigned char D.50935;
  int D.50936;
  _Bool D.50937;
  _Bool D.50938;
  const unsigned char * D.50941;
  unsigned char D.50942;
  int D.50943;
  const unsigned char * D.50944;
  unsigned char D.50945;
  int D.50946;
  _Bool D.50947;
  _Bool D.50948;
  const unsigned char * D.50951;
  unsigned char D.50952;
  int D.50953;
  const unsigned char * D.50954;
  unsigned char D.50955;
  int D.50956;
  int D.29058;
  int iftmp.8229;
  int D.29057;
  const char[4] * D.50966;
  unsigned char D.50967;
  int D.50968;
  unsigned char D.50969;
  int D.50970;
  _Bool D.50971;
  _Bool D.50972;
  _Bool D.50973;
  const unsigned char * D.50976;
  unsigned char D.50977;
  int D.50978;
  const unsigned char * D.50979;
  unsigned char D.50980;
  int D.50981;
  _Bool D.50982;
  _Bool D.50983;
  const unsigned char * D.50986;
  unsigned char D.50987;
  int D.50988;
  const unsigned char * D.50989;
  unsigned char D.50990;
  int D.50991;
  _Bool D.50992;
  _Bool D.50993;
  const unsigned char * D.50996;
  unsigned char D.50997;
  int D.50998;
  const unsigned char * D.50999;
  unsigned char D.51000;
  int D.51001;
  short unsigned int D.51009;
  unsigned int D.51010;
  int D.51011;
  struct MonoInst * * D.51012;
  struct MonoInst * D.51013;
  int D.51014;
  struct MonoInst * D.51018;
  struct MonoInst * ins;
  int opcode;

  ins = 0B;
  opcode = 0;
  D.50583 = cmethod->klass;
  D.50584 = mono_defaults.math_class;
  if (D.50583 == D.50584) goto <D.50585>; else goto <D.50586>;
  <D.50585>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.50590 = "Sin";
      D.50591 = MEM[(const unsigned char *)D.50590];
      D.50592 = (int) D.50591;
      D.50593 = *__s2;
      D.50594 = (int) D.50593;
      __result = D.50592 - D.50594;
      {
        D.50595 = __s2_len != 0;
        D.50596 = __result == 0;
        D.50597 = D.50595 & D.50596;
        if (D.50597 != 0) goto <D.50598>; else goto <D.50599>;
        <D.50598>:
        D.50600 = &MEM[(void *)"Sin" + 1B];
        D.50601 = *D.50600;
        D.50602 = (int) D.50601;
        D.50603 = __s2 + 1;
        D.50604 = *D.50603;
        D.50605 = (int) D.50604;
        __result = D.50602 - D.50605;
        D.50606 = __s2_len > 1;
        D.50596 = __result == 0;
        D.50607 = D.50606 & D.50596;
        if (D.50607 != 0) goto <D.50608>; else goto <D.50609>;
        <D.50608>:
        D.50610 = &MEM[(void *)"Sin" + 2B];
        D.50611 = *D.50610;
        D.50612 = (int) D.50611;
        D.50613 = __s2 + 2;
        D.50614 = *D.50613;
        D.50615 = (int) D.50614;
        __result = D.50612 - D.50615;
        D.50616 = __s2_len > 2;
        D.50596 = __result == 0;
        D.50617 = D.50616 & D.50596;
        if (D.50617 != 0) goto <D.50618>; else goto <D.50619>;
        <D.50618>:
        D.50620 = &MEM[(void *)"Sin" + 3B];
        D.50621 = *D.50620;
        D.50622 = (int) D.50621;
        D.50623 = __s2 + 3;
        D.50624 = *D.50623;
        D.50625 = (int) D.50624;
        __result = D.50622 - D.50625;
        <D.50619>:
        <D.50609>:
        <D.50599>:
      }
      D.28984 = __result;
    }
    iftmp.8221 = -D.28984;
    goto <D.50626>;
    <D.50589>:
    D.50627 = cmethod->name;
    iftmp.8221 = __builtin_strcmp (D.50627, "Sin");
    <D.50626>:
    D.28985 = iftmp.8221;
  }
  if (D.28985 == 0) goto <D.50628>; else goto <D.50629>;
  <D.50628>:
  opcode = 778;
  goto <D.50630>;
  <D.50629>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.50634 = "Cos";
      D.50635 = MEM[(const unsigned char *)D.50634];
      D.50636 = (int) D.50635;
      D.50637 = *__s2;
      D.50638 = (int) D.50637;
      __result = D.50636 - D.50638;
      {
        D.50639 = __s2_len != 0;
        D.50640 = __result == 0;
        D.50641 = D.50639 & D.50640;
        if (D.50641 != 0) goto <D.50642>; else goto <D.50643>;
        <D.50642>:
        D.50644 = &MEM[(void *)"Cos" + 1B];
        D.50645 = *D.50644;
        D.50646 = (int) D.50645;
        D.50647 = __s2 + 1;
        D.50648 = *D.50647;
        D.50649 = (int) D.50648;
        __result = D.50646 - D.50649;
        D.50650 = __s2_len > 1;
        D.50640 = __result == 0;
        D.50651 = D.50650 & D.50640;
        if (D.50651 != 0) goto <D.50652>; else goto <D.50653>;
        <D.50652>:
        D.50654 = &MEM[(void *)"Cos" + 2B];
        D.50655 = *D.50654;
        D.50656 = (int) D.50655;
        D.50657 = __s2 + 2;
        D.50658 = *D.50657;
        D.50659 = (int) D.50658;
        __result = D.50656 - D.50659;
        D.50660 = __s2_len > 2;
        D.50640 = __result == 0;
        D.50661 = D.50660 & D.50640;
        if (D.50661 != 0) goto <D.50662>; else goto <D.50663>;
        <D.50662>:
        D.50664 = &MEM[(void *)"Cos" + 3B];
        D.50665 = *D.50664;
        D.50666 = (int) D.50665;
        D.50667 = __s2 + 3;
        D.50668 = *D.50667;
        D.50669 = (int) D.50668;
        __result = D.50666 - D.50669;
        <D.50663>:
        <D.50653>:
        <D.50643>:
      }
      D.28993 = __result;
    }
    iftmp.8222 = -D.28993;
    goto <D.50670>;
    <D.50633>:
    D.50627 = cmethod->name;
    iftmp.8222 = __builtin_strcmp (D.50627, "Cos");
    <D.50670>:
    D.28994 = iftmp.8222;
  }
  if (D.28994 == 0) goto <D.50671>; else goto <D.50672>;
  <D.50671>:
  opcode = 779;
  goto <D.50673>;
  <D.50672>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.50677 = "Tan";
      D.50678 = MEM[(const unsigned char *)D.50677];
      D.50679 = (int) D.50678;
      D.50680 = *__s2;
      D.50681 = (int) D.50680;
      __result = D.50679 - D.50681;
      {
        D.50682 = __s2_len != 0;
        D.50683 = __result == 0;
        D.50684 = D.50682 & D.50683;
        if (D.50684 != 0) goto <D.50685>; else goto <D.50686>;
        <D.50685>:
        D.50687 = &MEM[(void *)"Tan" + 1B];
        D.50688 = *D.50687;
        D.50689 = (int) D.50688;
        D.50690 = __s2 + 1;
        D.50691 = *D.50690;
        D.50692 = (int) D.50691;
        __result = D.50689 - D.50692;
        D.50693 = __s2_len > 1;
        D.50683 = __result == 0;
        D.50694 = D.50693 & D.50683;
        if (D.50694 != 0) goto <D.50695>; else goto <D.50696>;
        <D.50695>:
        D.50697 = &MEM[(void *)"Tan" + 2B];
        D.50698 = *D.50697;
        D.50699 = (int) D.50698;
        D.50700 = __s2 + 2;
        D.50701 = *D.50700;
        D.50702 = (int) D.50701;
        __result = D.50699 - D.50702;
        D.50703 = __s2_len > 2;
        D.50683 = __result == 0;
        D.50704 = D.50703 & D.50683;
        if (D.50704 != 0) goto <D.50705>; else goto <D.50706>;
        <D.50705>:
        D.50707 = &MEM[(void *)"Tan" + 3B];
        D.50708 = *D.50707;
        D.50709 = (int) D.50708;
        D.50710 = __s2 + 3;
        D.50711 = *D.50710;
        D.50712 = (int) D.50711;
        __result = D.50709 - D.50712;
        <D.50706>:
        <D.50696>:
        <D.50686>:
      }
      D.29002 = __result;
    }
    iftmp.8223 = -D.29002;
    goto <D.50713>;
    <D.50676>:
    D.50627 = cmethod->name;
    iftmp.8223 = __builtin_strcmp (D.50627, "Tan");
    <D.50713>:
    D.29003 = iftmp.8223;
  }
  if (D.29003 == 0) goto <D.50714>; else goto <D.50715>;
  <D.50714>:
  opcode = 781;
  goto <D.50716>;
  <D.50715>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.50718>; else goto <D.50719>;
    <D.50718>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.50720 = "Atan";
      D.50721 = MEM[(const unsigned char *)D.50720];
      D.50722 = (int) D.50721;
      D.50723 = *__s2;
      D.50724 = (int) D.50723;
      __result = D.50722 - D.50724;
      {
        D.50725 = __s2_len != 0;
        D.50726 = __result == 0;
        D.50727 = D.50725 & D.50726;
        if (D.50727 != 0) goto <D.50728>; else goto <D.50729>;
        <D.50728>:
        D.50730 = &MEM[(void *)"Atan" + 1B];
        D.50731 = *D.50730;
        D.50732 = (int) D.50731;
        D.50733 = __s2 + 1;
        D.50734 = *D.50733;
        D.50735 = (int) D.50734;
        __result = D.50732 - D.50735;
        D.50736 = __s2_len > 1;
        D.50726 = __result == 0;
        D.50737 = D.50736 & D.50726;
        if (D.50737 != 0) goto <D.50738>; else goto <D.50739>;
        <D.50738>:
        D.50740 = &MEM[(void *)"Atan" + 2B];
        D.50741 = *D.50740;
        D.50742 = (int) D.50741;
        D.50743 = __s2 + 2;
        D.50744 = *D.50743;
        D.50745 = (int) D.50744;
        __result = D.50742 - D.50745;
        D.50746 = __s2_len > 2;
        D.50726 = __result == 0;
        D.50747 = D.50746 & D.50726;
        if (D.50747 != 0) goto <D.50748>; else goto <D.50749>;
        <D.50748>:
        D.50750 = &MEM[(void *)"Atan" + 3B];
        D.50751 = *D.50750;
        D.50752 = (int) D.50751;
        D.50753 = __s2 + 3;
        D.50754 = *D.50753;
        D.50755 = (int) D.50754;
        __result = D.50752 - D.50755;
        <D.50749>:
        <D.50739>:
        <D.50729>:
      }
      D.29011 = __result;
    }
    iftmp.8224 = -D.29011;
    goto <D.50756>;
    <D.50719>:
    D.50627 = cmethod->name;
    iftmp.8224 = __builtin_strcmp (D.50627, "Atan");
    <D.50756>:
    D.29012 = iftmp.8224;
  }
  if (D.29012 == 0) goto <D.50757>; else goto <D.50758>;
  <D.50757>:
  opcode = 782;
  goto <D.50759>;
  <D.50758>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.50761>; else goto <D.50762>;
    <D.50761>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.50763 = "Sqrt";
      D.50764 = MEM[(const unsigned char *)D.50763];
      D.50765 = (int) D.50764;
      D.50766 = *__s2;
      D.50767 = (int) D.50766;
      __result = D.50765 - D.50767;
      {
        D.50768 = __s2_len != 0;
        D.50769 = __result == 0;
        D.50770 = D.50768 & D.50769;
        if (D.50770 != 0) goto <D.50771>; else goto <D.50772>;
        <D.50771>:
        D.50773 = &MEM[(void *)"Sqrt" + 1B];
        D.50774 = *D.50773;
        D.50775 = (int) D.50774;
        D.50776 = __s2 + 1;
        D.50777 = *D.50776;
        D.50778 = (int) D.50777;
        __result = D.50775 - D.50778;
        D.50779 = __s2_len > 1;
        D.50769 = __result == 0;
        D.50780 = D.50779 & D.50769;
        if (D.50780 != 0) goto <D.50781>; else goto <D.50782>;
        <D.50781>:
        D.50783 = &MEM[(void *)"Sqrt" + 2B];
        D.50784 = *D.50783;
        D.50785 = (int) D.50784;
        D.50786 = __s2 + 2;
        D.50787 = *D.50786;
        D.50788 = (int) D.50787;
        __result = D.50785 - D.50788;
        D.50789 = __s2_len > 2;
        D.50769 = __result == 0;
        D.50790 = D.50789 & D.50769;
        if (D.50790 != 0) goto <D.50791>; else goto <D.50792>;
        <D.50791>:
        D.50793 = &MEM[(void *)"Sqrt" + 3B];
        D.50794 = *D.50793;
        D.50795 = (int) D.50794;
        D.50796 = __s2 + 3;
        D.50797 = *D.50796;
        D.50798 = (int) D.50797;
        __result = D.50795 - D.50798;
        <D.50792>:
        <D.50782>:
        <D.50772>:
      }
      D.29020 = __result;
    }
    iftmp.8225 = -D.29020;
    goto <D.50799>;
    <D.50762>:
    D.50627 = cmethod->name;
    iftmp.8225 = __builtin_strcmp (D.50627, "Sqrt");
    <D.50799>:
    D.29021 = iftmp.8225;
  }
  if (D.29021 == 0) goto <D.50800>; else goto <D.50801>;
  <D.50800>:
  opcode = 783;
  goto <D.50802>;
  <D.50801>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.50808 = "Abs";
      D.50809 = MEM[(const unsigned char *)D.50808];
      D.50810 = (int) D.50809;
      D.50811 = *__s2;
      D.50812 = (int) D.50811;
      __result = D.50810 - D.50812;
      {
        D.50813 = __s2_len != 0;
        D.50814 = __result == 0;
        D.50815 = D.50813 & D.50814;
        if (D.50815 != 0) goto <D.50816>; else goto <D.50817>;
        <D.50816>:
        D.50818 = &MEM[(void *)"Abs" + 1B];
        D.50819 = *D.50818;
        D.50820 = (int) D.50819;
        D.50821 = __s2 + 1;
        D.50822 = *D.50821;
        D.50823 = (int) D.50822;
        __result = D.50820 - D.50823;
        D.50824 = __s2_len > 1;
        D.50814 = __result == 0;
        D.50825 = D.50824 & D.50814;
        if (D.50825 != 0) goto <D.50826>; else goto <D.50827>;
        <D.50826>:
        D.50828 = &MEM[(void *)"Abs" + 2B];
        D.50829 = *D.50828;
        D.50830 = (int) D.50829;
        D.50831 = __s2 + 2;
        D.50832 = *D.50831;
        D.50833 = (int) D.50832;
        __result = D.50830 - D.50833;
        D.50834 = __s2_len > 2;
        D.50814 = __result == 0;
        D.50835 = D.50834 & D.50814;
        if (D.50835 != 0) goto <D.50836>; else goto <D.50837>;
        <D.50836>:
        D.50838 = &MEM[(void *)"Abs" + 3B];
        D.50839 = *D.50838;
        D.50840 = (int) D.50839;
        D.50841 = __s2 + 3;
        D.50842 = *D.50841;
        D.50843 = (int) D.50842;
        __result = D.50840 - D.50843;
        <D.50837>:
        <D.50827>:
        <D.50817>:
      }
      D.29029 = __result;
    }
    iftmp.8226 = -D.29029;
    goto <D.50844>;
    <D.50807>:
    D.50627 = cmethod->name;
    iftmp.8226 = __builtin_strcmp (D.50627, "Abs");
    <D.50844>:
    D.29030 = iftmp.8226;
  }
  if (D.29030 == 0) goto <D.50845>; else goto <D.50803>;
  <D.50845>:
  D.50846 = fsig->params[0];
  D.50847 = D.50846->type;
  if (D.50847 == 13) goto <D.50848>; else goto <D.50803>;
  <D.50848>:
  opcode = 780;
  goto <D.50804>;
  <D.50803>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.50850>; else goto <D.50851>;
    <D.50850>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.50852 = "Round";
      D.50853 = MEM[(const unsigned char *)D.50852];
      D.50854 = (int) D.50853;
      D.50855 = *__s2;
      D.50856 = (int) D.50855;
      __result = D.50854 - D.50856;
      {
        D.50857 = __s2_len != 0;
        D.50858 = __result == 0;
        D.50859 = D.50857 & D.50858;
        if (D.50859 != 0) goto <D.50860>; else goto <D.50861>;
        <D.50860>:
        D.50862 = &MEM[(void *)"Round" + 1B];
        D.50863 = *D.50862;
        D.50864 = (int) D.50863;
        D.50865 = __s2 + 1;
        D.50866 = *D.50865;
        D.50867 = (int) D.50866;
        __result = D.50864 - D.50867;
        D.50868 = __s2_len > 1;
        D.50858 = __result == 0;
        D.50869 = D.50868 & D.50858;
        if (D.50869 != 0) goto <D.50870>; else goto <D.50871>;
        <D.50870>:
        D.50872 = &MEM[(void *)"Round" + 2B];
        D.50873 = *D.50872;
        D.50874 = (int) D.50873;
        D.50875 = __s2 + 2;
        D.50876 = *D.50875;
        D.50877 = (int) D.50876;
        __result = D.50874 - D.50877;
        D.50878 = __s2_len > 2;
        D.50858 = __result == 0;
        D.50879 = D.50878 & D.50858;
        if (D.50879 != 0) goto <D.50880>; else goto <D.50881>;
        <D.50880>:
        D.50882 = &MEM[(void *)"Round" + 3B];
        D.50883 = *D.50882;
        D.50884 = (int) D.50883;
        D.50885 = __s2 + 3;
        D.50886 = *D.50885;
        D.50887 = (int) D.50886;
        __result = D.50884 - D.50887;
        <D.50881>:
        <D.50871>:
        <D.50861>:
      }
      D.29038 = __result;
    }
    iftmp.8227 = -D.29038;
    goto <D.50888>;
    <D.50851>:
    D.50627 = cmethod->name;
    iftmp.8227 = __builtin_strcmp (D.50627, "Round");
    <D.50888>:
    D.29039 = iftmp.8227;
  }
  if (D.29039 == 0) goto <D.50889>; else goto <D.50890>;
  <D.50889>:
  D.50891 = fsig->param_count;
  if (D.50891 == 1) goto <D.50892>; else goto <D.50893>;
  <D.50892>:
  D.50846 = fsig->params[0];
  D.50847 = D.50846->type;
  if (D.50847 == 13) goto <D.50894>; else goto <D.50895>;
  <D.50894>:
  opcode = 784;
  <D.50895>:
  <D.50893>:
  <D.50890>:
  <D.50804>:
  <D.50802>:
  <D.50759>:
  <D.50716>:
  <D.50673>:
  <D.50630>:
  if (opcode != 0) goto <D.50896>; else goto <D.50897>;
  <D.50896>:
  D.50898 = cfg->mempool;
  ins = mono_mempool_alloc (D.50898, 48);
  ins->data.op[1].const_val = 0;
  D.50899 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.50899;
  ins->prev = 0B;
  D.50900 = ins->prev;
  ins->next = D.50900;
  D.50901 = (short unsigned int) opcode;
  ins->opcode = D.50901;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.50902 = ins->sreg3;
  ins->sreg2 = D.50902;
  D.50903 = ins->sreg2;
  ins->sreg1 = D.50903;
  D.50904 = cfg->ip;
  ins->cil_code = D.50904;
  ins->type = 4;
  D.50905 = mono_alloc_freg (cfg);
  D.50906 = (int) D.50905;
  ins->dreg = D.50906;
  D.50907 = *args;
  D.50908 = D.50907->dreg;
  ins->sreg1 = D.50908;
  D.50909 = cfg->cbb;
  D.50910 = D.50909->last_ins;
  if (D.50910 != 0B) goto <D.50911>; else goto <D.50912>;
  <D.50911>:
  D.50909 = cfg->cbb;
  D.50910 = D.50909->last_ins;
  D.50910->next = ins;
  D.50909 = cfg->cbb;
  D.50910 = D.50909->last_ins;
  ins->prev = D.50910;
  D.50909 = cfg->cbb;
  D.50909->last_ins = ins;
  goto <D.50913>;
  <D.50912>:
  D.50909 = cfg->cbb;
  D.50909 = cfg->cbb;
  D.50909->last_ins = ins;
  D.50910 = D.50909->last_ins;
  D.50909->code = D.50910;
  <D.50913>:
  <D.50897>:
  D.50914 = cfg->opt;
  D.50915 = D.50914 & 256;
  if (D.50915 != 0) goto <D.50916>; else goto <D.50917>;
  <D.50916>:
  {
    int opcode;

    opcode = 0;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = cmethod->name;
        D.50921 = "Min";
        D.50922 = MEM[(const unsigned char *)D.50921];
        D.50923 = (int) D.50922;
        D.50924 = *__s2;
        D.50925 = (int) D.50924;
        __result = D.50923 - D.50925;
        {
          D.50926 = __s2_len != 0;
          D.50927 = __result == 0;
          D.50928 = D.50926 & D.50927;
          if (D.50928 != 0) goto <D.50929>; else goto <D.50930>;
          <D.50929>:
          D.50931 = &MEM[(void *)"Min" + 1B];
          D.50932 = *D.50931;
          D.50933 = (int) D.50932;
          D.50934 = __s2 + 1;
          D.50935 = *D.50934;
          D.50936 = (int) D.50935;
          __result = D.50933 - D.50936;
          D.50937 = __s2_len > 1;
          D.50927 = __result == 0;
          D.50938 = D.50937 & D.50927;
          if (D.50938 != 0) goto <D.50939>; else goto <D.50940>;
          <D.50939>:
          D.50941 = &MEM[(void *)"Min" + 2B];
          D.50942 = *D.50941;
          D.50943 = (int) D.50942;
          D.50944 = __s2 + 2;
          D.50945 = *D.50944;
          D.50946 = (int) D.50945;
          __result = D.50943 - D.50946;
          D.50947 = __s2_len > 2;
          D.50927 = __result == 0;
          D.50948 = D.50947 & D.50927;
          if (D.50948 != 0) goto <D.50949>; else goto <D.50950>;
          <D.50949>:
          D.50951 = &MEM[(void *)"Min" + 3B];
          D.50952 = *D.50951;
          D.50953 = (int) D.50952;
          D.50954 = __s2 + 3;
          D.50955 = *D.50954;
          D.50956 = (int) D.50955;
          __result = D.50953 - D.50956;
          <D.50950>:
          <D.50940>:
          <D.50930>:
        }
        D.29048 = __result;
      }
      iftmp.8228 = -D.29048;
      goto <D.50957>;
      <D.50920>:
      D.50627 = cmethod->name;
      iftmp.8228 = __builtin_strcmp (D.50627, "Min");
      <D.50957>:
      D.29049 = iftmp.8228;
    }
    if (D.29049 == 0) goto <D.50958>; else goto <D.50959>;
    <D.50958>:
    D.50846 = fsig->params[0];
    D.50847 = D.50846->type;
    if (D.50847 == 8) goto <D.50960>; else goto <D.50961>;
    <D.50960>:
    opcode = 751;
    <D.50961>:
    goto <D.50962>;
    <D.50959>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = cmethod->name;
        D.50966 = "Max";
        D.50967 = MEM[(const unsigned char *)D.50966];
        D.50968 = (int) D.50967;
        D.50969 = *__s2;
        D.50970 = (int) D.50969;
        __result = D.50968 - D.50970;
        {
          D.50971 = __s2_len != 0;
          D.50972 = __result == 0;
          D.50973 = D.50971 & D.50972;
          if (D.50973 != 0) goto <D.50974>; else goto <D.50975>;
          <D.50974>:
          D.50976 = &MEM[(void *)"Max" + 1B];
          D.50977 = *D.50976;
          D.50978 = (int) D.50977;
          D.50979 = __s2 + 1;
          D.50980 = *D.50979;
          D.50981 = (int) D.50980;
          __result = D.50978 - D.50981;
          D.50982 = __s2_len > 1;
          D.50972 = __result == 0;
          D.50983 = D.50982 & D.50972;
          if (D.50983 != 0) goto <D.50984>; else goto <D.50985>;
          <D.50984>:
          D.50986 = &MEM[(void *)"Max" + 2B];
          D.50987 = *D.50986;
          D.50988 = (int) D.50987;
          D.50989 = __s2 + 2;
          D.50990 = *D.50989;
          D.50991 = (int) D.50990;
          __result = D.50988 - D.50991;
          D.50992 = __s2_len > 2;
          D.50972 = __result == 0;
          D.50993 = D.50992 & D.50972;
          if (D.50993 != 0) goto <D.50994>; else goto <D.50995>;
          <D.50994>:
          D.50996 = &MEM[(void *)"Max" + 3B];
          D.50997 = *D.50996;
          D.50998 = (int) D.50997;
          D.50999 = __s2 + 3;
          D.51000 = *D.50999;
          D.51001 = (int) D.51000;
          __result = D.50998 - D.51001;
          <D.50995>:
          <D.50985>:
          <D.50975>:
        }
        D.29057 = __result;
      }
      iftmp.8229 = -D.29057;
      goto <D.51002>;
      <D.50965>:
      D.50627 = cmethod->name;
      iftmp.8229 = __builtin_strcmp (D.50627, "Max");
      <D.51002>:
      D.29058 = iftmp.8229;
    }
    if (D.29058 == 0) goto <D.51003>; else goto <D.51004>;
    <D.51003>:
    D.50846 = fsig->params[0];
    D.50847 = D.50846->type;
    if (D.50847 == 8) goto <D.51005>; else goto <D.51006>;
    <D.51005>:
    opcode = 752;
    <D.51006>:
    <D.51004>:
    <D.50962>:
    if (opcode != 0) goto <D.51007>; else goto <D.51008>;
    <D.51007>:
    D.50898 = cfg->mempool;
    ins = mono_mempool_alloc (D.50898, 48);
    ins->data.op[1].const_val = 0;
    D.50899 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.50899;
    ins->prev = 0B;
    D.50900 = ins->prev;
    ins->next = D.50900;
    D.51009 = (short unsigned int) opcode;
    ins->opcode = D.51009;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.50902 = ins->sreg3;
    ins->sreg2 = D.50902;
    D.50903 = ins->sreg2;
    ins->sreg1 = D.50903;
    D.50904 = cfg->ip;
    ins->cil_code = D.50904;
    ins->type = 1;
    D.51010 = mono_alloc_ireg (cfg);
    D.51011 = (int) D.51010;
    ins->dreg = D.51011;
    D.50907 = *args;
    D.50908 = D.50907->dreg;
    ins->sreg1 = D.50908;
    D.51012 = args + 4;
    D.51013 = *D.51012;
    D.51014 = D.51013->dreg;
    ins->sreg2 = D.51014;
    D.50909 = cfg->cbb;
    D.50910 = D.50909->last_ins;
    if (D.50910 != 0B) goto <D.51015>; else goto <D.51016>;
    <D.51015>:
    D.50909 = cfg->cbb;
    D.50910 = D.50909->last_ins;
    D.50910->next = ins;
    D.50909 = cfg->cbb;
    D.50910 = D.50909->last_ins;
    ins->prev = D.50910;
    D.50909 = cfg->cbb;
    D.50909->last_ins = ins;
    goto <D.51017>;
    <D.51016>:
    D.50909 = cfg->cbb;
    D.50909 = cfg->cbb;
    D.50909->last_ins = ins;
    D.50910 = D.50909->last_ins;
    D.50909->code = D.50910;
    <D.51017>:
    <D.51008>:
  }
  <D.50917>:
  <D.50586>:
  D.51018 = ins;
  return D.51018;
}


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

  D.51020 = 0;
  return D.51020;
}


mono_arch_get_patch_offset (guint8 * code)
{
  unsigned char D.51023;
  guint8 * D.51025;
  unsigned char D.51026;
  unsigned char D.51027;
  guint32 D.51029;
  unsigned char D.51036;
  int D.51037;
  int D.51038;
  unsigned char D.51043;
  _Bool D.51044;
  _Bool D.51045;
  _Bool D.51046;
  unsigned char D.51053;
  unsigned char D.51056;

  D.51023 = *code;
  if (D.51023 == 139) goto <D.51024>; else goto <D.51022>;
  <D.51024>:
  D.51025 = code + 1;
  D.51026 = *D.51025;
  D.51027 = D.51026 >> 6;
  if (D.51027 == 2) goto <D.51028>; else goto <D.51022>;
  <D.51028>:
  D.51029 = 2;
  return D.51029;
  <D.51022>:
  D.51023 = *code;
  if (D.51023 == 186) goto <D.51030>; else goto <D.51031>;
  <D.51030>:
  D.51029 = 1;
  return D.51029;
  <D.51031>:
  D.51023 = *code;
  if (D.51023 == 104) goto <D.51032>; else goto <D.51033>;
  <D.51032>:
  D.51029 = 1;
  return D.51029;
  <D.51033>:
  D.51023 = *code;
  if (D.51023 == 255) goto <D.51035>; else goto <D.51034>;
  <D.51035>:
  D.51025 = code + 1;
  D.51026 = *D.51025;
  D.51036 = D.51026 >> 3;
  D.51037 = (int) D.51036;
  D.51038 = D.51037 & 7;
  if (D.51038 == 6) goto <D.51039>; else goto <D.51034>;
  <D.51039>:
  D.51029 = 2;
  return D.51029;
  <D.51034>:
  D.51023 = *code;
  if (D.51023 == 255) goto <D.51041>; else goto <D.51040>;
  <D.51041>:
  D.51025 = code + 1;
  D.51026 = *D.51025;
  D.51036 = D.51026 >> 3;
  D.51037 = (int) D.51036;
  D.51038 = D.51037 & 7;
  if (D.51038 == 2) goto <D.51042>; else goto <D.51040>;
  <D.51042>:
  D.51029 = 2;
  return D.51029;
  <D.51040>:
  D.51043 = *code;
  D.51044 = D.51043 == 221;
  D.51045 = D.51043 == 217;
  D.51046 = D.51044 | D.51045;
  if (D.51046 != 0) goto <D.51047>; else goto <D.51048>;
  <D.51047>:
  D.51029 = 2;
  return D.51029;
  <D.51048>:
  D.51023 = *code;
  if (D.51023 == 88) goto <D.51050>; else goto <D.51049>;
  <D.51050>:
  D.51025 = code + 1;
  D.51026 = *D.51025;
  if (D.51026 == 5) goto <D.51051>; else goto <D.51049>;
  <D.51051>:
  D.51029 = 2;
  return D.51029;
  <D.51049>:
  D.51023 = *code;
  D.51053 = D.51023 + 168;
  if (D.51053 <= 8) goto <D.51054>; else goto <D.51052>;
  <D.51054>:
  D.51025 = code + 1;
  D.51026 = *D.51025;
  if (D.51026 == 129) goto <D.51055>; else goto <D.51052>;
  <D.51055>:
  D.51029 = 3;
  return D.51029;
  <D.51052>:
  D.51023 = *code;
  D.51056 = D.51023 + 72;
  if (D.51056 <= 7) goto <D.51057>; else goto <D.51058>;
  <D.51057>:
  D.51029 = 1;
  return D.51029;
  <D.51058>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 6116);
  D.51029 = 4294967295;
  return D.51029;
}


mono_breakpoint_clean_code (guint8 * method_start, guint8 * code, int offset, guint8 * buf, int size)
{
  sizetype offset.8230;
  sizetype D.51065;
  guint8 * D.51066;
  unsigned int size.8231;
  int code.8232;
  int method_start.8233;
  int D.51070;
  int D.51071;
  unsigned int D.51072;
  sizetype diff.8234;
  sizetype D.51074;
  guint8 * D.51075;
  sizetype size.8235;
  guint8 * D.51081;
  int ptr.8236;
  int D.51085;
  sizetype D.51086;
  guint8 * D.51087;
  gboolean D.51088;
  int i;
  gboolean can_write;

  can_write = 1;
  if (method_start == 0B) goto <D.51060>; else goto <D.51063>;
  <D.51063>:
  offset.8230 = (sizetype) offset;
  D.51065 = -offset.8230;
  D.51066 = code + D.51065;
  if (D.51066 >= method_start) goto <D.51060>; else goto <D.51061>;
  <D.51060>:
  size.8231 = (unsigned int) size;
  offset.8230 = (sizetype) offset;
  D.51065 = -offset.8230;
  D.51066 = code + D.51065;
  memcpy (buf, D.51066, size.8231);
  goto <D.51062>;
  <D.51061>:
  {
    int diff;

    code.8232 = (int) code;
    method_start.8233 = (int) method_start;
    diff = code.8232 - method_start.8233;
    size.8231 = (unsigned int) size;
    memset (buf, 0, size.8231);
    D.51070 = diff + size;
    D.51071 = D.51070 - offset;
    D.51072 = (unsigned int) D.51071;
    offset.8230 = (sizetype) offset;
    diff.8234 = (sizetype) diff;
    D.51074 = offset.8230 - diff.8234;
    D.51075 = buf + D.51074;
    memcpy (D.51075, method_start, D.51072);
  }
  <D.51062>:
  offset.8230 = (sizetype) offset;
  D.51065 = -offset.8230;
  code = code + D.51065;
  i = 0;
  goto <D.29081>;
  <D.29080>:
  {
    int idx;
    guint8 * ptr;

    idx = mono_breakpoint_info_index[i];
    if (idx <= 0) goto <D.51076>; else goto <D.51077>;
    <D.51076>:
    // predicted unlikely by continue predictor.
    goto <D.29078>;
    <D.51077>:
    ptr = mono_breakpoint_info[idx].address;
    if (ptr >= code) goto <D.51078>; else goto <D.51079>;
    <D.51078>:
    size.8235 = (sizetype) size;
    D.51081 = code + size.8235;
    if (D.51081 > ptr) goto <D.51082>; else goto <D.51083>;
    <D.51082>:
    {
      guint8 saved_byte;

      saved_byte = mono_breakpoint_info[idx].saved_byte;
      can_write = 0;
      ptr.8236 = (int) ptr;
      code.8232 = (int) code;
      D.51085 = ptr.8236 - code.8232;
      D.51086 = (sizetype) D.51085;
      D.51087 = buf + D.51086;
      *D.51087 = saved_byte;
    }
    <D.51083>:
    <D.51079>:
  }
  <D.29078>:
  i = i + 1;
  <D.29081>:
  if (i <= 63) goto <D.29080>; else goto <D.29082>;
  <D.29082>:
  D.51088 = can_write;
  return D.51088;
}


mono_x86_get_this_arg_offset (struct MonoGenericSharingContext * gsctx, struct MonoMethodSignature * sig)
{
  guint32 D.51090;

  D.51090 = 0;
  return D.51090;
}


mono_arch_get_this_arg_from_call (mgreg_t * regs, guint8 * code)
{
  mgreg_t * D.51092;
  int D.51093;
  int D.51094;
  int D.51095;
  unsigned int D.51096;
  unsigned int D.51097;
  sizetype D.51098;
  struct MonoObject * * D.51099;
  void * D.51102;
  guint32 esp;
  struct CallInfo * cinfo;
  void * res;
  int offset;

  D.51092 = regs + 16;
  D.51093 = *D.51092;
  esp = (guint32) D.51093;
  cinfo = 0B;
  offset = 0;
  D.51094 = offset / 4;
  D.51095 = D.51094 + 5;
  D.51096 = (unsigned int) D.51095;
  D.51097 = D.51096 * 4;
  D.51098 = D.51097 + esp;
  D.51099 = (struct MonoObject * *) D.51098;
  res = *D.51099;
  if (cinfo != 0B) goto <D.51100>; else goto <D.51101>;
  <D.51100>:
  monoeg_g_free (cinfo);
  <D.51101>:
  D.51102 = res;
  return D.51102;
}


mono_arch_get_delegate_invoke_impls ()
{
  unsigned int code_len.8237;
  struct MonoTrampInfo * D.51105;
  unsigned int i.8238;
  struct MonoTrampInfo * D.51107;
  struct GSList * D.51108;
  struct GSList * res;
  guint8 * code;
  guint32 code_len;
  int i;
  char * tramp_name;

  try
    {
      res = 0B;
      code = get_delegate_invoke_impl (1, 0, &code_len);
      code_len.8237 = code_len;
      D.51105 = mono_tramp_info_create ("delegate_invoke_impl_has_target", code, code_len.8237, 0B, 0B);
      res = monoeg_g_slist_prepend (res, D.51105);
      i = 0;
      goto <D.29172>;
      <D.29171>:
      i.8238 = (unsigned int) i;
      code = get_delegate_invoke_impl (0, i.8238, &code_len);
      tramp_name = monoeg_g_strdup_printf ("delegate_invoke_impl_target_%d", i);
      code_len.8237 = code_len;
      D.51107 = mono_tramp_info_create (tramp_name, code, code_len.8237, 0B, 0B);
      res = monoeg_g_slist_prepend (res, D.51107);
      monoeg_g_free (tramp_name);
      i = i + 1;
      <D.29172>:
      if (i <= 9) goto <D.29171>; else goto <D.29173>;
      <D.29173>:
      D.51108 = res;
      return D.51108;
    }
  finally
    {
      code_len = {CLOBBER};
    }
}


get_delegate_invoke_impl (gboolean has_target, guint32 param_count, guint32 * code_len)
{
  void * code.8239;
  guint8 * code.8240;
  guint8 * code.8241;
  guint8 * code.8242;
  guint8 * code.8243;
  guint8 * code.8244;
  guint8 * code.8245;
  guint8 * code.8246;
  guint8 * code.8247;
  guint8 * code.8248;
  guint8 * code.8249;
  guint8 * code.8250;
  guint8 * code.8251;
  guint8 * code.8252;
  guint8 * code.8253;
  guint8 * code.8254;
  guint8 * code.8255;
  guint8 * code.8256;
  guint8 * code.8257;
  guint8 * code.8258;
  guint8 * code.8259;
  guint8 * code.8260;
  guint8 * code.8261;
  unsigned char D.51144;
  guint8 * code.8262;
  guint8 * code.8263;
  unsigned char D.51147;
  guint8 * code.8264;
  guint8 * code.8265;
  unsigned char D.51150;
  guint8 * code.8266;
  guint8 * code.8267;
  unsigned char D.51153;
  guint8 * code.8268;
  guint8 * code.8269;
  guint8 * code.8270;
  guint8 * code.8271;
  guint8 * code.8272;
  guint8 * code.8273;
  guint8 * code.8274;
  guint8 * code.8275;
  unsigned char D.51167;
  guint8 * code.8276;
  guint8 * code.8277;
  unsigned char D.51170;
  guint8 * code.8278;
  guint8 * code.8279;
  unsigned char D.51173;
  guint8 * code.8280;
  guint8 * code.8281;
  unsigned char D.51176;
  guint8 * code.8282;
  guint8 * code.8283;
  guint8 * code.8284;
  guint8 * code.8285;
  guint8 * code.8286;
  guint8 * code.8287;
  guint8 * code.8288;
  guint8 * code.8289;
  guint8 * code.8290;
  guint8 * code.8291;
  guint8 * code.8292;
  guint8 * code.8293;
  guint8 * code.8294;
  guint8 * code.8295;
  guint8 * code.8296;
  guint8 * code.8297;
  guint8 * code.8298;
  guint8 * code.8299;
  guint8 * code.8300;
  guint8 * code.8301;
  unsigned char D.51205;
  guint8 * code.8302;
  guint8 * code.8303;
  unsigned char D.51208;
  guint8 * code.8304;
  guint8 * code.8305;
  unsigned char D.51211;
  guint8 * code.8306;
  guint8 * code.8307;
  unsigned char D.51214;
  guint8 * code.8308;
  guint8 * code.8309;
  guint8 * code.8310;
  guint8 * code.8311;
  guint8 * code.8312;
  guint8 * code.8313;
  guint8 * code.8314;
  guint8 * code.8315;
  unsigned char D.51228;
  guint8 * code.8316;
  guint8 * code.8317;
  unsigned char D.51231;
  guint8 * code.8318;
  guint8 * code.8319;
  unsigned char D.51234;
  guint8 * code.8320;
  guint8 * code.8321;
  unsigned char D.51237;
  guint8 * code.8322;
  guint8 * code.8323;
  guint8 * code.8324;
  guint8 * code.8325;
  guint8 * code.8326;
  guint8 * code.8327;
  guint8 * code.8328;
  guint8 * code.8329;
  guint8 * code.8330;
  guint8 * code.8331;
  guint8 * code.8332;
  guint8 * code.8333;
  guint8 * code.8334;
  guint8 * code.8335;
  guint8 * code.8336;
  guint8 * code.8337;
  guint8 * code.8338;
  guint8 * code.8339;
  guint8 * code.8340;
  guint8 * code.8341;
  unsigned char D.51266;
  guint8 * code.8342;
  guint8 * code.8343;
  unsigned char D.51269;
  guint8 * code.8344;
  guint8 * code.8345;
  unsigned char D.51272;
  guint8 * code.8346;
  guint8 * code.8347;
  unsigned char D.51275;
  guint8 * code.8348;
  guint8 * code.8349;
  guint8 * code.8350;
  guint8 * code.8351;
  guint8 * code.8352;
  guint8 * code.8353;
  guint8 * code.8354;
  guint8 * code.8355;
  unsigned char D.51289;
  guint8 * code.8356;
  guint8 * code.8357;
  unsigned char D.51292;
  guint8 * code.8358;
  guint8 * code.8359;
  unsigned char D.51295;
  guint8 * code.8360;
  guint8 * code.8361;
  unsigned char D.51298;
  guint8 * code.8362;
  guint8 * code.8363;
  guint8 * code.8364;
  guint8 * code.8365;
  guint8 * code.8366;
  guint8 * code.8367;
  guint8 * code.8368;
  guint8 * code.8369;
  guint8 * code.8370;
  guint8 * code.8371;
  guint8 * code.8372;
  guint8 * code.8373;
  guint8 * code.8374;
  guint8 * code.8375;
  guint8 * code.8376;
  guint8 * code.8377;
  unsigned char D.51323;
  guint8 * code.8378;
  guint8 * code.8379;
  unsigned char D.51326;
  guint8 * code.8380;
  guint8 * code.8381;
  unsigned char D.51329;
  guint8 * code.8382;
  guint8 * code.8383;
  unsigned char D.51332;
  guint8 * code.8384;
  guint8 * code.8385;
  guint8 * code.8386;
  guint8 * code.8387;
  guint8 * code.8388;
  guint8 * code.8389;
  guint8 * code.8390;
  guint8 * code.8391;
  unsigned char D.51346;
  guint8 * code.8392;
  guint8 * code.8393;
  unsigned char D.51349;
  guint8 * code.8394;
  guint8 * code.8395;
  unsigned char D.51352;
  guint8 * code.8396;
  guint8 * code.8397;
  unsigned char D.51355;
  int code.8398;
  guint8 * start.8399;
  int start.8400;
  int D.51359;
  _Bool D.51360;
  long int D.51361;
  long int D.51362;
  unsigned int D.51366;
  unsigned int D.51367;
  void * code.8401;
  guint8 * code.8402;
  guint8 * code.8403;
  guint8 * code.8404;
  guint8 * code.8405;
  guint8 * code.8406;
  guint8 * code.8407;
  guint8 * code.8408;
  guint8 * code.8409;
  guint8 * code.8410;
  guint8 * code.8411;
  guint8 * code.8412;
  guint8 * code.8413;
  guint8 * code.8414;
  guint8 * code.8415;
  guint8 * code.8416;
  guint8 * code.8417;
  guint8 * code.8418;
  guint8 * code.8419;
  guint8 * code.8420;
  guint8 * code.8421;
  unsigned char D.51397;
  guint8 * code.8422;
  guint8 * code.8423;
  unsigned char D.51400;
  guint8 * code.8424;
  guint8 * code.8425;
  unsigned char D.51403;
  guint8 * code.8426;
  guint8 * code.8427;
  unsigned char D.51406;
  guint8 * code.8428;
  guint8 * code.8429;
  guint8 * code.8430;
  guint8 * code.8431;
  guint8 * code.8432;
  guint8 * code.8433;
  guint8 * code.8434;
  guint8 * code.8435;
  unsigned char D.51420;
  guint8 * code.8436;
  guint8 * code.8437;
  unsigned char D.51423;
  guint8 * code.8438;
  guint8 * code.8439;
  unsigned char D.51426;
  guint8 * code.8440;
  guint8 * code.8441;
  unsigned char D.51429;
  guint8 * code.8442;
  guint8 * code.8443;
  guint8 * code.8444;
  guint8 * code.8445;
  guint8 * code.8446;
  guint8 * code.8447;
  guint8 * code.8448;
  guint8 * code.8449;
  guint8 * code.8450;
  guint8 * code.8451;
  int D.51445;
  int D.51446;
  unsigned int D.51447;
  unsigned int D.51448;
  guint8 * code.8452;
  guint8 * code.8453;
  guint8 * code.8454;
  guint8 * code.8455;
  unsigned char D.51455;
  unsigned char D.51456;
  guint8 * code.8456;
  guint8 * code.8457;
  guint8 * code.8458;
  guint8 * code.8459;
  guint8 * code.8460;
  guint8 * code.8461;
  unsigned char D.51464;
  guint8 * code.8462;
  guint8 * code.8463;
  unsigned char D.51467;
  guint8 * code.8464;
  guint8 * code.8465;
  unsigned char D.51470;
  guint8 * code.8466;
  guint8 * code.8467;
  unsigned char D.51473;
  guint8 * code.8468;
  guint8 * code.8469;
  guint8 * code.8470;
  guint8 * code.8471;
  guint8 * code.8472;
  guint8 * code.8473;
  guint8 * code.8474;
  guint8 * code.8475;
  unsigned char D.51487;
  guint8 * code.8476;
  guint8 * code.8477;
  unsigned char D.51490;
  guint8 * code.8478;
  guint8 * code.8479;
  unsigned char D.51493;
  guint8 * code.8480;
  guint8 * code.8481;
  unsigned char D.51496;
  guint8 * code.8482;
  guint8 * code.8483;
  guint8 * code.8484;
  guint8 * code.8485;
  guint8 * code.8486;
  guint8 * code.8487;
  guint8 * code.8488;
  guint8 * code.8489;
  guint8 * code.8490;
  guint8 * code.8491;
  int D.51512;
  int D.51513;
  unsigned int D.51514;
  unsigned int D.51515;
  guint8 * code.8492;
  guint8 * code.8493;
  guint8 * code.8494;
  guint8 * code.8495;
  unsigned char D.51522;
  unsigned char D.51523;
  guint8 * code.8496;
  guint8 * code.8497;
  guint8 * code.8498;
  guint8 * code.8499;
  guint8 * code.8500;
  guint8 * code.8501;
  unsigned char D.51531;
  guint8 * code.8502;
  guint8 * code.8503;
  unsigned char D.51534;
  guint8 * code.8504;
  guint8 * code.8505;
  unsigned char D.51537;
  guint8 * code.8506;
  guint8 * code.8507;
  unsigned char D.51540;
  guint8 * code.8508;
  guint8 * code.8509;
  guint8 * code.8510;
  guint8 * code.8511;
  guint8 * code.8512;
  guint8 * code.8513;
  guint8 * code.8514;
  guint8 * code.8515;
  unsigned char D.51554;
  guint8 * code.8516;
  guint8 * code.8517;
  unsigned char D.51557;
  guint8 * code.8518;
  guint8 * code.8519;
  unsigned char D.51560;
  guint8 * code.8520;
  guint8 * code.8521;
  unsigned char D.51563;
  unsigned int i.8522;
  guint8 * code.8523;
  guint8 * code.8524;
  guint8 * code.8525;
  guint8 * code.8526;
  guint8 * code.8527;
  guint8 * code.8528;
  guint8 * code.8529;
  guint8 * code.8530;
  guint8 * code.8531;
  guint8 * code.8532;
  guint8 * code.8533;
  guint8 * code.8534;
  guint8 * code.8535;
  guint8 * code.8536;
  guint8 * code.8537;
  guint8 * code.8538;
  unsigned char D.51589;
  guint8 * code.8539;
  guint8 * code.8540;
  unsigned char D.51592;
  guint8 * code.8541;
  guint8 * code.8542;
  unsigned char D.51595;
  guint8 * code.8543;
  guint8 * code.8544;
  unsigned char D.51598;
  guint8 * code.8545;
  guint8 * code.8546;
  guint8 * code.8547;
  guint8 * code.8548;
  guint8 * code.8549;
  guint8 * code.8550;
  guint8 * code.8551;
  guint8 * code.8552;
  unsigned char D.51612;
  guint8 * code.8553;
  guint8 * code.8554;
  unsigned char D.51615;
  guint8 * code.8555;
  guint8 * code.8556;
  unsigned char D.51618;
  guint8 * code.8557;
  guint8 * code.8558;
  unsigned char D.51621;
  unsigned int D.51626;
  int D.51627;
  void * D.51635;
  guint8 * code;
  guint8 * start;
  int code_reserve;
  static const char __PRETTY_FUNCTION__[25] = "get_delegate_invoke_impl";

  try
    {
      code_reserve = 64;
      if (has_target != 0) goto <D.51111>; else goto <D.51112>;
      <D.51111>:
      code.8239 = mono_global_codeman_reserve (code_reserve);
      code = code.8239;
      code.8240 = code;
      start = code.8240;
      switch (4) <default: <D.29107>, case 1: <D.29103>, case 2: <D.29105>, case 4: <D.29106>>
      <D.29103>:
      code.8240 = code;
      code.8241 = code.8240;
      code.8242 = code.8241 + 1;
      code = code.8242;
      *code.8241 = 138;
      goto <D.29104>;
      <D.29105>:
      code.8240 = code;
      code.8243 = code.8240;
      code.8244 = code.8243 + 1;
      code = code.8244;
      *code.8243 = 102;
      <D.29106>:
      code.8240 = code;
      code.8245 = code.8240;
      code.8246 = code.8245 + 1;
      code = code.8246;
      *code.8245 = 139;
      goto <D.29104>;
      <D.29107>:
      __assert_fail ("0", "mini-x86.c", 6217, &__PRETTY_FUNCTION__);
      <D.29104>:
      if (1 != 0) goto <D.51121>; else goto <D.51122>;
      <D.51121>:
      if (0 != 0) goto <D.51123>; else goto <D.51124>;
      <D.51123>:
      code.8240 = code;
      code.8247 = code.8240;
      code.8248 = code.8247 + 1;
      code = code.8248;
      *code.8247 = 4;
      code.8240 = code;
      code.8249 = code.8240;
      code.8250 = code.8249 + 1;
      code = code.8250;
      *code.8249 = 36;
      goto <D.51129>;
      <D.51124>:
      if (1 != 0) goto <D.51130>; else goto <D.51131>;
      <D.51130>:
      code.8240 = code;
      code.8251 = code.8240;
      code.8252 = code.8251 + 1;
      code = code.8252;
      *code.8251 = 68;
      code.8240 = code;
      code.8253 = code.8240;
      code.8254 = code.8253 + 1;
      code = code.8254;
      *code.8253 = 36;
      code.8240 = code;
      *code.8240 = 4;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51137>;
      <D.51131>:
      code.8240 = code;
      code.8256 = code.8240;
      code.8257 = code.8256 + 1;
      code = code.8257;
      *code.8256 = 132;
      code.8240 = code;
      code.8258 = code.8240;
      code.8259 = code.8258 + 1;
      code = code.8259;
      *code.8258 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.8240 = code;
            code.8260 = code.8240;
            code.8261 = code.8260 + 1;
            code = code.8261;
            D.51144 = imb.b[0];
            *code.8260 = D.51144;
            code.8240 = code;
            code.8262 = code.8240;
            code.8263 = code.8262 + 1;
            code = code.8263;
            D.51147 = imb.b[1];
            *code.8262 = D.51147;
            code.8240 = code;
            code.8264 = code.8240;
            code.8265 = code.8264 + 1;
            code = code.8265;
            D.51150 = imb.b[2];
            *code.8264 = D.51150;
            code.8240 = code;
            code.8266 = code.8240;
            code.8267 = code.8266 + 1;
            code = code.8267;
            D.51153 = imb.b[3];
            *code.8266 = D.51153;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51137>:
      <D.51129>:
      goto <D.29110>;
      <D.51122>:
      if (0 != 0) goto <D.51154>; else goto <D.51155>;
      <D.51154>:
      code.8240 = code;
      code.8268 = code.8240;
      code.8269 = code.8268 + 1;
      code = code.8269;
      *code.8268 = 4;
      goto <D.29110>;
      <D.51155>:
      if (1 != 0) goto <D.51158>; else goto <D.51159>;
      <D.51158>:
      code.8240 = code;
      code.8270 = code.8240;
      code.8271 = code.8270 + 1;
      code = code.8271;
      *code.8270 = 68;
      code.8240 = code;
      *code.8240 = 4;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51162>;
      <D.51159>:
      code.8240 = code;
      code.8272 = code.8240;
      code.8273 = code.8272 + 1;
      code = code.8273;
      *code.8272 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.8240 = code;
            code.8274 = code.8240;
            code.8275 = code.8274 + 1;
            code = code.8275;
            D.51167 = imb.b[0];
            *code.8274 = D.51167;
            code.8240 = code;
            code.8276 = code.8240;
            code.8277 = code.8276 + 1;
            code = code.8277;
            D.51170 = imb.b[1];
            *code.8276 = D.51170;
            code.8240 = code;
            code.8278 = code.8240;
            code.8279 = code.8278 + 1;
            code = code.8279;
            D.51173 = imb.b[2];
            *code.8278 = D.51173;
            code.8240 = code;
            code.8280 = code.8240;
            code.8281 = code.8280 + 1;
            code = code.8281;
            D.51176 = imb.b[3];
            *code.8280 = D.51176;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51162>:
      <D.29110>:
      switch (4) <default: <D.29116>, case 1: <D.29112>, case 2: <D.29114>, case 4: <D.29115>>
      <D.29112>:
      code.8240 = code;
      code.8282 = code.8240;
      code.8283 = code.8282 + 1;
      code = code.8283;
      *code.8282 = 138;
      goto <D.29113>;
      <D.29114>:
      code.8240 = code;
      code.8284 = code.8240;
      code.8285 = code.8284 + 1;
      code = code.8285;
      *code.8284 = 102;
      <D.29115>:
      code.8240 = code;
      code.8286 = code.8240;
      code.8287 = code.8286 + 1;
      code = code.8287;
      *code.8286 = 139;
      goto <D.29113>;
      <D.29116>:
      __assert_fail ("0", "mini-x86.c", 6218, &__PRETTY_FUNCTION__);
      <D.29113>:
      if (0 != 0) goto <D.51183>; else goto <D.51184>;
      <D.51183>:
      if (0 != 0) goto <D.51185>; else goto <D.51186>;
      <D.51185>:
      code.8240 = code;
      code.8288 = code.8240;
      code.8289 = code.8288 + 1;
      code = code.8289;
      *code.8288 = 12;
      code.8240 = code;
      code.8290 = code.8240;
      code.8291 = code.8290 + 1;
      code = code.8291;
      *code.8290 = 36;
      goto <D.51191>;
      <D.51186>:
      if (1 != 0) goto <D.51192>; else goto <D.51193>;
      <D.51192>:
      code.8240 = code;
      code.8292 = code.8240;
      code.8293 = code.8292 + 1;
      code = code.8293;
      *code.8292 = 76;
      code.8240 = code;
      code.8294 = code.8240;
      code.8295 = code.8294 + 1;
      code = code.8295;
      *code.8294 = 36;
      code.8240 = code;
      *code.8240 = 16;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51198>;
      <D.51193>:
      code.8240 = code;
      code.8296 = code.8240;
      code.8297 = code.8296 + 1;
      code = code.8297;
      *code.8296 = 140;
      code.8240 = code;
      code.8298 = code.8240;
      code.8299 = code.8298 + 1;
      code = code.8299;
      *code.8298 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.8240 = code;
            code.8300 = code.8240;
            code.8301 = code.8300 + 1;
            code = code.8301;
            D.51205 = imb.b[0];
            *code.8300 = D.51205;
            code.8240 = code;
            code.8302 = code.8240;
            code.8303 = code.8302 + 1;
            code = code.8303;
            D.51208 = imb.b[1];
            *code.8302 = D.51208;
            code.8240 = code;
            code.8304 = code.8240;
            code.8305 = code.8304 + 1;
            code = code.8305;
            D.51211 = imb.b[2];
            *code.8304 = D.51211;
            code.8240 = code;
            code.8306 = code.8240;
            code.8307 = code.8306 + 1;
            code = code.8307;
            D.51214 = imb.b[3];
            *code.8306 = D.51214;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51198>:
      <D.51191>:
      goto <D.29118>;
      <D.51184>:
      if (0 != 0) goto <D.51215>; else goto <D.51216>;
      <D.51215>:
      code.8240 = code;
      code.8308 = code.8240;
      code.8309 = code.8308 + 1;
      code = code.8309;
      *code.8308 = 8;
      goto <D.29118>;
      <D.51216>:
      if (1 != 0) goto <D.51219>; else goto <D.51220>;
      <D.51219>:
      code.8240 = code;
      code.8310 = code.8240;
      code.8311 = code.8310 + 1;
      code = code.8311;
      *code.8310 = 72;
      code.8240 = code;
      *code.8240 = 16;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51223>;
      <D.51220>:
      code.8240 = code;
      code.8312 = code.8240;
      code.8313 = code.8312 + 1;
      code = code.8313;
      *code.8312 = 136;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.8240 = code;
            code.8314 = code.8240;
            code.8315 = code.8314 + 1;
            code = code.8315;
            D.51228 = imb.b[0];
            *code.8314 = D.51228;
            code.8240 = code;
            code.8316 = code.8240;
            code.8317 = code.8316 + 1;
            code = code.8317;
            D.51231 = imb.b[1];
            *code.8316 = D.51231;
            code.8240 = code;
            code.8318 = code.8240;
            code.8319 = code.8318 + 1;
            code = code.8319;
            D.51234 = imb.b[2];
            *code.8318 = D.51234;
            code.8240 = code;
            code.8320 = code.8240;
            code.8321 = code.8320 + 1;
            code = code.8321;
            D.51237 = imb.b[3];
            *code.8320 = D.51237;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51223>:
      <D.29118>:
      switch (4) <default: <D.29124>, case 1: <D.29120>, case 2: <D.29122>, case 4: <D.29123>>
      <D.29120>:
      code.8240 = code;
      code.8322 = code.8240;
      code.8323 = code.8322 + 1;
      code = code.8323;
      *code.8322 = 136;
      goto <D.29121>;
      <D.29122>:
      code.8240 = code;
      code.8324 = code.8240;
      code.8325 = code.8324 + 1;
      code = code.8325;
      *code.8324 = 102;
      <D.29123>:
      code.8240 = code;
      code.8326 = code.8240;
      code.8327 = code.8326 + 1;
      code = code.8327;
      *code.8326 = 137;
      goto <D.29121>;
      <D.29124>:
      __assert_fail ("0", "mini-x86.c", 6219, &__PRETTY_FUNCTION__);
      <D.29121>:
      if (1 != 0) goto <D.51244>; else goto <D.51245>;
      <D.51244>:
      if (0 != 0) goto <D.51246>; else goto <D.51247>;
      <D.51246>:
      code.8240 = code;
      code.8328 = code.8240;
      code.8329 = code.8328 + 1;
      code = code.8329;
      *code.8328 = 12;
      code.8240 = code;
      code.8330 = code.8240;
      code.8331 = code.8330 + 1;
      code = code.8331;
      *code.8330 = 36;
      goto <D.51252>;
      <D.51247>:
      if (1 != 0) goto <D.51253>; else goto <D.51254>;
      <D.51253>:
      code.8240 = code;
      code.8332 = code.8240;
      code.8333 = code.8332 + 1;
      code = code.8333;
      *code.8332 = 76;
      code.8240 = code;
      code.8334 = code.8240;
      code.8335 = code.8334 + 1;
      code = code.8335;
      *code.8334 = 36;
      code.8240 = code;
      *code.8240 = 4;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51259>;
      <D.51254>:
      code.8240 = code;
      code.8336 = code.8240;
      code.8337 = code.8336 + 1;
      code = code.8337;
      *code.8336 = 140;
      code.8240 = code;
      code.8338 = code.8240;
      code.8339 = code.8338 + 1;
      code = code.8339;
      *code.8338 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.8240 = code;
            code.8340 = code.8240;
            code.8341 = code.8340 + 1;
            code = code.8341;
            D.51266 = imb.b[0];
            *code.8340 = D.51266;
            code.8240 = code;
            code.8342 = code.8240;
            code.8343 = code.8342 + 1;
            code = code.8343;
            D.51269 = imb.b[1];
            *code.8342 = D.51269;
            code.8240 = code;
            code.8344 = code.8240;
            code.8345 = code.8344 + 1;
            code = code.8345;
            D.51272 = imb.b[2];
            *code.8344 = D.51272;
            code.8240 = code;
            code.8346 = code.8240;
            code.8347 = code.8346 + 1;
            code = code.8347;
            D.51275 = imb.b[3];
            *code.8346 = D.51275;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51259>:
      <D.51252>:
      goto <D.29126>;
      <D.51245>:
      if (0 != 0) goto <D.51276>; else goto <D.51277>;
      <D.51276>:
      code.8240 = code;
      code.8348 = code.8240;
      code.8349 = code.8348 + 1;
      code = code.8349;
      *code.8348 = 12;
      goto <D.29126>;
      <D.51277>:
      if (1 != 0) goto <D.51280>; else goto <D.51281>;
      <D.51280>:
      code.8240 = code;
      code.8350 = code.8240;
      code.8351 = code.8350 + 1;
      code = code.8351;
      *code.8350 = 76;
      code.8240 = code;
      *code.8240 = 4;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51284>;
      <D.51281>:
      code.8240 = code;
      code.8352 = code.8240;
      code.8353 = code.8352 + 1;
      code = code.8353;
      *code.8352 = 140;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 4;
            code.8240 = code;
            code.8354 = code.8240;
            code.8355 = code.8354 + 1;
            code = code.8355;
            D.51289 = imb.b[0];
            *code.8354 = D.51289;
            code.8240 = code;
            code.8356 = code.8240;
            code.8357 = code.8356 + 1;
            code = code.8357;
            D.51292 = imb.b[1];
            *code.8356 = D.51292;
            code.8240 = code;
            code.8358 = code.8240;
            code.8359 = code.8358 + 1;
            code = code.8359;
            D.51295 = imb.b[2];
            *code.8358 = D.51295;
            code.8240 = code;
            code.8360 = code.8240;
            code.8361 = code.8360 + 1;
            code = code.8361;
            D.51298 = imb.b[3];
            *code.8360 = D.51298;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51284>:
      <D.29126>:
      code.8240 = code;
      code.8362 = code.8240;
      code.8363 = code.8362 + 1;
      code = code.8363;
      *code.8362 = 255;
      if (0 != 0) goto <D.51301>; else goto <D.51302>;
      <D.51301>:
      if (0 != 0) goto <D.51303>; else goto <D.51304>;
      <D.51303>:
      code.8240 = code;
      code.8364 = code.8240;
      code.8365 = code.8364 + 1;
      code = code.8365;
      *code.8364 = 36;
      code.8240 = code;
      code.8366 = code.8240;
      code.8367 = code.8366 + 1;
      code = code.8367;
      *code.8366 = 36;
      goto <D.51309>;
      <D.51304>:
      if (1 != 0) goto <D.51310>; else goto <D.51311>;
      <D.51310>:
      code.8240 = code;
      code.8368 = code.8240;
      code.8369 = code.8368 + 1;
      code = code.8369;
      *code.8368 = 100;
      code.8240 = code;
      code.8370 = code.8240;
      code.8371 = code.8370 + 1;
      code = code.8371;
      *code.8370 = 36;
      code.8240 = code;
      *code.8240 = 8;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51316>;
      <D.51311>:
      code.8240 = code;
      code.8372 = code.8240;
      code.8373 = code.8372 + 1;
      code = code.8373;
      *code.8372 = 164;
      code.8240 = code;
      code.8374 = code.8240;
      code.8375 = code.8374 + 1;
      code = code.8375;
      *code.8374 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.8240 = code;
            code.8376 = code.8240;
            code.8377 = code.8376 + 1;
            code = code.8377;
            D.51323 = imb.b[0];
            *code.8376 = D.51323;
            code.8240 = code;
            code.8378 = code.8240;
            code.8379 = code.8378 + 1;
            code = code.8379;
            D.51326 = imb.b[1];
            *code.8378 = D.51326;
            code.8240 = code;
            code.8380 = code.8240;
            code.8381 = code.8380 + 1;
            code = code.8381;
            D.51329 = imb.b[2];
            *code.8380 = D.51329;
            code.8240 = code;
            code.8382 = code.8240;
            code.8383 = code.8382 + 1;
            code = code.8383;
            D.51332 = imb.b[3];
            *code.8382 = D.51332;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51316>:
      <D.51309>:
      goto <D.29129>;
      <D.51302>:
      if (0 != 0) goto <D.51333>; else goto <D.51334>;
      <D.51333>:
      code.8240 = code;
      code.8384 = code.8240;
      code.8385 = code.8384 + 1;
      code = code.8385;
      *code.8384 = 32;
      goto <D.29129>;
      <D.51334>:
      if (1 != 0) goto <D.51337>; else goto <D.51338>;
      <D.51337>:
      code.8240 = code;
      code.8386 = code.8240;
      code.8387 = code.8386 + 1;
      code = code.8387;
      *code.8386 = 96;
      code.8240 = code;
      *code.8240 = 8;
      code.8240 = code;
      code.8255 = code.8240 + 1;
      code = code.8255;
      goto <D.51341>;
      <D.51338>:
      code.8240 = code;
      code.8388 = code.8240;
      code.8389 = code.8388 + 1;
      code = code.8389;
      *code.8388 = 160;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.8240 = code;
            code.8390 = code.8240;
            code.8391 = code.8390 + 1;
            code = code.8391;
            D.51346 = imb.b[0];
            *code.8390 = D.51346;
            code.8240 = code;
            code.8392 = code.8240;
            code.8393 = code.8392 + 1;
            code = code.8393;
            D.51349 = imb.b[1];
            *code.8392 = D.51349;
            code.8240 = code;
            code.8394 = code.8240;
            code.8395 = code.8394 + 1;
            code = code.8395;
            D.51352 = imb.b[2];
            *code.8394 = D.51352;
            code.8240 = code;
            code.8396 = code.8240;
            code.8397 = code.8396 + 1;
            code = code.8397;
            D.51355 = imb.b[3];
            *code.8396 = D.51355;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.51341>:
      <D.29129>:
      code.8240 = code;
      code.8398 = (int) code.8240;
      start.8399 = start;
      start.8400 = (int) start.8399;
      D.51359 = code.8398 - start.8400;
      D.51360 = D.51359 >= code_reserve;
      D.51361 = (long int) D.51360;
      D.51362 = __builtin_expect (D.51361, 0);
      if (D.51362 != 0) goto <D.51363>; else goto <D.51364>;
      <D.51363>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 6222, "(code - start) < code_reserve");
      <D.51364>:
      goto <D.51365>;
      <D.51112>:
      {
        int i;

        i = 0;
        D.51366 = param_count + 1;
        D.51367 = D.51366 * 8;
        code_reserve = (int) D.51367;
        code.8401 = mono_global_codeman_reserve (code_reserve);
        code = code.8401;
        code.8240 = code;
        start = code.8240;
        switch (4) <default: <D.29136>, case 1: <D.29132>, case 2: <D.29134>, case 4: <D.29135>>
        <D.29132>:
        code.8240 = code;
        code.8402 = code.8240;
        code.8403 = code.8402 + 1;
        code = code.8403;
        *code.8402 = 138;
        goto <D.29133>;
        <D.29134>:
        code.8240 = code;
        code.8404 = code.8240;
        code.8405 = code.8404 + 1;
        code = code.8405;
        *code.8404 = 102;
        <D.29135>:
        code.8240 = code;
        code.8406 = code.8240;
        code.8407 = code.8406 + 1;
        code = code.8407;
        *code.8406 = 139;
        goto <D.29133>;
        <D.29136>:
        __assert_fail ("0", "mini-x86.c", 6251, &__PRETTY_FUNCTION__);
        <D.29133>:
        if (1 != 0) goto <D.51375>; else goto <D.51376>;
        <D.51375>:
        if (0 != 0) goto <D.51377>; else goto <D.51378>;
        <D.51377>:
        code.8240 = code;
        code.8408 = code.8240;
        code.8409 = code.8408 + 1;
        code = code.8409;
        *code.8408 = 12;
        code.8240 = code;
        code.8410 = code.8240;
        code.8411 = code.8410 + 1;
        code = code.8411;
        *code.8410 = 36;
        goto <D.51383>;
        <D.51378>:
        if (1 != 0) goto <D.51384>; else goto <D.51385>;
        <D.51384>:
        code.8240 = code;
        code.8412 = code.8240;
        code.8413 = code.8412 + 1;
        code = code.8413;
        *code.8412 = 76;
        code.8240 = code;
        code.8414 = code.8240;
        code.8415 = code.8414 + 1;
        code = code.8415;
        *code.8414 = 36;
        code.8240 = code;
        *code.8240 = 4;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51390>;
        <D.51385>:
        code.8240 = code;
        code.8416 = code.8240;
        code.8417 = code.8416 + 1;
        code = code.8417;
        *code.8416 = 140;
        code.8240 = code;
        code.8418 = code.8240;
        code.8419 = code.8418 + 1;
        code = code.8419;
        *code.8418 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4;
              code.8240 = code;
              code.8420 = code.8240;
              code.8421 = code.8420 + 1;
              code = code.8421;
              D.51397 = imb.b[0];
              *code.8420 = D.51397;
              code.8240 = code;
              code.8422 = code.8240;
              code.8423 = code.8422 + 1;
              code = code.8423;
              D.51400 = imb.b[1];
              *code.8422 = D.51400;
              code.8240 = code;
              code.8424 = code.8240;
              code.8425 = code.8424 + 1;
              code = code.8425;
              D.51403 = imb.b[2];
              *code.8424 = D.51403;
              code.8240 = code;
              code.8426 = code.8240;
              code.8427 = code.8426 + 1;
              code = code.8427;
              D.51406 = imb.b[3];
              *code.8426 = D.51406;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51390>:
        <D.51383>:
        goto <D.29138>;
        <D.51376>:
        if (0 != 0) goto <D.51407>; else goto <D.51408>;
        <D.51407>:
        code.8240 = code;
        code.8428 = code.8240;
        code.8429 = code.8428 + 1;
        code = code.8429;
        *code.8428 = 12;
        goto <D.29138>;
        <D.51408>:
        if (1 != 0) goto <D.51411>; else goto <D.51412>;
        <D.51411>:
        code.8240 = code;
        code.8430 = code.8240;
        code.8431 = code.8430 + 1;
        code = code.8431;
        *code.8430 = 76;
        code.8240 = code;
        *code.8240 = 4;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51415>;
        <D.51412>:
        code.8240 = code;
        code.8432 = code.8240;
        code.8433 = code.8432 + 1;
        code = code.8433;
        *code.8432 = 140;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4;
              code.8240 = code;
              code.8434 = code.8240;
              code.8435 = code.8434 + 1;
              code = code.8435;
              D.51420 = imb.b[0];
              *code.8434 = D.51420;
              code.8240 = code;
              code.8436 = code.8240;
              code.8437 = code.8436 + 1;
              code = code.8437;
              D.51423 = imb.b[1];
              *code.8436 = D.51423;
              code.8240 = code;
              code.8438 = code.8240;
              code.8439 = code.8438 + 1;
              code = code.8439;
              D.51426 = imb.b[2];
              *code.8438 = D.51426;
              code.8240 = code;
              code.8440 = code.8240;
              code.8441 = code.8440 + 1;
              code = code.8441;
              D.51429 = imb.b[3];
              *code.8440 = D.51429;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51415>:
        <D.29138>:
        i = 0;
        goto <D.29157>;
        <D.29156>:
        switch (4) <default: <D.29144>, case 1: <D.29140>, case 2: <D.29142>, case 4: <D.29143>>
        <D.29140>:
        code.8240 = code;
        code.8442 = code.8240;
        code.8443 = code.8442 + 1;
        code = code.8443;
        *code.8442 = 138;
        goto <D.29141>;
        <D.29142>:
        code.8240 = code;
        code.8444 = code.8240;
        code.8445 = code.8444 + 1;
        code = code.8445;
        *code.8444 = 102;
        <D.29143>:
        code.8240 = code;
        code.8446 = code.8240;
        code.8447 = code.8446 + 1;
        code = code.8447;
        *code.8446 = 139;
        goto <D.29141>;
        <D.29144>:
        __assert_fail ("0", "mini-x86.c", 6255, &__PRETTY_FUNCTION__);
        <D.29141>:
        if (1 != 0) goto <D.51436>; else goto <D.51437>;
        <D.51436>:
        if (i == -2) goto <D.51438>; else goto <D.51439>;
        <D.51438>:
        code.8240 = code;
        code.8448 = code.8240;
        code.8449 = code.8448 + 1;
        code = code.8449;
        *code.8448 = 4;
        code.8240 = code;
        code.8450 = code.8240;
        code.8451 = code.8450 + 1;
        code = code.8451;
        *code.8450 = 36;
        goto <D.51444>;
        <D.51439>:
        D.51445 = i + 2;
        D.51446 = D.51445 * 4;
        D.51447 = (unsigned int) D.51446;
        D.51448 = D.51447 + 128;
        if (D.51448 <= 255) goto <D.51449>; else goto <D.51450>;
        <D.51449>:
        code.8240 = code;
        code.8452 = code.8240;
        code.8453 = code.8452 + 1;
        code = code.8453;
        *code.8452 = 68;
        code.8240 = code;
        code.8454 = code.8240;
        code.8455 = code.8454 + 1;
        code = code.8455;
        *code.8454 = 36;
        code.8240 = code;
        D.51445 = i + 2;
        D.51455 = (unsigned char) D.51445;
        D.51456 = D.51455 * 4;
        *code.8240 = D.51456;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51457>;
        <D.51450>:
        code.8240 = code;
        code.8456 = code.8240;
        code.8457 = code.8456 + 1;
        code = code.8457;
        *code.8456 = 132;
        code.8240 = code;
        code.8458 = code.8240;
        code.8459 = code.8458 + 1;
        code = code.8459;
        *code.8458 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              D.51445 = i + 2;
              D.51446 = D.51445 * 4;
              imb.val = D.51446;
              code.8240 = code;
              code.8460 = code.8240;
              code.8461 = code.8460 + 1;
              code = code.8461;
              D.51464 = imb.b[0];
              *code.8460 = D.51464;
              code.8240 = code;
              code.8462 = code.8240;
              code.8463 = code.8462 + 1;
              code = code.8463;
              D.51467 = imb.b[1];
              *code.8462 = D.51467;
              code.8240 = code;
              code.8464 = code.8240;
              code.8465 = code.8464 + 1;
              code = code.8465;
              D.51470 = imb.b[2];
              *code.8464 = D.51470;
              code.8240 = code;
              code.8466 = code.8240;
              code.8467 = code.8466 + 1;
              code = code.8467;
              D.51473 = imb.b[3];
              *code.8466 = D.51473;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51457>:
        <D.51444>:
        goto <D.29146>;
        <D.51437>:
        if (i == -2) goto <D.51474>; else goto <D.51475>;
        <D.51474>:
        code.8240 = code;
        code.8468 = code.8240;
        code.8469 = code.8468 + 1;
        code = code.8469;
        *code.8468 = 4;
        goto <D.29146>;
        <D.51475>:
        D.51445 = i + 2;
        D.51446 = D.51445 * 4;
        D.51447 = (unsigned int) D.51446;
        D.51448 = D.51447 + 128;
        if (D.51448 <= 255) goto <D.51478>; else goto <D.51479>;
        <D.51478>:
        code.8240 = code;
        code.8470 = code.8240;
        code.8471 = code.8470 + 1;
        code = code.8471;
        *code.8470 = 68;
        code.8240 = code;
        D.51445 = i + 2;
        D.51455 = (unsigned char) D.51445;
        D.51456 = D.51455 * 4;
        *code.8240 = D.51456;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51482>;
        <D.51479>:
        code.8240 = code;
        code.8472 = code.8240;
        code.8473 = code.8472 + 1;
        code = code.8473;
        *code.8472 = 132;
        {
          union x86_imm_buf imb;

          try
            {
              D.51445 = i + 2;
              D.51446 = D.51445 * 4;
              imb.val = D.51446;
              code.8240 = code;
              code.8474 = code.8240;
              code.8475 = code.8474 + 1;
              code = code.8475;
              D.51487 = imb.b[0];
              *code.8474 = D.51487;
              code.8240 = code;
              code.8476 = code.8240;
              code.8477 = code.8476 + 1;
              code = code.8477;
              D.51490 = imb.b[1];
              *code.8476 = D.51490;
              code.8240 = code;
              code.8478 = code.8240;
              code.8479 = code.8478 + 1;
              code = code.8479;
              D.51493 = imb.b[2];
              *code.8478 = D.51493;
              code.8240 = code;
              code.8480 = code.8240;
              code.8481 = code.8480 + 1;
              code = code.8481;
              D.51496 = imb.b[3];
              *code.8480 = D.51496;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51482>:
        <D.29146>:
        switch (4) <default: <D.29152>, case 1: <D.29148>, case 2: <D.29150>, case 4: <D.29151>>
        <D.29148>:
        code.8240 = code;
        code.8482 = code.8240;
        code.8483 = code.8482 + 1;
        code = code.8483;
        *code.8482 = 136;
        goto <D.29149>;
        <D.29150>:
        code.8240 = code;
        code.8484 = code.8240;
        code.8485 = code.8484 + 1;
        code = code.8485;
        *code.8484 = 102;
        <D.29151>:
        code.8240 = code;
        code.8486 = code.8240;
        code.8487 = code.8486 + 1;
        code = code.8487;
        *code.8486 = 137;
        goto <D.29149>;
        <D.29152>:
        __assert_fail ("0", "mini-x86.c", 6256, &__PRETTY_FUNCTION__);
        <D.29149>:
        if (1 != 0) goto <D.51503>; else goto <D.51504>;
        <D.51503>:
        if (i == -1) goto <D.51505>; else goto <D.51506>;
        <D.51505>:
        code.8240 = code;
        code.8488 = code.8240;
        code.8489 = code.8488 + 1;
        code = code.8489;
        *code.8488 = 4;
        code.8240 = code;
        code.8490 = code.8240;
        code.8491 = code.8490 + 1;
        code = code.8491;
        *code.8490 = 36;
        goto <D.51511>;
        <D.51506>:
        D.51512 = i + 1;
        D.51513 = D.51512 * 4;
        D.51514 = (unsigned int) D.51513;
        D.51515 = D.51514 + 128;
        if (D.51515 <= 255) goto <D.51516>; else goto <D.51517>;
        <D.51516>:
        code.8240 = code;
        code.8492 = code.8240;
        code.8493 = code.8492 + 1;
        code = code.8493;
        *code.8492 = 68;
        code.8240 = code;
        code.8494 = code.8240;
        code.8495 = code.8494 + 1;
        code = code.8495;
        *code.8494 = 36;
        code.8240 = code;
        D.51512 = i + 1;
        D.51522 = (unsigned char) D.51512;
        D.51523 = D.51522 * 4;
        *code.8240 = D.51523;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51524>;
        <D.51517>:
        code.8240 = code;
        code.8496 = code.8240;
        code.8497 = code.8496 + 1;
        code = code.8497;
        *code.8496 = 132;
        code.8240 = code;
        code.8498 = code.8240;
        code.8499 = code.8498 + 1;
        code = code.8499;
        *code.8498 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              D.51512 = i + 1;
              D.51513 = D.51512 * 4;
              imb.val = D.51513;
              code.8240 = code;
              code.8500 = code.8240;
              code.8501 = code.8500 + 1;
              code = code.8501;
              D.51531 = imb.b[0];
              *code.8500 = D.51531;
              code.8240 = code;
              code.8502 = code.8240;
              code.8503 = code.8502 + 1;
              code = code.8503;
              D.51534 = imb.b[1];
              *code.8502 = D.51534;
              code.8240 = code;
              code.8504 = code.8240;
              code.8505 = code.8504 + 1;
              code = code.8505;
              D.51537 = imb.b[2];
              *code.8504 = D.51537;
              code.8240 = code;
              code.8506 = code.8240;
              code.8507 = code.8506 + 1;
              code = code.8507;
              D.51540 = imb.b[3];
              *code.8506 = D.51540;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51524>:
        <D.51511>:
        goto <D.29154>;
        <D.51504>:
        if (i == -1) goto <D.51541>; else goto <D.51542>;
        <D.51541>:
        code.8240 = code;
        code.8508 = code.8240;
        code.8509 = code.8508 + 1;
        code = code.8509;
        *code.8508 = 4;
        goto <D.29154>;
        <D.51542>:
        D.51512 = i + 1;
        D.51513 = D.51512 * 4;
        D.51514 = (unsigned int) D.51513;
        D.51515 = D.51514 + 128;
        if (D.51515 <= 255) goto <D.51545>; else goto <D.51546>;
        <D.51545>:
        code.8240 = code;
        code.8510 = code.8240;
        code.8511 = code.8510 + 1;
        code = code.8511;
        *code.8510 = 68;
        code.8240 = code;
        D.51512 = i + 1;
        D.51522 = (unsigned char) D.51512;
        D.51523 = D.51522 * 4;
        *code.8240 = D.51523;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51549>;
        <D.51546>:
        code.8240 = code;
        code.8512 = code.8240;
        code.8513 = code.8512 + 1;
        code = code.8513;
        *code.8512 = 132;
        {
          union x86_imm_buf imb;

          try
            {
              D.51512 = i + 1;
              D.51513 = D.51512 * 4;
              imb.val = D.51513;
              code.8240 = code;
              code.8514 = code.8240;
              code.8515 = code.8514 + 1;
              code = code.8515;
              D.51554 = imb.b[0];
              *code.8514 = D.51554;
              code.8240 = code;
              code.8516 = code.8240;
              code.8517 = code.8516 + 1;
              code = code.8517;
              D.51557 = imb.b[1];
              *code.8516 = D.51557;
              code.8240 = code;
              code.8518 = code.8240;
              code.8519 = code.8518 + 1;
              code = code.8519;
              D.51560 = imb.b[2];
              *code.8518 = D.51560;
              code.8240 = code;
              code.8520 = code.8240;
              code.8521 = code.8520 + 1;
              code = code.8521;
              D.51563 = imb.b[3];
              *code.8520 = D.51563;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51549>:
        <D.29154>:
        i = i + 1;
        <D.29157>:
        i.8522 = (unsigned int) i;
        if (i.8522 < param_count) goto <D.29156>; else goto <D.29158>;
        <D.29158>:
        code.8240 = code;
        code.8523 = code.8240;
        code.8524 = code.8523 + 1;
        code = code.8524;
        *code.8523 = 255;
        if (0 != 0) goto <D.51567>; else goto <D.51568>;
        <D.51567>:
        if (0 != 0) goto <D.51569>; else goto <D.51570>;
        <D.51569>:
        code.8240 = code;
        code.8525 = code.8240;
        code.8526 = code.8525 + 1;
        code = code.8526;
        *code.8525 = 36;
        code.8240 = code;
        code.8527 = code.8240;
        code.8528 = code.8527 + 1;
        code = code.8528;
        *code.8527 = 36;
        goto <D.51575>;
        <D.51570>:
        if (1 != 0) goto <D.51576>; else goto <D.51577>;
        <D.51576>:
        code.8240 = code;
        code.8529 = code.8240;
        code.8530 = code.8529 + 1;
        code = code.8530;
        *code.8529 = 100;
        code.8240 = code;
        code.8531 = code.8240;
        code.8532 = code.8531 + 1;
        code = code.8532;
        *code.8531 = 36;
        code.8240 = code;
        *code.8240 = 8;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51582>;
        <D.51577>:
        code.8240 = code;
        code.8533 = code.8240;
        code.8534 = code.8533 + 1;
        code = code.8534;
        *code.8533 = 164;
        code.8240 = code;
        code.8535 = code.8240;
        code.8536 = code.8535 + 1;
        code = code.8536;
        *code.8535 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 8;
              code.8240 = code;
              code.8537 = code.8240;
              code.8538 = code.8537 + 1;
              code = code.8538;
              D.51589 = imb.b[0];
              *code.8537 = D.51589;
              code.8240 = code;
              code.8539 = code.8240;
              code.8540 = code.8539 + 1;
              code = code.8540;
              D.51592 = imb.b[1];
              *code.8539 = D.51592;
              code.8240 = code;
              code.8541 = code.8240;
              code.8542 = code.8541 + 1;
              code = code.8542;
              D.51595 = imb.b[2];
              *code.8541 = D.51595;
              code.8240 = code;
              code.8543 = code.8240;
              code.8544 = code.8543 + 1;
              code = code.8544;
              D.51598 = imb.b[3];
              *code.8543 = D.51598;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51582>:
        <D.51575>:
        goto <D.29160>;
        <D.51568>:
        if (0 != 0) goto <D.51599>; else goto <D.51600>;
        <D.51599>:
        code.8240 = code;
        code.8545 = code.8240;
        code.8546 = code.8545 + 1;
        code = code.8546;
        *code.8545 = 33;
        goto <D.29160>;
        <D.51600>:
        if (1 != 0) goto <D.51603>; else goto <D.51604>;
        <D.51603>:
        code.8240 = code;
        code.8547 = code.8240;
        code.8548 = code.8547 + 1;
        code = code.8548;
        *code.8547 = 97;
        code.8240 = code;
        *code.8240 = 8;
        code.8240 = code;
        code.8255 = code.8240 + 1;
        code = code.8255;
        goto <D.51607>;
        <D.51604>:
        code.8240 = code;
        code.8549 = code.8240;
        code.8550 = code.8549 + 1;
        code = code.8550;
        *code.8549 = 161;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 8;
              code.8240 = code;
              code.8551 = code.8240;
              code.8552 = code.8551 + 1;
              code = code.8552;
              D.51612 = imb.b[0];
              *code.8551 = D.51612;
              code.8240 = code;
              code.8553 = code.8240;
              code.8554 = code.8553 + 1;
              code = code.8554;
              D.51615 = imb.b[1];
              *code.8553 = D.51615;
              code.8240 = code;
              code.8555 = code.8240;
              code.8556 = code.8555 + 1;
              code = code.8556;
              D.51618 = imb.b[2];
              *code.8555 = D.51618;
              code.8240 = code;
              code.8557 = code.8240;
              code.8558 = code.8557 + 1;
              code = code.8558;
              D.51621 = imb.b[3];
              *code.8557 = D.51621;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51607>:
        <D.29160>:
        code.8240 = code;
        code.8398 = (int) code.8240;
        start.8399 = start;
        start.8400 = (int) start.8399;
        D.51359 = code.8398 - start.8400;
        D.51360 = D.51359 >= code_reserve;
        D.51361 = (long int) D.51360;
        D.51362 = __builtin_expect (D.51361, 0);
        if (D.51362 != 0) goto <D.51622>; else goto <D.51623>;
        <D.51622>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 6261, "(code - start) < code_reserve");
        <D.51623>:
      }
      <D.51365>:
      nacl_global_codeman_validate (&start, code_reserve, &code);
      code.8240 = code;
      code.8398 = (int) code.8240;
      start.8399 = start;
      start.8400 = (int) start.8399;
      D.51359 = code.8398 - start.8400;
      start.8399 = start;
      mono_debug_add_delegate_trampoline (start.8399, D.51359);
      if (code_len != 0B) goto <D.51624>; else goto <D.51625>;
      <D.51624>:
      code.8240 = code;
      code.8398 = (int) code.8240;
      start.8399 = start;
      start.8400 = (int) start.8399;
      D.51359 = code.8398 - start.8400;
      D.51626 = (unsigned int) D.51359;
      *code_len = D.51626;
      <D.51625>:
      D.51627 = mono_jit_map_is_enabled ();
      if (D.51627 != 0) goto <D.51628>; else goto <D.51629>;
      <D.51628>:
      {
        char * buff;

        if (has_target != 0) goto <D.51630>; else goto <D.51631>;
        <D.51630>:
        buff = "delegate_invoke_has_target";
        goto <D.51632>;
        <D.51631>:
        buff = monoeg_g_strdup_printf ("delegate_invoke_no_target_%d", param_count);
        <D.51632>:
        code.8240 = code;
        code.8398 = (int) code.8240;
        start.8399 = start;
        start.8400 = (int) start.8399;
        D.51359 = code.8398 - start.8400;
        start.8399 = start;
        mono_emit_jit_tramp (start.8399, D.51359, buff);
        if (has_target == 0) goto <D.51633>; else goto <D.51634>;
        <D.51633>:
        monoeg_g_free (buff);
        <D.51634>:
      }
      <D.51629>:
      D.51635 = start;
      return D.51635;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_get_delegate_invoke_impl (struct MonoMethodSignature * sig, gboolean has_target)
{
  short unsigned int D.51638;
  void * D.51641;
  struct MonoType * D.51642;
  int D.51643;
  guint8 * cached.8559;
  int mono_aot_only.8560;
  struct MonoType * D.51656;
  int D.51657;
  int D.51660;
  unsigned int D.51666;
  guint8 * code;
  guint8 * start;

  D.51638 = sig->param_count;
  if (D.51638 > 10) goto <D.51639>; else goto <D.51640>;
  <D.51639>:
  D.51641 = 0B;
  return D.51641;
  <D.51640>:
  D.51642 = sig->ret;
  D.51643 = mono_type_is_struct (D.51642);
  if (D.51643 != 0) goto <D.51644>; else goto <D.51645>;
  <D.51644>:
  D.51641 = 0B;
  return D.51641;
  <D.51645>:
  if (has_target != 0) goto <D.51646>; else goto <D.51647>;
  <D.51646>:
  {
    static guint8 * cached = 0B;

    cached.8559 = cached;
    if (cached.8559 != 0B) goto <D.51649>; else goto <D.51650>;
    <D.51649>:
    D.51641 = cached;
    return D.51641;
    <D.51650>:
    mono_aot_only.8560 = mono_aot_only;
    if (mono_aot_only.8560 != 0) goto <D.51652>; else goto <D.51653>;
    <D.51652>:
    start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
    goto <D.51654>;
    <D.51653>:
    start = get_delegate_invoke_impl (1, 0, 0B);
    <D.51654>:
    mono_memory_barrier ();
    cached = start;
  }
  goto <D.51655>;
  <D.51647>:
  {
    static guint8 * cache[11] = {0B};
    int i;

    i = 0;
    i = 0;
    goto <D.29184>;
    <D.29183>:
    D.51656 = sig->params[i];
    D.51657 = mono_is_regsize_var (D.51656);
    if (D.51657 == 0) goto <D.51658>; else goto <D.51659>;
    <D.51658>:
    D.51641 = 0B;
    return D.51641;
    <D.51659>:
    i = i + 1;
    <D.29184>:
    D.51638 = sig->param_count;
    D.51660 = (int) D.51638;
    if (D.51660 > i) goto <D.29183>; else goto <D.29185>;
    <D.29185>:
    D.51638 = sig->param_count;
    D.51660 = (int) D.51638;
    code = cache[D.51660];
    if (code != 0B) goto <D.51661>; else goto <D.51662>;
    <D.51661>:
    D.51641 = code;
    return D.51641;
    <D.51662>:
    mono_aot_only.8560 = mono_aot_only;
    if (mono_aot_only.8560 != 0) goto <D.51663>; else goto <D.51664>;
    <D.51663>:
    {
      char * name;

      D.51638 = sig->param_count;
      D.51660 = (int) D.51638;
      name = monoeg_g_strdup_printf ("delegate_invoke_impl_target_%d", D.51660);
      start = mono_aot_get_trampoline (name);
      monoeg_g_free (name);
    }
    goto <D.51665>;
    <D.51664>:
    D.51638 = sig->param_count;
    D.51666 = (unsigned int) D.51638;
    start = get_delegate_invoke_impl (0, D.51666, 0B);
    <D.51665>:
    mono_memory_barrier ();
    D.51638 = sig->param_count;
    D.51660 = (int) D.51638;
    cache[D.51660] = start;
  }
  <D.51655>:
  D.51641 = start;
  return D.51641;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


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

  switch (reg) <default: <D.29199>, case 0: <D.29191>, case 1: <D.29193>, case 2: <D.29194>, case 3: <D.29192>, case 4: <D.29195>, case 5: <D.29196>, case 6: <D.29197>, case 7: <D.29198>>
  <D.29191>:
  D.51668 = ctx->eax;
  return D.51668;
  <D.29192>:
  D.51668 = ctx->ebx;
  return D.51668;
  <D.29193>:
  D.51668 = ctx->ecx;
  return D.51668;
  <D.29194>:
  D.51668 = ctx->edx;
  return D.51668;
  <D.29195>:
  D.51668 = ctx->esp;
  return D.51668;
  <D.29196>:
  D.51668 = ctx->ebp;
  return D.51668;
  <D.29197>:
  D.51668 = ctx->esi;
  return D.51668;
  <D.29198>:
  D.51668 = ctx->edi;
  return D.51668;
  <D.29199>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 6378);
  D.51668 = 0;
  return D.51668;
}


mono_arch_context_set_int_reg (struct MonoContext * ctx, int reg, mgreg_t val)
{
  switch (reg) <default: <D.29214>, case 0: <D.29205>, case 1: <D.29208>, case 2: <D.29209>, case 3: <D.29207>, case 4: <D.29210>, case 5: <D.29211>, case 6: <D.29212>, case 7: <D.29213>>
  <D.29205>:
  ctx->eax = val;
  goto <D.29206>;
  <D.29207>:
  ctx->ebx = val;
  goto <D.29206>;
  <D.29208>:
  ctx->ecx = val;
  goto <D.29206>;
  <D.29209>:
  ctx->edx = val;
  goto <D.29206>;
  <D.29210>:
  ctx->esp = val;
  goto <D.29206>;
  <D.29211>:
  ctx->ebp = val;
  goto <D.29206>;
  <D.29212>:
  ctx->esi = val;
  goto <D.29206>;
  <D.29213>:
  ctx->edi = val;
  goto <D.29206>;
  <D.29214>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-x86.c", 6412);
  <D.29206>:
}


mono_arch_decompose_opts (struct MonoCompile * cfg, struct MonoInst * ins)
{
  unsigned int D.51670;
  unsigned int D.51671;
  short unsigned int D.51674;
  struct MonoMemPool * D.51675;
  int D.51676;
  struct MonoInst * D.51677;
  int D.51678;
  int D.51679;
  const unsigned char * D.51680;
  int D.51681;
  unsigned int D.51682;
  int D.51683;
  struct MonoInst * D.51684;
  struct MonoBasicBlock * D.51685;
  int D.51686;
  int D.51687;
  struct MonoClass * D.51688;
  int D.51689;
  short unsigned int D.51690;
  struct MonoInst * fconv;
  int dreg;
  int src_opcode;

  D.51670 = BIT_FIELD_REF <*cfg, 32, 3104>;
  D.51671 = D.51670 & 75497472;
  if (D.51671 != 75497472) goto <D.51672>; else goto <D.51673>;
  <D.51672>:
  return;
  <D.51673>:
  D.51674 = ins->opcode;
  src_opcode = (int) D.51674;
  switch (src_opcode) <default: <D.29232>, case 681: <D.29225>, case 682: <D.29227>, case 683: <D.29229>, case 689: <D.29228>, case 690: <D.29226>, case 691: <D.29230>>
  <D.29225>:
  <D.29226>:
  <D.29227>:
  <D.29228>:
  <D.29229>:
  <D.29230>:
  goto <D.29231>;
  <D.29232>:
  return;
  <D.29231>:
  D.51675 = cfg->mempool;
  fconv = mono_mempool_alloc (D.51675, 48);
  fconv->data.op[1].const_val = 0;
  D.51676 = fconv->data.op[1].const_val;
  fconv->data.op[0].const_val = D.51676;
  fconv->prev = 0B;
  D.51677 = fconv->prev;
  fconv->next = D.51677;
  fconv->opcode = 944;
  fconv->flags = 0;
  fconv->type = 0;
  fconv->dreg = -1;
  fconv->sreg3 = -1;
  D.51678 = fconv->sreg3;
  fconv->sreg2 = D.51678;
  D.51679 = fconv->sreg2;
  fconv->sreg1 = D.51679;
  D.51680 = cfg->ip;
  fconv->cil_code = D.51680;
  fconv->klass = 0B;
  D.51681 = ins->sreg1;
  fconv->sreg1 = D.51681;
  D.51682 = mono_alloc_ireg (cfg);
  D.51683 = (int) D.51682;
  fconv->dreg = D.51683;
  fconv->type = 7;
  D.51684 = get_float_to_x_spill_area (cfg);
  fconv->backend.spill_var = D.51684;
  D.51685 = cfg->cbb;
  mono_bblock_insert_before_ins (D.51685, ins, fconv);
  dreg = ins->dreg;
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51686 = ins->sreg3;
  ins->sreg2 = D.51686;
  D.51687 = ins->sreg2;
  ins->sreg1 = D.51687;
  ins->opcode = 945;
  D.51688 = mono_defaults.int32_class;
  ins->klass = D.51688;
  D.51689 = fconv->dreg;
  ins->sreg1 = D.51689;
  ins->dreg = dreg;
  ins->type = 1;
  D.51690 = (short unsigned int) src_opcode;
  ins->backend.source_opcode = D.51690;
}


get_float_to_x_spill_area (struct MonoCompile * cfg)
{
  struct MonoInst * D.51694;
  struct MonoClass * D.51697;
  struct MonoType * D.51698;
  struct MonoInst * D.51699;
  unsigned char D.51700;
  unsigned char D.51701;
  struct MonoInst * D.51702;

  D.51694 = cfg->fconv_to_r8_x_var;
  if (D.51694 == 0B) goto <D.51695>; else goto <D.51696>;
  <D.51695>:
  D.51697 = mono_defaults.double_class;
  D.51698 = &D.51697->byval_arg;
  D.51699 = mono_compile_create_var (cfg, D.51698, 329);
  cfg->fconv_to_r8_x_var = D.51699;
  D.51694 = cfg->fconv_to_r8_x_var;
  D.51694 = cfg->fconv_to_r8_x_var;
  D.51700 = D.51694->flags;
  D.51701 = D.51700 | 4;
  D.51694->flags = D.51701;
  <D.51696>:
  D.51702 = cfg->fconv_to_r8_x_var;
  return D.51702;
}


mono_arch_decompose_long_opts (struct MonoCompile * cfg, struct MonoInst * long_ins)
{
  short unsigned int D.51704;
  struct MonoMemPool * D.51707;
  int D.51708;
  struct MonoInst * D.51709;
  int D.51710;
  int D.51711;
  const unsigned char * D.51712;
  int D.51713;
  int D.51714;
  int D.51715;
  int D.51716;
  struct MonoBasicBlock * D.51717;
  struct MonoInst * D.51718;
  int D.51722;
  struct MonoInst * D.51723;
  int D.51724;
  int D.51725;
  int D.51726;
  int D.51727;
  int D.51731;
  struct MonoInst * D.51732;
  int D.51733;
  int D.51734;
  int D.51738;
  int D.51739;
  unsigned int D.51740;
  unsigned int D.51741;
  int D.51744;
  int D.51745;
  int D.51748;
  struct MonoInst * D.51749;
  struct MonoClass * D.51750;
  int D.51751;
  unsigned int D.51752;
  struct MonoClass * D.51756;
  int D.51757;
  int D.51758;
  int iftmp.8561;
  unsigned int D.51766;
  int D.51770;
  int D.51774;
  int D.51775;
  int D.51776;
  int D.51780;
  int D.51781;
  int D.51785;
  int D.51789;
  struct MonoInst * ins;
  int vreg;

  D.51704 = long_ins->opcode;
  if (D.51704 == 496) goto <D.51705>; else goto <D.51706>;
  <D.51705>:
  ins = long_ins;
  {
    struct MonoInst * inst;

    D.51707 = cfg->mempool;
    inst = mono_mempool_alloc (D.51707, 48);
    inst->data.op[1].const_val = 0;
    D.51708 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51708;
    inst->prev = 0B;
    D.51709 = inst->prev;
    inst->next = D.51709;
    inst->opcode = 582;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51710 = inst->sreg3;
    inst->sreg2 = D.51710;
    D.51711 = inst->sreg2;
    inst->sreg1 = D.51711;
    D.51712 = cfg->ip;
    inst->cil_code = D.51712;
    D.51713 = ins->dreg;
    D.51714 = D.51713 + 1;
    inst->dreg = D.51714;
    D.51715 = ins->sreg1;
    D.51716 = D.51715 + 1;
    inst->sreg1 = D.51716;
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    if (D.51718 != 0B) goto <D.51719>; else goto <D.51720>;
    <D.51719>:
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    D.51718->next = inst;
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    inst->prev = D.51718;
    D.51717 = cfg->cbb;
    D.51717->last_ins = inst;
    goto <D.51721>;
    <D.51720>:
    D.51717 = cfg->cbb;
    D.51717 = cfg->cbb;
    D.51717->last_ins = inst;
    D.51718 = D.51717->last_ins;
    D.51717->code = D.51718;
    <D.51721>:
  }
  {
    struct MonoInst * inst;

    D.51707 = cfg->mempool;
    inst = mono_mempool_alloc (D.51707, 48);
    inst->data.op[1].const_val = 0;
    D.51722 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51722;
    inst->prev = 0B;
    D.51723 = inst->prev;
    inst->next = D.51723;
    inst->opcode = 756;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51724 = inst->sreg3;
    inst->sreg2 = D.51724;
    D.51725 = inst->sreg2;
    inst->sreg1 = D.51725;
    D.51712 = cfg->ip;
    inst->cil_code = D.51712;
    D.51713 = ins->dreg;
    D.51726 = D.51713 + 2;
    inst->dreg = D.51726;
    D.51715 = ins->sreg1;
    D.51727 = D.51715 + 2;
    inst->sreg1 = D.51727;
    inst->data.op[1].const_val = 0;
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    if (D.51718 != 0B) goto <D.51728>; else goto <D.51729>;
    <D.51728>:
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    D.51718->next = inst;
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    inst->prev = D.51718;
    D.51717 = cfg->cbb;
    D.51717->last_ins = inst;
    goto <D.51730>;
    <D.51729>:
    D.51717 = cfg->cbb;
    D.51717 = cfg->cbb;
    D.51717->last_ins = inst;
    D.51718 = D.51717->last_ins;
    D.51717->code = D.51718;
    <D.51730>:
  }
  {
    struct MonoInst * inst;

    D.51707 = cfg->mempool;
    inst = mono_mempool_alloc (D.51707, 48);
    inst->data.op[1].const_val = 0;
    D.51731 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.51731;
    inst->prev = 0B;
    D.51732 = inst->prev;
    inst->next = D.51732;
    inst->opcode = 582;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.51733 = inst->sreg3;
    inst->sreg2 = D.51733;
    D.51734 = inst->sreg2;
    inst->sreg1 = D.51734;
    D.51712 = cfg->ip;
    inst->cil_code = D.51712;
    D.51713 = ins->dreg;
    D.51726 = D.51713 + 2;
    inst->dreg = D.51726;
    D.51713 = ins->dreg;
    D.51726 = D.51713 + 2;
    inst->sreg1 = D.51726;
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    if (D.51718 != 0B) goto <D.51735>; else goto <D.51736>;
    <D.51735>:
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    D.51718->next = inst;
    D.51717 = cfg->cbb;
    D.51718 = D.51717->last_ins;
    inst->prev = D.51718;
    D.51717 = cfg->cbb;
    D.51717->last_ins = inst;
    goto <D.51737>;
    <D.51736>:
    D.51717 = cfg->cbb;
    D.51717 = cfg->cbb;
    D.51717->last_ins = inst;
    D.51718 = D.51717->last_ins;
    D.51717->code = D.51718;
    <D.51737>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  return;
  <D.51706>:
  D.51740 = cfg->opt;
  D.51741 = D.51740 & 67108864;
  if (D.51741 == 0) goto <D.51742>; else goto <D.51743>;
  <D.51742>:
  return;
  <D.51743>:
  D.51704 = long_ins->opcode;
  D.51744 = (int) D.51704;
  switch (D.51744) <default: <D.51796>, case 931: <D.29242>, case 943: <D.29244>, case 951: <D.29245>>
  <D.29242>:
  vreg = long_ins->sreg1;
  D.51745 = long_ins->data.op[0].const_val;
  if (D.51745 != 0) goto <D.51746>; else goto <D.51747>;
  <D.51746>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 825;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51750 = long_ins->klass;
  ins->klass = D.51750;
  D.51751 = long_ins->sreg1;
  ins->sreg1 = D.51751;
  ins->data.op[0].const_val = 2;
  ins->type = 7;
  D.51752 = alloc_ireg (cfg);
  vreg = (int) D.51752;
  ins->dreg = vreg;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51753>; else goto <D.51754>;
  <D.51753>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51755>;
  <D.51754>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51755>:
  <D.51747>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 924;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51756 = mono_defaults.int32_class;
  ins->klass = D.51756;
  ins->sreg1 = vreg;
  ins->type = 1;
  D.51757 = long_ins->dreg;
  D.51758 = D.51757 + 1;
  ins->dreg = D.51758;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51759>; else goto <D.51760>;
  <D.51759>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51761>;
  <D.51760>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51761>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 825;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51750 = long_ins->klass;
  ins->klass = D.51750;
  D.51751 = long_ins->sreg1;
  ins->sreg1 = D.51751;
  D.51745 = long_ins->data.op[0].const_val;
  if (D.51745 != 0) goto <D.51763>; else goto <D.51764>;
  <D.51763>:
  iftmp.8561 = 3;
  goto <D.51765>;
  <D.51764>:
  iftmp.8561 = 1;
  <D.51765>:
  ins->data.op[0].const_val = iftmp.8561;
  ins->type = 7;
  D.51766 = alloc_ireg (cfg);
  vreg = (int) D.51766;
  ins->dreg = vreg;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51767>; else goto <D.51768>;
  <D.51767>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51769>;
  <D.51768>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51769>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 924;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51756 = mono_defaults.int32_class;
  ins->klass = D.51756;
  ins->sreg1 = vreg;
  ins->type = 1;
  D.51757 = long_ins->dreg;
  D.51770 = D.51757 + 2;
  ins->dreg = D.51770;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51771>; else goto <D.51772>;
  <D.51771>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51773>;
  <D.51772>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51773>:
  long_ins->opcode = 316;
  goto <D.29243>;
  <D.29244>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 940;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51757 = long_ins->dreg;
  ins->dreg = D.51757;
  D.51757 = long_ins->dreg;
  ins->sreg1 = D.51757;
  D.51774 = long_ins->sreg2;
  D.51775 = D.51774 + 1;
  ins->sreg2 = D.51775;
  D.51745 = long_ins->data.op[0].const_val;
  D.51776 = D.51745 * 2;
  ins->data.op[0].const_val = D.51776;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51777>; else goto <D.51778>;
  <D.51777>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51779>;
  <D.51778>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51779>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 940;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51757 = long_ins->dreg;
  ins->dreg = D.51757;
  D.51757 = long_ins->dreg;
  ins->sreg1 = D.51757;
  D.51774 = long_ins->sreg2;
  D.51780 = D.51774 + 2;
  ins->sreg2 = D.51780;
  D.51745 = long_ins->data.op[0].const_val;
  D.51776 = D.51745 * 2;
  D.51781 = D.51776 + 1;
  ins->data.op[0].const_val = D.51781;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51782>; else goto <D.51783>;
  <D.51782>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51784>;
  <D.51783>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51784>:
  long_ins->opcode = 316;
  goto <D.29243>;
  <D.29245>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 946;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51757 = long_ins->dreg;
  ins->dreg = D.51757;
  D.51751 = long_ins->sreg1;
  D.51785 = D.51751 + 1;
  ins->sreg1 = D.51785;
  D.51750 = long_ins->klass;
  ins->klass = D.51750;
  ins->type = 7;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51786>; else goto <D.51787>;
  <D.51786>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51788>;
  <D.51787>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51788>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 940;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51757 = long_ins->dreg;
  ins->dreg = D.51757;
  D.51757 = long_ins->dreg;
  ins->sreg1 = D.51757;
  D.51751 = long_ins->sreg1;
  D.51789 = D.51751 + 2;
  ins->sreg2 = D.51789;
  ins->data.op[0].const_val = 1;
  D.51750 = long_ins->klass;
  ins->klass = D.51750;
  ins->type = 7;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51790>; else goto <D.51791>;
  <D.51790>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51792>;
  <D.51791>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51792>:
  D.51707 = cfg->mempool;
  ins = mono_mempool_alloc (D.51707, 48);
  ins->data.op[1].const_val = 0;
  D.51748 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.51748;
  ins->prev = 0B;
  D.51749 = ins->prev;
  ins->next = D.51749;
  ins->opcode = 825;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.51738 = ins->sreg3;
  ins->sreg2 = D.51738;
  D.51739 = ins->sreg2;
  ins->sreg1 = D.51739;
  D.51712 = cfg->ip;
  ins->cil_code = D.51712;
  D.51757 = long_ins->dreg;
  ins->dreg = D.51757;
  D.51757 = long_ins->dreg;
  ins->sreg1 = D.51757;
  ins->data.op[0].const_val = 68;
  D.51750 = long_ins->klass;
  ins->klass = D.51750;
  ins->type = 7;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  if (D.51718 != 0B) goto <D.51793>; else goto <D.51794>;
  <D.51793>:
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  D.51718->next = ins;
  D.51717 = cfg->cbb;
  D.51718 = D.51717->last_ins;
  ins->prev = D.51718;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  goto <D.51795>;
  <D.51794>:
  D.51717 = cfg->cbb;
  D.51717 = cfg->cbb;
  D.51717->last_ins = ins;
  D.51718 = D.51717->last_ins;
  D.51717->code = D.51718;
  <D.51795>:
  long_ins->opcode = 316;
  goto <D.29243>;
  <D.51796>:
  <D.29243>:
}


mono_arch_install_handler_block_guard (struct MonoJitInfo * ji, struct MonoJitExceptionInfo * clause, struct MonoContext * ctx, void * new_value)
{
  unsigned char D.51798;
  void * D.51801;
  signed char * D.51804;
  signed char D.51805;
  int D.51810;
  sizetype offset.8562;
  void * * D.51812;
  void * D.51815;
  int D.51817;
  sizetype D.51818;
  char * D.51819;
  int offset;
  void * * sp;
  void * old_value;
  char * bp;
  const unsigned char * handler;

  handler = clause->handler_start;
  D.51798 = *handler;
  if (D.51798 != 137) goto <D.51799>; else goto <D.51800>;
  <D.51799>:
  D.51801 = 0B;
  return D.51801;
  <D.51800>:
  handler = handler + 1;
  D.51798 = *handler;
  if (D.51798 == 101) goto <D.51802>; else goto <D.51803>;
  <D.51802>:
  D.51804 = handler + 1;
  D.51805 = *D.51804;
  offset = (int) D.51805;
  goto <D.51806>;
  <D.51803>:
  D.51798 = *handler;
  if (D.51798 == 165) goto <D.51807>; else goto <D.51808>;
  <D.51807>:
  offset = MEM[(int *)handler + 1B];
  goto <D.51809>;
  <D.51808>:
  D.51801 = 0B;
  return D.51801;
  <D.51809>:
  <D.51806>:
  D.51810 = ctx->ebp;
  bp = (char *) D.51810;
  offset.8562 = (sizetype) offset;
  D.51812 = bp + offset.8562;
  sp = *D.51812;
  old_value = *sp;
  D.51815 = ji->code_start;
  if (D.51815 > old_value) goto <D.51813>; else goto <D.51816>;
  <D.51816>:
  D.51815 = ji->code_start;
  D.51817 = ji->code_size;
  D.51818 = (sizetype) D.51817;
  D.51819 = D.51815 + D.51818;
  if (D.51819 < old_value) goto <D.51813>; else goto <D.51814>;
  <D.51813>:
  D.51801 = old_value;
  return D.51801;
  <D.51814>:
  *sp = new_value;
  D.51801 = old_value;
  return D.51801;
}


mono_arch_emit_load_got_addr (guint8 * start, guint8 * code, struct MonoCompile * cfg, struct MonoJumpInfo * * ji)
{
  guint8 * code.8563;
  guint8 * code.8564;
  unsigned char D.51823;
  guint8 * code.8565;
  unsigned char D.51825;
  guint8 * code.8566;
  unsigned char D.51827;
  guint8 * code.8567;
  unsigned char D.51829;
  int code.8568;
  unsigned char * D.51833;
  int D.51834;
  int D.51835;
  int start.8569;
  int D.51838;
  struct MonoJumpInfo * D.51839;
  struct MonoJumpInfo * D.51840;
  guint8 * code.8570;
  guint8 * code.8571;
  guint8 * code.8572;
  unsigned char D.51846;
  guint8 * code.8573;
  unsigned char D.51848;
  guint8 * code.8574;
  unsigned char D.51850;
  guint8 * code.8575;
  unsigned char D.51852;
  guint8 * code.8576;
  guint8 * code.8577;
  guint8 * code.8578;
  guint8 * code.8579;
  guint8 * code.8580;
  unsigned char D.51861;
  guint8 * code.8581;
  unsigned char D.51863;
  guint8 * code.8582;
  unsigned char D.51865;
  guint8 * code.8583;
  unsigned char D.51867;
  guint8 * D.51868;

  code.8563 = code;
  code = code.8563 + 1;
  *code.8563 = 232;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8564 = code;
        code = code.8564 + 1;
        D.51823 = imb.b[0];
        *code.8564 = D.51823;
        code.8565 = code;
        code = code.8565 + 1;
        D.51825 = imb.b[1];
        *code.8565 = D.51825;
        code.8566 = code;
        code = code.8566 + 1;
        D.51827 = imb.b[2];
        *code.8566 = D.51827;
        code.8567 = code;
        code = code.8567 + 1;
        D.51829 = imb.b[3];
        *code.8567 = D.51829;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  if (cfg != 0B) goto <D.51830>; else goto <D.51831>;
  <D.51830>:
  code.8568 = (int) code;
  D.51833 = cfg->native_code;
  D.51834 = (int) D.51833;
  D.51835 = code.8568 - D.51834;
  mono_add_patch_info (cfg, D.51835, 27, 0B);
  goto <D.51836>;
  <D.51831>:
  code.8568 = (int) code;
  start.8569 = (int) start;
  D.51838 = code.8568 - start.8569;
  D.51839 = *ji;
  D.51840 = mono_patch_info_list_prepend (D.51839, D.51838, 27, 0B);
  *ji = D.51840;
  <D.51836>:
  code.8570 = code;
  code = code.8570 + 1;
  *code.8570 = 91;
  if (0 != 0) goto <D.51842>; else goto <D.51843>;
  <D.51842>:
  code.8571 = code;
  code = code.8571 + 1;
  *code.8571 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.8572 = code;
        code = code.8572 + 1;
        D.51846 = imb.b[0];
        *code.8572 = D.51846;
        code.8573 = code;
        code = code.8573 + 1;
        D.51848 = imb.b[1];
        *code.8573 = D.51848;
        code.8574 = code;
        code = code.8574 + 1;
        D.51850 = imb.b[2];
        *code.8574 = D.51850;
        code.8575 = code;
        code = code.8575 + 1;
        D.51852 = imb.b[3];
        *code.8575 = D.51852;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.29265>;
  <D.51843>:
  if (0 != 0) goto <D.51853>; else goto <D.51854>;
  <D.51853>:
  code.8576 = code;
  code = code.8576 + 1;
  *code.8576 = 131;
  code.8577 = code;
  code = code.8577 + 1;
  *code.8577 = 195;
  *code = 240;
  code = code + 1;
  goto <D.51857>;
  <D.51854>:
  code.8578 = code;
  code = code.8578 + 1;
  *code.8578 = 129;
  code.8579 = code;
  code = code.8579 + 1;
  *code.8579 = 195;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.8580 = code;
        code = code.8580 + 1;
        D.51861 = imb.b[0];
        *code.8580 = D.51861;
        code.8581 = code;
        code = code.8581 + 1;
        D.51863 = imb.b[1];
        *code.8581 = D.51863;
        code.8582 = code;
        code = code.8582 + 1;
        D.51865 = imb.b[2];
        *code.8582 = D.51865;
        code.8583 = code;
        code = code.8583 + 1;
        D.51867 = imb.b[3];
        *code.8583 = D.51867;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51857>:
  <D.29265>:
  D.51868 = code;
  return D.51868;
}


mono_arch_emit_load_aotconst (guint8 * start, guint8 * code, struct MonoJumpInfo * * ji, int tramp_type, const void * target)
{
  guint8 * code.8584;
  guint8 * code.8585;
  guint8 * code.8586;
  guint8 * code.8587;
  guint8 * code.8588;
  guint8 * code.8589;
  guint8 * code.8590;
  guint8 * code.8591;
  guint8 * code.8592;
  guint8 * code.8593;
  unsigned char D.51888;
  guint8 * code.8594;
  unsigned char D.51890;
  guint8 * code.8595;
  unsigned char D.51892;
  guint8 * code.8596;
  unsigned char D.51894;
  guint8 * code.8597;
  guint8 * code.8598;
  guint8 * code.8599;
  guint8 * code.8600;
  unsigned char D.51904;
  guint8 * code.8601;
  unsigned char D.51906;
  guint8 * code.8602;
  unsigned char D.51908;
  guint8 * code.8603;
  unsigned char D.51910;
  <unnamed type> tramp_type.8604;
  int code.8605;
  int start.8606;
  int D.51914;
  struct MonoJumpInfo * D.51915;
  struct MonoJumpInfo * D.51916;
  guint8 * code.8607;
  guint8 * code.8608;
  guint8 * code.8609;
  guint8 * code.8610;
  guint8 * code.8611;
  guint8 * code.8612;
  guint8 * code.8613;
  guint8 * code.8614;
  guint8 * code.8615;
  guint8 * code.8616;
  unsigned char D.51935;
  guint8 * code.8617;
  unsigned char D.51937;
  guint8 * code.8618;
  unsigned char D.51939;
  guint8 * code.8619;
  unsigned char D.51941;
  guint8 * code.8620;
  guint8 * code.8621;
  guint8 * code.8622;
  guint8 * code.8623;
  unsigned char D.51951;
  guint8 * code.8624;
  unsigned char D.51953;
  guint8 * code.8625;
  unsigned char D.51955;
  guint8 * code.8626;
  unsigned char D.51957;
  guint8 * D.51958;
  static const char __PRETTY_FUNCTION__[29] = "mono_arch_emit_load_aotconst";

  switch (4) <default: <D.29296>, case 1: <D.29292>, case 2: <D.29294>, case 4: <D.29295>>
  <D.29292>:
  code.8584 = code;
  code = code.8584 + 1;
  *code.8584 = 138;
  goto <D.29293>;
  <D.29294>:
  code.8585 = code;
  code = code.8585 + 1;
  *code.8585 = 102;
  <D.29295>:
  code.8586 = code;
  code = code.8586 + 1;
  *code.8586 = 139;
  goto <D.29293>;
  <D.29296>:
  __assert_fail ("0", "mini-x86.c", 6673, &__PRETTY_FUNCTION__);
  <D.29293>:
  if (0 != 0) goto <D.51873>; else goto <D.51874>;
  <D.51873>:
  if (0 != 0) goto <D.51875>; else goto <D.51876>;
  <D.51875>:
  code.8587 = code;
  code = code.8587 + 1;
  *code.8587 = 4;
  code.8588 = code;
  code = code.8588 + 1;
  *code.8588 = 36;
  goto <D.51879>;
  <D.51876>:
  if (1 != 0) goto <D.51880>; else goto <D.51881>;
  <D.51880>:
  code.8589 = code;
  code = code.8589 + 1;
  *code.8589 = 68;
  code.8590 = code;
  code = code.8590 + 1;
  *code.8590 = 36;
  *code = 4;
  code = code + 1;
  goto <D.51884>;
  <D.51881>:
  code.8591 = code;
  code = code.8591 + 1;
  *code.8591 = 132;
  code.8592 = code;
  code = code.8592 + 1;
  *code.8592 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.8593 = code;
        code = code.8593 + 1;
        D.51888 = imb.b[0];
        *code.8593 = D.51888;
        code.8594 = code;
        code = code.8594 + 1;
        D.51890 = imb.b[1];
        *code.8594 = D.51890;
        code.8595 = code;
        code = code.8595 + 1;
        D.51892 = imb.b[2];
        *code.8595 = D.51892;
        code.8596 = code;
        code = code.8596 + 1;
        D.51894 = imb.b[3];
        *code.8596 = D.51894;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51884>:
  <D.51879>:
  goto <D.29299>;
  <D.51874>:
  if (0 != 0) goto <D.51895>; else goto <D.51896>;
  <D.51895>:
  code.8597 = code;
  code = code.8597 + 1;
  *code.8597 = 3;
  goto <D.29299>;
  <D.51896>:
  if (1 != 0) goto <D.51898>; else goto <D.51899>;
  <D.51898>:
  code.8598 = code;
  code = code.8598 + 1;
  *code.8598 = 67;
  *code = 4;
  code = code + 1;
  goto <D.51901>;
  <D.51899>:
  code.8599 = code;
  code = code.8599 + 1;
  *code.8599 = 131;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 4;
        code.8600 = code;
        code = code.8600 + 1;
        D.51904 = imb.b[0];
        *code.8600 = D.51904;
        code.8601 = code;
        code = code.8601 + 1;
        D.51906 = imb.b[1];
        *code.8601 = D.51906;
        code.8602 = code;
        code = code.8602 + 1;
        D.51908 = imb.b[2];
        *code.8602 = D.51908;
        code.8603 = code;
        code = code.8603 + 1;
        D.51910 = imb.b[3];
        *code.8603 = D.51910;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51901>:
  <D.29299>:
  tramp_type.8604 = (<unnamed type>) tramp_type;
  code.8605 = (int) code;
  start.8606 = (int) start;
  D.51914 = code.8605 - start.8606;
  D.51915 = *ji;
  D.51916 = mono_patch_info_list_prepend (D.51915, D.51914, tramp_type.8604, target);
  *ji = D.51916;
  switch (4) <default: <D.29305>, case 1: <D.29301>, case 2: <D.29303>, case 4: <D.29304>>
  <D.29301>:
  code.8607 = code;
  code = code.8607 + 1;
  *code.8607 = 138;
  goto <D.29302>;
  <D.29303>:
  code.8608 = code;
  code = code.8608 + 1;
  *code.8608 = 102;
  <D.29304>:
  code.8609 = code;
  code = code.8609 + 1;
  *code.8609 = 139;
  goto <D.29302>;
  <D.29305>:
  __assert_fail ("0", "mini-x86.c", 6676, &__PRETTY_FUNCTION__);
  <D.29302>:
  if (0 != 0) goto <D.51920>; else goto <D.51921>;
  <D.51920>:
  if (0 != 0) goto <D.51922>; else goto <D.51923>;
  <D.51922>:
  code.8610 = code;
  code = code.8610 + 1;
  *code.8610 = 4;
  code.8611 = code;
  code = code.8611 + 1;
  *code.8611 = 36;
  goto <D.51926>;
  <D.51923>:
  if (0 != 0) goto <D.51927>; else goto <D.51928>;
  <D.51927>:
  code.8612 = code;
  code = code.8612 + 1;
  *code.8612 = 68;
  code.8613 = code;
  code = code.8613 + 1;
  *code.8613 = 36;
  *code = 240;
  code = code + 1;
  goto <D.51931>;
  <D.51928>:
  code.8614 = code;
  code = code.8614 + 1;
  *code.8614 = 132;
  code.8615 = code;
  code = code.8615 + 1;
  *code.8615 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.8616 = code;
        code = code.8616 + 1;
        D.51935 = imb.b[0];
        *code.8616 = D.51935;
        code.8617 = code;
        code = code.8617 + 1;
        D.51937 = imb.b[1];
        *code.8617 = D.51937;
        code.8618 = code;
        code = code.8618 + 1;
        D.51939 = imb.b[2];
        *code.8618 = D.51939;
        code.8619 = code;
        code = code.8619 + 1;
        D.51941 = imb.b[3];
        *code.8619 = D.51941;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51931>:
  <D.51926>:
  goto <D.29307>;
  <D.51921>:
  if (0 != 0) goto <D.51942>; else goto <D.51943>;
  <D.51942>:
  code.8620 = code;
  code = code.8620 + 1;
  *code.8620 = 0;
  goto <D.29307>;
  <D.51943>:
  if (0 != 0) goto <D.51945>; else goto <D.51946>;
  <D.51945>:
  code.8621 = code;
  code = code.8621 + 1;
  *code.8621 = 64;
  *code = 240;
  code = code + 1;
  goto <D.51948>;
  <D.51946>:
  code.8622 = code;
  code = code.8622 + 1;
  *code.8622 = 128;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -252645136;
        code.8623 = code;
        code = code.8623 + 1;
        D.51951 = imb.b[0];
        *code.8623 = D.51951;
        code.8624 = code;
        code = code.8624 + 1;
        D.51953 = imb.b[1];
        *code.8624 = D.51953;
        code.8625 = code;
        code = code.8625 + 1;
        D.51955 = imb.b[2];
        *code.8625 = D.51955;
        code.8626 = code;
        code = code.8626 + 1;
        D.51957 = imb.b[3];
        *code.8626 = D.51957;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51948>:
  <D.29307>:
  D.51958 = code;
  return D.51958;
}


mono_arch_get_trampolines (gboolean aot)
{
  struct MonoTrampInfo * info.8627;
  struct GSList * D.51961;
  struct MonoTrampInfo * info;
  struct GSList * tramps;

  try
    {
      tramps = 0B;
      mono_x86_get_signal_exception_trampoline (&info, aot);
      info.8627 = info;
      tramps = monoeg_g_slist_append (tramps, info.8627);
      D.51961 = tramps;
      return D.51961;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_arch_set_breakpoint (struct MonoJitInfo * ji, guint8 * ip)
{
  unsigned char D.51964;
  _Bool D.51965;
  long int D.51966;
  long int D.51967;
  guint8 * code.8628;
  guint8 * code.8629;
  void * bp_trigger_page.8630;
  int bp_trigger_page.8631;
  guint8 * code.8632;
  unsigned char D.51975;
  guint8 * code.8633;
  unsigned char D.51977;
  guint8 * code.8634;
  unsigned char D.51979;
  guint8 * code.8635;
  unsigned char D.51981;
  guint8 * code;

  code = ip;
  D.51964 = *code;
  D.51965 = D.51964 != 144;
  D.51966 = (long int) D.51965;
  D.51967 = __builtin_expect (D.51966, 0);
  if (D.51967 != 0) goto <D.51968>; else goto <D.51969>;
  <D.51968>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-x86.c", 6724, "code [0] == 0x90");
  <D.51969>:
  code.8628 = code;
  code = code.8628 + 1;
  *code.8628 = 59;
  code.8629 = code;
  code = code.8629 + 1;
  *code.8629 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        bp_trigger_page.8630 = bp_trigger_page;
        bp_trigger_page.8631 = (int) bp_trigger_page.8630;
        imb.val = bp_trigger_page.8631;
        code.8632 = code;
        code = code.8632 + 1;
        D.51975 = imb.b[0];
        *code.8632 = D.51975;
        code.8633 = code;
        code = code.8633 + 1;
        D.51977 = imb.b[1];
        *code.8633 = D.51977;
        code.8634 = code;
        code = code.8634 + 1;
        D.51979 = imb.b[2];
        *code.8634 = D.51979;
        code.8635 = code;
        code = code.8635 + 1;
        D.51981 = imb.b[3];
        *code.8635 = D.51981;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
}


mono_arch_clear_breakpoint (struct MonoJitInfo * ji, guint8 * ip)
{
  guint8 * code.8636;
  guint8 * code;
  int i;

  code = ip;
  i = 0;
  goto <D.29330>;
  <D.29329>:
  code.8636 = code;
  code = code.8636 + 1;
  *code.8636 = 144;
  i = i + 1;
  <D.29330>:
  if (i <= 5) goto <D.29329>; else goto <D.29331>;
  <D.29331>:
}


mono_arch_start_single_stepping ()
{
  int D.51983;
  unsigned int D.51984;
  void * ss_trigger_page.8637;

  D.51983 = mono_pagesize ();
  D.51984 = (unsigned int) D.51983;
  ss_trigger_page.8637 = ss_trigger_page;
  mono_mprotect (ss_trigger_page.8637, D.51984, 0);
}


mono_arch_stop_single_stepping ()
{
  int D.51986;
  unsigned int D.51987;
  void * ss_trigger_page.8638;

  D.51986 = mono_pagesize ();
  D.51987 = (unsigned int) D.51986;
  ss_trigger_page.8638 = ss_trigger_page;
  mono_mprotect (ss_trigger_page.8638, D.51987, 1);
}


mono_arch_is_single_step_event (void * info, void * sigctx)
{
  int D.51990;
  void * D.51992;
  void * ss_trigger_page.8639;
  guint8 * D.51995;
  gboolean D.51997;
  struct siginfo_t * sinfo;

  sinfo = info;
  D.51990 = sinfo->si_signo;
  if (D.51990 == 11) goto <D.51991>; else goto <D.51989>;
  <D.51991>:
  D.51992 = sinfo->_sifields._sigfault.si_addr;
  ss_trigger_page.8639 = ss_trigger_page;
  if (D.51992 >= ss_trigger_page.8639) goto <D.51994>; else goto <D.51989>;
  <D.51994>:
  D.51992 = sinfo->_sifields._sigfault.si_addr;
  ss_trigger_page.8639 = ss_trigger_page;
  D.51995 = ss_trigger_page.8639 + 128;
  if (D.51992 <= D.51995) goto <D.51996>; else goto <D.51989>;
  <D.51996>:
  D.51997 = 1;
  return D.51997;
  <D.51989>:
  D.51997 = 0;
  return D.51997;
}


mono_arch_is_breakpoint_event (void * info, void * sigctx)
{
  int D.52000;
  void * D.52002;
  void * bp_trigger_page.8640;
  guint8 * D.52005;
  gboolean D.52007;
  struct siginfo_t * sinfo;

  sinfo = info;
  D.52000 = sinfo->si_signo;
  if (D.52000 == 11) goto <D.52001>; else goto <D.51999>;
  <D.52001>:
  D.52002 = sinfo->_sifields._sigfault.si_addr;
  bp_trigger_page.8640 = bp_trigger_page;
  if (D.52002 >= bp_trigger_page.8640) goto <D.52004>; else goto <D.51999>;
  <D.52004>:
  D.52002 = sinfo->_sifields._sigfault.si_addr;
  bp_trigger_page.8640 = bp_trigger_page;
  D.52005 = bp_trigger_page.8640 + 128;
  if (D.52002 <= D.52005) goto <D.52006>; else goto <D.51999>;
  <D.52006>:
  D.52007 = 1;
  return D.52007;
  <D.51999>:
  D.52007 = 0;
  return D.52007;
}


mono_arch_skip_breakpoint (struct MonoContext * ctx, struct MonoJitInfo * ji)
{
  int D.52009;
  sizetype D.52010;
  sizetype D.52011;
  int D.52012;

  D.52009 = ctx->eip;
  D.52010 = (sizetype) D.52009;
  D.52011 = D.52010 + 6;
  D.52012 = (int) D.52011;
  ctx->eip = D.52012;
}


mono_arch_skip_single_step (struct MonoContext * ctx)
{
  int D.52013;
  sizetype D.52014;
  sizetype D.52015;
  int D.52016;

  D.52013 = ctx->eip;
  D.52014 = (sizetype) D.52013;
  D.52015 = D.52014 + 6;
  D.52016 = (int) D.52015;
  ctx->eip = D.52016;
}


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

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


mono_arch_init_lmf_ext (struct MonoLMFExt * ext, void * prev_lmf)
{
  unsigned int prev_lmf.8641;
  unsigned int D.52020;
  int D.52021;
  int D.52022;
  unsigned int D.52023;
  unsigned int ext.8642;

  prev_lmf.8641 = (unsigned int) prev_lmf;
  ext->lmf.previous_lmf = prev_lmf.8641;
  D.52020 = ext->lmf.previous_lmf;
  D.52021 = (int) D.52020;
  D.52022 = D.52021 | 2;
  D.52023 = (unsigned int) D.52022;
  ext->lmf.previous_lmf = D.52023;
  ext.8642 = (unsigned int) ext;
  ext->lmf.ebp = ext.8642;
}