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

  switch (reg) <default: <D.29239>, case 0: <D.24004>, case 1: <D.24006>, case 2: <D.24007>, case 3: <D.24005>, case 4: <D.24008>, case 5: <D.24009>, case 6: <D.24011>, case 7: <D.24010>, case 8: <D.24012>, case 9: <D.24013>, case 10: <D.24014>, case 11: <D.24015>, case 12: <D.24016>, case 13: <D.24017>, case 14: <D.24018>, case 15: <D.24019>>
  <D.24004>:
  D.29238 = "%rax";
  return D.29238;
  <D.24005>:
  D.29238 = "%rbx";
  return D.29238;
  <D.24006>:
  D.29238 = "%rcx";
  return D.29238;
  <D.24007>:
  D.29238 = "%rdx";
  return D.29238;
  <D.24008>:
  D.29238 = "%rsp";
  return D.29238;
  <D.24009>:
  D.29238 = "%rbp";
  return D.29238;
  <D.24010>:
  D.29238 = "%rdi";
  return D.29238;
  <D.24011>:
  D.29238 = "%rsi";
  return D.29238;
  <D.24012>:
  D.29238 = "%r8";
  return D.29238;
  <D.24013>:
  D.29238 = "%r9";
  return D.29238;
  <D.24014>:
  D.29238 = "%r10";
  return D.29238;
  <D.24015>:
  D.29238 = "%r11";
  return D.29238;
  <D.24016>:
  D.29238 = "%r12";
  return D.29238;
  <D.24017>:
  D.29238 = "%r13";
  return D.29238;
  <D.24018>:
  D.29238 = "%r14";
  return D.29238;
  <D.24019>:
  D.29238 = "%r15";
  return D.29238;
  <D.29239>:
  D.29238 = "unknown";
  return D.29238;
}


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

  if (reg <= 15) goto <D.29241>; else goto <D.29242>;
  <D.29241>:
  D.29243 = single_xmmregs[reg];
  return D.29243;
  <D.29242>:
  D.29243 = "unknown";
  return D.29243;
}


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

  if (reg <= 15) goto <D.29245>; else goto <D.29246>;
  <D.29245>:
  D.29247 = packed_xmmregs[reg];
  return D.29247;
  <D.29246>:
  D.29247 = "unknown";
  return D.29247;
}


mono_amd64_patch (unsigned char * code, void * target)
{
  amd64_patch (code, target);
}


amd64_patch (unsigned char * code, void * target)
{
  unsigned char D.29249;
  unsigned char D.29250;
  int D.29253;
  int D.29254;
  guint64 * D.29257;
  long unsigned int target.0;
  unsigned char * D.29264;
  unsigned char D.29265;
  unsigned char D.29266;
  int D.29268;
  int D.29269;
  guint32 * D.29271;
  long int target.1;
  unsigned int D.29273;
  unsigned int D.29274;
  long int code.2;
  unsigned long disp.3;
  unsigned long D.29283;
  _Bool D.29284;
  long int D.29285;
  long int D.29286;
  unsigned char D.29289;
  unsigned char D.29290;
  long int pos.4;
  long int D.29294;
  int D.29297;
  unsigned char * pos.5;
  unsigned char D.29299;
  unsigned char * pos.6;
  unsigned char D.29301;
  unsigned char * pos.7;
  unsigned char D.29303;
  unsigned char * pos.8;
  unsigned char D.29305;
  unsigned int disp.9;
  unsigned int D.29308;
  unsigned char D.29311;
  unsigned char D.29312;
  unsigned char D.29315;
  unsigned char D.29316;
  long int pos.10;
  long int D.29320;
  int D.29323;
  unsigned char * pos.11;
  unsigned char D.29325;
  unsigned char * pos.12;
  unsigned char D.29327;
  unsigned char * pos.13;
  unsigned char D.29329;
  unsigned char * pos.14;
  unsigned char D.29331;
  unsigned int disp.15;
  unsigned int D.29334;
  unsigned char D.29337;
  unsigned char D.29338;
  guint8 rex;
  static const char __PRETTY_FUNCTION__[12] = "amd64_patch";

  rex = 0;
  D.29249 = *code;
  D.29250 = D.29249 + 192;
  if (D.29250 <= 15) goto <D.29251>; else goto <D.29252>;
  <D.29251>:
  rex = *code;
  code = code + 1;
  <D.29252>:
  D.29249 = *code;
  D.29253 = (int) D.29249;
  D.29254 = D.29253 & 248;
  if (D.29254 == 184) goto <D.29255>; else goto <D.29256>;
  <D.29255>:
  D.29257 = code + 1;
  target.0 = (long unsigned int) target;
  *D.29257 = target.0;
  goto <D.29259>;
  <D.29256>:
  D.29249 = *code;
  if (D.29249 == 139) goto <D.29262>; else goto <D.29260>;
  <D.29262>:
  if (rex != 0) goto <D.29263>; else goto <D.29260>;
  <D.29263>:
  D.29264 = code + 1;
  D.29265 = *D.29264;
  D.29266 = D.29265 >> 6;
  if (D.29266 == 0) goto <D.29267>; else goto <D.29260>;
  <D.29267>:
  D.29264 = code + 1;
  D.29265 = *D.29264;
  D.29268 = (int) D.29265;
  D.29269 = D.29268 & 7;
  if (D.29269 == 5) goto <D.29270>; else goto <D.29260>;
  <D.29270>:
  D.29271 = code + 2;
  target.1 = (long int) target;
  D.29273 = (unsigned int) target.1;
  D.29274 = D.29273 + 4294967289;
  *D.29271 = D.29274;
  goto <D.29261>;
  <D.29260>:
  D.29249 = *code;
  if (D.29249 == 255) goto <D.29277>; else goto <D.29275>;
  <D.29277>:
  D.29264 = code + 1;
  D.29265 = *D.29264;
  if (D.29265 == 21) goto <D.29278>; else goto <D.29275>;
  <D.29278>:
  D.29271 = code + 2;
  target.1 = (long int) target;
  D.29273 = (unsigned int) target.1;
  D.29274 = D.29273 + 4294967289;
  *D.29271 = D.29274;
  goto <D.29276>;
  <D.29275>:
  D.29249 = *code;
  if (D.29249 == 232) goto <D.29279>; else goto <D.29280>;
  <D.29279>:
  {
    gint64 disp;

    target.1 = (long int) target;
    code.2 = (long int) code;
    disp = target.1 - code.2;
    disp.3 = (unsigned long) disp;
    D.29283 = disp.3 + 2147483648;
    D.29284 = D.29283 > 4294967295;
    D.29285 = (long int) D.29284;
    D.29286 = __builtin_expect (D.29285, 0);
    if (D.29286 != 0) goto <D.29287>; else goto <D.29288>;
    <D.29287>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 488, "amd64_is_imm32 (disp)");
    <D.29288>:
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = code + 1;
      size = 0;
      D.29249 = *code;
      D.29253 = (int) D.29249;
      switch (D.29253) <default: <D.24068>, case 15: <D.24046>, case 112: <D.24052>, case 113: <D.24053>, case 114: <D.24054>, case 115: <D.24055>, case 116: <D.24056>, case 117: <D.24057>, case 118: <D.24058>, case 119: <D.24059>, case 120: <D.24060>, case 121: <D.24061>, case 122: <D.24062>, case 123: <D.24063>, case 124: <D.24064>, case 125: <D.24065>, case 126: <D.24066>, case 127: <D.24067>, case 224: <D.24048>, case 225: <D.24049>, case 226: <D.24050>, case 232: <D.24043>, case 233: <D.24044>, case 235: <D.24051>>
      <D.24043>:
      <D.24044>:
      size = size + 1;
      goto <D.24045>;
      <D.24046>:
      D.29289 = *pos;
      D.29290 = D.29289 + 144;
      if (D.29290 > 31) goto <D.29291>; else goto <D.29292>;
      <D.29291>:
      __assert_fail ("0", "mini-amd64.c", 489, &__PRETTY_FUNCTION__);
      <D.29292>:
      size = size + 1;
      pos = pos + 1;
      goto <D.24045>;
      <D.24048>:
      <D.24049>:
      <D.24050>:
      <D.24051>:
      <D.24052>:
      <D.24053>:
      <D.24054>:
      <D.24055>:
      <D.24056>:
      <D.24057>:
      <D.24058>:
      <D.24059>:
      <D.24060>:
      <D.24061>:
      <D.24062>:
      <D.24063>:
      <D.24064>:
      <D.24065>:
      <D.24066>:
      <D.24067>:
      goto <D.24045>;
      <D.24068>:
      __assert_fail ("0", "mini-amd64.c", 489, &__PRETTY_FUNCTION__);
      <D.24045>:
      target.1 = (long int) target;
      pos.4 = (long int) pos;
      D.29294 = target.1 - pos.4;
      disp = (int) D.29294;
      if (size != 0) goto <D.29295>; else goto <D.29296>;
      <D.29295>:
      {
        union x86_imm_buf imb;

        try
          {
            D.29297 = disp + -4;
            imb.val = D.29297;
            pos.5 = pos;
            pos = pos.5 + 1;
            D.29299 = imb.b[0];
            *pos.5 = D.29299;
            pos.6 = pos;
            pos = pos.6 + 1;
            D.29301 = imb.b[1];
            *pos.6 = D.29301;
            pos.7 = pos;
            pos = pos.7 + 1;
            D.29303 = imb.b[2];
            *pos.7 = D.29303;
            pos.8 = pos;
            pos = pos.8 + 1;
            D.29305 = imb.b[3];
            *pos.8 = D.29305;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29306>;
      <D.29296>:
      disp.9 = (unsigned int) disp;
      D.29308 = disp.9 + 127;
      if (D.29308 <= 255) goto <D.29309>; else goto <D.29310>;
      <D.29309>:
      D.29311 = (unsigned char) disp;
      D.29312 = D.29311 + 255;
      *pos = D.29312;
      pos = pos + 1;
      goto <D.29313>;
      <D.29310>:
      __assert_fail ("0", "mini-amd64.c", 489, &__PRETTY_FUNCTION__);
      <D.29313>:
      <D.29306>:
    }
  }
  goto <D.29314>;
  <D.29280>:
  {
    unsigned char * pos;
    int disp;
    int size;

    pos = code + 1;
    size = 0;
    D.29249 = *code;
    D.29253 = (int) D.29249;
    switch (D.29253) <default: <D.24097>, case 15: <D.24076>, case 112: <D.24081>, case 113: <D.24082>, case 114: <D.24083>, case 115: <D.24084>, case 116: <D.24085>, case 117: <D.24086>, case 118: <D.24087>, case 119: <D.24088>, case 120: <D.24089>, case 121: <D.24090>, case 122: <D.24091>, case 123: <D.24092>, case 124: <D.24093>, case 125: <D.24094>, case 126: <D.24095>, case 127: <D.24096>, case 224: <D.24077>, case 225: <D.24078>, case 226: <D.24079>, case 232: <D.24073>, case 233: <D.24074>, case 235: <D.24080>>
    <D.24073>:
    <D.24074>:
    size = size + 1;
    goto <D.24075>;
    <D.24076>:
    D.29315 = *pos;
    D.29316 = D.29315 + 144;
    if (D.29316 > 31) goto <D.29317>; else goto <D.29318>;
    <D.29317>:
    __assert_fail ("0", "mini-amd64.c", 492, &__PRETTY_FUNCTION__);
    <D.29318>:
    size = size + 1;
    pos = pos + 1;
    goto <D.24075>;
    <D.24077>:
    <D.24078>:
    <D.24079>:
    <D.24080>:
    <D.24081>:
    <D.24082>:
    <D.24083>:
    <D.24084>:
    <D.24085>:
    <D.24086>:
    <D.24087>:
    <D.24088>:
    <D.24089>:
    <D.24090>:
    <D.24091>:
    <D.24092>:
    <D.24093>:
    <D.24094>:
    <D.24095>:
    <D.24096>:
    goto <D.24075>;
    <D.24097>:
    __assert_fail ("0", "mini-amd64.c", 492, &__PRETTY_FUNCTION__);
    <D.24075>:
    target.1 = (long int) target;
    pos.10 = (long int) pos;
    D.29320 = target.1 - pos.10;
    disp = (int) D.29320;
    if (size != 0) goto <D.29321>; else goto <D.29322>;
    <D.29321>:
    {
      union x86_imm_buf imb;

      try
        {
          D.29323 = disp + -4;
          imb.val = D.29323;
          pos.11 = pos;
          pos = pos.11 + 1;
          D.29325 = imb.b[0];
          *pos.11 = D.29325;
          pos.12 = pos;
          pos = pos.12 + 1;
          D.29327 = imb.b[1];
          *pos.12 = D.29327;
          pos.13 = pos;
          pos = pos.13 + 1;
          D.29329 = imb.b[2];
          *pos.13 = D.29329;
          pos.14 = pos;
          pos = pos.14 + 1;
          D.29331 = imb.b[3];
          *pos.14 = D.29331;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.29332>;
    <D.29322>:
    disp.15 = (unsigned int) disp;
    D.29334 = disp.15 + 127;
    if (D.29334 <= 255) goto <D.29335>; else goto <D.29336>;
    <D.29335>:
    D.29337 = (unsigned char) disp;
    D.29338 = D.29337 + 255;
    *pos = D.29338;
    pos = pos + 1;
    goto <D.29339>;
    <D.29336>:
    __assert_fail ("0", "mini-amd64.c", 492, &__PRETTY_FUNCTION__);
    <D.29339>:
    <D.29332>:
  }
  <D.29314>:
  <D.29276>:
  <D.29261>:
  <D.29259>:
}


mono_arch_get_argument_info (struct MonoGenericSharingContext * gsctx, struct MonoMethodSignature * csig, int param_count, struct MonoJitArgumentInfo * arg_info)
{
  unsigned char D.29342;
  unsigned char D.29343;
  sizetype D.29346;
  sizetype D.29347;
  sizetype D.29348;
  struct MonoJitArgumentInfo * D.29349;
  <unnamed-unsigned:1> D.29350;
  int D.29351;
  int D.29352;
  short unsigned int D.29353;
  short unsigned int D.29354;
  int D.29355;
  int k;
  struct CallInfo * cinfo;
  guint32 args_size;

  cinfo = get_call_info (0B, 0B, csig);
  args_size = cinfo->stack_usage;
  D.29342 = BIT_FIELD_REF <*csig, 8, 112>;
  D.29343 = D.29342 & 64;
  if (D.29343 != 0) goto <D.29344>; else goto <D.29345>;
  <D.29344>:
  arg_info->offset = 0;
  <D.29345>:
  k = 0;
  goto <D.24320>;
  <D.24319>:
  D.29346 = (sizetype) k;
  D.29347 = D.29346 + 1;
  D.29348 = D.29347 * 6;
  D.29349 = arg_info + D.29348;
  D.29350 = csig->hasthis;
  D.29351 = (int) D.29350;
  D.29352 = D.29351 + k;
  D.29353 = (short unsigned int) D.29352;
  D.29354 = D.29353 * 8;
  D.29349->offset = D.29354;
  D.29346 = (sizetype) k;
  D.29347 = D.29346 + 1;
  D.29348 = D.29347 * 6;
  D.29349 = arg_info + D.29348;
  D.29349->size = 0;
  k = k + 1;
  <D.24320>:
  if (k < param_count) goto <D.24319>; else goto <D.24321>;
  <D.24321>:
  monoeg_g_free (cinfo);
  D.29355 = (int) args_size;
  return D.29355;
}


get_call_info (struct MonoGenericSharingContext * gsctx, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  <unnamed-unsigned:1> D.29357;
  int D.29358;
  short unsigned int D.29359;
  int D.29360;
  <unnamed-unsigned:1> D.29361;
  long unsigned int D.29364;
  unsigned int D.29365;
  unsigned int D.29366;
  unsigned int D.29367;
  long unsigned int D.29369;
  long unsigned int D.29370;
  struct MonoType * D.29371;
  unsigned char D.29372;
  int D.29373;
  int D.29374;
  struct ArgInfo * D.29377;
  <unnamed type> D.29378;
  int D.29384;
  unsigned char D.29387;
  unsigned char D.29388;
  struct MonoType * D.29391;
  struct MonoType * D.29392;
  int D.29393;
  struct ArgInfo[1] * D.29396;
  struct ArgInfo * D.29398;
  short unsigned int D.29403;
  short unsigned int D.29404;
  struct ArgInfo * D.29409;
  unsigned int D.29410;
  unsigned int D.29411;
  short int D.29414;
  unsigned int D.29415;
  struct MonoType * D.29418;
  unsigned char D.29419;
  int D.29420;
  int D.29421;
  unsigned int stack_size.16;
  unsigned int stack_size.17;
  unsigned int D.29426;
  int D.29431;
  unsigned int gr.18;
  unsigned int fr.19;
  struct CallInfo * D.29436;
  guint32 i;
  guint32 gr;
  guint32 fr;
  guint32 pstart;
  struct MonoType * ret_type;
  int n;
  guint32 stack_size;
  struct CallInfo * cinfo;
  gboolean is_pinvoke;

  try
    {
      D.29357 = sig->hasthis;
      D.29358 = (int) D.29357;
      D.29359 = sig->param_count;
      D.29360 = (int) D.29359;
      n = D.29358 + D.29360;
      stack_size = 0;
      D.29361 = sig->pinvoke;
      is_pinvoke = (gboolean) D.29361;
      if (mp != 0B) goto <D.29362>; else goto <D.29363>;
      <D.29362>:
      D.29364 = (long unsigned int) n;
      D.29365 = (unsigned int) D.29364;
      D.29366 = D.29365 * 24;
      D.29367 = D.29366 + 100;
      cinfo = mono_mempool_alloc0 (mp, D.29367);
      goto <D.29368>;
      <D.29363>:
      D.29364 = (long unsigned int) n;
      D.29369 = D.29364 * 24;
      D.29370 = D.29369 + 100;
      cinfo = monoeg_malloc0 (D.29370);
      <D.29368>:
      cinfo->nargs = n;
      gr = 0;
      fr = 0;
      D.29371 = sig->ret;
      ret_type = mini_type_get_underlying_type (gsctx, D.29371);
      D.29372 = ret_type->type;
      D.29373 = (int) D.29372;
      switch (D.29373) <default: <D.24277>, case 1: <D.24276>, case 2: <D.24248>, case 3: <D.24253>, case 4: <D.24249>, case 5: <D.24250>, case 6: <D.24251>, case 7: <D.24252>, case 8: <D.24254>, case 9: <D.24255>, case 10: <D.24267>, case 11: <D.24266>, case 12: <D.24268>, case 13: <D.24269>, case 14: <D.24264>, case 15: <D.24258>, case 17: <D.24271>, case 18: <D.24260>, case 20: <D.24263>, case 21: <D.24270>, case 22: <D.24275>, case 24: <D.24256>, case 25: <D.24257>, case 27: <D.24259>, case 28: <D.24261>, case 29: <D.24262>>
      <D.24248>:
      <D.24249>:
      <D.24250>:
      <D.24251>:
      <D.24252>:
      <D.24253>:
      <D.24254>:
      <D.24255>:
      <D.24256>:
      <D.24257>:
      <D.24258>:
      <D.24259>:
      <D.24260>:
      <D.24261>:
      <D.24262>:
      <D.24263>:
      <D.24264>:
      cinfo->ret.storage = 0;
      cinfo->ret.reg = 0;
      goto <D.24265>;
      <D.24266>:
      <D.24267>:
      cinfo->ret.storage = 0;
      cinfo->ret.reg = 0;
      goto <D.24265>;
      <D.24268>:
      cinfo->ret.storage = 1;
      cinfo->ret.reg = 0;
      goto <D.24265>;
      <D.24269>:
      cinfo->ret.storage = 2;
      cinfo->ret.reg = 0;
      goto <D.24265>;
      <D.24270>:
      D.29374 = mono_type_generic_inst_is_valuetype (ret_type);
      if (D.29374 == 0) goto <D.29375>; else goto <D.29376>;
      <D.29375>:
      cinfo->ret.storage = 0;
      cinfo->ret.reg = 0;
      goto <D.24265>;
      <D.29376>:
      <D.24271>:
      {
        guint32 tmp_gr;
        guint32 tmp_fr;
        guint32 tmp_stacksize;

        try
          {
            tmp_gr = 0;
            tmp_fr = 0;
            tmp_stacksize = 0;
            D.29377 = &cinfo->ret;
            add_valuetype (gsctx, sig, D.29377, ret_type, 1, &tmp_gr, &tmp_fr, &tmp_stacksize);
            D.29378 = cinfo->ret.storage;
            if (D.29378 == 3) goto <D.29379>; else goto <D.29380>;
            <D.29379>:
            cinfo->vtype_retaddr = 1;
            <D.29380>:
            goto <D.24265>;
          }
        finally
          {
            tmp_gr = {CLOBBER};
            tmp_fr = {CLOBBER};
            tmp_stacksize = {CLOBBER};
          }
      }
      <D.24275>:
      cinfo->vtype_retaddr = 1;
      goto <D.24265>;
      <D.24276>:
      goto <D.24265>;
      <D.24277>:
      D.29372 = ret_type->type;
      D.29373 = (int) D.29372;
      monoeg_g_log (0B, 4, "Can\'t handle as return value 0x%x", D.29373);
      <D.24278>:
      goto <D.24278>;
      <D.24265>:
      pstart = 0;
      D.29384 = cinfo->vtype_retaddr;
      if (D.29384 != 0) goto <D.29385>; else goto <D.29381>;
      <D.29385>:
      if (is_pinvoke == 0) goto <D.29386>; else goto <D.29381>;
      <D.29386>:
      D.29387 = BIT_FIELD_REF <*sig, 8, 112>;
      D.29388 = D.29387 & 64;
      if (D.29388 != 0) goto <D.29382>; else goto <D.29389>;
      <D.29389>:
      D.29359 = sig->param_count;
      if (D.29359 != 0) goto <D.29390>; else goto <D.29381>;
      <D.29390>:
      D.29391 = sig->params[0];
      D.29392 = mini_type_get_underlying_type (gsctx, D.29391);
      D.29393 = mono_type_is_reference (D.29392);
      if (D.29393 != 0) goto <D.29382>; else goto <D.29381>;
      <D.29382>:
      D.29387 = BIT_FIELD_REF <*sig, 8, 112>;
      D.29388 = D.29387 & 64;
      if (D.29388 != 0) goto <D.29394>; else goto <D.29395>;
      <D.29394>:
      D.29396 = &cinfo->args;
      add_general (&gr, &stack_size, D.29396);
      goto <D.29397>;
      <D.29395>:
      D.29357 = sig->hasthis;
      D.29358 = (int) D.29357;
      D.29398 = &cinfo->args[D.29358];
      add_general (&gr, &stack_size, D.29398);
      pstart = 1;
      <D.29397>:
      D.29377 = &cinfo->ret;
      add_general (&gr, &stack_size, D.29377);
      cinfo->vret_arg_index = 1;
      goto <D.29383>;
      <D.29381>:
      D.29387 = BIT_FIELD_REF <*sig, 8, 112>;
      D.29388 = D.29387 & 64;
      if (D.29388 != 0) goto <D.29399>; else goto <D.29400>;
      <D.29399>:
      D.29396 = &cinfo->args;
      add_general (&gr, &stack_size, D.29396);
      <D.29400>:
      D.29384 = cinfo->vtype_retaddr;
      if (D.29384 != 0) goto <D.29401>; else goto <D.29402>;
      <D.29401>:
      D.29377 = &cinfo->ret;
      add_general (&gr, &stack_size, D.29377);
      <D.29402>:
      <D.29383>:
      D.29403 = BIT_FIELD_REF <*sig, 16, 112>;
      D.29404 = D.29403 & 319;
      if (D.29404 == 5) goto <D.29405>; else goto <D.29406>;
      <D.29405>:
      if (n == 0) goto <D.29407>; else goto <D.29408>;
      <D.29407>:
      gr = 6;
      fr = 8;
      D.29409 = &cinfo->sig_cookie;
      add_general (&gr, &stack_size, D.29409);
      <D.29408>:
      <D.29406>:
      i = pstart;
      goto <D.24308>;
      <D.24307>:
      {
        struct ArgInfo * ainfo;
        struct MonoType * ptype;

        D.29357 = sig->hasthis;
        D.29410 = (unsigned int) D.29357;
        D.29411 = D.29410 + i;
        ainfo = &cinfo->args[D.29411];
        D.29403 = BIT_FIELD_REF <*sig, 16, 112>;
        D.29404 = D.29403 & 319;
        if (D.29404 == 5) goto <D.29412>; else goto <D.29413>;
        <D.29412>:
        D.29414 = sig->sentinelpos;
        D.29415 = (unsigned int) D.29414;
        if (D.29415 == i) goto <D.29416>; else goto <D.29417>;
        <D.29416>:
        gr = 6;
        fr = 8;
        D.29409 = &cinfo->sig_cookie;
        add_general (&gr, &stack_size, D.29409);
        <D.29417>:
        <D.29413>:
        D.29418 = sig->params[i];
        ptype = mini_type_get_underlying_type (gsctx, D.29418);
        D.29419 = ptype->type;
        D.29420 = (int) D.29419;
        switch (D.29420) <default: <D.24306>, case 2: <D.24281>, case 3: <D.24287>, case 4: <D.24282>, case 5: <D.24283>, case 6: <D.24285>, case 7: <D.24286>, case 8: <D.24288>, case 9: <D.24289>, case 10: <D.24303>, case 11: <D.24302>, case 12: <D.24304>, case 13: <D.24305>, case 14: <D.24296>, case 15: <D.24292>, case 17: <D.24300>, case 18: <D.24294>, case 20: <D.24298>, case 21: <D.24299>, case 22: <D.24301>, case 24: <D.24290>, case 25: <D.24291>, case 27: <D.24293>, case 28: <D.24295>, case 29: <D.24297>>
        <D.24281>:
        <D.24282>:
        <D.24283>:
        add_general (&gr, &stack_size, ainfo);
        goto <D.24284>;
        <D.24285>:
        <D.24286>:
        <D.24287>:
        add_general (&gr, &stack_size, ainfo);
        goto <D.24284>;
        <D.24288>:
        <D.24289>:
        add_general (&gr, &stack_size, ainfo);
        goto <D.24284>;
        <D.24290>:
        <D.24291>:
        <D.24292>:
        <D.24293>:
        <D.24294>:
        <D.24295>:
        <D.24296>:
        <D.24297>:
        <D.24298>:
        add_general (&gr, &stack_size, ainfo);
        goto <D.24284>;
        <D.24299>:
        D.29421 = mono_type_generic_inst_is_valuetype (ptype);
        if (D.29421 == 0) goto <D.29422>; else goto <D.29423>;
        <D.29422>:
        add_general (&gr, &stack_size, ainfo);
        goto <D.24284>;
        <D.29423>:
        <D.24300>:
        D.29418 = sig->params[i];
        add_valuetype (gsctx, sig, ainfo, D.29418, 0, &gr, &fr, &stack_size);
        goto <D.24284>;
        <D.24301>:
        stack_size.16 = stack_size;
        stack_size.17 = stack_size.16 + 24;
        stack_size = stack_size.17;
        ainfo->storage = 3;
        goto <D.24284>;
        <D.24302>:
        <D.24303>:
        add_general (&gr, &stack_size, ainfo);
        goto <D.24284>;
        <D.24304>:
        add_float (&fr, &stack_size, ainfo, 0);
        goto <D.24284>;
        <D.24305>:
        add_float (&fr, &stack_size, ainfo, 1);
        goto <D.24284>;
        <D.24306>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 1141);
        <D.24284>:
      }
      i = i + 1;
      <D.24308>:
      D.29359 = sig->param_count;
      D.29426 = (unsigned int) D.29359;
      if (D.29426 > i) goto <D.24307>; else goto <D.24309>;
      <D.24309>:
      D.29403 = BIT_FIELD_REF <*sig, 16, 112>;
      D.29404 = D.29403 & 319;
      if (D.29404 == 5) goto <D.29427>; else goto <D.29428>;
      <D.29427>:
      if (n > 0) goto <D.29429>; else goto <D.29430>;
      <D.29429>:
      D.29414 = sig->sentinelpos;
      D.29431 = (int) D.29414;
      D.29359 = sig->param_count;
      D.29360 = (int) D.29359;
      if (D.29431 == D.29360) goto <D.29432>; else goto <D.29433>;
      <D.29432>:
      gr = 6;
      fr = 8;
      D.29409 = &cinfo->sig_cookie;
      add_general (&gr, &stack_size, D.29409);
      <D.29433>:
      <D.29430>:
      <D.29428>:
      stack_size.16 = stack_size;
      cinfo->stack_usage = stack_size.16;
      gr.18 = gr;
      cinfo->reg_usage = gr.18;
      fr.19 = fr;
      cinfo->freg_usage = fr.19;
      D.29436 = cinfo;
      return D.29436;
    }
  finally
    {
      gr = {CLOBBER};
      fr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


add_valuetype (struct MonoGenericSharingContext * gsctx, struct MonoMethodSignature * sig, struct ArgInfo * ainfo, struct MonoType * type, gboolean is_return, guint32 * gr, guint32 * fr, guint32 * stack_size)
{
  <unnamed-unsigned:1> D.29443;
  int D.29444;
  struct MonoType * D.29445;
  int D.29446;
  unsigned char D.29450;
  unsigned char D.29451;
  int disable_vtypes_in_regs.20;
  _Bool D.29455;
  _Bool D.29456;
  _Bool D.29457;
  _Bool D.29459;
  _Bool D.29460;
  _Bool D.29461;
  unsigned int D.29465;
  _Bool D.29470;
  long int D.29471;
  long int D.29472;
  <unnamed-unsigned:1> D.29475;
  int D.29476;
  struct MonoMarshalSpec * D.29477;
  struct MonoClassField * D.29478;
  struct MonoType * D.29479;
  int D.29480;
  unsigned int D.29481;
  unsigned int D.29484;
  unsigned int D.29487;
  unsigned int D.29490;
  short int D.29491;
  unsigned int D.29492;
  unsigned int D.29493;
  unsigned int D.29494;
  _Bool D.29500;
  _Bool D.29501;
  unsigned int D.29507;
  unsigned int D.29510;
  unsigned int D.29511;
  unsigned int D.29512;
  unsigned int size.21;
  unsigned int D.29519;
  unsigned int D.29530;
  unsigned int D.29531;
  _Bool D.29532;
  long int D.29533;
  long int D.29534;
  ArgumentClass D.29539;
  ArgumentClass D.29541;
  unsigned int D.29542;
  unsigned int D.29543;
  <unnamed type> D.29544;
  int nquads.22;
  ArgumentClass D.29546;
  <unnamed type> D.29552;
  signed char D.29553;
  <unnamed type> D.29555;
  signed char D.29556;
  unsigned int D.29557;
  unsigned int D.29561;
  signed char D.29565;
  unsigned int D.29566;
  unsigned int orig_gr.23;
  unsigned int orig_fr.24;
  unsigned int D.29575;
  unsigned int D.29576;
  guint32 size;
  guint32 quad;
  guint32 nquads;
  guint32 i;
  guint32 quadsize[2];
  ArgumentClass args[2];
  struct MonoMarshalType * info;
  struct MonoClass * klass;
  struct MonoGenericSharingContext tmp_gsctx;
  gboolean pass_on_stack;

  try
    {
      quadsize[0] = 8;
      quadsize[1] = 8;
      info = 0B;
      pass_on_stack = 0;
      if (gsctx == 0B) goto <D.29441>; else goto <D.29442>;
      <D.29441>:
      gsctx = &tmp_gsctx;
      <D.29442>:
      klass = mono_class_from_mono_type (type);
      D.29443 = sig->pinvoke;
      D.29444 = (int) D.29443;
      D.29445 = &klass->byval_arg;
      D.29446 = mini_type_stack_size_full (gsctx, D.29445, 0B, D.29444);
      size = (guint32) D.29446;
      D.29450 = BIT_FIELD_REF <*sig, 8, 120>;
      D.29451 = D.29450 & 1;
      if (D.29451 == 0) goto <D.29452>; else goto <D.29447>;
      <D.29452>:
      disable_vtypes_in_regs.20 = disable_vtypes_in_regs;
      if (disable_vtypes_in_regs.20 == 0) goto <D.29454>; else goto <D.29447>;
      <D.29454>:
      D.29455 = is_return != 0;
      D.29456 = size == 8;
      D.29457 = D.29455 & D.29456;
      if (D.29457 != 0) goto <D.29448>; else goto <D.29458>;
      <D.29458>:
      D.29459 = is_return == 0;
      D.29460 = size <= 16;
      D.29461 = D.29459 & D.29460;
      if (D.29461 != 0) goto <D.29448>; else goto <D.29447>;
      <D.29448>:
      goto <D.29449>;
      <D.29447>:
      D.29450 = BIT_FIELD_REF <*sig, 8, 120>;
      D.29451 = D.29450 & 1;
      if (D.29451 == 0) goto <D.29462>; else goto <D.29464>;
      <D.29464>:
      D.29465 = size + 4294967295;
      if (D.29465 > 15) goto <D.29462>; else goto <D.29463>;
      <D.29462>:
      pass_on_stack = 1;
      <D.29463>:
      <D.29449>:
      D.29450 = BIT_FIELD_REF <*sig, 8, 120>;
      D.29451 = D.29450 & 1;
      if (D.29451 != 0) goto <D.29466>; else goto <D.29467>;
      <D.29466>:
      if (pass_on_stack == 0) goto <D.29468>; else goto <D.29469>;
      <D.29468>:
      {
        guint32 align;
        guint32 field_size;

        try
          {
            info = mono_marshal_load_type_info (klass);
            D.29470 = info == 0B;
            D.29471 = (long int) D.29470;
            D.29472 = __builtin_expect (D.29471, 0);
            if (D.29472 != 0) goto <D.29473>; else goto <D.29474>;
            <D.29473>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 749, "info");
            <D.29474>:
            i = 0;
            goto <D.24213>;
            <D.24212>:
            D.29475 = klass->unicode;
            D.29476 = (int) D.29475;
            D.29477 = info->fields[i].mspec;
            D.29478 = info->fields[i].field;
            D.29479 = D.29478->type;
            D.29480 = mono_marshal_type_size (D.29479, D.29477, &align, 1, D.29476);
            field_size = (guint32) D.29480;
            D.29481 = info->fields[i].offset;
            if (D.29481 <= 7) goto <D.29482>; else goto <D.29483>;
            <D.29482>:
            D.29481 = info->fields[i].offset;
            D.29484 = D.29481 + field_size;
            if (D.29484 > 8) goto <D.29485>; else goto <D.29486>;
            <D.29485>:
            pass_on_stack = 1;
            goto <D.24211>;
            <D.29486>:
            <D.29483>:
            i = i + 1;
            <D.24213>:
            D.29487 = info->num_fields;
            if (D.29487 > i) goto <D.24212>; else goto <D.24211>;
            <D.24211>:
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      <D.29469>:
      <D.29467>:
      if (pass_on_stack != 0) goto <D.29488>; else goto <D.29489>;
      <D.29488>:
      D.29490 = *stack_size;
      D.29491 = (short int) D.29490;
      ainfo->offset = D.29491;
      D.29490 = *stack_size;
      D.29492 = size + 7;
      D.29493 = D.29492 & 4294967288;
      D.29494 = D.29490 + D.29493;
      *stack_size = D.29494;
      ainfo->storage = 3;
      return;
      <D.29489>:
      if (size > 8) goto <D.29495>; else goto <D.29496>;
      <D.29495>:
      nquads = 2;
      goto <D.29497>;
      <D.29496>:
      nquads = 1;
      <D.29497>:
      D.29450 = BIT_FIELD_REF <*sig, 8, 120>;
      D.29451 = D.29450 & 1;
      if (D.29451 == 0) goto <D.29498>; else goto <D.29499>;
      <D.29498>:
      args[0] = 2;
      args[1] = 2;
      D.29455 = is_return != 0;
      D.29500 = nquads != 1;
      D.29501 = D.29455 & D.29500;
      if (D.29501 != 0) goto <D.29502>; else goto <D.29503>;
      <D.29502>:
      args[0] = 1;
      args[1] = 1;
      <D.29503>:
      goto <D.29504>;
      <D.29499>:
      info = mono_marshal_load_type_info (klass);
      D.29470 = info == 0B;
      D.29471 = (long int) D.29470;
      D.29472 = __builtin_expect (D.29471, 0);
      if (D.29472 != 0) goto <D.29505>; else goto <D.29506>;
      <D.29505>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 795, "info");
      <D.29506>:
      D.29507 = info->native_size;
      if (D.29507 > 16) goto <D.29508>; else goto <D.29509>;
      <D.29508>:
      D.29490 = *stack_size;
      D.29491 = (short int) D.29490;
      ainfo->offset = D.29491;
      D.29490 = *stack_size;
      D.29507 = info->native_size;
      D.29510 = D.29507 + 7;
      D.29511 = D.29510 & 4294967288;
      D.29512 = D.29490 + D.29511;
      *stack_size = D.29512;
      ainfo->storage = 3;
      return;
      <D.29509>:
      args[0] = 0;
      args[1] = 0;
      quad = 0;
      goto <D.24222>;
      <D.24221>:
      {
        int size;
        guint32 align;
        ArgumentClass class1;

        try
          {
            D.29487 = info->num_fields;
            if (D.29487 == 0) goto <D.29513>; else goto <D.29514>;
            <D.29513>:
            class1 = 1;
            goto <D.29515>;
            <D.29514>:
            class1 = 0;
            <D.29515>:
            i = 0;
            goto <D.24219>;
            <D.24218>:
            D.29475 = klass->unicode;
            D.29476 = (int) D.29475;
            D.29477 = info->fields[i].mspec;
            D.29478 = info->fields[i].field;
            D.29479 = D.29478->type;
            size = mono_marshal_type_size (D.29479, D.29477, &align, 1, D.29476);
            D.29481 = info->fields[i].offset;
            if (D.29481 <= 7) goto <D.29516>; else goto <D.29517>;
            <D.29516>:
            D.29481 = info->fields[i].offset;
            size.21 = (unsigned int) size;
            D.29519 = D.29481 + size.21;
            if (D.29519 > 8) goto <D.29520>; else goto <D.29521>;
            <D.29520>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 851);
            <D.29521>:
            <D.29517>:
            if (quad == 0) goto <D.29522>; else goto <D.29523>;
            <D.29522>:
            D.29481 = info->fields[i].offset;
            if (D.29481 > 7) goto <D.29524>; else goto <D.29525>;
            <D.29524>:
            // predicted unlikely by continue predictor.
            goto <D.24217>;
            <D.29525>:
            <D.29523>:
            if (quad == 1) goto <D.29526>; else goto <D.29527>;
            <D.29526>:
            D.29481 = info->fields[i].offset;
            if (D.29481 <= 7) goto <D.29528>; else goto <D.29529>;
            <D.29528>:
            // predicted unlikely by continue predictor.
            goto <D.24217>;
            <D.29529>:
            <D.29527>:
            D.29481 = info->fields[i].offset;
            size.21 = (unsigned int) size;
            D.29519 = D.29481 + size.21;
            D.29530 = quad * 8;
            D.29531 = D.29519 - D.29530;
            quadsize[quad] = D.29531;
            D.29478 = info->fields[i].field;
            D.29479 = D.29478->type;
            class1 = merge_argument_class_from_type (gsctx, D.29479, class1);
            <D.24217>:
            i = i + 1;
            <D.24219>:
            D.29487 = info->num_fields;
            if (D.29487 > i) goto <D.24218>; else goto <D.24220>;
            <D.24220>:
            D.29532 = class1 == 0;
            D.29533 = (long int) D.29532;
            D.29534 = __builtin_expect (D.29533, 0);
            if (D.29534 != 0) goto <D.29535>; else goto <D.29536>;
            <D.29535>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 866, "class1 != ARG_CLASS_NO_CLASS");
            <D.29536>:
            args[quad] = class1;
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      quad = quad + 1;
      <D.24222>:
      if (quad < nquads) goto <D.24221>; else goto <D.24223>;
      <D.24223>:
      <D.29504>:
      D.29539 = args[0];
      if (D.29539 == 1) goto <D.29537>; else goto <D.29540>;
      <D.29540>:
      D.29541 = args[1];
      if (D.29541 == 1) goto <D.29537>; else goto <D.29538>;
      <D.29537>:
      args[1] = 1;
      D.29541 = args[1];
      args[0] = D.29541;
      <D.29538>:
      {
        int orig_gr;
        int orig_fr;

        D.29542 = *gr;
        orig_gr = (int) D.29542;
        D.29543 = *fr;
        orig_fr = (int) D.29543;
        ainfo->storage = 4;
        ainfo->pair_storage[1] = 6;
        D.29544 = ainfo->pair_storage[1];
        ainfo->pair_storage[0] = D.29544;
        nquads.22 = (int) nquads;
        ainfo->nregs = nquads.22;
        quad = 0;
        goto <D.24232>;
        <D.24231>:
        D.29546 = args[quad];
        switch (D.29546) <default: <D.24230>, case 1: <D.24229>, case 2: <D.24226>, case 3: <D.24228>>
        <D.24226>:
        D.29542 = *gr;
        if (D.29542 > 5) goto <D.29547>; else goto <D.29548>;
        <D.29547>:
        args[quad] = 1;
        goto <D.29549>;
        <D.29548>:
        ainfo->pair_storage[quad] = 0;
        if (is_return != 0) goto <D.29550>; else goto <D.29551>;
        <D.29550>:
        D.29542 = *gr;
        D.29552 = return_regs[D.29542];
        D.29553 = (signed char) D.29552;
        ainfo->pair_regs[quad] = D.29553;
        goto <D.29554>;
        <D.29551>:
        D.29542 = *gr;
        D.29555 = param_regs[D.29542];
        D.29556 = (signed char) D.29555;
        ainfo->pair_regs[quad] = D.29556;
        <D.29554>:
        D.29542 = *gr;
        D.29557 = D.29542 + 1;
        *gr = D.29557;
        <D.29549>:
        goto <D.24227>;
        <D.24228>:
        D.29543 = *fr;
        if (D.29543 > 7) goto <D.29558>; else goto <D.29559>;
        <D.29558>:
        args[quad] = 1;
        goto <D.29560>;
        <D.29559>:
        D.29561 = quadsize[quad];
        if (D.29561 <= 4) goto <D.29562>; else goto <D.29563>;
        <D.29562>:
        ainfo->pair_storage[quad] = 1;
        goto <D.29564>;
        <D.29563>:
        ainfo->pair_storage[quad] = 2;
        <D.29564>:
        D.29543 = *fr;
        D.29565 = (signed char) D.29543;
        ainfo->pair_regs[quad] = D.29565;
        D.29543 = *fr;
        D.29566 = D.29543 + 1;
        *fr = D.29566;
        <D.29560>:
        goto <D.24227>;
        <D.24229>:
        goto <D.24227>;
        <D.24230>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 911);
        <D.24227>:
        quad = quad + 1;
        <D.24232>:
        if (quad < nquads) goto <D.24231>; else goto <D.24233>;
        <D.24233>:
        D.29539 = args[0];
        if (D.29539 == 1) goto <D.29567>; else goto <D.29569>;
        <D.29569>:
        D.29541 = args[1];
        if (D.29541 == 1) goto <D.29567>; else goto <D.29568>;
        <D.29567>:
        orig_gr.23 = (unsigned int) orig_gr;
        *gr = orig_gr.23;
        orig_fr.24 = (unsigned int) orig_fr;
        *fr = orig_fr.24;
        D.29490 = *stack_size;
        D.29491 = (short int) D.29490;
        ainfo->offset = D.29491;
        D.29450 = BIT_FIELD_REF <*sig, 8, 120>;
        D.29451 = D.29450 & 1;
        if (D.29451 != 0) goto <D.29572>; else goto <D.29573>;
        <D.29572>:
        D.29490 = *stack_size;
        D.29507 = info->native_size;
        D.29510 = D.29507 + 7;
        D.29511 = D.29510 & 4294967288;
        D.29512 = D.29490 + D.29511;
        *stack_size = D.29512;
        goto <D.29574>;
        <D.29573>:
        D.29490 = *stack_size;
        D.29575 = nquads * 8;
        D.29576 = D.29490 + D.29575;
        *stack_size = D.29576;
        <D.29574>:
        ainfo->storage = 3;
        <D.29568>:
      }
    }
  finally
    {
      quadsize = {CLOBBER};
      args = {CLOBBER};
      tmp_gsctx = {CLOBBER};
    }
}


merge_argument_class_from_type (struct MonoGenericSharingContext * gsctx, struct MonoType * type, ArgumentClass class1)
{
  unsigned char D.29581;
  int D.29582;
  int D.29583;
  struct MonoClass * D.29586;
  struct MonoClassField * D.29587;
  struct MonoType * D.29588;
  unsigned int i.25;
  unsigned int D.29590;
  _Bool D.29597;
  _Bool D.29598;
  _Bool D.29599;
  _Bool D.29603;
  _Bool D.29604;
  _Bool D.29605;
  ArgumentClass D.29609;
  ArgumentClass class2;
  struct MonoType * ptype;

  class2 = 0;
  ptype = mini_type_get_underlying_type (gsctx, type);
  D.29581 = ptype->type;
  D.29582 = (int) D.29581;
  switch (D.29582) <default: <D.24188>, case 2: <D.24158>, case 3: <D.24159>, case 4: <D.24160>, case 5: <D.24161>, case 6: <D.24162>, case 7: <D.24163>, case 8: <D.24164>, case 9: <D.24165>, case 10: <D.24175>, case 11: <D.24176>, case 12: <D.24178>, case 13: <D.24179>, case 14: <D.24168>, case 15: <D.24172>, case 17: <D.24182>, case 18: <D.24170>, case 20: <D.24174>, case 21: <D.24181>, case 22: <D.24180>, case 24: <D.24166>, case 25: <D.24167>, case 27: <D.24173>, case 28: <D.24169>, case 29: <D.24171>>
  <D.24158>:
  <D.24159>:
  <D.24160>:
  <D.24161>:
  <D.24162>:
  <D.24163>:
  <D.24164>:
  <D.24165>:
  <D.24166>:
  <D.24167>:
  <D.24168>:
  <D.24169>:
  <D.24170>:
  <D.24171>:
  <D.24172>:
  <D.24173>:
  <D.24174>:
  <D.24175>:
  <D.24176>:
  class2 = 2;
  goto <D.24177>;
  <D.24178>:
  <D.24179>:
  class2 = 3;
  goto <D.24177>;
  <D.24180>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 644);
  <D.24181>:
  D.29583 = mono_type_generic_inst_is_valuetype (ptype);
  if (D.29583 == 0) goto <D.29584>; else goto <D.29585>;
  <D.29584>:
  class2 = 2;
  goto <D.24177>;
  <D.29585>:
  <D.24182>:
  {
    struct MonoMarshalType * info;
    int i;

    D.29586 = ptype->data.klass;
    info = mono_marshal_load_type_info (D.29586);
    i = 0;
    goto <D.24186>;
    <D.24185>:
    class2 = class1;
    D.29587 = info->fields[i].field;
    D.29588 = D.29587->type;
    class2 = merge_argument_class_from_type (gsctx, D.29588, class2);
    i = i + 1;
    <D.24186>:
    i.25 = (unsigned int) i;
    D.29590 = info->num_fields;
    if (i.25 < D.29590) goto <D.24185>; else goto <D.24187>;
    <D.24187>:
    goto <D.24177>;
  }
  <D.24188>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 663);
  <D.24177>:
  if (class1 == class2) goto <D.29591>; else goto <D.29592>;
  <D.29591>:
  goto <D.29593>;
  <D.29592>:
  if (class1 == 0) goto <D.29594>; else goto <D.29595>;
  <D.29594>:
  class1 = class2;
  goto <D.29596>;
  <D.29595>:
  D.29597 = class1 == 1;
  D.29598 = class2 == 1;
  D.29599 = D.29597 | D.29598;
  if (D.29599 != 0) goto <D.29600>; else goto <D.29601>;
  <D.29600>:
  class1 = 1;
  goto <D.29602>;
  <D.29601>:
  D.29603 = class1 == 2;
  D.29604 = class2 == 2;
  D.29605 = D.29603 | D.29604;
  if (D.29605 != 0) goto <D.29606>; else goto <D.29607>;
  <D.29606>:
  class1 = 2;
  goto <D.29608>;
  <D.29607>:
  class1 = 3;
  <D.29608>:
  <D.29602>:
  <D.29596>:
  <D.29593>:
  D.29609 = class1;
  return D.29609;
}


add_float (guint32 * gr, guint32 * stack_size, struct ArgInfo * ainfo, gboolean is_double)
{
  unsigned int D.29611;
  short int D.29612;
  unsigned int D.29613;
  unsigned int D.29616;
  signed char D.29621;
  unsigned int D.29622;

  D.29611 = *stack_size;
  D.29612 = (short int) D.29611;
  ainfo->offset = D.29612;
  D.29613 = *gr;
  if (D.29613 > 7) goto <D.29614>; else goto <D.29615>;
  <D.29614>:
  ainfo->storage = 3;
  D.29611 = *stack_size;
  D.29616 = D.29611 + 8;
  *stack_size = D.29616;
  goto <D.29617>;
  <D.29615>:
  if (is_double != 0) goto <D.29618>; else goto <D.29619>;
  <D.29618>:
  ainfo->storage = 2;
  goto <D.29620>;
  <D.29619>:
  ainfo->storage = 1;
  <D.29620>:
  D.29613 = *gr;
  D.29621 = (signed char) D.29613;
  ainfo->reg = D.29621;
  D.29613 = *gr;
  D.29622 = D.29613 + 1;
  *gr = D.29622;
  <D.29617>:
}


add_general (guint32 * gr, guint32 * stack_size, struct ArgInfo * ainfo)
{
  unsigned int D.29623;
  short int D.29624;
  unsigned int D.29625;
  unsigned int D.29628;
  <unnamed type> D.29630;
  signed char D.29631;
  unsigned int D.29632;

  D.29623 = *stack_size;
  D.29624 = (short int) D.29623;
  ainfo->offset = D.29624;
  D.29625 = *gr;
  if (D.29625 > 5) goto <D.29626>; else goto <D.29627>;
  <D.29626>:
  ainfo->storage = 3;
  D.29623 = *stack_size;
  D.29628 = D.29623 + 8;
  *stack_size = D.29628;
  goto <D.29629>;
  <D.29627>:
  ainfo->storage = 0;
  D.29625 = *gr;
  D.29630 = param_regs[D.29625];
  D.29631 = (signed char) D.29630;
  ainfo->reg = D.29631;
  D.29625 = *gr;
  D.29632 = D.29625 + 1;
  *gr = D.29632;
  <D.29629>:
}


mono_arch_tail_call_supported (struct MonoCompile * cfg, struct MonoMethodSignature * caller_sig, struct MonoMethodSignature * callee_sig)
{
  unsigned int D.29633;
  unsigned int D.29634;
  _Bool D.29635;
  struct MonoType * D.29636;
  int D.29639;
  <unnamed type> D.29642;
  gboolean D.29645;
  struct CallInfo * c1;
  struct CallInfo * c2;
  gboolean res;
  struct MonoType * callee_ret;

  c1 = get_call_info (0B, 0B, caller_sig);
  c2 = get_call_info (0B, 0B, callee_sig);
  D.29633 = c1->stack_usage;
  D.29634 = c2->stack_usage;
  D.29635 = D.29633 >= D.29634;
  res = (gboolean) D.29635;
  D.29636 = callee_sig->ret;
  callee_ret = mini_replace_type (D.29636);
  if (callee_ret != 0B) goto <D.29637>; else goto <D.29638>;
  <D.29637>:
  D.29639 = mono_type_is_struct (callee_ret);
  if (D.29639 != 0) goto <D.29640>; else goto <D.29641>;
  <D.29640>:
  D.29642 = c2->ret.storage;
  if (D.29642 != 4) goto <D.29643>; else goto <D.29644>;
  <D.29643>:
  res = 0;
  <D.29644>:
  <D.29641>:
  <D.29638>:
  monoeg_g_free (c1);
  monoeg_g_free (c2);
  D.29645 = res;
  return D.29645;
}


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

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


mono_arch_init ()
{
  int D.29650;
  long unsigned int D.29651;
  void * ss_trigger_page.29;
  int D.29653;
  long unsigned int D.29654;
  void * bp_trigger_page.30;
  int D.29656;
  long unsigned int D.29657;
  void * bp_trigger_page.31;
  int flags;

  InitializeCriticalSection (&mini_arch_mutex);
  flags = 257;
  breakpoint_size = 8;
  breakpoint_fault_size = 8;
  single_step_fault_size = 4;
  D.29650 = mono_pagesize ();
  D.29651 = (long unsigned int) D.29650;
  ss_trigger_page.29 = mono_valloc (0B, D.29651, flags);
  ss_trigger_page = ss_trigger_page.29;
  D.29653 = mono_pagesize ();
  D.29654 = (long unsigned int) D.29653;
  bp_trigger_page.30 = mono_valloc (0B, D.29654, flags);
  bp_trigger_page = bp_trigger_page.30;
  D.29656 = mono_pagesize ();
  D.29657 = (long unsigned int) D.29656;
  bp_trigger_page.31 = bp_trigger_page;
  mono_mprotect (bp_trigger_page.31, D.29657, 0);
  mono_aot_register_jit_icall ("mono_amd64_throw_exception", mono_amd64_throw_exception);
  mono_aot_register_jit_icall ("mono_amd64_throw_corlib_exception", mono_amd64_throw_corlib_exception);
  mono_aot_register_jit_icall ("mono_amd64_get_original_ip", mono_amd64_get_original_ip);
}


mono_arch_cleanup ()
{
  DeleteCriticalSection (&mini_arch_mutex);
}


mono_arch_cpu_optimizations (guint32 * exclude_mask)
{
  int mono_hwcap_x86_has_cmov.32;
  int mono_hwcap_x86_has_fcmov.33;
  unsigned int D.29666;
  unsigned int D.29667;
  unsigned int D.29669;
  guint32 D.29670;
  guint32 opts;

  opts = 0;
  *exclude_mask = 0;
  mono_hwcap_x86_has_cmov.32 = mono_hwcap_x86_has_cmov;
  if (mono_hwcap_x86_has_cmov.32 != 0) goto <D.29660>; else goto <D.29661>;
  <D.29660>:
  opts = opts | 256;
  mono_hwcap_x86_has_fcmov.33 = mono_hwcap_x86_has_fcmov;
  if (mono_hwcap_x86_has_fcmov.33 != 0) goto <D.29663>; else goto <D.29664>;
  <D.29663>:
  opts = opts | 16384;
  goto <D.29665>;
  <D.29664>:
  D.29666 = *exclude_mask;
  D.29667 = D.29666 | 16384;
  *exclude_mask = D.29667;
  <D.29665>:
  goto <D.29668>;
  <D.29661>:
  D.29666 = *exclude_mask;
  D.29669 = D.29666 | 256;
  *exclude_mask = D.29669;
  <D.29668>:
  D.29670 = opts;
  return D.29670;
}


mono_arch_cpu_enumerate_simd_versions ()
{
  int mono_hwcap_x86_has_sse1.34;
  int mono_hwcap_x86_has_sse2.35;
  int mono_hwcap_x86_has_sse3.36;
  int mono_hwcap_x86_has_ssse3.37;
  int mono_hwcap_x86_has_sse41.38;
  int mono_hwcap_x86_has_sse42.39;
  int mono_hwcap_x86_has_sse4a.40;
  guint32 D.29693;
  guint32 sse_opts;

  sse_opts = 0;
  mono_hwcap_x86_has_sse1.34 = mono_hwcap_x86_has_sse1;
  if (mono_hwcap_x86_has_sse1.34 != 0) goto <D.29673>; else goto <D.29674>;
  <D.29673>:
  sse_opts = sse_opts | 1;
  <D.29674>:
  mono_hwcap_x86_has_sse2.35 = mono_hwcap_x86_has_sse2;
  if (mono_hwcap_x86_has_sse2.35 != 0) goto <D.29676>; else goto <D.29677>;
  <D.29676>:
  sse_opts = sse_opts | 2;
  <D.29677>:
  mono_hwcap_x86_has_sse3.36 = mono_hwcap_x86_has_sse3;
  if (mono_hwcap_x86_has_sse3.36 != 0) goto <D.29679>; else goto <D.29680>;
  <D.29679>:
  sse_opts = sse_opts | 4;
  <D.29680>:
  mono_hwcap_x86_has_ssse3.37 = mono_hwcap_x86_has_ssse3;
  if (mono_hwcap_x86_has_ssse3.37 != 0) goto <D.29682>; else goto <D.29683>;
  <D.29682>:
  sse_opts = sse_opts | 8;
  <D.29683>:
  mono_hwcap_x86_has_sse41.38 = mono_hwcap_x86_has_sse41;
  if (mono_hwcap_x86_has_sse41.38 != 0) goto <D.29685>; else goto <D.29686>;
  <D.29685>:
  sse_opts = sse_opts | 16;
  <D.29686>:
  mono_hwcap_x86_has_sse42.39 = mono_hwcap_x86_has_sse42;
  if (mono_hwcap_x86_has_sse42.39 != 0) goto <D.29688>; else goto <D.29689>;
  <D.29688>:
  sse_opts = sse_opts | 32;
  <D.29689>:
  mono_hwcap_x86_has_sse4a.40 = mono_hwcap_x86_has_sse4a;
  if (mono_hwcap_x86_has_sse4a.40 != 0) goto <D.29691>; else goto <D.29692>;
  <D.29691>:
  sse_opts = sse_opts | 64;
  <D.29692>:
  D.29693 = sse_opts;
  return D.29693;
}


mono_arch_get_allocatable_int_vars (struct MonoCompile * cfg)
{
  struct MonoInst * * D.29695;
  long unsigned int D.29696;
  long unsigned int D.29697;
  struct MonoInst * * D.29698;
  struct MonoMethodVar * D.29699;
  long unsigned int D.29700;
  unsigned int D.29701;
  unsigned int D.29702;
  unsigned char D.29707;
  int D.29708;
  int D.29709;
  short unsigned int D.29711;
  short unsigned int D.29712;
  struct MonoType * D.29713;
  int D.29714;
  struct MonoMethodVar * D.29717;
  int D.29718;
  _Bool D.29719;
  long int D.29720;
  long int D.29721;
  unsigned int i.41;
  unsigned int D.29725;
  _Bool D.29726;
  long int D.29727;
  long int D.29728;
  unsigned int D.29731;
  struct GList * D.29732;
  struct GList * vars;
  int i;

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

    D.29695 = cfg->varinfo;
    D.29696 = (long unsigned int) i;
    D.29697 = D.29696 * 8;
    D.29698 = D.29695 + D.29697;
    ins = *D.29698;
    D.29699 = cfg->vars;
    D.29696 = (long unsigned int) i;
    D.29700 = D.29696 * 80;
    vmv = D.29699 + D.29700;
    D.29701 = vmv->range.first_use.abs_pos;
    D.29702 = vmv->range.last_use.abs_pos;
    if (D.29701 >= D.29702) goto <D.29703>; else goto <D.29704>;
    <D.29703>:
    // predicted unlikely by continue predictor.
    goto <D.24357>;
    <D.29704>:
    D.29707 = ins->flags;
    D.29708 = (int) D.29707;
    D.29709 = D.29708 & 22;
    if (D.29709 != 0) goto <D.29705>; else goto <D.29710>;
    <D.29710>:
    D.29711 = ins->opcode;
    D.29712 = D.29711 + 65207;
    if (D.29712 > 1) goto <D.29705>; else goto <D.29706>;
    <D.29705>:
    // predicted unlikely by continue predictor.
    goto <D.24357>;
    <D.29706>:
    D.29713 = ins->data.op[1].vtype;
    D.29714 = mono_is_regsize_var (D.29713);
    if (D.29714 != 0) goto <D.29715>; else goto <D.29716>;
    <D.29715>:
    D.29699 = cfg->vars;
    D.29696 = (long unsigned int) i;
    D.29700 = D.29696 * 80;
    D.29717 = D.29699 + D.29700;
    D.29718 = D.29717->reg;
    D.29719 = D.29718 != -1;
    D.29720 = (long int) D.29719;
    D.29721 = __builtin_expect (D.29720, 0);
    if (D.29721 != 0) goto <D.29722>; else goto <D.29723>;
    <D.29722>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1383, "MONO_VARINFO (cfg, i)->reg == -1");
    <D.29723>:
    i.41 = (unsigned int) i;
    D.29725 = vmv->idx;
    D.29726 = i.41 != D.29725;
    D.29727 = (long int) D.29726;
    D.29728 = __builtin_expect (D.29727, 0);
    if (D.29728 != 0) goto <D.29729>; else goto <D.29730>;
    <D.29729>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1384, "i == vmv->idx");
    <D.29730>:
    vars = monoeg_g_list_prepend (vars, vmv);
    <D.29716>:
  }
  <D.24357>:
  i = i + 1;
  <D.24359>:
  i.41 = (unsigned int) i;
  D.29731 = cfg->num_varinfo;
  if (i.41 < D.29731) goto <D.24358>; else goto <D.24360>;
  <D.24360>:
  vars = mono_varlist_sort (cfg, vars, 0);
  D.29732 = vars;
  return D.29732;
}


mono_arch_get_global_int_regs (struct MonoCompile * cfg)
{
  unsigned char D.29734;
  unsigned char D.29735;
  int D.29738;
  struct GList * D.29744;
  struct GList * regs;

  regs = 0B;
  mono_arch_compute_omit_fp (cfg);
  D.29734 = BIT_FIELD_REF <*cfg, 8, 5608>;
  D.29735 = D.29734 & 16;
  if (D.29735 != 0) goto <D.29736>; else goto <D.29737>;
  <D.29736>:
  D.29738 = cfg->arch.omit_fp;
  if (D.29738 != 0) goto <D.29739>; else goto <D.29740>;
  <D.29739>:
  regs = monoeg_g_list_prepend (regs, 5B);
  <D.29740>:
  regs = monoeg_g_list_prepend (regs, 3B);
  regs = monoeg_g_list_prepend (regs, 12B);
  regs = monoeg_g_list_prepend (regs, 13B);
  regs = monoeg_g_list_prepend (regs, 14B);
  regs = monoeg_g_list_prepend (regs, 15B);
  regs = monoeg_g_list_prepend (regs, 10B);
  regs = monoeg_g_list_prepend (regs, 9B);
  regs = monoeg_g_list_prepend (regs, 8B);
  regs = monoeg_g_list_prepend (regs, 7B);
  regs = monoeg_g_list_prepend (regs, 6B);
  regs = monoeg_g_list_prepend (regs, 2B);
  regs = monoeg_g_list_prepend (regs, 1B);
  regs = monoeg_g_list_prepend (regs, 0B);
  goto <D.29741>;
  <D.29737>:
  D.29738 = cfg->arch.omit_fp;
  if (D.29738 != 0) goto <D.29742>; else goto <D.29743>;
  <D.29742>:
  regs = monoeg_g_list_prepend (regs, 5B);
  <D.29743>:
  regs = monoeg_g_list_prepend (regs, 3B);
  regs = monoeg_g_list_prepend (regs, 12B);
  regs = monoeg_g_list_prepend (regs, 13B);
  regs = monoeg_g_list_prepend (regs, 14B);
  regs = monoeg_g_list_prepend (regs, 15B);
  <D.29741>:
  D.29744 = regs;
  return D.29744;
}


mono_arch_compute_omit_fp (struct MonoCompile * cfg)
{
  int D.29746;
  struct MonoMethod * D.29749;
  void * D.29750;
  struct MonoMemPool * D.29753;
  struct MonoGenericSharingContext * D.29754;
  struct CallInfo * D.29755;
  unsigned char D.29756;
  unsigned char D.29757;
  int D.29760;
  unsigned int D.29763;
  unsigned int D.29764;
  short unsigned int D.29767;
  short unsigned int D.29768;
  unsigned int D.29771;
  short unsigned int D.29774;
  short unsigned int D.29775;
  struct MonoTraceSpec * mono_jit_trace_calls.42;
  int D.29783;
  unsigned int D.29784;
  unsigned int D.29785;
  <unnamed type> D.29786;
  short unsigned int D.29789;
  int D.29790;
  <unnamed-unsigned:1> D.29791;
  int D.29792;
  int D.29793;
  unsigned int D.29794;
  struct MonoInst * * D.29795;
  long unsigned int D.29796;
  long unsigned int D.29797;
  struct MonoInst * * D.29798;
  struct MonoType * D.29799;
  int D.29800;
  unsigned int i.43;
  unsigned int D.29802;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;
  int locals_size;
  struct CallInfo * cinfo;

  D.29746 = cfg->arch.omit_fp_computed;
  if (D.29746 != 0) goto <D.29747>; else goto <D.29748>;
  <D.29747>:
  return;
  <D.29748>:
  header = cfg->header;
  D.29749 = cfg->method;
  sig = mono_method_signature (D.29749);
  D.29750 = cfg->arch.cinfo;
  if (D.29750 == 0B) goto <D.29751>; else goto <D.29752>;
  <D.29751>:
  D.29753 = cfg->mempool;
  D.29754 = cfg->generic_sharing_context;
  D.29755 = get_call_info (D.29754, D.29753, sig);
  cfg->arch.cinfo = D.29755;
  <D.29752>:
  cinfo = cfg->arch.cinfo;
  cfg->arch.omit_fp = 1;
  cfg->arch.omit_fp_computed = 1;
  D.29756 = BIT_FIELD_REF <*cfg, 8, 5616>;
  D.29757 = D.29756 & 32;
  if (D.29757 != 0) goto <D.29758>; else goto <D.29759>;
  <D.29758>:
  cfg->arch.omit_fp = 0;
  <D.29759>:
  D.29760 = debug_omit_fp ();
  if (D.29760 == 0) goto <D.29761>; else goto <D.29762>;
  <D.29761>:
  cfg->arch.omit_fp = 0;
  <D.29762>:
  D.29763 = cfg->flags;
  D.29764 = D.29763 & 1;
  if (D.29764 != 0) goto <D.29765>; else goto <D.29766>;
  <D.29765>:
  cfg->arch.omit_fp = 0;
  <D.29766>:
  D.29767 = BIT_FIELD_REF <*header, 16, 112>;
  D.29768 = D.29767 & 32767;
  if (D.29768 != 0) goto <D.29769>; else goto <D.29770>;
  <D.29769>:
  cfg->arch.omit_fp = 0;
  <D.29770>:
  D.29771 = cfg->param_area;
  if (D.29771 != 0) goto <D.29772>; else goto <D.29773>;
  <D.29772>:
  cfg->arch.omit_fp = 0;
  <D.29773>:
  D.29774 = BIT_FIELD_REF <*sig, 16, 112>;
  D.29775 = D.29774 & 319;
  if (D.29775 == 5) goto <D.29776>; else goto <D.29777>;
  <D.29776>:
  cfg->arch.omit_fp = 0;
  <D.29777>:
  mono_jit_trace_calls.42 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.42 != 0B) goto <D.29782>; else goto <D.29778>;
  <D.29782>:
  D.29749 = cfg->method;
  D.29783 = mono_trace_eval (D.29749);
  if (D.29783 != 0) goto <D.29779>; else goto <D.29778>;
  <D.29778>:
  D.29784 = cfg->prof_options;
  D.29785 = D.29784 & 4096;
  if (D.29785 != 0) goto <D.29779>; else goto <D.29780>;
  <D.29779>:
  cfg->arch.omit_fp = 0;
  <D.29780>:
  i = 0;
  goto <D.24371>;
  <D.24370>:
  {
    struct ArgInfo * ainfo;

    ainfo = &cinfo->args[i];
    D.29786 = ainfo->storage;
    if (D.29786 == 3) goto <D.29787>; else goto <D.29788>;
    <D.29787>:
    cfg->arch.omit_fp = 0;
    <D.29788>:
  }
  i = i + 1;
  <D.24371>:
  D.29789 = sig->param_count;
  D.29790 = (int) D.29789;
  D.29791 = sig->hasthis;
  D.29792 = (int) D.29791;
  D.29793 = D.29790 + D.29792;
  if (D.29793 > i) goto <D.24370>; else goto <D.24372>;
  <D.24372>:
  locals_size = 0;
  D.29794 = cfg->locals_start;
  i = (int) D.29794;
  goto <D.24376>;
  <D.24375>:
  {
    struct MonoInst * ins;
    int ialign;

    try
      {
        D.29795 = cfg->varinfo;
        D.29796 = (long unsigned int) i;
        D.29797 = D.29796 * 8;
        D.29798 = D.29795 + D.29797;
        ins = *D.29798;
        D.29799 = ins->data.op[1].vtype;
        D.29800 = mono_type_size (D.29799, &ialign);
        locals_size = D.29800 + locals_size;
      }
    finally
      {
        ialign = {CLOBBER};
      }
  }
  i = i + 1;
  <D.24376>:
  i.43 = (unsigned int) i;
  D.29802 = cfg->num_varinfo;
  if (i.43 < D.29802) goto <D.24375>; else goto <D.24377>;
  <D.24377>:
}


debug_omit_fp ()
{
  gboolean D.29804;

  D.29804 = 1;
  return D.29804;
}


mono_arch_get_global_fp_regs (struct MonoCompile * cfg)
{
  long int D.29806;
  void * D.29807;
  struct GList * D.29808;
  struct GList * regs;
  int i;

  regs = 0B;
  i = 0;
  goto <D.24388>;
  <D.24387>:
  D.29806 = (long int) i;
  D.29807 = (void *) D.29806;
  regs = monoeg_g_list_prepend (regs, D.29807);
  i = i + 1;
  <D.24388>:
  if (i <= 15) goto <D.24387>; else goto <D.24389>;
  <D.24389>:
  D.29808 = regs;
  return D.29808;
}


mono_arch_get_iregs_clobbered_by_call (struct MonoCallInst * call)
{
  struct GList * r.44;
  struct GList * D.29813;
  static struct GList * r = 0B;

  r.44 = r;
  if (r.44 == 0B) goto <D.29811>; else goto <D.29812>;
  <D.29811>:
  {
    struct GList * regs;

    regs = 0B;
    regs = monoeg_g_list_prepend (regs, 5B);
    regs = monoeg_g_list_prepend (regs, 3B);
    regs = monoeg_g_list_prepend (regs, 12B);
    regs = monoeg_g_list_prepend (regs, 13B);
    regs = monoeg_g_list_prepend (regs, 14B);
    regs = monoeg_g_list_prepend (regs, 15B);
    regs = monoeg_g_list_prepend (regs, 10B);
    regs = monoeg_g_list_prepend (regs, 9B);
    regs = monoeg_g_list_prepend (regs, 8B);
    regs = monoeg_g_list_prepend (regs, 7B);
    regs = monoeg_g_list_prepend (regs, 6B);
    regs = monoeg_g_list_prepend (regs, 2B);
    regs = monoeg_g_list_prepend (regs, 1B);
    regs = monoeg_g_list_prepend (regs, 0B);
    InterlockedCompareExchangePointer (&r, regs, 0B);
  }
  <D.29812>:
  D.29813 = r;
  return D.29813;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.29815;
  long unsigned int exch.45;
  long unsigned int comp.46;
  long unsigned int D.29818;

  exch.45 = (long unsigned int) exch;
  comp.46 = (long unsigned int) comp;
  D.29818 = __sync_val_compare_and_swap_8 (dest, comp.46, exch.45);
  D.29815 = (void *) D.29818;
  return D.29815;
}


mono_arch_get_fregs_clobbered_by_call (struct MonoCallInst * call)
{
  struct GList * r.47;
  int D.29823;
  long int D.29824;
  void * D.29825;
  struct GList * D.29826;
  int i;
  static struct GList * r = 0B;

  r.47 = r;
  if (r.47 == 0B) goto <D.29821>; else goto <D.29822>;
  <D.29821>:
  {
    struct GList * regs;

    regs = 0B;
    i = 0;
    goto <D.24402>;
    <D.24401>:
    D.29823 = i + 16;
    D.29824 = (long int) D.29823;
    D.29825 = (void *) D.29824;
    regs = monoeg_g_list_prepend (regs, D.29825);
    i = i + 1;
    <D.24402>:
    if (i <= 15) goto <D.24401>; else goto <D.24403>;
    <D.24403>:
    InterlockedCompareExchangePointer (&r, regs, 0B);
  }
  <D.29822>:
  D.29826 = r;
  return D.29826;
}


mono_arch_regalloc_cost (struct MonoCompile * cfg, struct MonoMethodVar * vmv)
{
  struct MonoInst * * D.29828;
  unsigned int D.29829;
  long unsigned int D.29830;
  long unsigned int D.29831;
  struct MonoInst * * D.29832;
  struct MonoMethod * D.29833;
  unsigned char D.29834;
  unsigned char D.29835;
  guint32 D.29838;
  short unsigned int D.29839;
  _Bool D.29840;
  guint32 iftmp.48;
  struct MonoInst * ins;

  D.29828 = cfg->varinfo;
  D.29829 = vmv->idx;
  D.29830 = (long unsigned int) D.29829;
  D.29831 = D.29830 * 8;
  D.29832 = D.29828 + D.29831;
  ins = *D.29832;
  D.29833 = cfg->method;
  D.29834 = BIT_FIELD_REF <*D.29833, 8, 264>;
  D.29835 = D.29834 & 1;
  if (D.29835 != 0) goto <D.29836>; else goto <D.29837>;
  <D.29836>:
  D.29839 = ins->opcode;
  D.29840 = D.29839 != 330;
  D.29838 = (guint32) D.29840;
  return D.29838;
  <D.29837>:
  D.29839 = ins->opcode;
  if (D.29839 == 330) goto <D.29842>; else goto <D.29843>;
  <D.29842>:
  iftmp.48 = 1;
  goto <D.29844>;
  <D.29843>:
  iftmp.48 = 2;
  <D.29844>:
  D.29838 = iftmp.48;
  return D.29838;
}


mono_arch_fill_argument_info (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29846;
  struct MonoType * D.29847;
  unsigned char D.29848;
  <unnamed type> D.29851;
  int D.29856;
  struct MonoClass * D.29858;
  unsigned char D.29859;
  unsigned char D.29860;
  int D.29862;
  struct MonoInst * D.29863;
  signed char D.29864;
  long int D.29865;
  struct MonoInst * D.29866;
  struct MonoInst * * D.29867;
  long unsigned int D.29868;
  long unsigned int D.29869;
  struct MonoInst * * D.29870;
  unsigned char D.29873;
  unsigned char D.29874;
  struct MonoClass * D.29877;
  <unnamed-unsigned:1> D.29878;
  int D.29879;
  int D.29880;
  <unnamed type> D.29881;
  signed char D.29882;
  long int D.29883;
  short unsigned int D.29884;
  int D.29885;
  int D.29886;
  struct MonoType * sig_ret;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  struct MonoInst * ins;
  int i;
  struct CallInfo * cinfo;

  header = cfg->header;
  D.29846 = cfg->method;
  sig = mono_method_signature (D.29846);
  cinfo = cfg->arch.cinfo;
  D.29847 = sig->ret;
  sig_ret = mini_replace_type (D.29847);
  D.29848 = sig_ret->type;
  if (D.29848 != 1) goto <D.29849>; else goto <D.29850>;
  <D.29849>:
  D.29851 = cinfo->ret.storage;
  switch (D.29851) <default: <D.24423>, case 0: <D.24418>, case 1: <D.24419>, case 2: <D.24420>, case 4: <D.24422>>
  <D.24418>:
  <D.24419>:
  <D.24420>:
  D.29856 = mono_type_is_struct (sig_ret);
  if (D.29856 != 0) goto <D.29857>; else goto <D.29852>;
  <D.29857>:
  D.29858 = mono_class_from_mono_type (sig_ret);
  D.29859 = BIT_FIELD_REF <*D.29858, 8, 256>;
  D.29860 = D.29859 & 16;
  if (D.29860 == 0) goto <D.29853>; else goto <D.29852>;
  <D.29852>:
  D.29848 = sig_ret->type;
  if (D.29848 == 22) goto <D.29861>; else goto <D.29854>;
  <D.29861>:
  D.29862 = cinfo->vtype_retaddr;
  if (D.29862 != 0) goto <D.29853>; else goto <D.29854>;
  <D.29853>:
  D.29863 = cfg->vret_addr;
  D.29863->opcode = 366;
  D.29863 = cfg->vret_addr;
  D.29864 = cinfo->ret.reg;
  D.29865 = (long int) D.29864;
  D.29863->data.op[0].const_val = D.29865;
  goto <D.29855>;
  <D.29854>:
  D.29866 = cfg->ret;
  D.29866->opcode = 366;
  D.29866 = cfg->ret;
  D.29864 = cinfo->ret.reg;
  D.29865 = (long int) D.29864;
  D.29866->data.op[0].const_val = D.29865;
  <D.29855>:
  goto <D.24421>;
  <D.24422>:
  D.29866 = cfg->ret;
  D.29866->opcode = 367;
  D.29866 = cfg->ret;
  D.29866->sreg1 = -1;
  D.29866 = cfg->ret;
  D.29866->data.op[0].const_val = -1;
  goto <D.24421>;
  <D.24423>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 1653);
  <D.24421>:
  <D.29850>:
  i = 0;
  goto <D.24434>;
  <D.24433>:
  {
    struct ArgInfo * ainfo;
    struct MonoType * arg_type;

    ainfo = &cinfo->args[i];
    D.29867 = cfg->args;
    D.29868 = (long unsigned int) i;
    D.29869 = D.29868 * 8;
    D.29870 = D.29867 + D.29869;
    ins = *D.29870;
    D.29873 = BIT_FIELD_REF <*sig, 8, 112>;
    D.29874 = D.29873 & 64;
    if (D.29874 != 0) goto <D.29875>; else goto <D.29871>;
    <D.29875>:
    if (i == 0) goto <D.29876>; else goto <D.29871>;
    <D.29876>:
    D.29877 = mono_defaults.object_class;
    arg_type = &D.29877->byval_arg;
    goto <D.29872>;
    <D.29871>:
    D.29878 = sig->hasthis;
    D.29879 = (int) D.29878;
    D.29880 = i - D.29879;
    arg_type = sig->params[D.29880];
    <D.29872>:
    D.29881 = ainfo->storage;
    switch (D.29881) <default: <D.24432>, case 0: <D.24426>, case 1: <D.24427>, case 2: <D.24428>, case 3: <D.24430>, case 4: <D.24431>>
    <D.24426>:
    <D.24427>:
    <D.24428>:
    ins->opcode = 366;
    D.29882 = ainfo->reg;
    D.29883 = (long int) D.29882;
    ins->data.op[0].const_val = D.29883;
    goto <D.24429>;
    <D.24430>:
    ins->opcode = 367;
    ins->sreg1 = -1;
    ins->data.op[0].const_val = -1;
    goto <D.24429>;
    <D.24431>:
    ins->opcode = 316;
    goto <D.24429>;
    <D.24432>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 1685);
    <D.24429>:
  }
  i = i + 1;
  <D.24434>:
  D.29884 = sig->param_count;
  D.29885 = (int) D.29884;
  D.29878 = sig->hasthis;
  D.29879 = (int) D.29878;
  D.29886 = D.29885 + D.29879;
  if (D.29886 > i) goto <D.24433>; else goto <D.24435>;
  <D.24435>:
}


mono_arch_allocate_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.29887;
  struct MonoType * D.29888;
  int D.29889;
  unsigned int D.29892;
  unsigned int D.29893;
  unsigned char D.29895;
  unsigned char D.29896;
  int D.29902;
  int D.29903;
  long unsigned int D.29906;
  int D.29907;
  long unsigned int D.29908;
  long unsigned int D.29909;
  unsigned int offset.49;
  unsigned int D.29913;
  int D.29916;
  unsigned char D.29917;
  <unnamed type> D.29920;
  int D.29925;
  struct MonoClass * D.29927;
  unsigned char D.29928;
  unsigned char D.29929;
  int D.29931;
  unsigned char D.29932;
  unsigned char D.29933;
  struct MonoInst * D.29936;
  signed char D.29937;
  long int D.29938;
  unsigned int D.29940;
  int D.29941;
  long int D.29944;
  long int D.29946;
  unsigned int D.29947;
  _Bool D.29948;
  long int D.29949;
  long int D.29950;
  struct MonoInst * D.29953;
  int iftmp.50;
  <unnamed type> D.29957;
  int iftmp.51;
  long int D.29968;
  int D.29969;
  _Bool D.29972;
  int D.29973;
  unsigned int locals_stack_size.52;
  gchar * D.29977;
  unsigned int locals_stack_align.53;
  unsigned int offset.54;
  unsigned int D.29982;
  unsigned int D.29983;
  unsigned int D.29984;
  unsigned int D.29985;
  unsigned int D.29988;
  int D.29989;
  unsigned int D.29991;
  int D.29992;
  unsigned int D.29993;
  long unsigned int D.29994;
  long unsigned int D.29995;
  gint32 * D.29996;
  int D.29997;
  struct MonoInst * * D.30000;
  long unsigned int D.30001;
  struct MonoInst * * D.30002;
  int D.30005;
  long int D.30006;
  int D.30008;
  long int D.30009;
  unsigned int i.55;
  unsigned int D.30011;
  short unsigned int D.30012;
  short unsigned int D.30013;
  _Bool D.30016;
  long int D.30017;
  long int D.30018;
  <unnamed type> D.30021;
  _Bool D.30022;
  long int D.30023;
  long int D.30024;
  short int D.30027;
  int D.30028;
  int D.30029;
  struct MonoInst * * D.30030;
  struct MonoInst * * D.30031;
  short unsigned int D.30032;
  unsigned char D.30037;
  unsigned char D.30038;
  struct MonoClass * D.30041;
  <unnamed-unsigned:1> D.30042;
  int D.30043;
  int D.30044;
  <unnamed type> D.30047;
  signed char D.30048;
  long int D.30049;
  short int D.30052;
  int D.30053;
  int D.30054;
  long int D.30055;
  unsigned int D.30056;
  int D.30057;
  unsigned int iftmp.56;
  int D.30063;
  long unsigned int D.30064;
  unsigned int D.30065;
  unsigned int D.30067;
  unsigned int iftmp.57;
  unsigned int D.30073;
  unsigned char D.30074;
  int D.30075;
  int D.30076;
  <unnamed type> D.30079;
  _Bool D.30080;
  _Bool D.30081;
  _Bool D.30082;
  int D.30087;
  struct MonoMemPool * D.30092;
  long int D.30093;
  struct MonoInst * D.30094;
  int D.30095;
  int D.30096;
  const unsigned char * D.30097;
  <unnamed type> D.30098;
  unsigned int iftmp.58;
  unsigned int D.30114;
  unsigned int iftmp.59;
  unsigned int D.30120;
  short unsigned int D.30121;
  int D.30122;
  int D.30123;
  struct MonoType * sig_ret;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  struct MonoInst * ins;
  int i;
  int offset;
  guint32 locals_stack_size;
  guint32 locals_stack_align;
  gint32 * offsets;
  struct CallInfo * cinfo;

  try
    {
      header = cfg->header;
      D.29887 = cfg->method;
      sig = mono_method_signature (D.29887);
      cinfo = cfg->arch.cinfo;
      D.29888 = sig->ret;
      sig_ret = mini_replace_type (D.29888);
      mono_arch_compute_omit_fp (cfg);
      D.29889 = cfg->arch.omit_fp;
      if (D.29889 != 0) goto <D.29890>; else goto <D.29891>;
      <D.29890>:
      D.29892 = cfg->flags;
      D.29893 = D.29892 | 64;
      cfg->flags = D.29893;
      cfg->frame_reg = 4;
      offset = 0;
      goto <D.29894>;
      <D.29891>:
      cfg->frame_reg = 5;
      offset = 0;
      <D.29894>:
      D.29887 = cfg->method;
      D.29895 = BIT_FIELD_REF <*D.29887, 8, 264>;
      D.29896 = D.29895 & 1;
      if (D.29896 != 0) goto <D.29897>; else goto <D.29898>;
      <D.29897>:
      goto <D.29899>;
      <D.29898>:
      D.29889 = cfg->arch.omit_fp;
      if (D.29889 != 0) goto <D.29900>; else goto <D.29901>;
      <D.29900>:
      cfg->arch.reg_save_area_offset = offset;
      <D.29901>:
      i = 0;
      goto <D.24450>;
      <D.24449>:
      D.29902 = 61480 >> i;
      D.29903 = D.29902 & 1;
      if (D.29903 != 0) goto <D.29904>; else goto <D.29905>;
      <D.29904>:
      D.29906 = cfg->used_int_regs;
      D.29907 = 1 << i;
      D.29908 = (long unsigned int) D.29907;
      D.29909 = D.29906 & D.29908;
      if (D.29909 != 0) goto <D.29910>; else goto <D.29911>;
      <D.29910>:
      offset.49 = (unsigned int) offset;
      D.29913 = offset.49 + 8;
      offset = (int) D.29913;
      <D.29911>:
      <D.29905>:
      i = i + 1;
      <D.24450>:
      if (i <= 16) goto <D.24449>; else goto <D.24451>;
      <D.24451>:
      D.29889 = cfg->arch.omit_fp;
      if (D.29889 == 0) goto <D.29914>; else goto <D.29915>;
      <D.29914>:
      D.29916 = -offset;
      cfg->arch.reg_save_area_offset = D.29916;
      <D.29915>:
      <D.29899>:
      D.29917 = sig_ret->type;
      if (D.29917 != 1) goto <D.29918>; else goto <D.29919>;
      <D.29918>:
      D.29920 = cinfo->ret.storage;
      switch (D.29920) <default: <D.24457>, case 0: <D.24452>, case 1: <D.24453>, case 2: <D.24454>, case 4: <D.24456>>
      <D.24452>:
      <D.24453>:
      <D.24454>:
      D.29925 = mono_type_is_struct (sig_ret);
      if (D.29925 != 0) goto <D.29926>; else goto <D.29921>;
      <D.29926>:
      D.29927 = mono_class_from_mono_type (sig_ret);
      D.29928 = BIT_FIELD_REF <*D.29927, 8, 256>;
      D.29929 = D.29928 & 16;
      if (D.29929 == 0) goto <D.29922>; else goto <D.29921>;
      <D.29921>:
      D.29917 = sig_ret->type;
      if (D.29917 == 22) goto <D.29930>; else goto <D.29923>;
      <D.29930>:
      D.29931 = cinfo->vtype_retaddr;
      if (D.29931 != 0) goto <D.29922>; else goto <D.29923>;
      <D.29922>:
      D.29932 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29933 = D.29932 & 16;
      if (D.29933 != 0) goto <D.29934>; else goto <D.29935>;
      <D.29934>:
      D.29936 = cfg->vret_addr;
      D.29936->opcode = 366;
      D.29936 = cfg->vret_addr;
      D.29937 = cinfo->ret.reg;
      D.29938 = (long int) D.29937;
      D.29936->data.op[0].const_val = D.29938;
      goto <D.29939>;
      <D.29935>:
      D.29936 = cfg->vret_addr;
      D.29936->opcode = 367;
      D.29936 = cfg->vret_addr;
      D.29940 = cfg->frame_reg;
      D.29941 = (int) D.29940;
      D.29936->sreg1 = D.29941;
      D.29889 = cfg->arch.omit_fp;
      if (D.29889 != 0) goto <D.29942>; else goto <D.29943>;
      <D.29942>:
      D.29936 = cfg->vret_addr;
      D.29944 = (long int) offset;
      D.29936->data.op[0].const_val = D.29944;
      offset = offset + 8;
      goto <D.29945>;
      <D.29943>:
      offset = offset + 8;
      D.29936 = cfg->vret_addr;
      D.29916 = -offset;
      D.29946 = (long int) D.29916;
      D.29936->data.op[0].const_val = D.29946;
      <D.29945>:
      D.29947 = cfg->verbose_level;
      D.29948 = D.29947 > 1;
      D.29949 = (long int) D.29948;
      D.29950 = __builtin_expect (D.29949, 0);
      if (D.29950 != 0) goto <D.29951>; else goto <D.29952>;
      <D.29951>:
      printf ("vret_addr =");
      D.29936 = cfg->vret_addr;
      mono_print_ins (D.29936);
      <D.29952>:
      <D.29939>:
      goto <D.29924>;
      <D.29923>:
      D.29953 = cfg->ret;
      D.29953->opcode = 366;
      D.29953 = cfg->ret;
      D.29937 = cinfo->ret.reg;
      D.29938 = (long int) D.29937;
      D.29953->data.op[0].const_val = D.29938;
      <D.29924>:
      goto <D.24455>;
      <D.24456>:
      D.29953 = cfg->ret;
      D.29953->opcode = 367;
      D.29953 = cfg->ret;
      D.29940 = cfg->frame_reg;
      D.29941 = (int) D.29940;
      D.29953->sreg1 = D.29941;
      D.29889 = cfg->arch.omit_fp;
      if (D.29889 != 0) goto <D.29954>; else goto <D.29955>;
      <D.29954>:
      D.29953 = cfg->ret;
      D.29944 = (long int) offset;
      D.29953->data.op[0].const_val = D.29944;
      D.29957 = cinfo->ret.pair_storage[1];
      if (D.29957 == 6) goto <D.29958>; else goto <D.29959>;
      <D.29958>:
      iftmp.50 = 8;
      goto <D.29960>;
      <D.29959>:
      iftmp.50 = 16;
      <D.29960>:
      offset = iftmp.50 + offset;
      goto <D.29961>;
      <D.29955>:
      D.29957 = cinfo->ret.pair_storage[1];
      if (D.29957 == 6) goto <D.29963>; else goto <D.29964>;
      <D.29963>:
      iftmp.51 = 8;
      goto <D.29965>;
      <D.29964>:
      iftmp.51 = 16;
      <D.29965>:
      offset = iftmp.51 + offset;
      D.29953 = cfg->ret;
      D.29916 = -offset;
      D.29946 = (long int) D.29916;
      D.29953->data.op[0].const_val = D.29946;
      <D.29961>:
      goto <D.24455>;
      <D.24457>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 1795);
      <D.24455>:
      D.29932 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29933 = D.29932 & 16;
      if (D.29933 == 0) goto <D.29966>; else goto <D.29967>;
      <D.29966>:
      D.29953 = cfg->ret;
      D.29953 = cfg->ret;
      D.29968 = D.29953->data.op[0].const_val;
      D.29969 = (int) D.29968;
      D.29953->dreg = D.29969;
      <D.29967>:
      <D.29919>:
      D.29932 = BIT_FIELD_REF <*cfg, 8, 5608>;
      D.29933 = D.29932 & 16;
      if (D.29933 == 0) goto <D.29970>; else goto <D.29971>;
      <D.29970>:
      D.29889 = cfg->arch.omit_fp;
      D.29972 = D.29889 == 0;
      D.29973 = (int) D.29972;
      offsets = mono_allocate_stack_slots (cfg, D.29973, &locals_stack_size, &locals_stack_align);
      locals_stack_size.52 = locals_stack_size;
      if (locals_stack_size.52 > 1048576) goto <D.29975>; else goto <D.29976>;
      <D.29975>:
      {
        char * mname;

        D.29887 = cfg->method;
        mname = mono_method_full_name (D.29887, 1);
        cfg->exception_type = 3;
        D.29977 = monoeg_g_strdup_printf ("Method %s stack is too big.", mname);
        cfg->exception_message = D.29977;
        monoeg_g_free (mname);
        return;
      }
      <D.29976>:
      locals_stack_align.53 = locals_stack_align;
      if (locals_stack_align.53 != 0) goto <D.29979>; else goto <D.29980>;
      <D.29979>:
      locals_stack_align.53 = locals_stack_align;
      offset.54 = (unsigned int) offset;
      D.29982 = locals_stack_align.53 + offset.54;
      D.29983 = D.29982 + 4294967295;
      offset = (int) D.29983;
      locals_stack_align.53 = locals_stack_align;
      D.29984 = -locals_stack_align.53;
      offset.54 = (unsigned int) offset;
      D.29985 = D.29984 & offset.54;
      offset = (int) D.29985;
      <D.29980>:
      D.29889 = cfg->arch.omit_fp;
      if (D.29889 != 0) goto <D.29986>; else goto <D.29987>;
      <D.29986>:
      cfg->locals_min_stack_offset = offset;
      offset.54 = (unsigned int) offset;
      locals_stack_size.52 = locals_stack_size;
      D.29988 = offset.54 + locals_stack_size.52;
      D.29989 = (int) D.29988;
      cfg->locals_max_stack_offset = D.29989;
      goto <D.29990>;
      <D.29987>:
      offset.54 = (unsigned int) offset;
      locals_stack_size.52 = locals_stack_size;
      D.29988 = offset.54 + locals_stack_size.52;
      D.29991 = -D.29988;
      D.29992 = (int) D.29991;
      cfg->locals_min_stack_offset = D.29992;
      D.29916 = -offset;
      cfg->locals_max_stack_offset = D.29916;
      <D.29990>:
      D.29993 = cfg->locals_start;
      i = (int) D.29993;
      goto <D.24461>;
      <D.24460>:
      D.29994 = (long unsigned int) i;
      D.29995 = D.29994 * 4;
      D.29996 = offsets + D.29995;
      D.29997 = *D.29996;
      if (D.29997 != -1) goto <D.29998>; else goto <D.29999>;
      <D.29998>:
      {
        struct MonoInst * ins;

        D.30000 = cfg->varinfo;
        D.29994 = (long unsigned int) i;
        D.30001 = D.29994 * 8;
        D.30002 = D.30000 + D.30001;
        ins = *D.30002;
        ins->opcode = 367;
        D.29940 = cfg->frame_reg;
        D.29941 = (int) D.29940;
        ins->sreg1 = D.29941;
        D.29889 = cfg->arch.omit_fp;
        if (D.29889 != 0) goto <D.30003>; else goto <D.30004>;
        <D.30003>:
        D.29994 = (long unsigned int) i;
        D.29995 = D.29994 * 4;
        D.29996 = offsets + D.29995;
        D.29997 = *D.29996;
        D.30005 = D.29997 + offset;
        D.30006 = (long int) D.30005;
        ins->data.op[0].const_val = D.30006;
        goto <D.30007>;
        <D.30004>:
        D.29994 = (long unsigned int) i;
        D.29995 = D.29994 * 4;
        D.29996 = offsets + D.29995;
        D.29997 = *D.29996;
        D.30005 = D.29997 + offset;
        D.30008 = -D.30005;
        D.30009 = (long int) D.30008;
        ins->data.op[0].const_val = D.30009;
        <D.30007>:
      }
      <D.29999>:
      i = i + 1;
      <D.24461>:
      i.55 = (unsigned int) i;
      D.30011 = cfg->num_varinfo;
      if (i.55 < D.30011) goto <D.24460>; else goto <D.24462>;
      <D.24462>:
      offset.54 = (unsigned int) offset;
      locals_stack_size.52 = locals_stack_size;
      D.29988 = offset.54 + locals_stack_size.52;
      offset = (int) D.29988;
      <D.29971>:
      D.30012 = BIT_FIELD_REF <*sig, 16, 112>;
      D.30013 = D.30012 & 319;
      if (D.30013 == 5) goto <D.30014>; else goto <D.30015>;
      <D.30014>:
      D.29889 = cfg->arch.omit_fp;
      D.30016 = D.29889 != 0;
      D.30017 = (long int) D.30016;
      D.30018 = __builtin_expect (D.30017, 0);
      if (D.30018 != 0) goto <D.30019>; else goto <D.30020>;
      <D.30019>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1840, "!cfg->arch.omit_fp");
      <D.30020>:
      D.30021 = cinfo->sig_cookie.storage;
      D.30022 = D.30021 != 3;
      D.30023 = (long int) D.30022;
      D.30024 = __builtin_expect (D.30023, 0);
      if (D.30024 != 0) goto <D.30025>; else goto <D.30026>;
      <D.30025>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1841, "cinfo->sig_cookie.storage == ArgOnStack");
      <D.30026>:
      D.30027 = cinfo->sig_cookie.offset;
      D.30028 = (int) D.30027;
      D.30029 = D.30028 + 16;
      cfg->sig_cookie = D.30029;
      <D.30015>:
      i = 0;
      goto <D.24484>;
      <D.24483>:
      D.30030 = cfg->args;
      D.29994 = (long unsigned int) i;
      D.30001 = D.29994 * 8;
      D.30031 = D.30030 + D.30001;
      ins = *D.30031;
      D.30032 = ins->opcode;
      if (D.30032 != 366) goto <D.30033>; else goto <D.30034>;
      <D.30033>:
      {
        struct ArgInfo * ainfo;
        gboolean inreg;
        struct MonoType * arg_type;

        ainfo = &cinfo->args[i];
        inreg = 1;
        D.30037 = BIT_FIELD_REF <*sig, 8, 112>;
        D.30038 = D.30037 & 64;
        if (D.30038 != 0) goto <D.30039>; else goto <D.30035>;
        <D.30039>:
        if (i == 0) goto <D.30040>; else goto <D.30035>;
        <D.30040>:
        D.30041 = mono_defaults.object_class;
        arg_type = &D.30041->byval_arg;
        goto <D.30036>;
        <D.30035>:
        D.30042 = sig->hasthis;
        D.30043 = (int) D.30042;
        D.30044 = i - D.30043;
        arg_type = sig->params[D.30044];
        <D.30036>:
        D.29932 = BIT_FIELD_REF <*cfg, 8, 5608>;
        D.29933 = D.29932 & 16;
        if (D.29933 != 0) goto <D.30045>; else goto <D.30046>;
        <D.30045>:
        D.30047 = ainfo->storage;
        switch (D.30047) <default: <D.24472>, case 0: <D.24466>, case 1: <D.24467>, case 2: <D.24468>, case 3: <D.24470>, case 4: <D.24471>>
        <D.24466>:
        <D.24467>:
        <D.24468>:
        ins->opcode = 366;
        D.30048 = ainfo->reg;
        D.30049 = (long int) D.30048;
        ins->data.op[0].const_val = D.30049;
        goto <D.24469>;
        <D.24470>:
        D.29889 = cfg->arch.omit_fp;
        D.30016 = D.29889 != 0;
        D.30017 = (long int) D.30016;
        D.30018 = __builtin_expect (D.30017, 0);
        if (D.30018 != 0) goto <D.30050>; else goto <D.30051>;
        <D.30050>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1867, "!cfg->arch.omit_fp");
        <D.30051>:
        ins->opcode = 367;
        D.29940 = cfg->frame_reg;
        D.29941 = (int) D.29940;
        ins->sreg1 = D.29941;
        D.30052 = ainfo->offset;
        D.30053 = (int) D.30052;
        D.30054 = D.30053 + 16;
        D.30055 = (long int) D.30054;
        ins->data.op[0].const_val = D.30055;
        goto <D.24469>;
        <D.24471>:
        ins->opcode = 367;
        D.29940 = cfg->frame_reg;
        D.29941 = (int) D.29940;
        ins->sreg1 = D.29941;
        offset.49 = (unsigned int) offset;
        D.30056 = offset.49 + 7;
        D.30057 = (int) D.30056;
        offset = D.30057 & -8;
        D.29889 = cfg->arch.omit_fp;
        if (D.29889 != 0) goto <D.30058>; else goto <D.30059>;
        <D.30058>:
        D.29944 = (long int) offset;
        ins->data.op[0].const_val = D.29944;
        D.30047 = ainfo->storage;
        if (D.30047 == 4) goto <D.30061>; else goto <D.30062>;
        <D.30061>:
        D.30063 = ainfo->nregs;
        D.30064 = (long unsigned int) D.30063;
        D.30065 = (unsigned int) D.30064;
        iftmp.56 = D.30065 * 8;
        goto <D.30066>;
        <D.30062>:
        iftmp.56 = 8;
        <D.30066>:
        offset.49 = (unsigned int) offset;
        D.30067 = iftmp.56 + offset.49;
        offset = (int) D.30067;
        goto <D.30068>;
        <D.30059>:
        D.30047 = ainfo->storage;
        if (D.30047 == 4) goto <D.30070>; else goto <D.30071>;
        <D.30070>:
        D.30063 = ainfo->nregs;
        D.30064 = (long unsigned int) D.30063;
        D.30065 = (unsigned int) D.30064;
        iftmp.57 = D.30065 * 8;
        goto <D.30072>;
        <D.30071>:
        iftmp.57 = 8;
        <D.30072>:
        offset.49 = (unsigned int) offset;
        D.30073 = iftmp.57 + offset.49;
        offset = (int) D.30073;
        D.29916 = -offset;
        D.29946 = (long int) D.29916;
        ins->data.op[0].const_val = D.29946;
        <D.30068>:
        goto <D.24469>;
        <D.24472>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 1886);
        <D.24469>:
        // predicted unlikely by continue predictor.
        goto <D.24473>;
        <D.30046>:
        D.30074 = ins->flags;
        D.30075 = (int) D.30074;
        D.30076 = D.30075 & 20;
        if (D.30076 != 0) goto <D.30077>; else goto <D.30078>;
        <D.30077>:
        inreg = 0;
        <D.30078>:
        D.30079 = ainfo->storage;
        D.30080 = D.30079 <= 2;
        D.30081 = D.30079 == 4;
        D.30082 = D.30080 | D.30081;
        if (D.30082 != 0) goto <D.30083>; else goto <D.30084>;
        <D.30083>:
        inreg = 0;
        <D.30084>:
        ins->opcode = 367;
        D.30047 = ainfo->storage;
        switch (D.30047) <default: <D.24482>, case 0: <D.24474>, case 1: <D.24475>, case 2: <D.24476>, case 3: <D.24478>, case 4: <D.24479>, case 5: <D.24480>>
        <D.24474>:
        <D.24475>:
        <D.24476>:
        if (inreg != 0) goto <D.30085>; else goto <D.30086>;
        <D.30085>:
        ins->opcode = 366;
        D.30048 = ainfo->reg;
        D.30087 = (int) D.30048;
        ins->dreg = D.30087;
        <D.30086>:
        goto <D.24477>;
        <D.24478>:
        D.29889 = cfg->arch.omit_fp;
        D.30016 = D.29889 != 0;
        D.30017 = (long int) D.30016;
        D.30018 = __builtin_expect (D.30017, 0);
        if (D.30018 != 0) goto <D.30088>; else goto <D.30089>;
        <D.30088>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1916, "!cfg->arch.omit_fp");
        <D.30089>:
        ins->opcode = 367;
        D.29940 = cfg->frame_reg;
        D.29941 = (int) D.29940;
        ins->sreg1 = D.29941;
        D.30052 = ainfo->offset;
        D.30053 = (int) D.30052;
        D.30054 = D.30053 + 16;
        D.30055 = (long int) D.30054;
        ins->data.op[0].const_val = D.30055;
        goto <D.24477>;
        <D.24479>:
        goto <D.24477>;
        <D.24480>:
        {
          struct MonoInst * indir;

          D.29889 = cfg->arch.omit_fp;
          D.30016 = D.29889 != 0;
          D.30017 = (long int) D.30016;
          D.30018 = __builtin_expect (D.30017, 0);
          if (D.30018 != 0) goto <D.30090>; else goto <D.30091>;
          <D.30090>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 1925, "!cfg->arch.omit_fp");
          <D.30091>:
          D.30092 = cfg->mempool;
          indir = mono_mempool_alloc (D.30092, 80);
          indir->data.op[1].const_val = 0;
          D.30093 = indir->data.op[1].const_val;
          indir->data.op[0].const_val = D.30093;
          indir->prev = 0B;
          D.30094 = indir->prev;
          indir->next = D.30094;
          indir->opcode = 0;
          indir->flags = 0;
          indir->type = 0;
          indir->dreg = -1;
          indir->sreg3 = -1;
          D.30095 = indir->sreg3;
          indir->sreg2 = D.30095;
          D.30096 = indir->sreg2;
          indir->sreg1 = D.30096;
          D.30097 = cfg->ip;
          indir->cil_code = D.30097;
          indir->opcode = 367;
          D.30098 = ainfo->pair_storage[0];
          if (D.30098 == 0) goto <D.30099>; else goto <D.30100>;
          <D.30099>:
          D.29940 = cfg->frame_reg;
          D.29941 = (int) D.29940;
          indir->sreg1 = D.29941;
          offset.49 = (unsigned int) offset;
          D.30056 = offset.49 + 7;
          D.30057 = (int) D.30056;
          offset = D.30057 & -8;
          offset.49 = (unsigned int) offset;
          D.29913 = offset.49 + 8;
          offset = (int) D.29913;
          D.29916 = -offset;
          D.29946 = (long int) D.29916;
          indir->data.op[0].const_val = D.29946;
          goto <D.30101>;
          <D.30100>:
          D.29940 = cfg->frame_reg;
          D.29941 = (int) D.29940;
          indir->sreg1 = D.29941;
          D.30052 = ainfo->offset;
          D.30053 = (int) D.30052;
          D.30054 = D.30053 + 16;
          D.30055 = (long int) D.30054;
          indir->data.op[0].const_val = D.30055;
          <D.30101>:
          ins->opcode = 368;
          ins->data.op[0].src = indir;
          goto <D.24477>;
        }
        <D.24482>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 1946);
        <D.24477>:
        if (inreg == 0) goto <D.30102>; else goto <D.30103>;
        <D.30102>:
        D.30047 = ainfo->storage;
        if (D.30047 != 3) goto <D.30104>; else goto <D.30105>;
        <D.30104>:
        D.30047 = ainfo->storage;
        if (D.30047 != 5) goto <D.30106>; else goto <D.30107>;
        <D.30106>:
        ins->opcode = 367;
        D.29940 = cfg->frame_reg;
        D.29941 = (int) D.29940;
        ins->sreg1 = D.29941;
        offset.49 = (unsigned int) offset;
        D.30056 = offset.49 + 7;
        D.30057 = (int) D.30056;
        offset = D.30057 & -8;
        D.29889 = cfg->arch.omit_fp;
        if (D.29889 != 0) goto <D.30108>; else goto <D.30109>;
        <D.30108>:
        D.29944 = (long int) offset;
        ins->data.op[0].const_val = D.29944;
        D.30047 = ainfo->storage;
        if (D.30047 == 4) goto <D.30111>; else goto <D.30112>;
        <D.30111>:
        D.30063 = ainfo->nregs;
        D.30064 = (long unsigned int) D.30063;
        D.30065 = (unsigned int) D.30064;
        iftmp.58 = D.30065 * 8;
        goto <D.30113>;
        <D.30112>:
        iftmp.58 = 8;
        <D.30113>:
        offset.49 = (unsigned int) offset;
        D.30114 = iftmp.58 + offset.49;
        offset = (int) D.30114;
        goto <D.30115>;
        <D.30109>:
        D.30047 = ainfo->storage;
        if (D.30047 == 4) goto <D.30117>; else goto <D.30118>;
        <D.30117>:
        D.30063 = ainfo->nregs;
        D.30064 = (long unsigned int) D.30063;
        D.30065 = (unsigned int) D.30064;
        iftmp.59 = D.30065 * 8;
        goto <D.30119>;
        <D.30118>:
        iftmp.59 = 8;
        <D.30119>:
        offset.49 = (unsigned int) offset;
        D.30120 = iftmp.59 + offset.49;
        offset = (int) D.30120;
        D.29916 = -offset;
        D.29946 = (long int) D.29916;
        ins->data.op[0].const_val = D.29946;
        <D.30115>:
        <D.30107>:
        <D.30105>:
        <D.30103>:
      }
      <D.30034>:
      <D.24473>:
      i = i + 1;
      <D.24484>:
      D.30121 = sig->param_count;
      D.30122 = (int) D.30121;
      D.30042 = sig->hasthis;
      D.30043 = (int) D.30042;
      D.30123 = D.30122 + D.30043;
      if (D.30123 > i) goto <D.24483>; else goto <D.24485>;
      <D.24485>:
      cfg->stack_offset = offset;
    }
  finally
    {
      locals_stack_size = {CLOBBER};
      locals_stack_align = {CLOBBER};
    }
}


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

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


mono_arch_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.30130;
  void * D.30131;
  struct MonoMemPool * D.30134;
  struct MonoGenericSharingContext * D.30135;
  struct CallInfo * D.30136;
  <unnamed type> D.30137;
  struct MonoType * D.30140;
  int D.30143;
  struct MonoClass * D.30146;
  struct MonoType * D.30147;
  struct MonoInst * D.30148;
  unsigned int D.30149;
  _Bool D.30150;
  long int D.30151;
  long int D.30152;
  struct MonoInst * D.30155;
  unsigned char D.30156;
  unsigned char D.30157;
  unsigned char D.30160;
  unsigned char D.30161;
  unsigned char D.30164;
  unsigned char D.30165;
  unsigned char D.30166;
  unsigned char D.30167;
  unsigned char D.30168;
  unsigned char D.30169;
  int D.30174;
  int optimize_for_xen.60;
  struct MonoMethodSignature * sig;
  struct CallInfo * cinfo;
  struct MonoType * sig_ret;

  D.30130 = cfg->method;
  sig = mono_method_signature (D.30130);
  D.30131 = cfg->arch.cinfo;
  if (D.30131 == 0B) goto <D.30132>; else goto <D.30133>;
  <D.30132>:
  D.30134 = cfg->mempool;
  D.30135 = cfg->generic_sharing_context;
  D.30136 = get_call_info (D.30135, D.30134, sig);
  cfg->arch.cinfo = D.30136;
  <D.30133>:
  cinfo = cfg->arch.cinfo;
  D.30137 = cinfo->ret.storage;
  if (D.30137 == 4) goto <D.30138>; else goto <D.30139>;
  <D.30138>:
  cfg->ret_var_is_local = 1;
  <D.30139>:
  D.30140 = sig->ret;
  sig_ret = mini_replace_type (D.30140);
  D.30137 = cinfo->ret.storage;
  if (D.30137 != 4) goto <D.30141>; else goto <D.30142>;
  <D.30141>:
  D.30143 = mono_type_is_struct (sig_ret);
  if (D.30143 != 0) goto <D.30144>; else goto <D.30145>;
  <D.30144>:
  D.30146 = mono_defaults.int_class;
  D.30147 = &D.30146->byval_arg;
  D.30148 = mono_compile_create_var (cfg, D.30147, 330);
  cfg->vret_addr = D.30148;
  D.30149 = cfg->verbose_level;
  D.30150 = D.30149 > 1;
  D.30151 = (long int) D.30150;
  D.30152 = __builtin_expect (D.30151, 0);
  if (D.30152 != 0) goto <D.30153>; else goto <D.30154>;
  <D.30153>:
  printf ("vret_addr = ");
  D.30155 = cfg->vret_addr;
  mono_print_ins (D.30155);
  <D.30154>:
  <D.30145>:
  <D.30142>:
  D.30156 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.30157 = D.30156 & 32;
  if (D.30157 != 0) goto <D.30158>; else goto <D.30159>;
  <D.30158>:
  {
    struct MonoInst * ins;

    D.30160 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.30161 = D.30160 & 64;
    if (D.30161 != 0) goto <D.30162>; else goto <D.30163>;
    <D.30162>:
    {
      struct MonoInst * ins;

      D.30146 = mono_defaults.int_class;
      D.30147 = &D.30146->byval_arg;
      ins = mono_compile_create_var (cfg, D.30147, 329);
      D.30164 = ins->flags;
      D.30165 = D.30164 | 4;
      ins->flags = D.30165;
      cfg->arch.seq_point_info_var = ins;
    }
    <D.30163>:
    D.30146 = mono_defaults.int_class;
    D.30147 = &D.30146->byval_arg;
    ins = mono_compile_create_var (cfg, D.30147, 329);
    D.30166 = ins->flags;
    D.30167 = D.30166 | 4;
    ins->flags = D.30167;
    cfg->arch.ss_trigger_page_var = ins;
  }
  <D.30159>:
  cfg->arch.no_pushes = 1;
  D.30130 = cfg->method;
  D.30168 = BIT_FIELD_REF <*D.30130, 8, 264>;
  D.30169 = D.30168 & 1;
  if (D.30169 != 0) goto <D.30170>; else goto <D.30171>;
  <D.30170>:
  cfg->create_lmf_var = 1;
  <D.30171>:
  D.30130 = cfg->method;
  D.30168 = BIT_FIELD_REF <*D.30130, 8, 264>;
  D.30169 = D.30168 & 1;
  if (D.30169 != 0) goto <D.30172>; else goto <D.30173>;
  <D.30172>:
  cfg->lmf_ir = 1;
  D.30174 = mono_get_lmf_tls_offset ();
  if (D.30174 != -1) goto <D.30175>; else goto <D.30176>;
  <D.30175>:
  optimize_for_xen.60 = optimize_for_xen;
  if (optimize_for_xen.60 == 0) goto <D.30178>; else goto <D.30179>;
  <D.30178>:
  cfg->lmf_ir_mono_lmf = 1;
  <D.30179>:
  <D.30176>:
  <D.30173>:
}


mono_arch_emit_call (struct MonoCompile * cfg, struct MonoCallInst * call)
{
  short unsigned int D.30180;
  int D.30181;
  <unnamed-unsigned:1> D.30182;
  int D.30183;
  struct MonoMemPool * D.30184;
  struct MonoGenericSharingContext * D.30185;
  int D.30188;
  int D.30191;
  long int D.30194;
  struct MonoInst * D.30195;
  int D.30196;
  int D.30197;
  const unsigned char * D.30198;
  struct MonoBasicBlock * D.30199;
  struct MonoInst * D.30200;
  sizetype D.30206;
  struct MonoInst * * D.30207;
  long unsigned int D.30208;
  long unsigned int D.30209;
  struct MonoInst * * D.30210;
  unsigned char D.30213;
  unsigned char D.30214;
  struct MonoClass * D.30217;
  int D.30218;
  <unnamed type> D.30219;
  int D.30222;
  unsigned char D.30225;
  unsigned char D.30226;
  unsigned char D.30229;
  unsigned char D.30230;
  unsigned char D.30233;
  long int D.30236;
  struct MonoInst * D.30237;
  int D.30238;
  int D.30239;
  int D.30240;
  short int D.30241;
  long int D.30242;
  long int D.30249;
  struct MonoInst * D.30250;
  int D.30251;
  int D.30252;
  long int D.30257;
  struct MonoInst * D.30258;
  int D.30259;
  int D.30260;
  long int D.30265;
  struct MonoInst * D.30266;
  int D.30267;
  int D.30268;
  unsigned char D.30272;
  unsigned char D.30273;
  long int D.30276;
  struct MonoInst * D.30277;
  int D.30278;
  int D.30279;
  signed char D.30285;
  int D.30286;
  struct MonoInst * * D.30291;
  struct MonoInst * * D.30292;
  struct MonoInst * D.30293;
  unsigned char D.30294;
  unsigned char D.30295;
  long int D.30296;
  struct MonoInst * D.30297;
  int D.30298;
  int D.30299;
  struct MonoType * * D.30300;
  struct MonoType * * D.30301;
  struct MonoType * D.30302;
  unsigned int D.30303;
  short unsigned int D.30304;
  struct MonoClass * D.30305;
  int D.30306;
  short unsigned int D.30307;
  struct MonoClass * D.30310;
  struct MonoType * D.30317;
  int D.30318;
  unsigned char D.30320;
  unsigned char D.30324;
  unsigned char D.30325;
  struct MonoClass * D.30328;
  struct MonoType * D.30329;
  int D.30330;
  int D.30332;
  _Bool D.30333;
  long int D.30334;
  long int D.30335;
  gchar * D.30342;
  long int D.30345;
  struct MonoInst * D.30346;
  int D.30347;
  int D.30348;
  int size.61;
  void * D.30350;
  void * D.30351;
  unsigned char D.30358;
  unsigned char D.30359;
  long int D.30364;
  struct MonoInst * D.30365;
  int D.30366;
  int D.30367;
  long int D.30374;
  struct MonoInst * D.30375;
  int D.30376;
  int D.30377;
  short unsigned int D.30384;
  short unsigned int D.30385;
  short int D.30388;
  int D.30389;
  struct MonoType * D.30396;
  int D.30399;
  <unnamed type> D.30402;
  <unnamed type> D.30407;
  <unnamed type> D.30409;
  struct MonoInst * D.30411;
  int D.30414;
  int D.30415;
  void * D.30418;
  struct MonoClass * D.30421;
  struct MonoType * D.30422;
  struct MonoInst * D.30423;
  unsigned char D.30424;
  unsigned char D.30425;
  long int D.30426;
  struct MonoInst * D.30427;
  int D.30428;
  int D.30429;
  int D.30430;
  int D.30431;
  long int D.30436;
  struct MonoInst * D.30437;
  int D.30438;
  int D.30439;
  unsigned int D.30440;
  int D.30441;
  signed char D.30445;
  int D.30446;
  int D.30447;
  struct MonoMethod * D.30448;
  unsigned char D.30449;
  unsigned char D.30450;
  unsigned int D.30456;
  struct MonoInst * arg;
  struct MonoInst * in;
  struct MonoMethodSignature * sig;
  struct MonoType * sig_ret;
  int i;
  int n;
  int stack_size;
  struct CallInfo * cinfo;
  struct ArgInfo * ainfo;

  stack_size = 0;
  sig = call->signature;
  D.30180 = sig->param_count;
  D.30181 = (int) D.30180;
  D.30182 = sig->hasthis;
  D.30183 = (int) D.30182;
  n = D.30181 + D.30183;
  D.30184 = cfg->mempool;
  D.30185 = cfg->generic_sharing_context;
  cinfo = get_call_info (D.30185, D.30184, sig);
  sig_ret = sig->ret;
  if (0 != 0) goto <D.30186>; else goto <D.30187>;
  <D.30186>:
  cfg->disable_llvm = 1;
  return;
  <D.30187>:
  D.30188 = cinfo->need_stack_align;
  if (D.30188 != 0) goto <D.30189>; else goto <D.30190>;
  <D.30189>:
  D.30191 = cfg->arch.no_pushes;
  if (D.30191 == 0) goto <D.30192>; else goto <D.30193>;
  <D.30192>:
  {
    struct MonoInst * inst;

    D.30184 = cfg->mempool;
    inst = mono_mempool_alloc (D.30184, 80);
    inst->data.op[1].const_val = 0;
    D.30194 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30194;
    inst->prev = 0B;
    D.30195 = inst->prev;
    inst->next = D.30195;
    inst->opcode = 434;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30196 = inst->sreg3;
    inst->sreg2 = D.30196;
    D.30197 = inst->sreg2;
    inst->sreg1 = D.30197;
    D.30198 = cfg->ip;
    inst->cil_code = D.30198;
    inst->dreg = 4;
    inst->sreg1 = 4;
    inst->data.op[1].const_val = 8;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    if (D.30200 != 0B) goto <D.30201>; else goto <D.30202>;
    <D.30201>:
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    D.30200->next = inst;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    inst->prev = D.30200;
    D.30199 = cfg->cbb;
    D.30199->last_ins = inst;
    goto <D.30203>;
    <D.30202>:
    D.30199 = cfg->cbb;
    D.30199 = cfg->cbb;
    D.30199->last_ins = inst;
    D.30200 = D.30199->last_ins;
    D.30199->code = D.30200;
    <D.30203>:
  }
  <D.30193>:
  <D.30190>:
  D.30191 = cfg->arch.no_pushes;
  if (D.30191 != 0) goto <D.30204>; else goto <D.30205>;
  <D.30204>:
  i = 0;
  goto <D.24552>;
  <D.24551>:
  {
    struct MonoType * t;

    D.30206 = (sizetype) i;
    ainfo = &cinfo->args[D.30206];
    D.30207 = call->args;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30210 = D.30207 + D.30209;
    in = *D.30210;
    D.30213 = BIT_FIELD_REF <*sig, 8, 112>;
    D.30214 = D.30213 & 64;
    if (D.30214 != 0) goto <D.30215>; else goto <D.30211>;
    <D.30215>:
    if (i == 0) goto <D.30216>; else goto <D.30211>;
    <D.30216>:
    D.30217 = mono_defaults.object_class;
    t = &D.30217->byval_arg;
    goto <D.30212>;
    <D.30211>:
    D.30182 = sig->hasthis;
    D.30183 = (int) D.30182;
    D.30218 = i - D.30183;
    t = sig->params[D.30218];
    <D.30212>:
    D.30219 = ainfo->storage;
    if (D.30219 == 3) goto <D.30220>; else goto <D.30221>;
    <D.30220>:
    D.30222 = mono_type_is_struct (t);
    if (D.30222 == 0) goto <D.30223>; else goto <D.30224>;
    <D.30223>:
    D.30225 = BIT_FIELD_REF <*call, 8, 1088>;
    D.30226 = D.30225 & 2;
    if (D.30226 == 0) goto <D.30227>; else goto <D.30228>;
    <D.30227>:
    D.30229 = BIT_FIELD_REF <*t, 8, 88>;
    D.30230 = D.30229 & 64;
    if (D.30230 == 0) goto <D.30231>; else goto <D.30232>;
    <D.30231>:
    D.30233 = t->type;
    if (D.30233 == 12) goto <D.30234>; else goto <D.30235>;
    <D.30234>:
    {
      struct MonoInst * inst;

      D.30184 = cfg->mempool;
      inst = mono_mempool_alloc (D.30184, 80);
      inst->data.op[1].const_val = 0;
      D.30236 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30236;
      inst->prev = 0B;
      D.30237 = inst->prev;
      inst->next = D.30237;
      inst->opcode = 379;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30238 = inst->sreg3;
      inst->sreg2 = D.30238;
      D.30239 = inst->sreg2;
      inst->sreg1 = D.30239;
      D.30198 = cfg->ip;
      inst->cil_code = D.30198;
      D.30240 = in->dreg;
      inst->sreg1 = D.30240;
      inst->dreg = 4;
      D.30241 = ainfo->offset;
      D.30242 = (long int) D.30241;
      inst->data.op[0].const_val = D.30242;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      if (D.30200 != 0B) goto <D.30243>; else goto <D.30244>;
      <D.30243>:
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      D.30200->next = inst;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      inst->prev = D.30200;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      goto <D.30245>;
      <D.30244>:
      D.30199 = cfg->cbb;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      D.30200 = D.30199->last_ins;
      D.30199->code = D.30200;
      <D.30245>:
    }
    goto <D.30246>;
    <D.30235>:
    D.30233 = t->type;
    if (D.30233 == 13) goto <D.30247>; else goto <D.30248>;
    <D.30247>:
    {
      struct MonoInst * inst;

      D.30184 = cfg->mempool;
      inst = mono_mempool_alloc (D.30184, 80);
      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;
      inst->opcode = 380;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30251 = inst->sreg3;
      inst->sreg2 = D.30251;
      D.30252 = inst->sreg2;
      inst->sreg1 = D.30252;
      D.30198 = cfg->ip;
      inst->cil_code = D.30198;
      D.30240 = in->dreg;
      inst->sreg1 = D.30240;
      inst->dreg = 4;
      D.30241 = ainfo->offset;
      D.30242 = (long int) D.30241;
      inst->data.op[0].const_val = D.30242;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      if (D.30200 != 0B) goto <D.30253>; else goto <D.30254>;
      <D.30253>:
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      D.30200->next = inst;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      inst->prev = D.30200;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      goto <D.30255>;
      <D.30254>:
      D.30199 = cfg->cbb;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      D.30200 = D.30199->last_ins;
      D.30199->code = D.30200;
      <D.30255>:
    }
    goto <D.30256>;
    <D.30248>:
    {
      struct MonoInst * inst;

      D.30184 = cfg->mempool;
      inst = mono_mempool_alloc (D.30184, 80);
      inst->data.op[1].const_val = 0;
      D.30257 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30257;
      inst->prev = 0B;
      D.30258 = inst->prev;
      inst->next = D.30258;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30259 = inst->sreg3;
      inst->sreg2 = D.30259;
      D.30260 = inst->sreg2;
      inst->sreg1 = D.30260;
      D.30198 = cfg->ip;
      inst->cil_code = D.30198;
      D.30240 = in->dreg;
      inst->sreg1 = D.30240;
      inst->dreg = 4;
      D.30241 = ainfo->offset;
      D.30242 = (long int) D.30241;
      inst->data.op[0].const_val = D.30242;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      if (D.30200 != 0B) goto <D.30261>; else goto <D.30262>;
      <D.30261>:
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      D.30200->next = inst;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      inst->prev = D.30200;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      goto <D.30263>;
      <D.30262>:
      D.30199 = cfg->cbb;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      D.30200 = D.30199->last_ins;
      D.30199->code = D.30200;
      <D.30263>:
    }
    <D.30256>:
    <D.30246>:
    goto <D.30264>;
    <D.30232>:
    {
      struct MonoInst * inst;

      D.30184 = cfg->mempool;
      inst = mono_mempool_alloc (D.30184, 80);
      inst->data.op[1].const_val = 0;
      D.30265 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30265;
      inst->prev = 0B;
      D.30266 = inst->prev;
      inst->next = D.30266;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30267 = inst->sreg3;
      inst->sreg2 = D.30267;
      D.30268 = inst->sreg2;
      inst->sreg1 = D.30268;
      D.30198 = cfg->ip;
      inst->cil_code = D.30198;
      D.30240 = in->dreg;
      inst->sreg1 = D.30240;
      inst->dreg = 4;
      D.30241 = ainfo->offset;
      D.30242 = (long int) D.30241;
      inst->data.op[0].const_val = D.30242;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      if (D.30200 != 0B) goto <D.30269>; else goto <D.30270>;
      <D.30269>:
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      D.30200->next = inst;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      inst->prev = D.30200;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      goto <D.30271>;
      <D.30270>:
      D.30199 = cfg->cbb;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      D.30200 = D.30199->last_ins;
      D.30199->code = D.30200;
      <D.30271>:
    }
    <D.30264>:
    D.30272 = BIT_FIELD_REF <*cfg, 8, 5632>;
    D.30273 = D.30272 & 128;
    if (D.30273 != 0) goto <D.30274>; else goto <D.30275>;
    <D.30274>:
    {
      struct MonoInst * def;

      D.30184 = cfg->mempool;
      def = mono_mempool_alloc (D.30184, 80);
      def->data.op[1].const_val = 0;
      D.30276 = def->data.op[1].const_val;
      def->data.op[0].const_val = D.30276;
      def->prev = 0B;
      D.30277 = def->prev;
      def->next = D.30277;
      def->opcode = 1003;
      def->flags = 0;
      def->type = 0;
      def->dreg = -1;
      def->sreg3 = -1;
      D.30278 = def->sreg3;
      def->sreg2 = D.30278;
      D.30279 = def->sreg2;
      def->sreg1 = D.30279;
      D.30198 = cfg->ip;
      def->cil_code = D.30198;
      D.30241 = ainfo->offset;
      D.30242 = (long int) D.30241;
      def->data.op[0].const_val = D.30242;
      def->data.op[1].vtype = t;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      if (D.30200 != 0B) goto <D.30280>; else goto <D.30281>;
      <D.30280>:
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      D.30200->next = def;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      def->prev = D.30200;
      D.30199 = cfg->cbb;
      D.30199->last_ins = def;
      goto <D.30282>;
      <D.30281>:
      D.30199 = cfg->cbb;
      D.30199 = cfg->cbb;
      D.30199->last_ins = def;
      D.30200 = D.30199->last_ins;
      D.30199->code = D.30200;
      <D.30282>:
    }
    <D.30275>:
    <D.30228>:
    <D.30224>:
    <D.30221>:
  }
  i = i + 1;
  <D.24552>:
  if (i < n) goto <D.24551>; else goto <D.24553>;
  <D.24553>:
  <D.30205>:
  i = 0;
  goto <D.24555>;
  <D.24554>:
  D.30206 = (sizetype) i;
  ainfo = &cinfo->args[D.30206];
  D.30207 = call->args;
  D.30208 = (long unsigned int) i;
  D.30209 = D.30208 * 8;
  D.30210 = D.30207 + D.30209;
  in = *D.30210;
  D.30219 = ainfo->storage;
  if (D.30219 == 0) goto <D.30283>; else goto <D.30284>;
  <D.30283>:
  D.30285 = ainfo->reg;
  D.30286 = (int) D.30285;
  D.30219 = ainfo->storage;
  add_outarg_reg (cfg, call, D.30219, D.30286, in);
  <D.30284>:
  i = i + 1;
  <D.24555>:
  if (i < n) goto <D.24554>; else goto <D.24556>;
  <D.24556>:
  i = n + -1;
  goto <D.24571>;
  <D.24570>:
  D.30206 = (sizetype) i;
  ainfo = &cinfo->args[D.30206];
  D.30207 = call->args;
  D.30208 = (long unsigned int) i;
  D.30209 = D.30208 * 8;
  D.30210 = D.30207 + D.30209;
  in = *D.30210;
  D.30219 = ainfo->storage;
  switch (D.30219) <default: <D.24569>, case 0: <D.24557>, case 1: <D.24559>, case 2: <D.24560>, case 3: <D.24561>, case 4: <D.24562>, case 5: <D.24563>>
  <D.24557>:
  goto <D.24558>;
  <D.24559>:
  <D.24560>:
  D.30285 = ainfo->reg;
  D.30286 = (int) D.30285;
  D.30219 = ainfo->storage;
  add_outarg_reg (cfg, call, D.30219, D.30286, in);
  goto <D.24558>;
  <D.24561>:
  <D.24562>:
  <D.24563>:
  D.30219 = ainfo->storage;
  if (D.30219 == 3) goto <D.30289>; else goto <D.30287>;
  <D.30289>:
  D.30225 = BIT_FIELD_REF <*call, 8, 1088>;
  D.30226 = D.30225 & 2;
  if (D.30226 != 0) goto <D.30290>; else goto <D.30287>;
  <D.30290>:
  {
    struct MonoInst * call_inst;

    call_inst = call;
    D.30291 = cfg->args;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30292 = D.30291 + D.30209;
    D.30293 = *D.30292;
    D.30291 = cfg->args;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30292 = D.30291 + D.30209;
    D.30293 = *D.30292;
    D.30294 = D.30293->flags;
    D.30295 = D.30294 | 4;
    D.30293->flags = D.30295;
    D.30184 = cfg->mempool;
    call_inst = mono_mempool_alloc (D.30184, 80);
    call_inst->data.op[1].const_val = 0;
    D.30296 = call_inst->data.op[1].const_val;
    call_inst->data.op[0].const_val = D.30296;
    call_inst->prev = 0B;
    D.30297 = call_inst->prev;
    call_inst->next = D.30297;
    call_inst->opcode = 428;
    call_inst->flags = 0;
    call_inst->type = 0;
    call_inst->dreg = -1;
    call_inst->sreg3 = -1;
    D.30298 = call_inst->sreg3;
    call_inst->sreg2 = D.30298;
    D.30299 = call_inst->sreg2;
    call_inst->sreg1 = D.30299;
    D.30198 = cfg->ip;
    call_inst->cil_code = D.30198;
    D.30300 = cfg->arg_types;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30301 = D.30300 + D.30209;
    D.30302 = *D.30301;
    D.30303 = mono_type_to_regmove (cfg, D.30302);
    D.30304 = (short unsigned int) D.30303;
    call_inst->opcode = D.30304;
    D.30291 = cfg->args;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30292 = D.30291 + D.30209;
    D.30293 = *D.30292;
    D.30305 = D.30293->klass;
    call_inst->klass = D.30305;
    D.30240 = in->dreg;
    call_inst->sreg1 = D.30240;
    D.30291 = cfg->args;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30292 = D.30291 + D.30209;
    D.30293 = *D.30292;
    D.30306 = D.30293->dreg;
    call_inst->dreg = D.30306;
    D.30307 = call_inst->opcode;
    if (D.30307 == 431) goto <D.30308>; else goto <D.30309>;
    <D.30308>:
    D.30300 = cfg->arg_types;
    D.30208 = (long unsigned int) i;
    D.30209 = D.30208 * 8;
    D.30301 = D.30300 + D.30209;
    D.30302 = *D.30301;
    D.30310 = mono_class_from_mono_type (D.30302);
    call_inst->klass = D.30310;
    <D.30309>:
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    if (D.30200 != 0B) goto <D.30311>; else goto <D.30312>;
    <D.30311>:
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    D.30200->next = call_inst;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    call_inst->prev = D.30200;
    D.30199 = cfg->cbb;
    D.30199->last_ins = call_inst;
    goto <D.30313>;
    <D.30312>:
    D.30199 = cfg->cbb;
    D.30199 = cfg->cbb;
    D.30199->last_ins = call_inst;
    D.30200 = D.30199->last_ins;
    D.30199->code = D.30200;
    <D.30313>:
  }
  goto <D.30288>;
  <D.30287>:
  D.30182 = sig->hasthis;
  D.30183 = (int) D.30182;
  if (D.30183 <= i) goto <D.30316>; else goto <D.30314>;
  <D.30316>:
  D.30182 = sig->hasthis;
  D.30183 = (int) D.30182;
  D.30218 = i - D.30183;
  D.30317 = sig->params[D.30218];
  D.30318 = mono_type_is_struct (D.30317);
  if (D.30318 != 0) goto <D.30319>; else goto <D.30314>;
  <D.30319>:
  {
    guint32 align;
    guint32 size;

    try
      {
        D.30182 = sig->hasthis;
        D.30183 = (int) D.30182;
        D.30218 = i - D.30183;
        D.30317 = sig->params[D.30218];
        D.30320 = D.30317->type;
        if (D.30320 == 22) goto <D.30321>; else goto <D.30322>;
        <D.30321>:
        size = 24;
        align = 8;
        goto <D.30323>;
        <D.30322>:
        D.30324 = BIT_FIELD_REF <*sig, 8, 120>;
        D.30325 = D.30324 & 1;
        if (D.30325 != 0) goto <D.30326>; else goto <D.30327>;
        <D.30326>:
        D.30328 = in->klass;
        D.30329 = &D.30328->byval_arg;
        D.30330 = mono_type_native_stack_size (D.30329, &align);
        size = (guint32) D.30330;
        goto <D.30331>;
        <D.30327>:
        D.30328 = in->klass;
        D.30332 = mono_class_value_size (D.30328, &align);
        size = (guint32) D.30332;
        <D.30331>:
        <D.30323>:
        D.30328 = in->klass;
        D.30333 = D.30328 == 0B;
        D.30334 = (long int) D.30333;
        D.30335 = __builtin_expect (D.30334, 0);
        if (D.30335 != 0) goto <D.30336>; else goto <D.30337>;
        <D.30336>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2359, "in->klass");
        <D.30337>:
        D.30219 = ainfo->storage;
        if (D.30219 == 3) goto <D.30338>; else goto <D.30339>;
        <D.30338>:
        if (size > 9999) goto <D.30340>; else goto <D.30341>;
        <D.30340>:
        cfg->exception_type = 3;
        D.30342 = monoeg_g_strdup_printf ("Passing an argument of size \'%d\'.", size);
        cfg->exception_message = D.30342;
        <D.30341>:
        <D.30339>:
        if (size != 0) goto <D.30343>; else goto <D.30344>;
        <D.30343>:
        D.30184 = cfg->mempool;
        arg = mono_mempool_alloc (D.30184, 80);
        arg->data.op[1].const_val = 0;
        D.30345 = arg->data.op[1].const_val;
        arg->data.op[0].const_val = D.30345;
        arg->prev = 0B;
        D.30346 = arg->prev;
        arg->next = D.30346;
        arg->opcode = 333;
        arg->flags = 0;
        arg->type = 0;
        arg->dreg = -1;
        arg->sreg3 = -1;
        D.30347 = arg->sreg3;
        arg->sreg2 = D.30347;
        D.30348 = arg->sreg2;
        arg->sreg1 = D.30348;
        D.30198 = cfg->ip;
        arg->cil_code = D.30198;
        D.30240 = in->dreg;
        arg->sreg1 = D.30240;
        D.30328 = in->klass;
        arg->klass = D.30328;
        size.61 = (int) size;
        arg->backend.size = size.61;
        arg->data.op[0].p = call;
        D.30184 = cfg->mempool;
        D.30350 = mono_mempool_alloc (D.30184, 24);
        arg->data.op[1].p = D.30350;
        D.30351 = arg->data.op[1].p;
        memcpy (D.30351, ainfo, 24);
        D.30199 = cfg->cbb;
        D.30200 = D.30199->last_ins;
        if (D.30200 != 0B) goto <D.30352>; else goto <D.30353>;
        <D.30352>:
        D.30199 = cfg->cbb;
        D.30200 = D.30199->last_ins;
        D.30200->next = arg;
        D.30199 = cfg->cbb;
        D.30200 = D.30199->last_ins;
        arg->prev = D.30200;
        D.30199 = cfg->cbb;
        D.30199->last_ins = arg;
        goto <D.30354>;
        <D.30353>:
        D.30199 = cfg->cbb;
        D.30199 = cfg->cbb;
        D.30199->last_ins = arg;
        D.30200 = D.30199->last_ins;
        D.30199->code = D.30200;
        <D.30354>:
        <D.30344>:
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  goto <D.30315>;
  <D.30314>:
  D.30191 = cfg->arch.no_pushes;
  if (D.30191 != 0) goto <D.30355>; else goto <D.30356>;
  <D.30355>:
  goto <D.30357>;
  <D.30356>:
  D.30184 = cfg->mempool;
  arg = mono_mempool_alloc (D.30184, 80);
  arg->data.op[1].const_val = 0;
  D.30345 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30345;
  arg->prev = 0B;
  D.30346 = arg->prev;
  arg->next = D.30346;
  arg->opcode = 1034;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30347 = arg->sreg3;
  arg->sreg2 = D.30347;
  D.30348 = arg->sreg2;
  arg->sreg1 = D.30348;
  D.30198 = cfg->ip;
  arg->cil_code = D.30198;
  D.30240 = in->dreg;
  arg->sreg1 = D.30240;
  D.30182 = sig->hasthis;
  D.30183 = (int) D.30182;
  D.30218 = i - D.30183;
  D.30317 = sig->params[D.30218];
  D.30358 = BIT_FIELD_REF <*D.30317, 8, 88>;
  D.30359 = D.30358 & 64;
  if (D.30359 == 0) goto <D.30360>; else goto <D.30361>;
  <D.30360>:
  D.30182 = sig->hasthis;
  D.30183 = (int) D.30182;
  D.30218 = i - D.30183;
  D.30317 = sig->params[D.30218];
  D.30320 = D.30317->type;
  if (D.30320 == 12) goto <D.30362>; else goto <D.30363>;
  <D.30362>:
  {
    struct MonoInst * inst;

    D.30184 = cfg->mempool;
    inst = mono_mempool_alloc (D.30184, 80);
    inst->data.op[1].const_val = 0;
    D.30364 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30364;
    inst->prev = 0B;
    D.30365 = inst->prev;
    inst->next = D.30365;
    inst->opcode = 434;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30366 = inst->sreg3;
    inst->sreg2 = D.30366;
    D.30367 = inst->sreg2;
    inst->sreg1 = D.30367;
    D.30198 = cfg->ip;
    inst->cil_code = D.30198;
    inst->dreg = 4;
    inst->sreg1 = 4;
    inst->data.op[1].const_val = 8;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    if (D.30200 != 0B) goto <D.30368>; else goto <D.30369>;
    <D.30368>:
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    D.30200->next = inst;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    inst->prev = D.30200;
    D.30199 = cfg->cbb;
    D.30199->last_ins = inst;
    goto <D.30370>;
    <D.30369>:
    D.30199 = cfg->cbb;
    D.30199 = cfg->cbb;
    D.30199->last_ins = inst;
    D.30200 = D.30199->last_ins;
    D.30199->code = D.30200;
    <D.30370>:
  }
  arg->opcode = 379;
  arg->dreg = 4;
  arg->data.op[0].const_val = 0;
  goto <D.30371>;
  <D.30363>:
  D.30182 = sig->hasthis;
  D.30183 = (int) D.30182;
  D.30218 = i - D.30183;
  D.30317 = sig->params[D.30218];
  D.30320 = D.30317->type;
  if (D.30320 == 13) goto <D.30372>; else goto <D.30373>;
  <D.30372>:
  {
    struct MonoInst * inst;

    D.30184 = cfg->mempool;
    inst = mono_mempool_alloc (D.30184, 80);
    inst->data.op[1].const_val = 0;
    D.30374 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30374;
    inst->prev = 0B;
    D.30375 = inst->prev;
    inst->next = D.30375;
    inst->opcode = 434;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30376 = inst->sreg3;
    inst->sreg2 = D.30376;
    D.30377 = inst->sreg2;
    inst->sreg1 = D.30377;
    D.30198 = cfg->ip;
    inst->cil_code = D.30198;
    inst->dreg = 4;
    inst->sreg1 = 4;
    inst->data.op[1].const_val = 8;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    if (D.30200 != 0B) goto <D.30378>; else goto <D.30379>;
    <D.30378>:
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    D.30200->next = inst;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    inst->prev = D.30200;
    D.30199 = cfg->cbb;
    D.30199->last_ins = inst;
    goto <D.30380>;
    <D.30379>:
    D.30199 = cfg->cbb;
    D.30199 = cfg->cbb;
    D.30199->last_ins = inst;
    D.30200 = D.30199->last_ins;
    D.30199->code = D.30200;
    <D.30380>:
  }
  arg->opcode = 380;
  arg->dreg = 4;
  arg->data.op[0].const_val = 0;
  <D.30373>:
  <D.30371>:
  <D.30361>:
  D.30199 = cfg->cbb;
  D.30200 = D.30199->last_ins;
  if (D.30200 != 0B) goto <D.30381>; else goto <D.30382>;
  <D.30381>:
  D.30199 = cfg->cbb;
  D.30200 = D.30199->last_ins;
  D.30200->next = arg;
  D.30199 = cfg->cbb;
  D.30200 = D.30199->last_ins;
  arg->prev = D.30200;
  D.30199 = cfg->cbb;
  D.30199->last_ins = arg;
  goto <D.30383>;
  <D.30382>:
  D.30199 = cfg->cbb;
  D.30199 = cfg->cbb;
  D.30199->last_ins = arg;
  D.30200 = D.30199->last_ins;
  D.30199->code = D.30200;
  <D.30383>:
  <D.30357>:
  <D.30315>:
  <D.30288>:
  goto <D.24558>;
  <D.24569>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2403);
  <D.24558>:
  D.30384 = BIT_FIELD_REF <*sig, 16, 112>;
  D.30385 = D.30384 & 319;
  if (D.30385 == 5) goto <D.30386>; else goto <D.30387>;
  <D.30386>:
  D.30388 = sig->sentinelpos;
  D.30389 = (int) D.30388;
  if (D.30389 == i) goto <D.30390>; else goto <D.30391>;
  <D.30390>:
  emit_sig_cookie (cfg, call, cinfo);
  <D.30391>:
  <D.30387>:
  i = i + -1;
  <D.24571>:
  if (i >= 0) goto <D.24570>; else goto <D.24572>;
  <D.24572>:
  D.30384 = BIT_FIELD_REF <*sig, 16, 112>;
  D.30385 = D.30384 & 319;
  if (D.30385 == 5) goto <D.30392>; else goto <D.30393>;
  <D.30392>:
  D.30388 = sig->sentinelpos;
  D.30389 = (int) D.30388;
  if (D.30389 == n) goto <D.30394>; else goto <D.30395>;
  <D.30394>:
  emit_sig_cookie (cfg, call, cinfo);
  <D.30395>:
  <D.30393>:
  D.30396 = sig->ret;
  sig_ret = mini_replace_type (D.30396);
  if (sig_ret != 0B) goto <D.30397>; else goto <D.30398>;
  <D.30397>:
  D.30399 = mono_type_is_struct (sig_ret);
  if (D.30399 != 0) goto <D.30400>; else goto <D.30401>;
  <D.30400>:
  {
    struct MonoInst * vtarg;

    D.30402 = cinfo->ret.storage;
    if (D.30402 == 4) goto <D.30403>; else goto <D.30404>;
    <D.30403>:
    D.30407 = cinfo->ret.pair_storage[0];
    if (D.30407 == 0) goto <D.30408>; else goto <D.30405>;
    <D.30408>:
    D.30409 = cinfo->ret.pair_storage[1];
    if (D.30409 == 6) goto <D.30410>; else goto <D.30405>;
    <D.30410>:
    call->vret_in_reg = 1;
    D.30411 = call->vret_var;
    if (D.30411 != 0B) goto <D.30412>; else goto <D.30413>;
    <D.30412>:
    D.30411 = call->vret_var;
    D.30411->opcode = 316;
    D.30411 = call->vret_var;
    D.30411->dreg = -1;
    D.30411 = call->vret_var;
    D.30411 = call->vret_var;
    D.30411 = call->vret_var;
    D.30411->sreg3 = -1;
    D.30414 = D.30411->sreg3;
    D.30411->sreg2 = D.30414;
    D.30415 = D.30411->sreg2;
    D.30411->sreg1 = D.30415;
    <D.30413>:
    goto <D.30406>;
    <D.30405>:
    D.30225 = BIT_FIELD_REF <*call, 8, 1088>;
    D.30226 = D.30225 & 2;
    if (D.30226 != 0) goto <D.30416>; else goto <D.30417>;
    <D.30416>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2435);
    <D.30417>:
    D.30418 = cfg->arch.vret_addr_loc;
    if (D.30418 == 0B) goto <D.30419>; else goto <D.30420>;
    <D.30419>:
    D.30421 = mono_defaults.int_class;
    D.30422 = &D.30421->byval_arg;
    D.30423 = mono_compile_create_var (cfg, D.30422, 329);
    cfg->arch.vret_addr_loc = D.30423;
    D.30418 = cfg->arch.vret_addr_loc;
    D.30418 = cfg->arch.vret_addr_loc;
    D.30424 = MEM[(struct MonoInst *)D.30418].flags;
    D.30425 = D.30424 | 4;
    MEM[(struct MonoInst *)D.30418].flags = D.30425;
    <D.30420>:
    {
      struct MonoInst * inst;

      D.30184 = cfg->mempool;
      inst = mono_mempool_alloc (D.30184, 80);
      inst->data.op[1].const_val = 0;
      D.30426 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30426;
      inst->prev = 0B;
      D.30427 = inst->prev;
      inst->next = D.30427;
      inst->opcode = 428;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30428 = inst->sreg3;
      inst->sreg2 = D.30428;
      D.30429 = inst->sreg2;
      inst->sreg1 = D.30429;
      D.30198 = cfg->ip;
      inst->cil_code = D.30198;
      D.30418 = cfg->arch.vret_addr_loc;
      D.30430 = MEM[(struct MonoInst *)D.30418].dreg;
      inst->dreg = D.30430;
      D.30411 = call->vret_var;
      D.30431 = D.30411->dreg;
      inst->sreg1 = D.30431;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      if (D.30200 != 0B) goto <D.30432>; else goto <D.30433>;
      <D.30432>:
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      D.30200->next = inst;
      D.30199 = cfg->cbb;
      D.30200 = D.30199->last_ins;
      inst->prev = D.30200;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      goto <D.30434>;
      <D.30433>:
      D.30199 = cfg->cbb;
      D.30199 = cfg->cbb;
      D.30199->last_ins = inst;
      D.30200 = D.30199->last_ins;
      D.30199->code = D.30200;
      <D.30434>:
    }
    <D.30406>:
    goto <D.30435>;
    <D.30404>:
    D.30184 = cfg->mempool;
    vtarg = mono_mempool_alloc (D.30184, 80);
    vtarg->data.op[1].const_val = 0;
    D.30436 = vtarg->data.op[1].const_val;
    vtarg->data.op[0].const_val = D.30436;
    vtarg->prev = 0B;
    D.30437 = vtarg->prev;
    vtarg->next = D.30437;
    vtarg->opcode = 428;
    vtarg->flags = 0;
    vtarg->type = 0;
    vtarg->dreg = -1;
    vtarg->sreg3 = -1;
    D.30438 = vtarg->sreg3;
    vtarg->sreg2 = D.30438;
    D.30439 = vtarg->sreg2;
    vtarg->sreg1 = D.30439;
    D.30198 = cfg->ip;
    vtarg->cil_code = D.30198;
    D.30411 = call->vret_var;
    D.30431 = D.30411->dreg;
    vtarg->sreg1 = D.30431;
    D.30440 = mono_alloc_preg (cfg);
    D.30441 = (int) D.30440;
    vtarg->dreg = D.30441;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    if (D.30200 != 0B) goto <D.30442>; else goto <D.30443>;
    <D.30442>:
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    D.30200->next = vtarg;
    D.30199 = cfg->cbb;
    D.30200 = D.30199->last_ins;
    vtarg->prev = D.30200;
    D.30199 = cfg->cbb;
    D.30199->last_ins = vtarg;
    goto <D.30444>;
    <D.30443>:
    D.30199 = cfg->cbb;
    D.30199 = cfg->cbb;
    D.30199->last_ins = vtarg;
    D.30200 = D.30199->last_ins;
    D.30199->code = D.30200;
    <D.30444>:
    D.30445 = cinfo->ret.reg;
    D.30446 = (int) D.30445;
    D.30447 = vtarg->dreg;
    mono_call_inst_add_outarg_reg (cfg, call, D.30447, D.30446, 0);
    <D.30435>:
  }
  <D.30401>:
  <D.30398>:
  D.30448 = cfg->method;
  D.30449 = BIT_FIELD_REF <*D.30448, 8, 264>;
  D.30450 = D.30449 & 1;
  if (D.30450 != 0) goto <D.30451>; else goto <D.30452>;
  <D.30451>:
  D.30184 = cfg->mempool;
  arg = mono_mempool_alloc (D.30184, 80);
  arg->data.op[1].const_val = 0;
  D.30345 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30345;
  arg->prev = 0B;
  D.30346 = arg->prev;
  arg->next = D.30346;
  arg->opcode = 1074;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30347 = arg->sreg3;
  arg->sreg2 = D.30347;
  D.30348 = arg->sreg2;
  arg->sreg1 = D.30348;
  D.30198 = cfg->ip;
  arg->cil_code = D.30198;
  D.30199 = cfg->cbb;
  D.30200 = D.30199->last_ins;
  if (D.30200 != 0B) goto <D.30453>; else goto <D.30454>;
  <D.30453>:
  D.30199 = cfg->cbb;
  D.30200 = D.30199->last_ins;
  D.30200->next = arg;
  D.30199 = cfg->cbb;
  D.30200 = D.30199->last_ins;
  arg->prev = D.30200;
  D.30199 = cfg->cbb;
  D.30199->last_ins = arg;
  goto <D.30455>;
  <D.30454>:
  D.30199 = cfg->cbb;
  D.30199 = cfg->cbb;
  D.30199->last_ins = arg;
  D.30200 = D.30199->last_ins;
  D.30199->code = D.30200;
  <D.30455>:
  <D.30452>:
  D.30456 = cinfo->stack_usage;
  call->stack_usage = D.30456;
}


add_outarg_reg (struct MonoCompile * cfg, struct MonoCallInst * call, ArgStorage storage, int reg, struct MonoInst * tree)
{
  struct MonoMemPool * D.30459;
  long int D.30460;
  struct MonoInst * D.30461;
  int D.30462;
  int D.30463;
  const unsigned char * D.30464;
  int D.30465;
  unsigned int D.30466;
  unsigned int D.30467;
  int D.30468;
  struct MonoBasicBlock * D.30469;
  struct MonoInst * D.30470;
  int D.30474;
  unsigned int D.30475;
  int D.30476;
  unsigned int D.30480;
  int D.30481;
  struct MonoInst * ins;

  switch (storage) <default: <D.24506>, case 0: <D.24502>, case 1: <D.24504>, case 2: <D.24505>>
  <D.24502>:
  D.30459 = cfg->mempool;
  ins = mono_mempool_alloc (D.30459, 80);
  ins->data.op[1].const_val = 0;
  D.30460 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.30460;
  ins->prev = 0B;
  D.30461 = ins->prev;
  ins->next = D.30461;
  ins->opcode = 428;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.30462 = ins->sreg3;
  ins->sreg2 = D.30462;
  D.30463 = ins->sreg2;
  ins->sreg1 = D.30463;
  D.30464 = cfg->ip;
  ins->cil_code = D.30464;
  D.30465 = tree->dreg;
  D.30466 = (unsigned int) D.30465;
  D.30467 = mono_alloc_ireg_copy (cfg, D.30466);
  D.30468 = (int) D.30467;
  ins->dreg = D.30468;
  D.30465 = tree->dreg;
  ins->sreg1 = D.30465;
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  if (D.30470 != 0B) goto <D.30471>; else goto <D.30472>;
  <D.30471>:
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  D.30470->next = ins;
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  ins->prev = D.30470;
  D.30469 = cfg->cbb;
  D.30469->last_ins = ins;
  goto <D.30473>;
  <D.30472>:
  D.30469 = cfg->cbb;
  D.30469 = cfg->cbb;
  D.30469->last_ins = ins;
  D.30470 = D.30469->last_ins;
  D.30469->code = D.30470;
  <D.30473>:
  D.30474 = ins->dreg;
  mono_call_inst_add_outarg_reg (cfg, call, D.30474, reg, 0);
  goto <D.24503>;
  <D.24504>:
  D.30459 = cfg->mempool;
  ins = mono_mempool_alloc (D.30459, 80);
  ins->data.op[1].const_val = 0;
  D.30460 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.30460;
  ins->prev = 0B;
  D.30461 = ins->prev;
  ins->next = D.30461;
  ins->opcode = 1047;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.30462 = ins->sreg3;
  ins->sreg2 = D.30462;
  D.30463 = ins->sreg2;
  ins->sreg1 = D.30463;
  D.30464 = cfg->ip;
  ins->cil_code = D.30464;
  D.30475 = mono_alloc_freg (cfg);
  D.30476 = (int) D.30475;
  ins->dreg = D.30476;
  D.30465 = tree->dreg;
  ins->sreg1 = D.30465;
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  if (D.30470 != 0B) goto <D.30477>; else goto <D.30478>;
  <D.30477>:
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  D.30470->next = ins;
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  ins->prev = D.30470;
  D.30469 = cfg->cbb;
  D.30469->last_ins = ins;
  goto <D.30479>;
  <D.30478>:
  D.30469 = cfg->cbb;
  D.30469 = cfg->cbb;
  D.30469->last_ins = ins;
  D.30470 = D.30469->last_ins;
  D.30469->code = D.30470;
  <D.30479>:
  D.30474 = ins->dreg;
  mono_call_inst_add_outarg_reg (cfg, call, D.30474, reg, 1);
  goto <D.24503>;
  <D.24505>:
  D.30459 = cfg->mempool;
  ins = mono_mempool_alloc (D.30459, 80);
  ins->data.op[1].const_val = 0;
  D.30460 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.30460;
  ins->prev = 0B;
  D.30461 = ins->prev;
  ins->next = D.30461;
  ins->opcode = 430;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.30462 = ins->sreg3;
  ins->sreg2 = D.30462;
  D.30463 = ins->sreg2;
  ins->sreg1 = D.30463;
  D.30464 = cfg->ip;
  ins->cil_code = D.30464;
  D.30480 = mono_alloc_freg (cfg);
  D.30481 = (int) D.30480;
  ins->dreg = D.30481;
  D.30465 = tree->dreg;
  ins->sreg1 = D.30465;
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  if (D.30470 != 0B) goto <D.30482>; else goto <D.30483>;
  <D.30482>:
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  D.30470->next = ins;
  D.30469 = cfg->cbb;
  D.30470 = D.30469->last_ins;
  ins->prev = D.30470;
  D.30469 = cfg->cbb;
  D.30469->last_ins = ins;
  goto <D.30484>;
  <D.30483>:
  D.30469 = cfg->cbb;
  D.30469 = cfg->cbb;
  D.30469->last_ins = ins;
  D.30470 = D.30469->last_ins;
  D.30469->code = D.30470;
  <D.30484>:
  D.30474 = ins->dreg;
  mono_call_inst_add_outarg_reg (cfg, call, D.30474, reg, 1);
  goto <D.24503>;
  <D.24506>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2070);
  <D.24503>:
}


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

  D.30486 = __builtin_object_size (__dest, 0);
  D.30485 = __builtin___memcpy_chk (__dest, __src, __len, D.30486);
  return D.30485;
}


emit_sig_cookie (struct MonoCompile * cfg, struct MonoCallInst * call, struct CallInfo * cinfo)
{
  unsigned char D.30488;
  unsigned char D.30489;
  <unnamed type> D.30492;
  _Bool D.30493;
  long int D.30494;
  long int D.30495;
  struct MonoMethodSignature * D.30498;
  struct MonoMethod * D.30499;
  struct MonoClass * D.30500;
  struct MonoImage * D.30501;
  short unsigned int D.30502;
  short int D.30503;
  short unsigned int D.30504;
  short unsigned int D.30505;
  long unsigned int D.30506;
  long unsigned int D.30507;
  sizetype D.30508;
  struct MonoType * * D.30509;
  struct MonoType *[0:] * D.30510;
  unsigned int D.30511;
  struct MonoMemPool * D.30512;
  long int D.30513;
  struct MonoInst * D.30514;
  guint16 iftmp.62;
  unsigned char D.30516;
  unsigned char D.30517;
  int D.30521;
  int D.30522;
  const unsigned char * D.30523;
  struct MonoBasicBlock * D.30524;
  struct MonoInst * D.30525;
  int D.30529;
  long int D.30532;
  struct MonoInst * D.30533;
  int D.30534;
  int D.30535;
  short int D.30536;
  long int D.30537;
  long int D.30542;
  struct MonoInst * D.30543;
  int D.30544;
  int D.30545;
  struct MonoInst * arg;
  struct MonoMethodSignature * tmp_sig;
  int sig_reg;

  D.30488 = BIT_FIELD_REF <*call, 8, 1088>;
  D.30489 = D.30488 & 2;
  if (D.30489 != 0) goto <D.30490>; else goto <D.30491>;
  <D.30490>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2103);
  <D.30491>:
  D.30492 = cinfo->sig_cookie.storage;
  D.30493 = D.30492 != 3;
  D.30494 = (long int) D.30493;
  D.30495 = __builtin_expect (D.30494, 0);
  if (D.30495 != 0) goto <D.30496>; else goto <D.30497>;
  <D.30496>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2105, "cinfo->sig_cookie.storage == ArgOnStack");
  <D.30497>:
  D.30498 = call->signature;
  D.30499 = cfg->method;
  D.30500 = D.30499->klass;
  D.30501 = D.30500->image;
  tmp_sig = mono_metadata_signature_dup_full (D.30501, D.30498);
  D.30502 = tmp_sig->param_count;
  D.30498 = call->signature;
  D.30503 = D.30498->sentinelpos;
  D.30504 = (short unsigned int) D.30503;
  D.30505 = D.30502 - D.30504;
  tmp_sig->param_count = D.30505;
  tmp_sig->sentinelpos = 0;
  D.30502 = tmp_sig->param_count;
  D.30506 = (long unsigned int) D.30502;
  D.30507 = D.30506 * 8;
  D.30498 = call->signature;
  D.30498 = call->signature;
  D.30503 = D.30498->sentinelpos;
  D.30508 = (sizetype) D.30503;
  D.30509 = &D.30498->params[D.30508];
  D.30510 = &tmp_sig->params;
  memcpy (D.30510, D.30509, D.30507);
  D.30511 = mono_alloc_ireg (cfg);
  sig_reg = (int) D.30511;
  {
    struct MonoInst * inst;

    D.30512 = cfg->mempool;
    inst = mono_mempool_alloc (D.30512, 80);
    inst->data.op[1].const_val = 0;
    D.30513 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30513;
    inst->prev = 0B;
    D.30514 = inst->prev;
    inst->next = D.30514;
    D.30516 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.30517 = D.30516 & 64;
    if (D.30517 != 0) goto <D.30518>; else goto <D.30519>;
    <D.30518>:
    iftmp.62 = 736;
    goto <D.30520>;
    <D.30519>:
    iftmp.62 = 363;
    <D.30520>:
    inst->opcode = iftmp.62;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30521 = inst->sreg3;
    inst->sreg2 = D.30521;
    D.30522 = inst->sreg2;
    inst->sreg1 = D.30522;
    D.30523 = cfg->ip;
    inst->cil_code = D.30523;
    inst->dreg = sig_reg;
    inst->data.op[0].p = tmp_sig;
    inst->data.op[1].const_val = 44;
    D.30524 = cfg->cbb;
    D.30525 = D.30524->last_ins;
    if (D.30525 != 0B) goto <D.30526>; else goto <D.30527>;
    <D.30526>:
    D.30524 = cfg->cbb;
    D.30525 = D.30524->last_ins;
    D.30525->next = inst;
    D.30524 = cfg->cbb;
    D.30525 = D.30524->last_ins;
    inst->prev = D.30525;
    D.30524 = cfg->cbb;
    D.30524->last_ins = inst;
    goto <D.30528>;
    <D.30527>:
    D.30524 = cfg->cbb;
    D.30524 = cfg->cbb;
    D.30524->last_ins = inst;
    D.30525 = D.30524->last_ins;
    D.30524->code = D.30525;
    <D.30528>:
  }
  D.30529 = cfg->arch.no_pushes;
  if (D.30529 != 0) goto <D.30530>; else goto <D.30531>;
  <D.30530>:
  {
    struct MonoInst * inst;

    D.30512 = cfg->mempool;
    inst = mono_mempool_alloc (D.30512, 80);
    inst->data.op[1].const_val = 0;
    D.30532 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30532;
    inst->prev = 0B;
    D.30533 = inst->prev;
    inst->next = D.30533;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30534 = inst->sreg3;
    inst->sreg2 = D.30534;
    D.30535 = inst->sreg2;
    inst->sreg1 = D.30535;
    D.30523 = cfg->ip;
    inst->cil_code = D.30523;
    inst->sreg1 = sig_reg;
    inst->dreg = 4;
    D.30536 = cinfo->sig_cookie.offset;
    D.30537 = (long int) D.30536;
    inst->data.op[0].const_val = D.30537;
    D.30524 = cfg->cbb;
    D.30525 = D.30524->last_ins;
    if (D.30525 != 0B) goto <D.30538>; else goto <D.30539>;
    <D.30538>:
    D.30524 = cfg->cbb;
    D.30525 = D.30524->last_ins;
    D.30525->next = inst;
    D.30524 = cfg->cbb;
    D.30525 = D.30524->last_ins;
    inst->prev = D.30525;
    D.30524 = cfg->cbb;
    D.30524->last_ins = inst;
    goto <D.30540>;
    <D.30539>:
    D.30524 = cfg->cbb;
    D.30524 = cfg->cbb;
    D.30524->last_ins = inst;
    D.30525 = D.30524->last_ins;
    D.30524->code = D.30525;
    <D.30540>:
  }
  goto <D.30541>;
  <D.30531>:
  D.30512 = cfg->mempool;
  arg = mono_mempool_alloc (D.30512, 80);
  arg->data.op[1].const_val = 0;
  D.30542 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30542;
  arg->prev = 0B;
  D.30543 = arg->prev;
  arg->next = D.30543;
  arg->opcode = 1034;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30544 = arg->sreg3;
  arg->sreg2 = D.30544;
  D.30545 = arg->sreg2;
  arg->sreg1 = D.30545;
  D.30523 = cfg->ip;
  arg->cil_code = D.30523;
  arg->sreg1 = sig_reg;
  D.30524 = cfg->cbb;
  D.30525 = D.30524->last_ins;
  if (D.30525 != 0B) goto <D.30546>; else goto <D.30547>;
  <D.30546>:
  D.30524 = cfg->cbb;
  D.30525 = D.30524->last_ins;
  D.30525->next = arg;
  D.30524 = cfg->cbb;
  D.30525 = D.30524->last_ins;
  arg->prev = D.30525;
  D.30524 = cfg->cbb;
  D.30524->last_ins = arg;
  goto <D.30548>;
  <D.30547>:
  D.30524 = cfg->cbb;
  D.30524 = cfg->cbb;
  D.30524->last_ins = arg;
  D.30525 = D.30524->last_ins;
  D.30524->code = D.30525;
  <D.30548>:
  <D.30541>:
}


mono_arch_emit_outarg_vt (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * src)
{
  <unnamed type> D.30549;
  <unnamed type> D.30552;
  struct MonoMemPool * D.30555;
  long int D.30556;
  struct MonoInst * D.30557;
  int D.30558;
  short unsigned int D.30559;
  int D.30560;
  int D.30561;
  const unsigned char * D.30562;
  int D.30563;
  long unsigned int D.30564;
  long unsigned int D.30565;
  long int D.30566;
  unsigned int D.30567;
  int D.30568;
  unsigned int D.30569;
  int D.30570;
  struct MonoBasicBlock * D.30571;
  struct MonoInst * D.30572;
  signed char D.30576;
  int D.30577;
  struct MonoClass * D.30581;
  struct MonoType * D.30582;
  int D.30583;
  _Bool D.30584;
  long int D.30585;
  long int D.30586;
  long int D.30589;
  struct MonoInst * D.30590;
  int D.30591;
  int D.30592;
  unsigned char D.30593;
  unsigned char D.30594;
  struct MonoClass * D.30595;
  unsigned int D.30596;
  int D.30597;
  int D.30601;
  <unnamed type> D.30602;
  long int D.30605;
  struct MonoInst * D.30606;
  int D.30607;
  int D.30608;
  unsigned int D.30609;
  int D.30610;
  signed char D.30614;
  int D.30615;
  int D.30616;
  unsigned int D.30626;
  long int D.30627;
  struct MonoInst * D.30628;
  int D.30629;
  int D.30630;
  long int D.30634;
  struct MonoInst * D.30635;
  int D.30636;
  int D.30637;
  short int D.30638;
  long int D.30639;
  int D.30652;
  long int D.30654;
  struct MonoInst * D.30655;
  int D.30656;
  int D.30657;
  long unsigned int D.30658;
  long unsigned int D.30659;
  long int D.30660;
  long int D.30661;
  long int D.30669;
  unsigned char D.30673;
  unsigned char D.30674;
  long int D.30677;
  struct MonoInst * D.30678;
  int D.30679;
  int D.30680;
  struct MonoInst * arg;
  struct MonoCallInst * call;
  struct ArgInfo * ainfo;
  int size;

  call = ins->data.op[0].p;
  ainfo = ins->data.op[1].p;
  size = ins->backend.size;
  D.30549 = ainfo->storage;
  if (D.30549 == 4) goto <D.30550>; else goto <D.30551>;
  <D.30550>:
  {
    struct MonoInst * load;
    int part;

    part = 0;
    goto <D.24593>;
    <D.24592>:
    D.30552 = ainfo->pair_storage[part];
    if (D.30552 == 6) goto <D.30553>; else goto <D.30554>;
    <D.30553>:
    // predicted unlikely by continue predictor.
    goto <D.24586>;
    <D.30554>:
    D.30555 = cfg->mempool;
    load = mono_mempool_alloc (D.30555, 80);
    load->data.op[1].const_val = 0;
    D.30556 = load->data.op[1].const_val;
    load->data.op[0].const_val = D.30556;
    load->prev = 0B;
    D.30557 = load->prev;
    load->next = D.30557;
    D.30552 = ainfo->pair_storage[part];
    D.30558 = arg_storage_to_load_membase (D.30552);
    D.30559 = (short unsigned int) D.30558;
    load->opcode = D.30559;
    load->flags = 0;
    load->type = 0;
    load->dreg = -1;
    load->sreg3 = -1;
    D.30560 = load->sreg3;
    load->sreg2 = D.30560;
    D.30561 = load->sreg2;
    load->sreg1 = D.30561;
    D.30562 = cfg->ip;
    load->cil_code = D.30562;
    D.30563 = src->dreg;
    load->sreg1 = D.30563;
    D.30564 = (long unsigned int) part;
    D.30565 = D.30564 * 8;
    D.30566 = (long int) D.30565;
    load->data.op[0].const_val = D.30566;
    D.30552 = ainfo->pair_storage[part];
    switch (D.30552) <default: <D.24591>, case 0: <D.24587>, case 1: <D.24590>, case 2: <D.24589>>
    <D.24587>:
    D.30567 = mono_alloc_ireg (cfg);
    D.30568 = (int) D.30567;
    load->dreg = D.30568;
    goto <D.24588>;
    <D.24589>:
    <D.24590>:
    D.30569 = mono_alloc_freg (cfg);
    D.30570 = (int) D.30569;
    load->dreg = D.30570;
    goto <D.24588>;
    <D.24591>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2503);
    <D.24588>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    if (D.30572 != 0B) goto <D.30573>; else goto <D.30574>;
    <D.30573>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    D.30572->next = load;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    load->prev = D.30572;
    D.30571 = cfg->cbb;
    D.30571->last_ins = load;
    goto <D.30575>;
    <D.30574>:
    D.30571 = cfg->cbb;
    D.30571 = cfg->cbb;
    D.30571->last_ins = load;
    D.30572 = D.30571->last_ins;
    D.30571->code = D.30572;
    <D.30575>:
    D.30576 = ainfo->pair_regs[part];
    D.30577 = (int) D.30576;
    D.30552 = ainfo->pair_storage[part];
    add_outarg_reg (cfg, call, D.30552, D.30577, load);
    <D.24586>:
    part = part + 1;
    <D.24593>:
    if (part <= 1) goto <D.24592>; else goto <D.24594>;
    <D.24594>:
  }
  goto <D.30578>;
  <D.30551>:
  D.30549 = ainfo->storage;
  if (D.30549 == 5) goto <D.30579>; else goto <D.30580>;
  <D.30579>:
  {
    struct MonoInst * vtaddr;
    struct MonoInst * load;

    D.30581 = ins->klass;
    D.30582 = &D.30581->byval_arg;
    vtaddr = mono_compile_create_var (cfg, D.30582, 329);
    D.30583 = cfg->arch.no_pushes;
    D.30584 = D.30583 != 0;
    D.30585 = (long int) D.30584;
    D.30586 = __builtin_expect (D.30585, 0);
    if (D.30586 != 0) goto <D.30587>; else goto <D.30588>;
    <D.30587>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2513, "!cfg->arch.no_pushes");
    <D.30588>:
    D.30555 = cfg->mempool;
    load = mono_mempool_alloc (D.30555, 80);
    load->data.op[1].const_val = 0;
    D.30589 = load->data.op[1].const_val;
    load->data.op[0].const_val = D.30589;
    load->prev = 0B;
    D.30590 = load->prev;
    load->next = D.30590;
    load->opcode = 314;
    load->flags = 0;
    load->type = 0;
    load->dreg = -1;
    load->sreg3 = -1;
    D.30591 = load->sreg3;
    load->sreg2 = D.30591;
    D.30592 = load->sreg2;
    load->sreg1 = D.30592;
    D.30562 = cfg->ip;
    load->cil_code = D.30562;
    cfg->has_indirection = 1;
    load->data.op[0].p = vtaddr;
    D.30593 = vtaddr->flags;
    D.30594 = D.30593 | 16;
    vtaddr->flags = D.30594;
    load->type = 5;
    D.30595 = vtaddr->klass;
    load->klass = D.30595;
    D.30596 = mono_alloc_ireg (cfg);
    D.30597 = (int) D.30596;
    load->dreg = D.30597;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    if (D.30572 != 0B) goto <D.30598>; else goto <D.30599>;
    <D.30598>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    D.30572->next = load;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    load->prev = D.30572;
    D.30571 = cfg->cbb;
    D.30571->last_ins = load;
    goto <D.30600>;
    <D.30599>:
    D.30571 = cfg->cbb;
    D.30571 = cfg->cbb;
    D.30571->last_ins = load;
    D.30572 = D.30571->last_ins;
    D.30571->code = D.30572;
    <D.30600>:
    D.30563 = src->dreg;
    D.30601 = load->dreg;
    mini_emit_memcpy (cfg, D.30601, 0, D.30563, 0, size, 4);
    D.30602 = ainfo->pair_storage[0];
    if (D.30602 == 0) goto <D.30603>; else goto <D.30604>;
    <D.30603>:
    D.30555 = cfg->mempool;
    arg = mono_mempool_alloc (D.30555, 80);
    arg->data.op[1].const_val = 0;
    D.30605 = arg->data.op[1].const_val;
    arg->data.op[0].const_val = D.30605;
    arg->prev = 0B;
    D.30606 = arg->prev;
    arg->next = D.30606;
    arg->opcode = 1038;
    arg->flags = 0;
    arg->type = 0;
    arg->dreg = -1;
    arg->sreg3 = -1;
    D.30607 = arg->sreg3;
    arg->sreg2 = D.30607;
    D.30608 = arg->sreg2;
    arg->sreg1 = D.30608;
    D.30562 = cfg->ip;
    arg->cil_code = D.30562;
    D.30609 = mono_alloc_ireg (cfg);
    D.30610 = (int) D.30609;
    arg->dreg = D.30610;
    D.30601 = load->dreg;
    arg->sreg1 = D.30601;
    arg->data.op[1].const_val = 0;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    if (D.30572 != 0B) goto <D.30611>; else goto <D.30612>;
    <D.30611>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    D.30572->next = arg;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    arg->prev = D.30572;
    D.30571 = cfg->cbb;
    D.30571->last_ins = arg;
    goto <D.30613>;
    <D.30612>:
    D.30571 = cfg->cbb;
    D.30571 = cfg->cbb;
    D.30571->last_ins = arg;
    D.30572 = D.30571->last_ins;
    D.30571->code = D.30572;
    <D.30613>:
    D.30614 = ainfo->pair_regs[0];
    D.30615 = (int) D.30614;
    D.30616 = arg->dreg;
    mono_call_inst_add_outarg_reg (cfg, call, D.30616, D.30615, 0);
    goto <D.30617>;
    <D.30604>:
    D.30555 = cfg->mempool;
    arg = mono_mempool_alloc (D.30555, 80);
    arg->data.op[1].const_val = 0;
    D.30605 = arg->data.op[1].const_val;
    arg->data.op[0].const_val = D.30605;
    arg->prev = 0B;
    D.30606 = arg->prev;
    arg->next = D.30606;
    arg->opcode = 1034;
    arg->flags = 0;
    arg->type = 0;
    arg->dreg = -1;
    arg->sreg3 = -1;
    D.30607 = arg->sreg3;
    arg->sreg2 = D.30607;
    D.30608 = arg->sreg2;
    arg->sreg1 = D.30608;
    D.30562 = cfg->ip;
    arg->cil_code = D.30562;
    D.30601 = load->dreg;
    arg->sreg1 = D.30601;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    if (D.30572 != 0B) goto <D.30618>; else goto <D.30619>;
    <D.30618>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    D.30572->next = arg;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    arg->prev = D.30572;
    D.30571 = cfg->cbb;
    D.30571->last_ins = arg;
    goto <D.30620>;
    <D.30619>:
    D.30571 = cfg->cbb;
    D.30571 = cfg->cbb;
    D.30571->last_ins = arg;
    D.30572 = D.30571->last_ins;
    D.30571->code = D.30572;
    <D.30620>:
    <D.30617>:
  }
  goto <D.30621>;
  <D.30580>:
  if (size == 8) goto <D.30622>; else goto <D.30623>;
  <D.30622>:
  D.30583 = cfg->arch.no_pushes;
  if (D.30583 != 0) goto <D.30624>; else goto <D.30625>;
  <D.30624>:
  {
    int dreg;

    D.30626 = mono_alloc_ireg (cfg);
    dreg = (int) D.30626;
    {
      struct MonoInst * inst;

      D.30555 = cfg->mempool;
      inst = mono_mempool_alloc (D.30555, 80);
      inst->data.op[1].const_val = 0;
      D.30627 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30627;
      inst->prev = 0B;
      D.30628 = inst->prev;
      inst->next = D.30628;
      inst->opcode = 391;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30629 = inst->sreg3;
      inst->sreg2 = D.30629;
      D.30630 = inst->sreg2;
      inst->sreg1 = D.30630;
      D.30562 = cfg->ip;
      inst->cil_code = D.30562;
      inst->dreg = dreg;
      D.30563 = src->dreg;
      inst->sreg1 = D.30563;
      inst->data.op[0].const_val = 0;
      D.30571 = cfg->cbb;
      D.30572 = D.30571->last_ins;
      if (D.30572 != 0B) goto <D.30631>; else goto <D.30632>;
      <D.30631>:
      D.30571 = cfg->cbb;
      D.30572 = D.30571->last_ins;
      D.30572->next = inst;
      D.30571 = cfg->cbb;
      D.30572 = D.30571->last_ins;
      inst->prev = D.30572;
      D.30571 = cfg->cbb;
      D.30571->last_ins = inst;
      goto <D.30633>;
      <D.30632>:
      D.30571 = cfg->cbb;
      D.30571 = cfg->cbb;
      D.30571->last_ins = inst;
      D.30572 = D.30571->last_ins;
      D.30571->code = D.30572;
      <D.30633>:
    }
    {
      struct MonoInst * inst;

      D.30555 = cfg->mempool;
      inst = mono_mempool_alloc (D.30555, 80);
      inst->data.op[1].const_val = 0;
      D.30634 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.30634;
      inst->prev = 0B;
      D.30635 = inst->prev;
      inst->next = D.30635;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.30636 = inst->sreg3;
      inst->sreg2 = D.30636;
      D.30637 = inst->sreg2;
      inst->sreg1 = D.30637;
      D.30562 = cfg->ip;
      inst->cil_code = D.30562;
      inst->sreg1 = dreg;
      inst->dreg = 4;
      D.30638 = ainfo->offset;
      D.30639 = (long int) D.30638;
      inst->data.op[0].const_val = D.30639;
      D.30571 = cfg->cbb;
      D.30572 = D.30571->last_ins;
      if (D.30572 != 0B) goto <D.30640>; else goto <D.30641>;
      <D.30640>:
      D.30571 = cfg->cbb;
      D.30572 = D.30571->last_ins;
      D.30572->next = inst;
      D.30571 = cfg->cbb;
      D.30572 = D.30571->last_ins;
      inst->prev = D.30572;
      D.30571 = cfg->cbb;
      D.30571->last_ins = inst;
      goto <D.30642>;
      <D.30641>:
      D.30571 = cfg->cbb;
      D.30571 = cfg->cbb;
      D.30571->last_ins = inst;
      D.30572 = D.30571->last_ins;
      D.30571->code = D.30572;
      <D.30642>:
    }
  }
  goto <D.30643>;
  <D.30625>:
  D.30555 = cfg->mempool;
  arg = mono_mempool_alloc (D.30555, 80);
  arg->data.op[1].const_val = 0;
  D.30605 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30605;
  arg->prev = 0B;
  D.30606 = arg->prev;
  arg->next = D.30606;
  arg->opcode = 1032;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30607 = arg->sreg3;
  arg->sreg2 = D.30607;
  D.30608 = arg->sreg2;
  arg->sreg1 = D.30608;
  D.30562 = cfg->ip;
  arg->cil_code = D.30562;
  D.30563 = src->dreg;
  arg->sreg1 = D.30563;
  arg->data.op[0].const_val = 0;
  D.30571 = cfg->cbb;
  D.30572 = D.30571->last_ins;
  if (D.30572 != 0B) goto <D.30644>; else goto <D.30645>;
  <D.30644>:
  D.30571 = cfg->cbb;
  D.30572 = D.30571->last_ins;
  D.30572->next = arg;
  D.30571 = cfg->cbb;
  D.30572 = D.30571->last_ins;
  arg->prev = D.30572;
  D.30571 = cfg->cbb;
  D.30571->last_ins = arg;
  goto <D.30646>;
  <D.30645>:
  D.30571 = cfg->cbb;
  D.30571 = cfg->cbb;
  D.30571->last_ins = arg;
  D.30572 = D.30571->last_ins;
  D.30571->code = D.30572;
  <D.30646>:
  <D.30643>:
  goto <D.30647>;
  <D.30623>:
  if (size <= 40) goto <D.30648>; else goto <D.30649>;
  <D.30648>:
  D.30583 = cfg->arch.no_pushes;
  if (D.30583 != 0) goto <D.30650>; else goto <D.30651>;
  <D.30650>:
  D.30563 = src->dreg;
  D.30638 = ainfo->offset;
  D.30652 = (int) D.30638;
  mini_emit_memcpy (cfg, 4, D.30652, D.30563, 0, size, 4);
  goto <D.30653>;
  <D.30651>:
  {
    struct MonoInst * inst;

    D.30555 = cfg->mempool;
    inst = mono_mempool_alloc (D.30555, 80);
    inst->data.op[1].const_val = 0;
    D.30654 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30654;
    inst->prev = 0B;
    D.30655 = inst->prev;
    inst->next = D.30655;
    inst->opcode = 434;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30656 = inst->sreg3;
    inst->sreg2 = D.30656;
    D.30657 = inst->sreg2;
    inst->sreg1 = D.30657;
    D.30562 = cfg->ip;
    inst->cil_code = D.30562;
    inst->dreg = 4;
    inst->sreg1 = 4;
    D.30658 = (long unsigned int) size;
    D.30659 = D.30658 + 7;
    D.30660 = (long int) D.30659;
    D.30661 = D.30660 & -8;
    inst->data.op[1].const_val = D.30661;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    if (D.30572 != 0B) goto <D.30662>; else goto <D.30663>;
    <D.30662>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    D.30572->next = inst;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    inst->prev = D.30572;
    D.30571 = cfg->cbb;
    D.30571->last_ins = inst;
    goto <D.30664>;
    <D.30663>:
    D.30571 = cfg->cbb;
    D.30571 = cfg->cbb;
    D.30571->last_ins = inst;
    D.30572 = D.30571->last_ins;
    D.30571->code = D.30572;
    <D.30664>:
  }
  D.30563 = src->dreg;
  mini_emit_memcpy (cfg, 4, 0, D.30563, 0, size, 4);
  <D.30653>:
  goto <D.30665>;
  <D.30649>:
  D.30583 = cfg->arch.no_pushes;
  if (D.30583 != 0) goto <D.30666>; else goto <D.30667>;
  <D.30666>:
  D.30563 = src->dreg;
  D.30638 = ainfo->offset;
  D.30652 = (int) D.30638;
  mini_emit_memcpy (cfg, 4, D.30652, D.30563, 0, size, 4);
  goto <D.30668>;
  <D.30667>:
  D.30555 = cfg->mempool;
  arg = mono_mempool_alloc (D.30555, 80);
  arg->data.op[1].const_val = 0;
  D.30605 = arg->data.op[1].const_val;
  arg->data.op[0].const_val = D.30605;
  arg->prev = 0B;
  D.30606 = arg->prev;
  arg->next = D.30606;
  arg->opcode = 1035;
  arg->flags = 0;
  arg->type = 0;
  arg->dreg = -1;
  arg->sreg3 = -1;
  D.30607 = arg->sreg3;
  arg->sreg2 = D.30607;
  D.30608 = arg->sreg2;
  arg->sreg1 = D.30608;
  D.30562 = cfg->ip;
  arg->cil_code = D.30562;
  D.30563 = src->dreg;
  arg->sreg1 = D.30563;
  arg->data.op[0].const_val = 0;
  D.30669 = (long int) size;
  arg->data.op[1].const_val = D.30669;
  D.30571 = cfg->cbb;
  D.30572 = D.30571->last_ins;
  if (D.30572 != 0B) goto <D.30670>; else goto <D.30671>;
  <D.30670>:
  D.30571 = cfg->cbb;
  D.30572 = D.30571->last_ins;
  D.30572->next = arg;
  D.30571 = cfg->cbb;
  D.30572 = D.30571->last_ins;
  arg->prev = D.30572;
  D.30571 = cfg->cbb;
  D.30571->last_ins = arg;
  goto <D.30672>;
  <D.30671>:
  D.30571 = cfg->cbb;
  D.30571 = cfg->cbb;
  D.30571->last_ins = arg;
  D.30572 = D.30571->last_ins;
  D.30571->code = D.30572;
  <D.30672>:
  <D.30668>:
  <D.30665>:
  <D.30647>:
  D.30673 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.30674 = D.30673 & 128;
  if (D.30674 != 0) goto <D.30675>; else goto <D.30676>;
  <D.30675>:
  {
    struct MonoInst * def;

    D.30555 = cfg->mempool;
    def = mono_mempool_alloc (D.30555, 80);
    def->data.op[1].const_val = 0;
    D.30677 = def->data.op[1].const_val;
    def->data.op[0].const_val = D.30677;
    def->prev = 0B;
    D.30678 = def->prev;
    def->next = D.30678;
    def->opcode = 1003;
    def->flags = 0;
    def->type = 0;
    def->dreg = -1;
    def->sreg3 = -1;
    D.30679 = def->sreg3;
    def->sreg2 = D.30679;
    D.30680 = def->sreg2;
    def->sreg1 = D.30680;
    D.30562 = cfg->ip;
    def->cil_code = D.30562;
    D.30638 = ainfo->offset;
    D.30639 = (long int) D.30638;
    def->data.op[0].const_val = D.30639;
    D.30581 = ins->klass;
    D.30582 = &D.30581->byval_arg;
    def->data.op[1].vtype = D.30582;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    if (D.30572 != 0B) goto <D.30681>; else goto <D.30682>;
    <D.30681>:
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    D.30572->next = def;
    D.30571 = cfg->cbb;
    D.30572 = D.30571->last_ins;
    def->prev = D.30572;
    D.30571 = cfg->cbb;
    D.30571->last_ins = def;
    goto <D.30683>;
    <D.30682>:
    D.30571 = cfg->cbb;
    D.30571 = cfg->cbb;
    D.30571->last_ins = def;
    D.30572 = D.30571->last_ins;
    D.30571->code = D.30572;
    <D.30683>:
  }
  <D.30676>:
  <D.30621>:
  <D.30578>:
}


arg_storage_to_load_membase (ArgStorage storage)
{
  int D.30684;

  switch (storage) <default: <D.24513>, case 0: <D.24510>, case 1: <D.24512>, case 2: <D.24511>>
  <D.24510>:
  D.30684 = 391;
  return D.30684;
  <D.24511>:
  D.30684 = 400;
  return D.30684;
  <D.24512>:
  D.30684 = 399;
  return D.30684;
  <D.24513>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2089);
  D.30684 = -1;
  return D.30684;
}


mono_arch_emit_setret (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoInst * val)
{
  struct MonoMethodSignature * D.30686;
  struct MonoType * D.30687;
  unsigned char D.30688;
  struct MonoMemPool * D.30693;
  long int D.30694;
  struct MonoInst * D.30695;
  int D.30696;
  int D.30697;
  const unsigned char * D.30698;
  struct MonoInst * D.30699;
  int D.30700;
  int D.30701;
  struct MonoBasicBlock * D.30702;
  struct MonoInst * D.30703;
  long int D.30708;
  struct MonoInst * D.30709;
  int D.30710;
  int D.30711;
  long int D.30717;
  struct MonoInst * D.30718;
  int D.30719;
  int D.30720;
  long int D.30724;
  struct MonoInst * D.30725;
  int D.30726;
  int D.30727;
  struct MonoType * ret;

  D.30686 = mono_method_signature (method);
  D.30687 = D.30686->ret;
  ret = mini_replace_type (D.30687);
  D.30688 = ret->type;
  if (D.30688 == 12) goto <D.30689>; else goto <D.30690>;
  <D.30689>:
  if (0 != 0) goto <D.30691>; else goto <D.30692>;
  <D.30691>:
  {
    struct MonoInst * inst;

    D.30693 = cfg->mempool;
    inst = mono_mempool_alloc (D.30693, 80);
    inst->data.op[1].const_val = 0;
    D.30694 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30694;
    inst->prev = 0B;
    D.30695 = inst->prev;
    inst->next = D.30695;
    inst->opcode = 430;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30696 = inst->sreg3;
    inst->sreg2 = D.30696;
    D.30697 = inst->sreg2;
    inst->sreg1 = D.30697;
    D.30698 = cfg->ip;
    inst->cil_code = D.30698;
    D.30699 = cfg->ret;
    D.30700 = D.30699->dreg;
    inst->dreg = D.30700;
    D.30701 = val->dreg;
    inst->sreg1 = D.30701;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    if (D.30703 != 0B) goto <D.30704>; else goto <D.30705>;
    <D.30704>:
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    D.30703->next = inst;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    inst->prev = D.30703;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    goto <D.30706>;
    <D.30705>:
    D.30702 = cfg->cbb;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    D.30703 = D.30702->last_ins;
    D.30702->code = D.30703;
    <D.30706>:
  }
  goto <D.30707>;
  <D.30692>:
  {
    struct MonoInst * inst;

    D.30693 = cfg->mempool;
    inst = mono_mempool_alloc (D.30693, 80);
    inst->data.op[1].const_val = 0;
    D.30708 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30708;
    inst->prev = 0B;
    D.30709 = inst->prev;
    inst->next = D.30709;
    inst->opcode = 1047;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30710 = inst->sreg3;
    inst->sreg2 = D.30710;
    D.30711 = inst->sreg2;
    inst->sreg1 = D.30711;
    D.30698 = cfg->ip;
    inst->cil_code = D.30698;
    D.30699 = cfg->ret;
    D.30700 = D.30699->dreg;
    inst->dreg = D.30700;
    D.30701 = val->dreg;
    inst->sreg1 = D.30701;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    if (D.30703 != 0B) goto <D.30712>; else goto <D.30713>;
    <D.30712>:
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    D.30703->next = inst;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    inst->prev = D.30703;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    goto <D.30714>;
    <D.30713>:
    D.30702 = cfg->cbb;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    D.30703 = D.30702->last_ins;
    D.30702->code = D.30703;
    <D.30714>:
  }
  <D.30707>:
  return;
  <D.30690>:
  D.30688 = ret->type;
  if (D.30688 == 13) goto <D.30715>; else goto <D.30716>;
  <D.30715>:
  {
    struct MonoInst * inst;

    D.30693 = cfg->mempool;
    inst = mono_mempool_alloc (D.30693, 80);
    inst->data.op[1].const_val = 0;
    D.30717 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30717;
    inst->prev = 0B;
    D.30718 = inst->prev;
    inst->next = D.30718;
    inst->opcode = 430;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30719 = inst->sreg3;
    inst->sreg2 = D.30719;
    D.30720 = inst->sreg2;
    inst->sreg1 = D.30720;
    D.30698 = cfg->ip;
    inst->cil_code = D.30698;
    D.30699 = cfg->ret;
    D.30700 = D.30699->dreg;
    inst->dreg = D.30700;
    D.30701 = val->dreg;
    inst->sreg1 = D.30701;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    if (D.30703 != 0B) goto <D.30721>; else goto <D.30722>;
    <D.30721>:
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    D.30703->next = inst;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    inst->prev = D.30703;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    goto <D.30723>;
    <D.30722>:
    D.30702 = cfg->cbb;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    D.30703 = D.30702->last_ins;
    D.30702->code = D.30703;
    <D.30723>:
  }
  return;
  <D.30716>:
  {
    struct MonoInst * inst;

    D.30693 = cfg->mempool;
    inst = mono_mempool_alloc (D.30693, 80);
    inst->data.op[1].const_val = 0;
    D.30724 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30724;
    inst->prev = 0B;
    D.30725 = inst->prev;
    inst->next = D.30725;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30726 = inst->sreg3;
    inst->sreg2 = D.30726;
    D.30727 = inst->sreg2;
    inst->sreg1 = D.30727;
    D.30698 = cfg->ip;
    inst->cil_code = D.30698;
    D.30699 = cfg->ret;
    D.30700 = D.30699->dreg;
    inst->dreg = D.30700;
    D.30701 = val->dreg;
    inst->sreg1 = D.30701;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    if (D.30703 != 0B) goto <D.30728>; else goto <D.30729>;
    <D.30728>:
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    D.30703->next = inst;
    D.30702 = cfg->cbb;
    D.30703 = D.30702->last_ins;
    inst->prev = D.30703;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    goto <D.30730>;
    <D.30729>:
    D.30702 = cfg->cbb;
    D.30702 = cfg->cbb;
    D.30702->last_ins = inst;
    D.30703 = D.30702->last_ins;
    D.30702->code = D.30703;
    <D.30730>:
  }
}


mono_arch_dyn_call_prepare (struct MonoMethodSignature * sig)
{
  int D.30732;
  struct MonoDynCallInfo * D.30735;
  struct ArchDynCallInfo * info;
  struct CallInfo * cinfo;

  cinfo = get_call_info (0B, 0B, sig);
  D.30732 = dyn_call_supported (sig, cinfo);
  if (D.30732 == 0) goto <D.30733>; else goto <D.30734>;
  <D.30733>:
  monoeg_g_free (cinfo);
  D.30735 = 0B;
  return D.30735;
  <D.30734>:
  info = monoeg_malloc0 (16);
  info->sig = sig;
  info->cinfo = cinfo;
  D.30735 = info;
  return D.30735;
}


dyn_call_supported (struct MonoMethodSignature * sig, struct CallInfo * cinfo)
{
  <unnamed type> D.30737;
  <unnamed type> D.30738;
  _Bool D.30739;
  _Bool D.30740;
  _Bool D.30741;
  gboolean D.30744;
  <unnamed type> D.30745;
  _Bool D.30746;
  _Bool D.30747;
  _Bool D.30748;
  <unnamed type> D.30751;
  <unnamed type> D.30752;
  _Bool D.30753;
  _Bool D.30754;
  _Bool D.30755;
  <unnamed type> D.30758;
  _Bool D.30759;
  _Bool D.30760;
  _Bool D.30761;
  int D.30764;
  int i;

  D.30737 = cinfo->ret.storage;
  switch (D.30737) <default: <D.24631>, case 0: <D.24627>, case 4: <D.24629>, case 6: <D.24626>>
  <D.24626>:
  <D.24627>:
  goto <D.24628>;
  <D.24629>:
  {
    struct ArgInfo * ainfo;

    ainfo = &cinfo->ret;
    D.30738 = ainfo->pair_storage[0];
    D.30739 = D.30738 != 6;
    D.30740 = D.30738 != 0;
    D.30741 = D.30739 & D.30740;
    if (D.30741 != 0) goto <D.30742>; else goto <D.30743>;
    <D.30742>:
    D.30744 = 0;
    return D.30744;
    <D.30743>:
    D.30745 = ainfo->pair_storage[1];
    D.30746 = D.30745 != 6;
    D.30747 = D.30745 != 0;
    D.30748 = D.30746 & D.30747;
    if (D.30748 != 0) goto <D.30749>; else goto <D.30750>;
    <D.30749>:
    D.30744 = 0;
    return D.30744;
    <D.30750>:
    goto <D.24628>;
  }
  <D.24631>:
  D.30744 = 0;
  return D.30744;
  <D.24628>:
  i = 0;
  goto <D.24638>;
  <D.24637>:
  {
    struct ArgInfo * ainfo;

    ainfo = &cinfo->args[i];
    D.30751 = ainfo->storage;
    switch (D.30751) <default: <D.24636>, case 0: <D.24633>, case 4: <D.24635>>
    <D.24633>:
    goto <D.24634>;
    <D.24635>:
    D.30752 = ainfo->pair_storage[0];
    D.30753 = D.30752 != 6;
    D.30754 = D.30752 != 0;
    D.30755 = D.30753 & D.30754;
    if (D.30755 != 0) goto <D.30756>; else goto <D.30757>;
    <D.30756>:
    D.30744 = 0;
    return D.30744;
    <D.30757>:
    D.30758 = ainfo->pair_storage[1];
    D.30759 = D.30758 != 6;
    D.30760 = D.30758 != 0;
    D.30761 = D.30759 & D.30760;
    if (D.30761 != 0) goto <D.30762>; else goto <D.30763>;
    <D.30762>:
    D.30744 = 0;
    return D.30744;
    <D.30763>:
    goto <D.24634>;
    <D.24636>:
    D.30744 = 0;
    return D.30744;
    <D.24634>:
  }
  i = i + 1;
  <D.24638>:
  D.30764 = cinfo->nargs;
  if (D.30764 > i) goto <D.24637>; else goto <D.24639>;
  <D.24639>:
  D.30744 = 1;
  return D.30744;
}


mono_arch_dyn_call_free (struct MonoDynCallInfo * info)
{
  struct CallInfo * D.30768;
  struct ArchDynCallInfo * ainfo;

  ainfo = info;
  D.30768 = ainfo->cinfo;
  monoeg_g_free (D.30768);
  monoeg_g_free (ainfo);
}


mono_arch_start_dyn_call (struct MonoDynCallInfo * info, void * * * args, guint8 * ret, guint8 * buf, int buf_len)
{
  unsigned int buf_len.63;
  _Bool D.30770;
  long int D.30771;
  long int D.30772;
  unsigned char D.30777;
  unsigned char D.30778;
  struct CallInfo * D.30780;
  int D.30781;
  int greg.64;
  int arg_index.65;
  long unsigned int D.30784;
  long unsigned int D.30785;
  void * * * D.30786;
  void * * D.30787;
  void * D.30788;
  long int D.30789;
  int D.30792;
  int greg.66;
  long int ret.67;
  struct MonoType * D.30797;
  int arg_index.68;
  long unsigned int D.30799;
  long unsigned int D.30800;
  void * * * D.30801;
  unsigned char D.30802;
  unsigned char D.30803;
  int greg.69;
  void * D.30807;
  long int D.30808;
  unsigned char D.30809;
  int D.30810;
  <unnamed-unsigned:1> D.30811;
  int D.30812;
  int D.30813;
  signed char D.30814;
  unsigned int D.30815;
  <unnamed type> D.30816;
  _Bool D.30817;
  long int D.30818;
  long int D.30819;
  int greg.70;
  int greg.71;
  unsigned char D.30824;
  long int D.30825;
  int greg.72;
  signed char D.30827;
  long int D.30828;
  int greg.73;
  short int D.30830;
  long int D.30831;
  int greg.74;
  short unsigned int D.30833;
  long int D.30834;
  int greg.75;
  int D.30836;
  long int D.30837;
  int greg.76;
  unsigned int D.30839;
  long int D.30840;
  int D.30841;
  int greg.77;
  <unnamed type> D.30845;
  _Bool D.30846;
  long int D.30847;
  long int D.30848;
  <unnamed type> D.30851;
  _Bool D.30854;
  long int D.30855;
  long int D.30856;
  int greg.78;
  long int D.30860;
  <unnamed type> D.30861;
  _Bool D.30864;
  long int D.30865;
  long int D.30866;
  int greg.79;
  long int D.30870;
  short unsigned int D.30871;
  int D.30872;
  _Bool D.30873;
  long int D.30874;
  long int D.30875;
  struct ArchDynCallInfo * dinfo;
  struct DynCallArgs * p;
  int arg_index;
  int greg;
  int i;
  int pindex;
  struct MonoMethodSignature * sig;

  dinfo = info;
  p = buf;
  sig = dinfo->sig;
  buf_len.63 = (unsigned int) buf_len;
  D.30770 = buf_len.63 <= 63;
  D.30771 = (long int) D.30770;
  D.30772 = __builtin_expect (D.30771, 0);
  if (D.30772 != 0) goto <D.30773>; else goto <D.30774>;
  <D.30773>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2741, "buf_len >= sizeof (DynCallArgs)");
  <D.30774>:
  p->res = 0;
  p->ret = ret;
  arg_index = 0;
  greg = 0;
  pindex = 0;
  D.30777 = BIT_FIELD_REF <*sig, 8, 112>;
  D.30778 = D.30777 & 64;
  if (D.30778 != 0) goto <D.30775>; else goto <D.30779>;
  <D.30779>:
  D.30780 = dinfo->cinfo;
  D.30781 = D.30780->vret_arg_index;
  if (D.30781 == 1) goto <D.30775>; else goto <D.30776>;
  <D.30775>:
  greg.64 = greg;
  greg = greg.64 + 1;
  arg_index.65 = arg_index;
  arg_index = arg_index.65 + 1;
  D.30784 = (long unsigned int) arg_index.65;
  D.30785 = D.30784 * 8;
  D.30786 = args + D.30785;
  D.30787 = *D.30786;
  D.30788 = *D.30787;
  D.30789 = (long int) D.30788;
  p->regs[greg.64] = D.30789;
  D.30777 = BIT_FIELD_REF <*sig, 8, 112>;
  D.30778 = D.30777 & 64;
  if (D.30778 == 0) goto <D.30790>; else goto <D.30791>;
  <D.30790>:
  pindex = 1;
  <D.30791>:
  <D.30776>:
  D.30780 = dinfo->cinfo;
  D.30792 = D.30780->vtype_retaddr;
  if (D.30792 != 0) goto <D.30793>; else goto <D.30794>;
  <D.30793>:
  greg.66 = greg;
  greg = greg.66 + 1;
  ret.67 = (long int) ret;
  p->regs[greg.66] = ret.67;
  <D.30794>:
  i = pindex;
  goto <D.24690>;
  <D.24689>:
  {
    struct MonoType * t;
    void * * arg;

    D.30797 = sig->params[i];
    t = mono_type_get_underlying_type (D.30797);
    arg_index.68 = arg_index;
    arg_index = arg_index.68 + 1;
    D.30799 = (long unsigned int) arg_index.68;
    D.30800 = D.30799 * 8;
    D.30801 = args + D.30800;
    arg = *D.30801;
    D.30802 = BIT_FIELD_REF <*t, 8, 88>;
    D.30803 = D.30802 & 64;
    if (D.30803 != 0) goto <D.30804>; else goto <D.30805>;
    <D.30804>:
    greg.69 = greg;
    greg = greg.69 + 1;
    D.30807 = *arg;
    D.30808 = (long int) D.30807;
    p->regs[greg.69] = D.30808;
    // predicted unlikely by continue predictor.
    goto <D.24665>;
    <D.30805>:
    D.30809 = t->type;
    D.30810 = (int) D.30809;
    switch (D.30810) <default: <D.24688>, case 2: <D.24677>, case 3: <D.24682>, case 4: <D.24679>, case 5: <D.24678>, case 6: <D.24680>, case 7: <D.24681>, case 8: <D.24683>, case 9: <D.24684>, case 10: <D.24674>, case 11: <D.24675>, case 14: <D.24666>, case 15: <D.24671>, case 17: <D.24686>, case 18: <D.24667>, case 20: <D.24668>, case 21: <D.24685>, case 24: <D.24672>, case 25: <D.24673>, case 28: <D.24670>, case 29: <D.24669>>
    <D.24666>:
    <D.24667>:
    <D.24668>:
    <D.24669>:
    <D.24670>:
    <D.24671>:
    <D.24672>:
    <D.24673>:
    <D.24674>:
    <D.24675>:
    D.30780 = dinfo->cinfo;
    D.30811 = sig->hasthis;
    D.30812 = (int) D.30811;
    D.30813 = D.30812 + i;
    D.30814 = D.30780->args[D.30813].reg;
    D.30815 = (unsigned int) D.30814;
    D.30816 = param_regs[greg];
    D.30817 = D.30815 != D.30816;
    D.30818 = (long int) D.30817;
    D.30819 = __builtin_expect (D.30818, 0);
    if (D.30819 != 0) goto <D.30820>; else goto <D.30821>;
    <D.30820>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2781, "dinfo->cinfo->args [i + sig->hasthis].reg == param_regs [greg]");
    <D.30821>:
    greg.70 = greg;
    greg = greg.70 + 1;
    D.30807 = *arg;
    D.30808 = (long int) D.30807;
    p->regs[greg.70] = D.30808;
    goto <D.24676>;
    <D.24677>:
    <D.24678>:
    greg.71 = greg;
    greg = greg.71 + 1;
    D.30824 = MEM[(guint8 *)arg];
    D.30825 = (long int) D.30824;
    p->regs[greg.71] = D.30825;
    goto <D.24676>;
    <D.24679>:
    greg.72 = greg;
    greg = greg.72 + 1;
    D.30827 = MEM[(gint8 *)arg];
    D.30828 = (long int) D.30827;
    p->regs[greg.72] = D.30828;
    goto <D.24676>;
    <D.24680>:
    greg.73 = greg;
    greg = greg.73 + 1;
    D.30830 = MEM[(gint16 *)arg];
    D.30831 = (long int) D.30830;
    p->regs[greg.73] = D.30831;
    goto <D.24676>;
    <D.24681>:
    <D.24682>:
    greg.74 = greg;
    greg = greg.74 + 1;
    D.30833 = MEM[(guint16 *)arg];
    D.30834 = (long int) D.30833;
    p->regs[greg.74] = D.30834;
    goto <D.24676>;
    <D.24683>:
    greg.75 = greg;
    greg = greg.75 + 1;
    D.30836 = MEM[(gint32 *)arg];
    D.30837 = (long int) D.30836;
    p->regs[greg.75] = D.30837;
    goto <D.24676>;
    <D.24684>:
    greg.76 = greg;
    greg = greg.76 + 1;
    D.30839 = MEM[(guint32 *)arg];
    D.30840 = (long int) D.30839;
    p->regs[greg.76] = D.30840;
    goto <D.24676>;
    <D.24685>:
    D.30841 = mono_type_is_reference (t);
    if (D.30841 != 0) goto <D.30842>; else goto <D.30843>;
    <D.30842>:
    greg.77 = greg;
    greg = greg.77 + 1;
    D.30807 = *arg;
    D.30808 = (long int) D.30807;
    p->regs[greg.77] = D.30808;
    goto <D.24676>;
    <D.30843>:
    <D.24686>:
    {
      struct ArgInfo * ainfo;

      D.30780 = dinfo->cinfo;
      D.30811 = sig->hasthis;
      D.30812 = (int) D.30811;
      D.30813 = D.30812 + i;
      ainfo = &D.30780->args[D.30813];
      D.30845 = ainfo->storage;
      D.30846 = D.30845 != 4;
      D.30847 = (long int) D.30846;
      D.30848 = __builtin_expect (D.30847, 0);
      if (D.30848 != 0) goto <D.30849>; else goto <D.30850>;
      <D.30849>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2821, "ainfo->storage == ArgValuetypeInReg");
      <D.30850>:
      D.30851 = ainfo->pair_storage[0];
      if (D.30851 != 6) goto <D.30852>; else goto <D.30853>;
      <D.30852>:
      D.30851 = ainfo->pair_storage[0];
      D.30854 = D.30851 != 0;
      D.30855 = (long int) D.30854;
      D.30856 = __builtin_expect (D.30855, 0);
      if (D.30856 != 0) goto <D.30857>; else goto <D.30858>;
      <D.30857>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2823, "ainfo->pair_storage [0] == ArgInIReg");
      <D.30858>:
      greg.78 = greg;
      greg = greg.78 + 1;
      D.30860 = MEM[(mgreg_t *)arg];
      p->regs[greg.78] = D.30860;
      <D.30853>:
      D.30861 = ainfo->pair_storage[1];
      if (D.30861 != 6) goto <D.30862>; else goto <D.30863>;
      <D.30862>:
      D.30861 = ainfo->pair_storage[1];
      D.30864 = D.30861 != 0;
      D.30865 = (long int) D.30864;
      D.30866 = __builtin_expect (D.30865, 0);
      if (D.30866 != 0) goto <D.30867>; else goto <D.30868>;
      <D.30867>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2827, "ainfo->pair_storage [1] == ArgInIReg");
      <D.30868>:
      greg.79 = greg;
      greg = greg.79 + 1;
      D.30870 = MEM[(mgreg_t *)arg + 8B];
      p->regs[greg.79] = D.30870;
      <D.30863>:
      goto <D.24676>;
    }
    <D.24688>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2833);
    <D.24676>:
  }
  <D.24665>:
  i = i + 1;
  <D.24690>:
  D.30871 = sig->param_count;
  D.30872 = (int) D.30871;
  if (D.30872 > i) goto <D.24689>; else goto <D.24691>;
  <D.24691>:
  D.30873 = greg > 6;
  D.30874 = (long int) D.30873;
  D.30875 = __builtin_expect (D.30874, 0);
  if (D.30875 != 0) goto <D.30876>; else goto <D.30877>;
  <D.30876>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2837, "greg <= PARAM_REGS");
  <D.30877>:
}


mono_arch_finish_dyn_call (struct MonoDynCallInfo * info, guint8 * buf)
{
  struct MonoType * D.30878;
  unsigned char D.30879;
  int D.30880;
  void * res.80;
  signed char D.30882;
  unsigned char D.30883;
  short int D.30884;
  short unsigned int D.30885;
  int D.30886;
  unsigned int D.30887;
  long unsigned int res.81;
  int D.30889;
  struct CallInfo * D.30892;
  int D.30893;
  <unnamed type> D.30897;
  _Bool D.30898;
  long int D.30899;
  long int D.30900;
  <unnamed type> D.30903;
  _Bool D.30906;
  long int D.30907;
  long int D.30908;
  <unnamed type> D.30911;
  _Bool D.30912;
  long int D.30913;
  long int D.30914;
  struct ArchDynCallInfo * dinfo;
  struct MonoMethodSignature * sig;
  guint8 * ret;
  mgreg_t res;
  struct MonoType * sig_ret;

  dinfo = info;
  sig = dinfo->sig;
  ret = MEM[(struct DynCallArgs *)buf].ret;
  res = MEM[(struct DynCallArgs *)buf].res;
  D.30878 = sig->ret;
  sig_ret = mono_type_get_underlying_type (D.30878);
  D.30879 = sig_ret->type;
  D.30880 = (int) D.30879;
  switch (D.30880) <default: <D.24724>, case 1: <D.24701>, case 2: <D.24713>, case 3: <D.24716>, case 4: <D.24711>, case 5: <D.24712>, case 6: <D.24714>, case 7: <D.24715>, case 8: <D.24717>, case 9: <D.24718>, case 10: <D.24719>, case 11: <D.24720>, case 14: <D.24703>, case 15: <D.24710>, case 17: <D.24722>, case 18: <D.24704>, case 20: <D.24705>, case 21: <D.24721>, case 24: <D.24708>, case 25: <D.24709>, case 28: <D.24707>, case 29: <D.24706>>
  <D.24701>:
  MEM[(void * *)ret] = 0B;
  goto <D.24702>;
  <D.24703>:
  <D.24704>:
  <D.24705>:
  <D.24706>:
  <D.24707>:
  <D.24708>:
  <D.24709>:
  <D.24710>:
  res.80 = (void *) res;
  MEM[(void * *)ret] = res.80;
  goto <D.24702>;
  <D.24711>:
  D.30882 = (signed char) res;
  MEM[(gint8 *)ret] = D.30882;
  goto <D.24702>;
  <D.24712>:
  <D.24713>:
  D.30883 = (unsigned char) res;
  *ret = D.30883;
  goto <D.24702>;
  <D.24714>:
  D.30884 = (short int) res;
  MEM[(gint16 *)ret] = D.30884;
  goto <D.24702>;
  <D.24715>:
  <D.24716>:
  D.30885 = (short unsigned int) res;
  MEM[(guint16 *)ret] = D.30885;
  goto <D.24702>;
  <D.24717>:
  D.30886 = (int) res;
  MEM[(gint32 *)ret] = D.30886;
  goto <D.24702>;
  <D.24718>:
  D.30887 = (unsigned int) res;
  MEM[(guint32 *)ret] = D.30887;
  goto <D.24702>;
  <D.24719>:
  MEM[(gint64 *)ret] = res;
  goto <D.24702>;
  <D.24720>:
  res.81 = (long unsigned int) res;
  MEM[(guint64 *)ret] = res.81;
  goto <D.24702>;
  <D.24721>:
  D.30889 = mono_type_is_reference (sig_ret);
  if (D.30889 != 0) goto <D.30890>; else goto <D.30891>;
  <D.30890>:
  res.80 = (void *) res;
  MEM[(void * *)ret] = res.80;
  goto <D.24702>;
  <D.30891>:
  <D.24722>:
  D.30892 = dinfo->cinfo;
  D.30893 = D.30892->vtype_retaddr;
  if (D.30893 != 0) goto <D.30894>; else goto <D.30895>;
  <D.30894>:
  goto <D.30896>;
  <D.30895>:
  {
    struct ArgInfo * ainfo;

    D.30892 = dinfo->cinfo;
    ainfo = &D.30892->ret;
    D.30897 = ainfo->storage;
    D.30898 = D.30897 != 4;
    D.30899 = (long int) D.30898;
    D.30900 = __builtin_expect (D.30899, 0);
    if (D.30900 != 0) goto <D.30901>; else goto <D.30902>;
    <D.30901>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2911, "ainfo->storage == ArgValuetypeInReg");
    <D.30902>:
    D.30903 = ainfo->pair_storage[0];
    if (D.30903 != 6) goto <D.30904>; else goto <D.30905>;
    <D.30904>:
    D.30903 = ainfo->pair_storage[0];
    D.30906 = D.30903 != 0;
    D.30907 = (long int) D.30906;
    D.30908 = __builtin_expect (D.30907, 0);
    if (D.30908 != 0) goto <D.30909>; else goto <D.30910>;
    <D.30909>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2914, "ainfo->pair_storage [0] == ArgInIReg");
    <D.30910>:
    MEM[(mgreg_t *)ret] = res;
    <D.30905>:
    D.30911 = ainfo->pair_storage[1];
    D.30912 = D.30911 != 6;
    D.30913 = (long int) D.30912;
    D.30914 = __builtin_expect (D.30913, 0);
    if (D.30914 != 0) goto <D.30915>; else goto <D.30916>;
    <D.30915>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 2918, "ainfo->pair_storage [1] == ArgNone");
    <D.30916>:
  }
  <D.30896>:
  goto <D.24702>;
  <D.24724>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 2922);
  <D.24702>:
}


mono_arch_peephole_pass_1 (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.82;
  short unsigned int D.30921;
  int D.30922;
  int D.30923;
  int D.30926;
  long int D.30929;
  int D.30932;
  short unsigned int D.30940;
  _Bool D.30941;
  _Bool D.30942;
  _Bool D.30943;
  short unsigned int D.30945;
  long int D.30947;
  int D.30949;
  int D.30950;
  short unsigned int D.30951;
  short unsigned int D.30952;
  short unsigned int D.30953;
  _Bool D.30954;
  _Bool D.30955;
  _Bool D.30956;
  short unsigned int D.30962;
  int D.30964;
  long int D.30966;
  int D.30968;
  int D.30969;
  short unsigned int D.30976;
  int D.30979;
  long int D.30982;
  long int D.30983;
  int D.30986;
  struct MonoInst * iftmp.83;
  struct MonoInst * ins;
  struct MonoInst * n;

  ins = bb->code;
  if (ins != 0B) goto <D.30918>; else goto <D.30919>;
  <D.30918>:
  iftmp.82 = ins->next;
  goto <D.30920>;
  <D.30919>:
  iftmp.82 = 0B;
  <D.30920>:
  n = iftmp.82;
  goto <D.24796>;
  <D.24795>:
  {
    struct MonoInst * last_ins;

    last_ins = ins->prev;
    D.30921 = ins->opcode;
    D.30922 = (int) D.30921;
    switch (D.30922) <default: <D.30989>, case 323: <D.24791>, case 327: <D.24793>, case 328: <D.24792>, case 433: <D.24781>, case 492: <D.24785>, case 542: <D.24783>, case 578: <D.24786>, case 629: <D.24782>, case 1050: <D.24794>>
    <D.24781>:
    <D.24782>:
    <D.24783>:
    D.30923 = ins->sreg1;
    if (D.30923 <= 15) goto <D.30924>; else goto <D.30925>;
    <D.30924>:
    D.30926 = ins->dreg;
    if (D.30926 > 15) goto <D.30927>; else goto <D.30928>;
    <D.30927>:
    D.30929 = ins->data.op[1].const_val;
    if (D.30929 > 0) goto <D.30930>; else goto <D.30931>;
    <D.30930>:
    ins->opcode = 1038;
    D.30923 = ins->sreg1;
    ins->sreg1 = D.30923;
    <D.30931>:
    <D.30928>:
    <D.30925>:
    goto <D.24784>;
    <D.24785>:
    <D.24786>:
    D.30923 = ins->sreg1;
    D.30932 = ins->sreg2;
    if (D.30923 == D.30932) goto <D.30933>; else goto <D.30934>;
    <D.30933>:
    D.30923 = ins->sreg1;
    D.30926 = ins->dreg;
    if (D.30923 == D.30926) goto <D.30935>; else goto <D.30936>;
    <D.30935>:
    {
      struct MonoInst * ins2;

      ins2 = ins->next;
      goto <D.24790>;
      <D.24789>:
      D.30940 = ins2->opcode;
      D.30941 = D.30940 == 384;
      D.30942 = D.30940 == 387;
      D.30943 = D.30941 | D.30942;
      if (D.30943 != 0) goto <D.30937>; else goto <D.30944>;
      <D.30944>:
      D.30945 = ins2->opcode;
      if (D.30945 == 388) goto <D.30937>; else goto <D.30946>;
      <D.30946>:
      D.30945 = ins2->opcode;
      if (D.30945 == 384) goto <D.30937>; else goto <D.30938>;
      <D.30937>:
      D.30947 = ins2->data.op[1].const_val;
      if (D.30947 == 0) goto <D.30948>; else goto <D.30938>;
      <D.30948>:
      D.30945 = ins2->opcode;
      D.30949 = (int) D.30945;
      D.30950 = store_membase_imm_to_store_membase_reg (D.30949);
      D.30951 = (short unsigned int) D.30950;
      ins2->opcode = D.30951;
      D.30926 = ins->dreg;
      ins2->sreg1 = D.30926;
      goto <D.30939>;
      <D.30938>:
      D.30952 = ins2->opcode;
      D.30953 = D.30952 + 65151;
      D.30954 = D.30953 <= 1;
      D.30955 = D.30952 == 378;
      D.30956 = D.30954 | D.30955;
      if (D.30956 != 0) goto <D.30957>; else goto <D.30958>;
      <D.30958>:
      D.30945 = ins2->opcode;
      if (D.30945 == 374) goto <D.30959>; else goto <D.30960>;
      <D.30959>:
      goto <D.30961>;
      <D.30960>:
      D.30945 = ins2->opcode;
      D.30962 = D.30945 + 65174;
      if (D.30962 <= 1) goto <D.30963>; else goto <D.24788>;
      <D.30963>:
      D.30964 = ins2->dreg;
      D.30926 = ins->dreg;
      if (D.30964 == D.30926) goto <D.30965>; else goto <D.24788>;
      <D.30965>:
      D.30966 = ins2->data.op[0].const_val;
      if (D.30966 == 0) goto <D.30967>; else goto <D.24788>;
      <D.30967>:
      ins2->opcode = 316;
      ins2->dreg = -1;
      ins2->sreg3 = -1;
      D.30968 = ins2->sreg3;
      ins2->sreg2 = D.30968;
      D.30969 = ins2->sreg2;
      ins2->sreg1 = D.30969;
      <D.30961>:
      <D.30957>:
      <D.30939>:
      ins2 = ins2->next;
      <D.24790>:
      if (ins2 != 0B) goto <D.24789>; else goto <D.24788>;
      <D.24788>:
    }
    <D.30936>:
    <D.30934>:
    goto <D.24784>;
    <D.24791>:
    <D.24792>:
    D.30929 = ins->data.op[1].const_val;
    if (D.30929 == 0) goto <D.30970>; else goto <D.30971>;
    <D.30970>:
    ins->opcode = 1046;
    <D.30971>:
    goto <D.24784>;
    <D.24793>:
    D.30929 = ins->data.op[1].const_val;
    if (D.30929 == 0) goto <D.30972>; else goto <D.30973>;
    <D.30972>:
    ins->opcode = 1005;
    <D.30973>:
    goto <D.24784>;
    <D.24794>:
    if (last_ins != 0B) goto <D.30974>; else goto <D.30975>;
    <D.30974>:
    D.30976 = last_ins->opcode;
    if (D.30976 == 377) goto <D.30977>; else goto <D.30978>;
    <D.30977>:
    D.30923 = ins->sreg1;
    D.30979 = last_ins->dreg;
    if (D.30923 == D.30979) goto <D.30980>; else goto <D.30981>;
    <D.30980>:
    D.30982 = ins->data.op[0].const_val;
    D.30983 = last_ins->data.op[0].const_val;
    if (D.30982 == D.30983) goto <D.30984>; else goto <D.30985>;
    <D.30984>:
    ins->opcode = 327;
    D.30986 = last_ins->sreg1;
    ins->sreg1 = D.30986;
    D.30929 = ins->data.op[1].const_val;
    if (D.30929 == 0) goto <D.30987>; else goto <D.30988>;
    <D.30987>:
    ins->opcode = 1005;
    <D.30988>:
    <D.30985>:
    <D.30981>:
    <D.30978>:
    <D.30975>:
    goto <D.24784>;
    <D.30989>:
    <D.24784>:
    mono_peephole_ins (bb, ins);
  }
  ins = n;
  if (ins != 0B) goto <D.30991>; else goto <D.30992>;
  <D.30991>:
  iftmp.83 = ins->next;
  goto <D.30993>;
  <D.30992>:
  iftmp.83 = 0B;
  <D.30993>:
  n = iftmp.83;
  <D.24796>:
  if (ins != 0B) goto <D.24795>; else goto <D.24797>;
  <D.24797>:
}


store_membase_imm_to_store_membase_reg (int opcode)
{
  int D.30994;

  switch (opcode) <default: <D.30995>, case 384: <D.24771>, case 387: <D.24772>, case 388: <D.24773>>
  <D.24771>:
  D.30994 = 374;
  return D.30994;
  <D.24772>:
  D.30994 = 377;
  return D.30994;
  <D.24773>:
  D.30994 = 378;
  return D.30994;
  <D.30995>:
  D.30994 = -1;
  return D.30994;
}


mono_arch_peephole_pass_2 (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.84;
  short unsigned int D.31001;
  int D.31002;
  long int D.31004;
  struct MonoInst * D.31006;
  short unsigned int D.31009;
  short unsigned int D.31010;
  _Bool D.31011;
  _Bool D.31012;
  _Bool D.31013;
  short unsigned int D.31015;
  int D.31020;
  int D.31021;
  int D.31022;
  short unsigned int D.31034;
  _Bool D.31035;
  _Bool D.31036;
  _Bool D.31037;
  short unsigned int D.31039;
  long int D.31041;
  int D.31043;
  int D.31044;
  short unsigned int D.31045;
  short unsigned int D.31046;
  short unsigned int D.31047;
  _Bool D.31048;
  _Bool D.31049;
  _Bool D.31050;
  short unsigned int D.31064;
  int D.31066;
  long int D.31068;
  int D.31070;
  int D.31071;
  long int D.31072;
  struct MonoInst * iftmp.85;
  struct MonoInst * ins;
  struct MonoInst * n;

  ins = bb->code;
  if (ins != 0B) goto <D.30998>; else goto <D.30999>;
  <D.30998>:
  iftmp.84 = ins->next;
  goto <D.31000>;
  <D.30999>:
  iftmp.84 = 0B;
  <D.31000>:
  n = iftmp.84;
  goto <D.24816>;
  <D.24815>:
  D.31001 = ins->opcode;
  D.31002 = (int) D.31001;
  switch (D.31002) <default: <D.31081>, case 362: <D.24804>, case 363: <D.24805>, case 492: <D.24807>, case 578: <D.24808>, case 629: <D.24813>, case 630: <D.24814>>
  <D.24804>:
  <D.24805>:
  D.31004 = ins->data.op[0].const_val;
  if (D.31004 == 0) goto <D.31005>; else goto <D.24806>;
  <D.31005>:
  D.31006 = ins->next;
  if (D.31006 == 0B) goto <D.31003>; else goto <D.31007>;
  <D.31007>:
  D.31006 = ins->next;
  if (D.31006 != 0B) goto <D.31008>; else goto <D.24806>;
  <D.31008>:
  D.31006 = ins->next;
  D.31009 = D.31006->opcode;
  D.31010 = D.31009 + 64781;
  D.31011 = D.31010 > 1;
  D.31012 = D.31009 != 623;
  D.31013 = D.31011 & D.31012;
  if (D.31013 != 0) goto <D.31014>; else goto <D.24806>;
  <D.31014>:
  D.31006 = ins->next;
  D.31015 = D.31006->opcode;
  if (D.31015 != 624) goto <D.31016>; else goto <D.24806>;
  <D.31016>:
  D.31006 = ins->next;
  D.31015 = D.31006->opcode;
  if (D.31015 != 757) goto <D.31017>; else goto <D.24806>;
  <D.31017>:
  D.31006 = ins->next;
  D.31015 = D.31006->opcode;
  if (D.31015 != 758) goto <D.31018>; else goto <D.24806>;
  <D.31018>:
  D.31006 = ins->next;
  D.31015 = D.31006->opcode;
  if (D.31015 != 625) goto <D.31019>; else goto <D.24806>;
  <D.31019>:
  D.31006 = ins->next;
  D.31015 = D.31006->opcode;
  if (D.31015 != 626) goto <D.31003>; else goto <D.24806>;
  <D.31003>:
  ins->opcode = 492;
  D.31020 = ins->dreg;
  ins->sreg1 = D.31020;
  D.31020 = ins->dreg;
  ins->sreg2 = D.31020;
  <D.24807>:
  D.31021 = ins->sreg1;
  D.31022 = ins->sreg2;
  if (D.31021 == D.31022) goto <D.31023>; else goto <D.31024>;
  <D.31023>:
  D.31021 = ins->sreg1;
  D.31020 = ins->dreg;
  if (D.31021 == D.31020) goto <D.31025>; else goto <D.31026>;
  <D.31025>:
  ins->opcode = 578;
  <D.31026>:
  <D.31024>:
  <D.24808>:
  D.31021 = ins->sreg1;
  D.31022 = ins->sreg2;
  if (D.31021 == D.31022) goto <D.31027>; else goto <D.31028>;
  <D.31027>:
  D.31021 = ins->sreg1;
  D.31020 = ins->dreg;
  if (D.31021 == D.31020) goto <D.31029>; else goto <D.31030>;
  <D.31029>:
  {
    struct MonoInst * ins2;

    ins2 = ins->next;
    goto <D.24812>;
    <D.24811>:
    D.31034 = ins2->opcode;
    D.31035 = D.31034 == 384;
    D.31036 = D.31034 == 387;
    D.31037 = D.31035 | D.31036;
    if (D.31037 != 0) goto <D.31031>; else goto <D.31038>;
    <D.31038>:
    D.31039 = ins2->opcode;
    if (D.31039 == 388) goto <D.31031>; else goto <D.31040>;
    <D.31040>:
    D.31039 = ins2->opcode;
    if (D.31039 == 384) goto <D.31031>; else goto <D.31032>;
    <D.31031>:
    D.31041 = ins2->data.op[1].const_val;
    if (D.31041 == 0) goto <D.31042>; else goto <D.31032>;
    <D.31042>:
    D.31039 = ins2->opcode;
    D.31043 = (int) D.31039;
    D.31044 = store_membase_imm_to_store_membase_reg (D.31043);
    D.31045 = (short unsigned int) D.31044;
    ins2->opcode = D.31045;
    D.31020 = ins->dreg;
    ins2->sreg1 = D.31020;
    goto <D.31033>;
    <D.31032>:
    D.31046 = ins2->opcode;
    D.31047 = D.31046 + 65151;
    D.31048 = D.31047 <= 1;
    D.31049 = D.31046 == 377;
    D.31050 = D.31048 | D.31049;
    if (D.31050 != 0) goto <D.31051>; else goto <D.31052>;
    <D.31052>:
    D.31039 = ins2->opcode;
    if (D.31039 == 378) goto <D.31053>; else goto <D.31054>;
    <D.31054>:
    D.31039 = ins2->opcode;
    if (D.31039 == 374) goto <D.31055>; else goto <D.31056>;
    <D.31056>:
    D.31039 = ins2->opcode;
    if (D.31039 == 998) goto <D.31057>; else goto <D.31058>;
    <D.31058>:
    D.31039 = ins2->opcode;
    if (D.31039 == 1000) goto <D.31059>; else goto <D.31060>;
    <D.31060>:
    D.31039 = ins2->opcode;
    if (D.31039 == 1001) goto <D.31061>; else goto <D.31062>;
    <D.31061>:
    goto <D.31063>;
    <D.31062>:
    D.31039 = ins2->opcode;
    D.31064 = D.31039 + 65174;
    if (D.31064 <= 1) goto <D.31065>; else goto <D.24810>;
    <D.31065>:
    D.31066 = ins2->dreg;
    D.31020 = ins->dreg;
    if (D.31066 == D.31020) goto <D.31067>; else goto <D.24810>;
    <D.31067>:
    D.31068 = ins2->data.op[0].const_val;
    if (D.31068 == 0) goto <D.31069>; else goto <D.24810>;
    <D.31069>:
    ins2->opcode = 316;
    ins2->dreg = -1;
    ins2->sreg3 = -1;
    D.31070 = ins2->sreg3;
    ins2->sreg2 = D.31070;
    D.31071 = ins2->sreg2;
    ins2->sreg1 = D.31071;
    <D.31063>:
    <D.31059>:
    <D.31057>:
    <D.31055>:
    <D.31053>:
    <D.31051>:
    <D.31033>:
    ins2 = ins2->next;
    <D.24812>:
    if (ins2 != 0B) goto <D.24811>; else goto <D.24810>;
    <D.24810>:
  }
  <D.31030>:
  <D.31028>:
  goto <D.24806>;
  <D.24813>:
  D.31072 = ins->data.op[1].const_val;
  if (D.31072 == 1) goto <D.31073>; else goto <D.31074>;
  <D.31073>:
  D.31020 = ins->dreg;
  D.31021 = ins->sreg1;
  if (D.31020 == D.31021) goto <D.31075>; else goto <D.31076>;
  <D.31075>:
  ins->opcode = 1011;
  <D.31076>:
  <D.31074>:
  goto <D.24806>;
  <D.24814>:
  D.31072 = ins->data.op[1].const_val;
  if (D.31072 == 1) goto <D.31077>; else goto <D.31078>;
  <D.31077>:
  D.31020 = ins->dreg;
  D.31021 = ins->sreg1;
  if (D.31020 == D.31021) goto <D.31079>; else goto <D.31080>;
  <D.31079>:
  ins->opcode = 1013;
  <D.31080>:
  <D.31078>:
  goto <D.24806>;
  <D.31081>:
  <D.24806>:
  mono_peephole_ins (bb, ins);
  ins = n;
  if (ins != 0B) goto <D.31083>; else goto <D.31084>;
  <D.31083>:
  iftmp.85 = ins->next;
  goto <D.31085>;
  <D.31084>:
  iftmp.85 = 0B;
  <D.31085>:
  n = iftmp.85;
  <D.24816>:
  if (ins != 0B) goto <D.24815>; else goto <D.24817>;
  <D.24817>:
}


mono_arch_lowering_pass (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.86;
  short unsigned int D.31090;
  int D.31091;
  long int D.31094;
  unsigned int D.31096;
  int D.31097;
  unsigned long D.31098;
  unsigned long D.31099;
  struct MonoMemPool * D.31102;
  long int D.31103;
  struct MonoInst * D.31104;
  int D.31105;
  int D.31106;
  const unsigned char * D.31107;
  const unsigned char * D.31108;
  unsigned int D.31109;
  int D.31110;
  int D.31111;
  long int D.31112;
  unsigned long D.31113;
  unsigned long D.31114;
  unsigned int D.31117;
  int D.31118;
  unsigned int D.31121;
  int D.31122;
  unsigned int D.31123;
  unsigned int D.31124;
  struct MonoInst * iftmp.87;
  unsigned int D.31129;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * temp;

  ins = bb->code;
  if (ins != 0B) goto <D.31087>; else goto <D.31088>;
  <D.31087>:
  iftmp.86 = ins->next;
  goto <D.31089>;
  <D.31088>:
  iftmp.86 = 0B;
  <D.31089>:
  n = iftmp.86;
  goto <D.24844>;
  <D.24843>:
  D.31090 = ins->opcode;
  D.31091 = (int) D.31090;
  switch (D.31091) <default: <D.24842>, case 323: <D.24832>, case 328: <D.24833>, case 384: <D.24836>, case 388: <D.24837>, case 391: <D.24834>, case 398: <D.24835>, case 436: <D.24825>, case 438: <D.24826>, case 632: <D.24827>, case 633: <D.24828>, case 634: <D.24831>, case 635: <D.24829>, case 947: <D.24838>>
  <D.24825>:
  <D.24826>:
  <D.24827>:
  <D.24828>:
  <D.24829>:
  mono_decompose_op_imm (cfg, bb, ins);
  goto <D.24830>;
  <D.24831>:
  D.31094 = ins->data.op[1].const_val;
  if (D.31094 <= 0) goto <D.31092>; else goto <D.31095>;
  <D.31095>:
  D.31094 = ins->data.op[1].const_val;
  D.31096 = (unsigned int) D.31094;
  D.31097 = mono_is_power_of_two (D.31096);
  if (D.31097 == -1) goto <D.31092>; else goto <D.31093>;
  <D.31092>:
  mono_decompose_op_imm (cfg, bb, ins);
  <D.31093>:
  goto <D.24830>;
  <D.24832>:
  <D.24833>:
  D.31094 = ins->data.op[1].const_val;
  D.31098 = (unsigned long) D.31094;
  D.31099 = D.31098 + 2147483648;
  if (D.31099 > 4294967295) goto <D.31100>; else goto <D.31101>;
  <D.31100>:
  D.31102 = cfg->mempool;
  temp = mono_mempool_alloc (D.31102, 80);
  temp->data.op[1].const_val = 0;
  D.31103 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.31103;
  temp->prev = 0B;
  D.31104 = temp->prev;
  temp->next = D.31104;
  temp->opcode = 363;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.31105 = temp->sreg3;
  temp->sreg2 = D.31105;
  D.31106 = temp->sreg2;
  temp->sreg1 = D.31106;
  D.31107 = cfg->ip;
  temp->cil_code = D.31107;
  D.31108 = ins->cil_code;
  temp->cil_code = D.31108;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.31094 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.31094;
  D.31109 = mono_alloc_ireg (cfg);
  D.31110 = (int) D.31109;
  temp->dreg = D.31110;
  ins->opcode = 322;
  D.31111 = temp->dreg;
  ins->sreg2 = D.31111;
  <D.31101>:
  goto <D.24830>;
  <D.24834>:
  <D.24835>:
  D.31112 = ins->data.op[0].const_val;
  D.31113 = (unsigned long) D.31112;
  D.31114 = D.31113 + 2147483648;
  if (D.31114 > 4294967295) goto <D.31115>; else goto <D.31116>;
  <D.31115>:
  D.31102 = cfg->mempool;
  temp = mono_mempool_alloc (D.31102, 80);
  temp->data.op[1].const_val = 0;
  D.31103 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.31103;
  temp->prev = 0B;
  D.31104 = temp->prev;
  temp->next = D.31104;
  temp->opcode = 363;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.31105 = temp->sreg3;
  temp->sreg2 = D.31105;
  D.31106 = temp->sreg2;
  temp->sreg1 = D.31106;
  D.31107 = cfg->ip;
  temp->cil_code = D.31107;
  D.31108 = ins->cil_code;
  temp->cil_code = D.31108;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.31112 = ins->data.op[0].const_val;
  temp->data.op[0].const_val = D.31112;
  D.31117 = mono_alloc_ireg (cfg);
  D.31118 = (int) D.31117;
  temp->dreg = D.31118;
  ins->opcode = 1073;
  D.31111 = temp->dreg;
  ins->sreg2 = D.31111;
  <D.31116>:
  goto <D.24830>;
  <D.24836>:
  <D.24837>:
  D.31094 = ins->data.op[1].const_val;
  D.31098 = (unsigned long) D.31094;
  D.31099 = D.31098 + 2147483648;
  if (D.31099 > 4294967295) goto <D.31119>; else goto <D.31120>;
  <D.31119>:
  D.31102 = cfg->mempool;
  temp = mono_mempool_alloc (D.31102, 80);
  temp->data.op[1].const_val = 0;
  D.31103 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.31103;
  temp->prev = 0B;
  D.31104 = temp->prev;
  temp->next = D.31104;
  temp->opcode = 363;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.31105 = temp->sreg3;
  temp->sreg2 = D.31105;
  D.31106 = temp->sreg2;
  temp->sreg1 = D.31106;
  D.31107 = cfg->ip;
  temp->cil_code = D.31107;
  D.31108 = ins->cil_code;
  temp->cil_code = D.31108;
  mono_bblock_insert_before_ins (bb, ins, temp);
  D.31094 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.31094;
  D.31121 = mono_alloc_ireg (cfg);
  D.31122 = (int) D.31121;
  temp->dreg = D.31122;
  ins->opcode = 378;
  D.31111 = temp->dreg;
  ins->sreg1 = D.31111;
  <D.31120>:
  goto <D.24830>;
  <D.24838>:
  {
    int temp_reg1;
    int temp_reg2;
    int original_reg;

    D.31123 = mono_alloc_ireg (cfg);
    temp_reg1 = (int) D.31123;
    D.31124 = mono_alloc_ireg (cfg);
    temp_reg2 = (int) D.31124;
    original_reg = ins->sreg1;
    D.31102 = cfg->mempool;
    temp = mono_mempool_alloc (D.31102, 80);
    temp->data.op[1].const_val = 0;
    D.31103 = temp->data.op[1].const_val;
    temp->data.op[0].const_val = D.31103;
    temp->prev = 0B;
    D.31104 = temp->prev;
    temp->next = D.31104;
    temp->opcode = 595;
    temp->flags = 0;
    temp->type = 0;
    temp->dreg = -1;
    temp->sreg3 = -1;
    D.31105 = temp->sreg3;
    temp->sreg2 = D.31105;
    D.31106 = temp->sreg2;
    temp->sreg1 = D.31106;
    D.31107 = cfg->ip;
    temp->cil_code = D.31107;
    D.31108 = ins->cil_code;
    temp->cil_code = D.31108;
    mono_bblock_insert_before_ins (bb, ins, temp);
    temp->sreg1 = original_reg;
    temp->dreg = temp_reg1;
    D.31102 = cfg->mempool;
    temp = mono_mempool_alloc (D.31102, 80);
    temp->data.op[1].const_val = 0;
    D.31103 = temp->data.op[1].const_val;
    temp->data.op[0].const_val = D.31103;
    temp->prev = 0B;
    D.31104 = temp->prev;
    temp->next = D.31104;
    temp->opcode = 443;
    temp->flags = 0;
    temp->type = 0;
    temp->dreg = -1;
    temp->sreg3 = -1;
    D.31105 = temp->sreg3;
    temp->sreg2 = D.31105;
    D.31106 = temp->sreg2;
    temp->sreg1 = D.31106;
    D.31107 = cfg->ip;
    temp->cil_code = D.31107;
    D.31108 = ins->cil_code;
    temp->cil_code = D.31108;
    mono_bblock_insert_before_ins (bb, ins, temp);
    temp->sreg1 = temp_reg1;
    temp->dreg = temp_reg2;
    temp->data.op[1].const_val = 8;
    D.31102 = cfg->mempool;
    temp = mono_mempool_alloc (D.31102, 80);
    temp->data.op[1].const_val = 0;
    D.31103 = temp->data.op[1].const_val;
    temp->data.op[0].const_val = D.31103;
    temp->prev = 0B;
    D.31104 = temp->prev;
    temp->next = D.31104;
    temp->opcode = 491;
    temp->flags = 0;
    temp->type = 0;
    temp->dreg = -1;
    temp->sreg3 = -1;
    D.31105 = temp->sreg3;
    temp->sreg2 = D.31105;
    D.31106 = temp->sreg2;
    temp->sreg1 = D.31106;
    D.31107 = cfg->ip;
    temp->cil_code = D.31107;
    D.31108 = ins->cil_code;
    temp->cil_code = D.31108;
    mono_bblock_insert_before_ins (bb, ins, temp);
    temp->dreg = temp_reg2;
    D.31111 = temp->dreg;
    temp->sreg1 = D.31111;
    temp->sreg2 = temp_reg1;
    ins->opcode = 948;
    ins->sreg1 = temp_reg2;
  }
  goto <D.24830>;
  <D.24842>:
  goto <D.24830>;
  <D.24830>:
  ins = n;
  if (ins != 0B) goto <D.31126>; else goto <D.31127>;
  <D.31126>:
  iftmp.87 = ins->next;
  goto <D.31128>;
  <D.31127>:
  iftmp.87 = 0B;
  <D.31128>:
  n = iftmp.87;
  <D.24844>:
  if (ins != 0B) goto <D.24843>; else goto <D.24845>;
  <D.24845>:
  D.31129 = cfg->next_vreg;
  bb->max_vreg = D.31129;
}


mono_amd64_have_tls_get ()
{
  gboolean D.31131;

  D.31131 = 1;
  return D.31131;
}


mono_amd64_get_tls_gs_offset ()
{
  int D.31133;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 3632);
  D.31133 = -1;
  return D.31133;
}


mono_amd64_emit_tls_get (guint8 * code, int dreg, int tls_offset)
{
  int optimize_for_xen.88;
  guint8 * code.89;
  guint8 * code.90;
  unsigned char iftmp.91;
  guint8 * code.92;
  unsigned char D.31149;
  guint8 * code.93;
  guint8 * code.94;
  guint8 * code.95;
  int D.31153;
  int D.31154;
  signed char D.31155;
  signed char D.31156;
  unsigned char D.31157;
  guint8 * code.96;
  guint8 * code.97;
  unsigned char D.31160;
  guint8 * code.98;
  unsigned char D.31162;
  guint8 * code.99;
  unsigned char D.31164;
  guint8 * code.100;
  unsigned char D.31166;
  guint8 * code.101;
  signed char iftmp.102;
  _Bool D.31174;
  signed char D.31175;
  signed char D.31176;
  guint8 * code.103;
  unsigned char D.31180;
  guint8 * code.104;
  guint8 * code.105;
  guint8 * code.106;
  signed char D.31186;
  unsigned char D.31187;
  guint8 * code.107;
  unsigned char D.31189;
  guint8 * code.108;
  unsigned char D.31191;
  guint8 * code.109;
  unsigned char D.31193;
  guint8 * code.110;
  unsigned char D.31195;
  guint8 * code.111;
  guint8 * code.112;
  unsigned int tls_offset.113;
  unsigned int D.31205;
  guint8 * code.114;
  signed char D.31209;
  unsigned char D.31210;
  guint8 * code.115;
  unsigned char D.31212;
  guint8 * code.116;
  signed char D.31215;
  unsigned char D.31216;
  guint8 * code.117;
  guint8 * code.118;
  unsigned char D.31219;
  guint8 * code.119;
  unsigned char D.31221;
  guint8 * code.120;
  unsigned char D.31223;
  guint8 * code.121;
  unsigned char D.31225;
  guint8 * code.122;
  signed char D.31231;
  signed char D.31232;
  signed char D.31233;
  unsigned char D.31234;
  guint8 * code.123;
  signed char D.31238;
  signed char D.31239;
  unsigned char D.31240;
  guint8 * code.124;
  signed char D.31243;
  signed char D.31244;
  unsigned char D.31245;
  guint8 * code.125;
  unsigned char D.31247;
  guint8 * code.126;
  unsigned char D.31249;
  guint8 * code.127;
  unsigned char D.31251;
  guint8 * code.128;
  unsigned char D.31253;
  guint8 * code.129;
  guint8 * code.130;
  unsigned char iftmp.131;
  guint8 * code.132;
  unsigned char D.31266;
  guint8 * code.133;
  guint8 * code.134;
  guint8 * code.135;
  guint8 * code.136;
  guint8 * code.137;
  unsigned char D.31272;
  guint8 * code.138;
  unsigned char D.31274;
  guint8 * code.139;
  unsigned char D.31276;
  guint8 * code.140;
  unsigned char D.31278;
  guint8 * D.31279;
  static const char __PRETTY_FUNCTION__[24] = "mono_amd64_emit_tls_get";

  optimize_for_xen.88 = optimize_for_xen;
  if (optimize_for_xen.88 != 0) goto <D.31136>; else goto <D.31137>;
  <D.31136>:
  code.89 = code;
  code = code.89 + 1;
  *code.89 = 100;
  if (0 != 0) goto <D.31139>; else goto <D.31140>;
  <D.31139>:
  code.90 = code;
  code = code.90 + 1;
  *code.90 = 102;
  <D.31140>:
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.31143>; else goto <D.31144>;
    <D.31143>:
    iftmp.91 = 12;
    goto <D.31145>;
    <D.31144>:
    iftmp.91 = 8;
    <D.31145>:
    _amd64_rex_bits = iftmp.91;
    if (_amd64_rex_bits != 0) goto <D.31146>; else goto <D.31147>;
    <D.31146>:
    code.92 = code;
    code = code.92 + 1;
    D.31149 = _amd64_rex_bits | 64;
    *code.92 = D.31149;
    <D.31147>:
  }
  switch (8) <default: <D.25006>, case 1: <D.25001>, case 2: <D.25003>, case 4: <D.25004>, case 8: <D.25005>>
  <D.25001>:
  code.93 = code;
  code = code.93 + 1;
  *code.93 = 138;
  goto <D.25002>;
  <D.25003>:
  <D.25004>:
  <D.25005>:
  code.94 = code;
  code = code.94 + 1;
  *code.94 = 139;
  goto <D.25002>;
  <D.25006>:
  __assert_fail ("0", "mini-amd64.c", 3662, &__PRETTY_FUNCTION__);
  <D.25002>:
  code.95 = code;
  code = code.95 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31156 = D.31155 | 4;
  D.31157 = (unsigned char) D.31156;
  *code.95 = D.31157;
  code.96 = code;
  code = code.96 + 1;
  *code.96 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.97 = code;
        code = code.97 + 1;
        D.31160 = imb.b[0];
        *code.97 = D.31160;
        code.98 = code;
        code = code.98 + 1;
        D.31162 = imb.b[1];
        *code.98 = D.31162;
        code.99 = code;
        code = code.99 + 1;
        D.31164 = imb.b[2];
        *code.99 = D.31164;
        code.100 = code;
        code = code.100 + 1;
        D.31166 = imb.b[3];
        *code.100 = D.31166;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  if (0 != 0) goto <D.31167>; else goto <D.31168>;
  <D.31167>:
  code.101 = code;
  code = code.101 + 1;
  *code.101 = 102;
  <D.31168>:
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.31171>; else goto <D.31172>;
    <D.31171>:
    iftmp.102 = 12;
    goto <D.31173>;
    <D.31172>:
    iftmp.102 = 8;
    <D.31173>:
    D.31174 = dreg > 7;
    D.31175 = (signed char) D.31174;
    D.31176 = iftmp.102 | D.31175;
    _amd64_rex_bits = (unsigned char) D.31176;
    if (_amd64_rex_bits != 0) goto <D.31177>; else goto <D.31178>;
    <D.31177>:
    code.103 = code;
    code = code.103 + 1;
    D.31180 = _amd64_rex_bits | 64;
    *code.103 = D.31180;
    <D.31178>:
  }
  switch (8) <default: <D.25015>, case 1: <D.25010>, case 2: <D.25012>, case 4: <D.25013>, case 8: <D.25014>>
  <D.25010>:
  code.104 = code;
  code = code.104 + 1;
  *code.104 = 138;
  goto <D.25011>;
  <D.25012>:
  <D.25013>:
  <D.25014>:
  code.105 = code;
  code = code.105 + 1;
  *code.105 = 139;
  goto <D.25011>;
  <D.25015>:
  __assert_fail ("0", "mini-amd64.c", 3663, &__PRETTY_FUNCTION__);
  <D.25011>:
  if (dreg == 16) goto <D.31183>; else goto <D.31184>;
  <D.31183>:
  code.106 = code;
  code = code.106 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31186 = D.31155 | 5;
  D.31187 = (unsigned char) D.31186;
  *code.106 = D.31187;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.107 = code;
        code = code.107 + 1;
        D.31189 = imb.b[0];
        *code.107 = D.31189;
        code.108 = code;
        code = code.108 + 1;
        D.31191 = imb.b[1];
        *code.108 = D.31191;
        code.109 = code;
        code = code.109 + 1;
        D.31193 = imb.b[2];
        *code.109 = D.31193;
        code.110 = code;
        code = code.110 + 1;
        D.31195 = imb.b[3];
        *code.110 = D.31195;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.31196>;
  <D.31184>:
  D.31153 = dreg & 7;
  if (D.31153 == 4) goto <D.31197>; else goto <D.31198>;
  <D.31197>:
  if (tls_offset == 0) goto <D.31199>; else goto <D.31200>;
  <D.31199>:
  code.111 = code;
  code = code.111 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31156 = D.31155 | 4;
  D.31157 = (unsigned char) D.31156;
  *code.111 = D.31157;
  code.112 = code;
  code = code.112 + 1;
  *code.112 = 36;
  goto <D.31203>;
  <D.31200>:
  tls_offset.113 = (unsigned int) tls_offset;
  D.31205 = tls_offset.113 + 128;
  if (D.31205 <= 255) goto <D.31206>; else goto <D.31207>;
  <D.31206>:
  code.114 = code;
  code = code.114 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31209 = D.31155 | 68;
  D.31210 = (unsigned char) D.31209;
  *code.114 = D.31210;
  code.115 = code;
  code = code.115 + 1;
  *code.115 = 36;
  D.31212 = (unsigned char) tls_offset;
  *code = D.31212;
  code = code + 1;
  goto <D.31213>;
  <D.31207>:
  code.116 = code;
  code = code.116 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31215 = D.31155 | -124;
  D.31216 = (unsigned char) D.31215;
  *code.116 = D.31216;
  code.117 = code;
  code = code.117 + 1;
  *code.117 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.118 = code;
        code = code.118 + 1;
        D.31219 = imb.b[0];
        *code.118 = D.31219;
        code.119 = code;
        code = code.119 + 1;
        D.31221 = imb.b[1];
        *code.119 = D.31221;
        code.120 = code;
        code = code.120 + 1;
        D.31223 = imb.b[2];
        *code.120 = D.31223;
        code.121 = code;
        code = code.121 + 1;
        D.31225 = imb.b[3];
        *code.121 = D.31225;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31213>:
  <D.31203>:
  goto <D.25018>;
  <D.31198>:
  if (tls_offset == 0) goto <D.31226>; else goto <D.31227>;
  <D.31226>:
  D.31153 = dreg & 7;
  if (D.31153 != 5) goto <D.31228>; else goto <D.31229>;
  <D.31228>:
  code.122 = code;
  code = code.122 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31231 = (signed char) dreg;
  D.31232 = D.31231 & 7;
  D.31233 = D.31155 | D.31232;
  D.31234 = (unsigned char) D.31233;
  *code.122 = D.31234;
  goto <D.25018>;
  <D.31229>:
  <D.31227>:
  tls_offset.113 = (unsigned int) tls_offset;
  D.31205 = tls_offset.113 + 128;
  if (D.31205 <= 255) goto <D.31235>; else goto <D.31236>;
  <D.31235>:
  code.123 = code;
  code = code.123 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31238 = D.31155 | 64;
  D.31231 = (signed char) dreg;
  D.31232 = D.31231 & 7;
  D.31239 = D.31238 | D.31232;
  D.31240 = (unsigned char) D.31239;
  *code.123 = D.31240;
  D.31212 = (unsigned char) tls_offset;
  *code = D.31212;
  code = code + 1;
  goto <D.31241>;
  <D.31236>:
  code.124 = code;
  code = code.124 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31243 = D.31155 | -128;
  D.31231 = (signed char) dreg;
  D.31232 = D.31231 & 7;
  D.31244 = D.31243 | D.31232;
  D.31245 = (unsigned char) D.31244;
  *code.124 = D.31245;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.125 = code;
        code = code.125 + 1;
        D.31247 = imb.b[0];
        *code.125 = D.31247;
        code.126 = code;
        code = code.126 + 1;
        D.31249 = imb.b[1];
        *code.126 = D.31249;
        code.127 = code;
        code = code.127 + 1;
        D.31251 = imb.b[2];
        *code.127 = D.31251;
        code.128 = code;
        code = code.128 + 1;
        D.31253 = imb.b[3];
        *code.128 = D.31253;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31241>:
  <D.25018>:
  <D.31196>:
  goto <D.31254>;
  <D.31137>:
  code.129 = code;
  code = code.129 + 1;
  *code.129 = 100;
  if (0 != 0) goto <D.31256>; else goto <D.31257>;
  <D.31256>:
  code.130 = code;
  code = code.130 + 1;
  *code.130 = 102;
  <D.31257>:
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.31260>; else goto <D.31261>;
    <D.31260>:
    iftmp.131 = 12;
    goto <D.31262>;
    <D.31261>:
    iftmp.131 = 8;
    <D.31262>:
    _amd64_rex_bits = iftmp.131;
    if (_amd64_rex_bits != 0) goto <D.31263>; else goto <D.31264>;
    <D.31263>:
    code.132 = code;
    code = code.132 + 1;
    D.31266 = _amd64_rex_bits | 64;
    *code.132 = D.31266;
    <D.31264>:
  }
  switch (8) <default: <D.25026>, case 1: <D.25021>, case 2: <D.25023>, case 4: <D.25024>, case 8: <D.25025>>
  <D.25021>:
  code.133 = code;
  code = code.133 + 1;
  *code.133 = 138;
  goto <D.25022>;
  <D.25023>:
  <D.25024>:
  <D.25025>:
  code.134 = code;
  code = code.134 + 1;
  *code.134 = 139;
  goto <D.25022>;
  <D.25026>:
  __assert_fail ("0", "mini-amd64.c", 3666, &__PRETTY_FUNCTION__);
  <D.25022>:
  code.135 = code;
  code = code.135 + 1;
  D.31153 = dreg & 7;
  D.31154 = D.31153 << 3;
  D.31155 = (signed char) D.31154;
  D.31156 = D.31155 | 4;
  D.31157 = (unsigned char) D.31156;
  *code.135 = D.31157;
  code.136 = code;
  code = code.136 + 1;
  *code.136 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.137 = code;
        code = code.137 + 1;
        D.31272 = imb.b[0];
        *code.137 = D.31272;
        code.138 = code;
        code = code.138 + 1;
        D.31274 = imb.b[1];
        *code.138 = D.31274;
        code.139 = code;
        code = code.139 + 1;
        D.31276 = imb.b[2];
        *code.139 = D.31276;
        code.140 = code;
        code = code.140 + 1;
        D.31278 = imb.b[3];
        *code.140 = D.31278;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31254>:
  D.31279 = code;
  return D.31279;
}


mono_arch_translate_tls_offset (int offset)
{
  int D.31281;

  D.31281 = offset;
  return D.31281;
}


mono_arch_output_basic_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  unsigned char * D.31283;
  unsigned int D.31284;
  sizetype D.31285;
  unsigned int D.31286;
  unsigned int D.31287;
  int D.31290;
  unsigned int D.31291;
  signed char D.31294;
  signed char D.31297;
  int D.31300;
  unsigned int D.31301;
  unsigned int D.31302;
  guint8 * code.141;
  guint8 * code.142;
  guint8 * code.143;
  guint8 * code.144;
  guint8 * code.145;
  guint8 * code.146;
  guint8 * code.147;
  unsigned char D.31314;
  int D.31315;
  guint8 * code.148;
  guint8 * code.149;
  guint8 * code.150;
  guint8 * code.151;
  guint8 * code.152;
  guint8 * code.153;
  guint8 * code.154;
  guint8 * code.155;
  guint8 * code.156;
  guint8 * code.157;
  guint8 * code.158;
  guint8 * code.159;
  guint8 * code.160;
  guint8 * code.161;
  guint8 * code.162;
  guint8 * code.163;
  guint8 * code.164;
  guint8 * code.165;
  guint8 * code.166;
  guint8 * code.167;
  guint8 * code.168;
  guint8 * code.169;
  guint8 * code.170;
  guint8 * code.171;
  guint8 * code.172;
  guint8 * code.173;
  guint8 * code.174;
  guint8 * code.175;
  unsigned int pad.176;
  unsigned int D.31345;
  int D.31346;
  unsigned int D.31347;
  int D.31350;
  int D.31351;
  unsigned int D.31352;
  unsigned int D.31353;
  unsigned char D.31356;
  unsigned char D.31357;
  _Bool D.31358;
  long int D.31359;
  long int D.31360;
  int D.31363;
  unsigned char * D.31364;
  int * D.31365;
  long unsigned int D.31366;
  long int D.31367;
  int D.31368;
  long unsigned int D.31369;
  _Bool D.31370;
  unsigned char iftmp.177;
  guint8 * code.178;
  unsigned char D.31378;
  guint8 * code.179;
  guint8 * code.180;
  unsigned char D.31383;
  guint8 * code.181;
  unsigned char D.31385;
  guint8 * code.182;
  unsigned char D.31387;
  guint8 * code.183;
  unsigned char D.31389;
  guint8 * code.184;
  unsigned char D.31391;
  guint8 * code.185;
  unsigned char D.31393;
  guint8 * code.186;
  unsigned char D.31395;
  guint8 * code.187;
  unsigned char D.31397;
  guint8 * code.188;
  unsigned char D.31400;
  guint8 * code.189;
  unsigned char D.31402;
  guint8 * code.190;
  unsigned char D.31404;
  guint8 * code.191;
  unsigned char D.31406;
  guint8 * code.192;
  unsigned char D.31410;
  guint8 * code.193;
  guint8 * code.194;
  guint8 * code.195;
  guint8 * code.196;
  guint8 * code.197;
  guint8 * code.198;
  guint8 * code.199;
  guint8 * code.200;
  unsigned char D.31427;
  guint8 * code.201;
  unsigned char D.31429;
  guint8 * code.202;
  unsigned char D.31431;
  guint8 * code.203;
  unsigned char D.31433;
  guint8 * code.204;
  guint8 * code.205;
  guint8 * code.206;
  guint8 * code.207;
  unsigned char D.31443;
  guint8 * code.208;
  unsigned char D.31445;
  guint8 * code.209;
  unsigned char D.31447;
  guint8 * code.210;
  unsigned char D.31449;
  long int code.211;
  long int D.31451;
  long int D.31452;
  struct MonoMethodDesc * mono_break_at_bb_method.212;
  struct MonoMethod * D.31456;
  int D.31457;
  int mono_break_at_bb_bb_num.213;
  guint8 * code.214;
  short unsigned int D.31464;
  int D.31465;
  int D.31466;
  short unsigned int D.31467;
  sizetype D.31468;
  sizetype D.31469;
  guint8 * D.31470;
  unsigned char D.31471;
  unsigned int D.31472;
  unsigned int max_len.215;
  unsigned int D.31474;
  unsigned int D.31475;
  _Bool D.31476;
  long int D.31477;
  long int D.31478;
  unsigned int D.31481;
  void * D.31482;
  sizetype D.31483;
  int D.31484;
  int D.31485;
  void * D.31486;
  unsigned char iftmp.216;
  int D.31490;
  guint8 * code.217;
  unsigned char D.31497;
  guint8 * code.218;
  guint8 * code.219;
  signed char D.31500;
  signed char D.31501;
  signed char D.31502;
  unsigned char D.31503;
  unsigned char iftmp.220;
  guint8 * code.221;
  unsigned char D.31511;
  guint8 * code.222;
  guint8 * code.223;
  signed char D.31514;
  unsigned char D.31515;
  int D.31516;
  _Bool D.31517;
  guint8 * code.224;
  unsigned char D.31521;
  guint8 * code.225;
  guint8 * code.226;
  unsigned char D.31526;
  unsigned char D.31527;
  guint8 * code.227;
  unsigned char D.31530;
  unsigned char D.31531;
  int D.31532;
  long int D.31535;
  guint8 * code.228;
  guint8 * code.229;
  unsigned int D.31541;
  unsigned int D.31542;
  guint8 * code.230;
  guint8 * code.231;
  unsigned char D.31547;
  guint8 * code.232;
  guint8 * code.233;
  int D.31551;
  guint8 * code.234;
  unsigned char D.31553;
  guint8 * code.235;
  unsigned char D.31555;
  guint8 * code.236;
  unsigned char D.31557;
  guint8 * code.237;
  unsigned char D.31559;
  guint8 * code.238;
  unsigned char D.31565;
  unsigned char D.31566;
  guint8 * code.239;
  signed char D.31570;
  signed char D.31571;
  signed char D.31572;
  unsigned char D.31573;
  guint8 * code.240;
  signed char D.31576;
  unsigned char D.31577;
  guint8 * code.241;
  unsigned char D.31579;
  guint8 * code.242;
  unsigned char D.31581;
  guint8 * code.243;
  unsigned char D.31583;
  guint8 * code.244;
  unsigned char D.31585;
  guint8 * code.245;
  int D.31589;
  _Bool D.31590;
  guint8 * code.246;
  unsigned char D.31594;
  guint8 * code.247;
  int D.31598;
  guint8 * code.248;
  guint8 * code.249;
  guint8 * code.250;
  guint8 * code.251;
  guint8 * code.252;
  guint8 * code.253;
  guint8 * code.254;
  unsigned char D.31614;
  guint8 * code.255;
  unsigned char D.31616;
  guint8 * code.256;
  unsigned char D.31618;
  guint8 * code.257;
  unsigned char D.31620;
  guint8 * code.258;
  unsigned char D.31626;
  unsigned char D.31627;
  guint8 * code.259;
  signed char D.31631;
  signed char D.31632;
  signed char D.31633;
  unsigned char D.31634;
  guint8 * code.260;
  signed char D.31637;
  unsigned char D.31638;
  guint8 * code.261;
  unsigned char D.31640;
  guint8 * code.262;
  unsigned char D.31642;
  guint8 * code.263;
  unsigned char D.31644;
  guint8 * code.264;
  unsigned char D.31646;
  long int D.31647;
  unsigned char D.31648;
  guint8 * code.265;
  guint8 * code.266;
  guint8 * code.267;
  guint8 * code.268;
  guint8 * code.269;
  guint8 * code.270;
  guint8 * code.271;
  guint8 * code.272;
  unsigned char D.31668;
  guint8 * code.273;
  unsigned char D.31670;
  guint8 * code.274;
  unsigned char D.31672;
  guint8 * code.275;
  unsigned char D.31674;
  guint8 * code.276;
  guint8 * code.277;
  guint8 * code.278;
  guint8 * code.279;
  unsigned char D.31686;
  guint8 * code.280;
  unsigned char D.31688;
  guint8 * code.281;
  unsigned char D.31690;
  guint8 * code.282;
  unsigned char D.31692;
  short int D.31693;
  guint8 * code.283;
  guint8 * code.284;
  guint8 * code.285;
  guint8 * code.286;
  guint8 * code.287;
  guint8 * code.288;
  guint8 * code.289;
  guint8 * code.290;
  unsigned char D.31711;
  guint8 * code.291;
  unsigned char D.31713;
  guint8 * code.292;
  unsigned char D.31715;
  guint8 * code.293;
  unsigned char D.31717;
  guint8 * code.294;
  guint8 * code.295;
  guint8 * code.296;
  guint8 * code.297;
  unsigned char D.31729;
  guint8 * code.298;
  unsigned char D.31731;
  guint8 * code.299;
  unsigned char D.31733;
  guint8 * code.300;
  unsigned char D.31735;
  int D.31736;
  guint8 * code.301;
  unsigned char D.31738;
  guint8 * code.302;
  unsigned char D.31740;
  guint8 * code.303;
  unsigned char D.31742;
  guint8 * code.304;
  unsigned char D.31744;
  guint8 * code.305;
  guint8 * code.306;
  unsigned char D.31751;
  guint8 * code.307;
  guint8 * code.308;
  guint8 * code.309;
  guint8 * code.310;
  guint8 * code.311;
  guint8 * code.312;
  guint8 * code.313;
  guint8 * code.314;
  unsigned char D.31770;
  guint8 * code.315;
  unsigned char D.31772;
  guint8 * code.316;
  unsigned char D.31774;
  guint8 * code.317;
  unsigned char D.31776;
  guint8 * code.318;
  guint8 * code.319;
  guint8 * code.320;
  guint8 * code.321;
  unsigned char D.31788;
  guint8 * code.322;
  unsigned char D.31790;
  guint8 * code.323;
  unsigned char D.31792;
  guint8 * code.324;
  unsigned char D.31794;
  guint8 * code.325;
  guint8 * code.326;
  guint8 * code.327;
  guint8 * code.328;
  guint8 * code.329;
  guint8 * code.330;
  guint8 * code.331;
  guint8 * code.332;
  unsigned char D.31814;
  guint8 * code.333;
  unsigned char D.31816;
  guint8 * code.334;
  unsigned char D.31818;
  guint8 * code.335;
  unsigned char D.31820;
  guint8 * code.336;
  guint8 * code.337;
  guint8 * code.338;
  guint8 * code.339;
  unsigned char D.31832;
  guint8 * code.340;
  unsigned char D.31834;
  guint8 * code.341;
  unsigned char D.31836;
  guint8 * code.342;
  unsigned char D.31838;
  guint8 * code.343;
  guint8 * code.344;
  guint8 * code.345;
  guint8 * code.346;
  guint8 * code.347;
  guint8 * code.348;
  guint8 * code.349;
  guint8 * code.350;
  unsigned char D.31856;
  guint8 * code.351;
  unsigned char D.31858;
  guint8 * code.352;
  unsigned char D.31860;
  guint8 * code.353;
  unsigned char D.31862;
  guint8 * code.354;
  guint8 * code.355;
  guint8 * code.356;
  guint8 * code.357;
  unsigned char D.31874;
  guint8 * code.358;
  unsigned char D.31876;
  guint8 * code.359;
  unsigned char D.31878;
  guint8 * code.360;
  unsigned char D.31880;
  guint8 * code.361;
  unsigned char D.31882;
  guint8 * code.362;
  unsigned char D.31884;
  guint8 * code.363;
  unsigned char D.31886;
  guint8 * code.364;
  unsigned char D.31888;
  guint8 * code.365;
  guint8 * code.366;
  unsigned char D.31895;
  guint8 * code.367;
  guint8 * code.368;
  guint8 * code.369;
  guint8 * code.370;
  guint8 * code.371;
  guint8 * code.372;
  guint8 * code.373;
  guint8 * code.374;
  unsigned char D.31914;
  guint8 * code.375;
  unsigned char D.31916;
  guint8 * code.376;
  unsigned char D.31918;
  guint8 * code.377;
  unsigned char D.31920;
  guint8 * code.378;
  guint8 * code.379;
  guint8 * code.380;
  guint8 * code.381;
  unsigned char D.31932;
  guint8 * code.382;
  unsigned char D.31934;
  guint8 * code.383;
  unsigned char D.31936;
  guint8 * code.384;
  unsigned char D.31938;
  guint8 * code.385;
  guint8 * code.386;
  guint8 * code.387;
  guint8 * code.388;
  guint8 * code.389;
  guint8 * code.390;
  guint8 * code.391;
  guint8 * code.392;
  unsigned char D.31958;
  guint8 * code.393;
  unsigned char D.31960;
  guint8 * code.394;
  unsigned char D.31962;
  guint8 * code.395;
  unsigned char D.31964;
  guint8 * code.396;
  guint8 * code.397;
  guint8 * code.398;
  guint8 * code.399;
  unsigned char D.31976;
  guint8 * code.400;
  unsigned char D.31978;
  guint8 * code.401;
  unsigned char D.31980;
  guint8 * code.402;
  unsigned char D.31982;
  guint8 * code.403;
  guint8 * code.404;
  guint8 * code.405;
  guint8 * code.406;
  guint8 * code.407;
  guint8 * code.408;
  guint8 * code.409;
  guint8 * code.410;
  unsigned char D.32000;
  guint8 * code.411;
  unsigned char D.32002;
  guint8 * code.412;
  unsigned char D.32004;
  guint8 * code.413;
  unsigned char D.32006;
  guint8 * code.414;
  guint8 * code.415;
  guint8 * code.416;
  guint8 * code.417;
  unsigned char D.32018;
  guint8 * code.418;
  unsigned char D.32020;
  guint8 * code.419;
  unsigned char D.32022;
  guint8 * code.420;
  unsigned char D.32024;
  guint8 * code.421;
  unsigned char D.32026;
  guint8 * code.422;
  unsigned char D.32028;
  guint8 * code.423;
  unsigned char D.32030;
  guint8 * code.424;
  unsigned char D.32032;
  guint8 * code.425;
  signed char iftmp.426;
  signed char D.32040;
  signed char D.32041;
  guint8 * code.427;
  unsigned char D.32045;
  guint8 * code.428;
  guint8 * code.429;
  guint8 * code.430;
  int D.32053;
  signed char D.32054;
  signed char D.32055;
  unsigned char D.32056;
  guint8 * code.431;
  guint8 * code.432;
  signed char D.32062;
  unsigned char D.32063;
  guint8 * code.433;
  guint8 * code.434;
  signed char D.32067;
  unsigned char D.32068;
  guint8 * code.435;
  guint8 * code.436;
  unsigned char D.32071;
  guint8 * code.437;
  unsigned char D.32073;
  guint8 * code.438;
  unsigned char D.32075;
  guint8 * code.439;
  unsigned char D.32077;
  guint8 * code.440;
  signed char D.32083;
  unsigned char D.32084;
  guint8 * code.441;
  signed char D.32088;
  signed char D.32089;
  unsigned char D.32090;
  guint8 * code.442;
  signed char D.32093;
  signed char D.32094;
  unsigned char D.32095;
  guint8 * code.443;
  unsigned char D.32097;
  guint8 * code.444;
  unsigned char D.32099;
  guint8 * code.445;
  unsigned char D.32101;
  guint8 * code.446;
  unsigned char D.32103;
  guint8 * code.447;
  signed char iftmp.448;
  signed char D.32111;
  guint8 * code.449;
  unsigned char D.32115;
  guint8 * code.450;
  guint8 * code.451;
  guint8 * code.452;
  guint8 * code.453;
  guint8 * code.454;
  guint8 * code.455;
  guint8 * code.456;
  guint8 * code.457;
  guint8 * code.458;
  unsigned char D.32133;
  guint8 * code.459;
  unsigned char D.32135;
  guint8 * code.460;
  unsigned char D.32137;
  guint8 * code.461;
  unsigned char D.32139;
  guint8 * code.462;
  guint8 * code.463;
  guint8 * code.464;
  guint8 * code.465;
  unsigned char D.32151;
  guint8 * code.466;
  unsigned char D.32153;
  guint8 * code.467;
  unsigned char D.32155;
  guint8 * code.468;
  unsigned char D.32157;
  guint8 * code.469;
  signed char iftmp.470;
  signed char D.32165;
  guint8 * code.471;
  unsigned char D.32169;
  guint8 * code.472;
  guint8 * code.473;
  guint8 * code.474;
  guint8 * code.475;
  guint8 * code.476;
  guint8 * code.477;
  guint8 * code.478;
  guint8 * code.479;
  guint8 * code.480;
  unsigned char D.32187;
  guint8 * code.481;
  unsigned char D.32189;
  guint8 * code.482;
  unsigned char D.32191;
  guint8 * code.483;
  unsigned char D.32193;
  guint8 * code.484;
  guint8 * code.485;
  guint8 * code.486;
  guint8 * code.487;
  unsigned char D.32205;
  guint8 * code.488;
  unsigned char D.32207;
  guint8 * code.489;
  unsigned char D.32209;
  guint8 * code.490;
  unsigned char D.32211;
  guint8 * code.491;
  signed char iftmp.492;
  signed char D.32219;
  guint8 * code.493;
  unsigned char D.32223;
  guint8 * code.494;
  guint8 * code.495;
  guint8 * code.496;
  guint8 * code.497;
  guint8 * code.498;
  guint8 * code.499;
  guint8 * code.500;
  guint8 * code.501;
  guint8 * code.502;
  unsigned char D.32241;
  guint8 * code.503;
  unsigned char D.32243;
  guint8 * code.504;
  unsigned char D.32245;
  guint8 * code.505;
  unsigned char D.32247;
  guint8 * code.506;
  guint8 * code.507;
  guint8 * code.508;
  guint8 * code.509;
  unsigned char D.32259;
  guint8 * code.510;
  unsigned char D.32261;
  guint8 * code.511;
  unsigned char D.32263;
  guint8 * code.512;
  unsigned char D.32265;
  guint8 * code.513;
  signed char iftmp.514;
  signed char D.32273;
  guint8 * code.515;
  unsigned char D.32277;
  guint8 * code.516;
  guint8 * code.517;
  guint8 * code.518;
  guint8 * code.519;
  guint8 * code.520;
  guint8 * code.521;
  guint8 * code.522;
  guint8 * code.523;
  guint8 * code.524;
  unsigned char D.32295;
  guint8 * code.525;
  unsigned char D.32297;
  guint8 * code.526;
  unsigned char D.32299;
  guint8 * code.527;
  unsigned char D.32301;
  guint8 * code.528;
  guint8 * code.529;
  guint8 * code.530;
  guint8 * code.531;
  unsigned char D.32313;
  guint8 * code.532;
  unsigned char D.32315;
  guint8 * code.533;
  unsigned char D.32317;
  guint8 * code.534;
  unsigned char D.32319;
  unsigned long D.32320;
  unsigned long D.32321;
  _Bool D.32322;
  long int D.32323;
  long int D.32324;
  guint8 * code.535;
  unsigned char iftmp.536;
  guint8 * code.537;
  unsigned char D.32337;
  guint8 * code.538;
  guint8 * code.539;
  guint8 * code.540;
  guint8 * code.541;
  guint8 * code.542;
  guint8 * code.543;
  guint8 * code.544;
  guint8 * code.545;
  unsigned char D.32356;
  guint8 * code.546;
  unsigned char D.32358;
  guint8 * code.547;
  unsigned char D.32360;
  guint8 * code.548;
  unsigned char D.32362;
  guint8 * code.549;
  guint8 * code.550;
  guint8 * code.551;
  guint8 * code.552;
  unsigned char D.32374;
  guint8 * code.553;
  unsigned char D.32376;
  guint8 * code.554;
  unsigned char D.32378;
  guint8 * code.555;
  unsigned char D.32380;
  guint8 * code.556;
  guint8 * code.557;
  guint8 * code.558;
  guint8 * code.559;
  guint8 * code.560;
  guint8 * code.561;
  guint8 * code.562;
  guint8 * code.563;
  unsigned char D.32400;
  guint8 * code.564;
  unsigned char D.32402;
  guint8 * code.565;
  unsigned char D.32404;
  guint8 * code.566;
  unsigned char D.32406;
  guint8 * code.567;
  guint8 * code.568;
  guint8 * code.569;
  guint8 * code.570;
  unsigned char D.32418;
  guint8 * code.571;
  unsigned char D.32420;
  guint8 * code.572;
  unsigned char D.32422;
  guint8 * code.573;
  unsigned char D.32424;
  guint8 * code.574;
  guint8 * code.575;
  guint8 * code.576;
  guint8 * code.577;
  guint8 * code.578;
  guint8 * code.579;
  guint8 * code.580;
  guint8 * code.581;
  unsigned char D.32442;
  guint8 * code.582;
  unsigned char D.32444;
  guint8 * code.583;
  unsigned char D.32446;
  guint8 * code.584;
  unsigned char D.32448;
  guint8 * code.585;
  guint8 * code.586;
  guint8 * code.587;
  guint8 * code.588;
  unsigned char D.32460;
  guint8 * code.589;
  unsigned char D.32462;
  guint8 * code.590;
  unsigned char D.32464;
  guint8 * code.591;
  unsigned char D.32466;
  guint8 * code.592;
  unsigned char D.32468;
  guint8 * code.593;
  unsigned char D.32470;
  guint8 * code.594;
  unsigned char D.32472;
  guint8 * code.595;
  unsigned char D.32474;
  guint8 * code.596;
  unsigned char iftmp.597;
  guint8 * code.598;
  unsigned char D.32487;
  guint8 * code.599;
  guint8 * code.600;
  guint8 * code.601;
  guint8 * code.602;
  guint8 * code.603;
  guint8 * code.604;
  guint8 * code.605;
  guint8 * code.606;
  unsigned char D.32506;
  guint8 * code.607;
  unsigned char D.32508;
  guint8 * code.608;
  unsigned char D.32510;
  guint8 * code.609;
  unsigned char D.32512;
  guint8 * code.610;
  guint8 * code.611;
  guint8 * code.612;
  guint8 * code.613;
  unsigned char D.32524;
  guint8 * code.614;
  unsigned char D.32526;
  guint8 * code.615;
  unsigned char D.32528;
  guint8 * code.616;
  unsigned char D.32530;
  guint8 * code.617;
  guint8 * code.618;
  guint8 * code.619;
  guint8 * code.620;
  guint8 * code.621;
  guint8 * code.622;
  guint8 * code.623;
  guint8 * code.624;
  unsigned char D.32550;
  guint8 * code.625;
  unsigned char D.32552;
  guint8 * code.626;
  unsigned char D.32554;
  guint8 * code.627;
  unsigned char D.32556;
  guint8 * code.628;
  guint8 * code.629;
  guint8 * code.630;
  guint8 * code.631;
  unsigned char D.32568;
  guint8 * code.632;
  unsigned char D.32570;
  guint8 * code.633;
  unsigned char D.32572;
  guint8 * code.634;
  unsigned char D.32574;
  guint8 * code.635;
  guint8 * code.636;
  guint8 * code.637;
  guint8 * code.638;
  guint8 * code.639;
  guint8 * code.640;
  guint8 * code.641;
  guint8 * code.642;
  unsigned char D.32592;
  guint8 * code.643;
  unsigned char D.32594;
  guint8 * code.644;
  unsigned char D.32596;
  guint8 * code.645;
  unsigned char D.32598;
  guint8 * code.646;
  guint8 * code.647;
  guint8 * code.648;
  guint8 * code.649;
  unsigned char D.32610;
  guint8 * code.650;
  unsigned char D.32612;
  guint8 * code.651;
  unsigned char D.32614;
  guint8 * code.652;
  unsigned char D.32616;
  guint8 * code.653;
  unsigned char D.32618;
  guint8 * code.654;
  unsigned char D.32620;
  guint8 * code.655;
  unsigned char D.32622;
  guint8 * code.656;
  unsigned char D.32624;
  guint8 * code.657;
  unsigned char iftmp.658;
  guint8 * code.659;
  unsigned char D.32637;
  guint8 * code.660;
  guint8 * code.661;
  guint8 * code.662;
  int D.32641;
  signed char D.32642;
  signed char D.32643;
  unsigned char D.32644;
  guint8 * code.663;
  guint8 * code.664;
  unsigned char D.32647;
  guint8 * code.665;
  unsigned char D.32649;
  guint8 * code.666;
  unsigned char D.32651;
  guint8 * code.667;
  unsigned char D.32653;
  long unsigned int D.32655;
  long unsigned int D.32656;
  _Bool D.32657;
  signed char iftmp.668;
  signed char D.32662;
  guint8 * code.669;
  unsigned char D.32666;
  guint8 * code.670;
  unsigned char D.32668;
  guint8 * code.671;
  unsigned char D.32672;
  guint8 * code.672;
  unsigned char D.32674;
  guint8 * code.673;
  unsigned char D.32676;
  guint8 * code.674;
  unsigned char D.32678;
  guint8 * code.675;
  unsigned char D.32680;
  guint8 * code.676;
  unsigned char D.32682;
  guint8 * code.677;
  unsigned char D.32684;
  guint8 * code.678;
  unsigned char D.32686;
  guint8 * code.679;
  unsigned char D.32689;
  guint8 * code.680;
  unsigned char D.32691;
  guint8 * code.681;
  unsigned char D.32693;
  guint8 * code.682;
  unsigned char D.32695;
  guint8 * code.683;
  signed char iftmp.684;
  signed char D.32703;
  guint8 * code.685;
  unsigned char D.32707;
  guint8 * code.686;
  guint8 * code.687;
  guint8 * code.688;
  signed char D.32713;
  unsigned char D.32714;
  guint8 * code.689;
  unsigned char D.32716;
  guint8 * code.690;
  unsigned char D.32718;
  guint8 * code.691;
  unsigned char D.32720;
  guint8 * code.692;
  unsigned char D.32722;
  guint8 * code.693;
  guint8 * code.694;
  guint8 * code.695;
  signed char D.32734;
  unsigned char D.32735;
  guint8 * code.696;
  guint8 * code.697;
  signed char D.32739;
  unsigned char D.32740;
  guint8 * code.698;
  guint8 * code.699;
  unsigned char D.32743;
  guint8 * code.700;
  unsigned char D.32745;
  guint8 * code.701;
  unsigned char D.32747;
  guint8 * code.702;
  unsigned char D.32749;
  guint8 * code.703;
  signed char D.32753;
  unsigned char D.32754;
  guint8 * code.704;
  signed char D.32758;
  signed char D.32759;
  unsigned char D.32760;
  guint8 * code.705;
  signed char D.32763;
  signed char D.32764;
  unsigned char D.32765;
  guint8 * code.706;
  unsigned char D.32767;
  guint8 * code.707;
  unsigned char D.32769;
  guint8 * code.708;
  unsigned char D.32771;
  guint8 * code.709;
  unsigned char D.32773;
  signed char iftmp.710;
  signed char D.32778;
  guint8 * code.711;
  unsigned char D.32782;
  guint8 * code.712;
  guint8 * code.713;
  unsigned char D.32787;
  guint8 * code.714;
  unsigned char D.32789;
  guint8 * code.715;
  unsigned char D.32791;
  guint8 * code.716;
  unsigned char D.32793;
  guint8 * code.717;
  unsigned char D.32795;
  guint8 * code.718;
  unsigned char D.32797;
  guint8 * code.719;
  unsigned char D.32799;
  guint8 * code.720;
  unsigned char D.32801;
  guint8 * code.721;
  unsigned char D.32804;
  guint8 * code.722;
  unsigned char D.32806;
  guint8 * code.723;
  unsigned char D.32808;
  guint8 * code.724;
  unsigned char D.32810;
  signed char iftmp.725;
  signed char D.32815;
  guint8 * code.726;
  unsigned char D.32819;
  guint8 * code.727;
  guint8 * code.728;
  guint8 * code.729;
  guint8 * code.730;
  guint8 * code.731;
  guint8 * code.732;
  guint8 * code.733;
  guint8 * code.734;
  unsigned char D.32836;
  guint8 * code.735;
  unsigned char D.32838;
  guint8 * code.736;
  unsigned char D.32840;
  guint8 * code.737;
  unsigned char D.32842;
  guint8 * code.738;
  guint8 * code.739;
  guint8 * code.740;
  guint8 * code.741;
  unsigned char D.32852;
  guint8 * code.742;
  unsigned char D.32854;
  guint8 * code.743;
  unsigned char D.32856;
  guint8 * code.744;
  unsigned char D.32858;
  guint8 * code.745;
  unsigned char iftmp.746;
  guint8 * code.747;
  unsigned char D.32871;
  guint8 * code.748;
  guint8 * code.749;
  guint8 * code.750;
  guint8 * code.751;
  guint8 * code.752;
  unsigned char D.32877;
  guint8 * code.753;
  unsigned char D.32879;
  guint8 * code.754;
  unsigned char D.32881;
  guint8 * code.755;
  unsigned char D.32883;
  signed char iftmp.756;
  signed char D.32889;
  guint8 * code.757;
  unsigned char D.32893;
  guint8 * code.758;
  guint8 * code.759;
  unsigned char D.32898;
  guint8 * code.760;
  unsigned char D.32900;
  guint8 * code.761;
  unsigned char D.32902;
  guint8 * code.762;
  unsigned char D.32904;
  guint8 * code.763;
  unsigned char D.32906;
  guint8 * code.764;
  unsigned char D.32908;
  guint8 * code.765;
  unsigned char D.32910;
  guint8 * code.766;
  unsigned char D.32912;
  guint8 * code.767;
  unsigned char D.32915;
  guint8 * code.768;
  unsigned char D.32917;
  guint8 * code.769;
  unsigned char D.32919;
  guint8 * code.770;
  unsigned char D.32921;
  guint8 * code.771;
  signed char iftmp.772;
  signed char D.32929;
  guint8 * code.773;
  unsigned char D.32933;
  guint8 * code.774;
  guint8 * code.775;
  guint8 * code.776;
  guint8 * code.777;
  unsigned char D.32940;
  guint8 * code.778;
  unsigned char D.32942;
  guint8 * code.779;
  unsigned char D.32944;
  guint8 * code.780;
  unsigned char D.32946;
  guint8 * code.781;
  guint8 * code.782;
  guint8 * code.783;
  guint8 * code.784;
  guint8 * code.785;
  guint8 * code.786;
  guint8 * code.787;
  unsigned char D.32963;
  guint8 * code.788;
  unsigned char D.32965;
  guint8 * code.789;
  unsigned char D.32967;
  guint8 * code.790;
  unsigned char D.32969;
  guint8 * code.791;
  guint8 * code.792;
  guint8 * code.793;
  guint8 * code.794;
  unsigned char D.32979;
  guint8 * code.795;
  unsigned char D.32981;
  guint8 * code.796;
  unsigned char D.32983;
  guint8 * code.797;
  unsigned char D.32985;
  signed char iftmp.798;
  signed char D.32990;
  guint8 * code.799;
  unsigned char D.32994;
  guint8 * code.800;
  guint8 * code.801;
  unsigned char D.32999;
  guint8 * code.802;
  unsigned char D.33001;
  guint8 * code.803;
  unsigned char D.33003;
  guint8 * code.804;
  unsigned char D.33005;
  guint8 * code.805;
  unsigned char D.33007;
  guint8 * code.806;
  unsigned char D.33009;
  guint8 * code.807;
  unsigned char D.33011;
  guint8 * code.808;
  unsigned char D.33013;
  guint8 * code.809;
  unsigned char D.33016;
  guint8 * code.810;
  unsigned char D.33018;
  guint8 * code.811;
  unsigned char D.33020;
  guint8 * code.812;
  unsigned char D.33022;
  signed char iftmp.813;
  signed char D.33027;
  guint8 * code.814;
  unsigned char D.33031;
  guint8 * code.815;
  guint8 * code.816;
  guint8 * code.817;
  guint8 * code.818;
  guint8 * code.819;
  guint8 * code.820;
  guint8 * code.821;
  guint8 * code.822;
  guint8 * code.823;
  unsigned char D.33053;
  guint8 * code.824;
  unsigned char D.33055;
  guint8 * code.825;
  unsigned char D.33057;
  guint8 * code.826;
  unsigned char D.33059;
  guint8 * code.827;
  guint8 * code.828;
  guint8 * code.829;
  guint8 * code.830;
  unsigned char D.33069;
  guint8 * code.831;
  unsigned char D.33071;
  guint8 * code.832;
  unsigned char D.33073;
  guint8 * code.833;
  unsigned char D.33075;
  signed char iftmp.834;
  signed char D.33080;
  guint8 * code.835;
  unsigned char D.33084;
  guint8 * code.836;
  guint8 * code.837;
  unsigned char D.33089;
  guint8 * code.838;
  unsigned char D.33091;
  guint8 * code.839;
  unsigned char D.33093;
  guint8 * code.840;
  unsigned char D.33095;
  guint8 * code.841;
  unsigned char D.33097;
  guint8 * code.842;
  unsigned char D.33099;
  guint8 * code.843;
  unsigned char D.33101;
  guint8 * code.844;
  unsigned char D.33103;
  guint8 * code.845;
  unsigned char D.33106;
  guint8 * code.846;
  unsigned char D.33108;
  guint8 * code.847;
  unsigned char D.33110;
  guint8 * code.848;
  unsigned char D.33112;
  signed char iftmp.849;
  signed char D.33117;
  guint8 * code.850;
  unsigned char D.33121;
  guint8 * code.851;
  guint8 * code.852;
  guint8 * code.853;
  guint8 * code.854;
  guint8 * code.855;
  guint8 * code.856;
  guint8 * code.857;
  guint8 * code.858;
  guint8 * code.859;
  unsigned char D.33143;
  guint8 * code.860;
  unsigned char D.33145;
  guint8 * code.861;
  unsigned char D.33147;
  guint8 * code.862;
  unsigned char D.33149;
  guint8 * code.863;
  guint8 * code.864;
  guint8 * code.865;
  guint8 * code.866;
  unsigned char D.33159;
  guint8 * code.867;
  unsigned char D.33161;
  guint8 * code.868;
  unsigned char D.33163;
  guint8 * code.869;
  unsigned char D.33165;
  unsigned long D.33166;
  unsigned long D.33167;
  _Bool D.33168;
  long int D.33169;
  long int D.33170;
  guint8 * code.870;
  signed char iftmp.871;
  signed char D.33180;
  signed char D.33181;
  guint8 * code.872;
  unsigned char D.33185;
  guint8 * code.873;
  guint8 * code.874;
  guint8 * code.875;
  guint8 * code.876;
  unsigned char D.33192;
  guint8 * code.877;
  unsigned char D.33194;
  guint8 * code.878;
  unsigned char D.33196;
  guint8 * code.879;
  unsigned char D.33198;
  guint8 * code.880;
  guint8 * code.881;
  guint8 * code.882;
  guint8 * code.883;
  guint8 * code.884;
  guint8 * code.885;
  guint8 * code.886;
  unsigned char D.33215;
  guint8 * code.887;
  unsigned char D.33217;
  guint8 * code.888;
  unsigned char D.33219;
  guint8 * code.889;
  unsigned char D.33221;
  guint8 * code.890;
  signed char D.33227;
  unsigned char D.33228;
  guint8 * code.891;
  signed char D.33232;
  unsigned char D.33233;
  guint8 * code.892;
  signed char D.33236;
  unsigned char D.33237;
  guint8 * code.893;
  unsigned char D.33239;
  guint8 * code.894;
  unsigned char D.33241;
  guint8 * code.895;
  unsigned char D.33243;
  guint8 * code.896;
  unsigned char D.33245;
  guint8 * code.897;
  signed char iftmp.898;
  signed char D.33255;
  guint8 * code.899;
  unsigned char D.33259;
  guint8 * code.900;
  guint8 * code.901;
  guint8 * code.902;
  guint8 * code.903;
  unsigned char D.33266;
  guint8 * code.904;
  unsigned char D.33268;
  guint8 * code.905;
  unsigned char D.33270;
  guint8 * code.906;
  unsigned char D.33272;
  guint8 * code.907;
  guint8 * code.908;
  guint8 * code.909;
  guint8 * code.910;
  guint8 * code.911;
  guint8 * code.912;
  guint8 * code.913;
  unsigned char D.33289;
  guint8 * code.914;
  unsigned char D.33291;
  guint8 * code.915;
  unsigned char D.33293;
  guint8 * code.916;
  unsigned char D.33295;
  guint8 * code.917;
  guint8 * code.918;
  guint8 * code.919;
  guint8 * code.920;
  unsigned char D.33307;
  guint8 * code.921;
  unsigned char D.33309;
  guint8 * code.922;
  unsigned char D.33311;
  guint8 * code.923;
  unsigned char D.33313;
  signed char iftmp.924;
  signed char D.33318;
  guint8 * code.925;
  unsigned char D.33322;
  guint8 * code.926;
  guint8 * code.927;
  guint8 * code.928;
  guint8 * code.929;
  guint8 * code.930;
  guint8 * code.931;
  guint8 * code.932;
  guint8 * code.933;
  unsigned char D.33339;
  guint8 * code.934;
  unsigned char D.33341;
  guint8 * code.935;
  unsigned char D.33343;
  guint8 * code.936;
  unsigned char D.33345;
  guint8 * code.937;
  guint8 * code.938;
  guint8 * code.939;
  guint8 * code.940;
  unsigned char D.33357;
  guint8 * code.941;
  unsigned char D.33359;
  guint8 * code.942;
  unsigned char D.33361;
  guint8 * code.943;
  unsigned char D.33363;
  guint8 * code.944;
  signed char iftmp.945;
  signed char D.33371;
  guint8 * code.946;
  unsigned char D.33375;
  guint8 * code.947;
  guint8 * code.948;
  guint8 * code.949;
  guint8 * code.950;
  unsigned char D.33382;
  guint8 * code.951;
  unsigned char D.33384;
  guint8 * code.952;
  unsigned char D.33386;
  guint8 * code.953;
  unsigned char D.33388;
  guint8 * code.954;
  guint8 * code.955;
  guint8 * code.956;
  guint8 * code.957;
  guint8 * code.958;
  guint8 * code.959;
  guint8 * code.960;
  unsigned char D.33405;
  guint8 * code.961;
  unsigned char D.33407;
  guint8 * code.962;
  unsigned char D.33409;
  guint8 * code.963;
  unsigned char D.33411;
  guint8 * code.964;
  guint8 * code.965;
  guint8 * code.966;
  guint8 * code.967;
  unsigned char D.33423;
  guint8 * code.968;
  unsigned char D.33425;
  guint8 * code.969;
  unsigned char D.33427;
  guint8 * code.970;
  unsigned char D.33429;
  signed char iftmp.971;
  signed char D.33434;
  guint8 * code.972;
  unsigned char D.33438;
  guint8 * code.973;
  guint8 * code.974;
  guint8 * code.975;
  guint8 * code.976;
  guint8 * code.977;
  guint8 * code.978;
  guint8 * code.979;
  guint8 * code.980;
  guint8 * code.981;
  unsigned char D.33460;
  guint8 * code.982;
  unsigned char D.33462;
  guint8 * code.983;
  unsigned char D.33464;
  guint8 * code.984;
  unsigned char D.33466;
  guint8 * code.985;
  guint8 * code.986;
  guint8 * code.987;
  guint8 * code.988;
  unsigned char D.33478;
  guint8 * code.989;
  unsigned char D.33480;
  guint8 * code.990;
  unsigned char D.33482;
  guint8 * code.991;
  unsigned char D.33484;
  signed char iftmp.992;
  signed char D.33489;
  guint8 * code.993;
  unsigned char D.33493;
  guint8 * code.994;
  guint8 * code.995;
  guint8 * code.996;
  guint8 * code.997;
  guint8 * code.998;
  guint8 * code.999;
  guint8 * code.1000;
  guint8 * code.1001;
  guint8 * code.1002;
  unsigned char D.33515;
  guint8 * code.1003;
  unsigned char D.33517;
  guint8 * code.1004;
  unsigned char D.33519;
  guint8 * code.1005;
  unsigned char D.33521;
  guint8 * code.1006;
  guint8 * code.1007;
  guint8 * code.1008;
  guint8 * code.1009;
  unsigned char D.33533;
  guint8 * code.1010;
  unsigned char D.33535;
  guint8 * code.1011;
  unsigned char D.33537;
  guint8 * code.1012;
  unsigned char D.33539;
  signed char iftmp.1013;
  signed char D.33544;
  guint8 * code.1014;
  unsigned char D.33548;
  guint8 * code.1015;
  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.33570;
  guint8 * code.1024;
  unsigned char D.33572;
  guint8 * code.1025;
  unsigned char D.33574;
  guint8 * code.1026;
  unsigned char D.33576;
  guint8 * code.1027;
  guint8 * code.1028;
  guint8 * code.1029;
  guint8 * code.1030;
  unsigned char D.33588;
  guint8 * code.1031;
  unsigned char D.33590;
  guint8 * code.1032;
  unsigned char D.33592;
  guint8 * code.1033;
  unsigned char D.33594;
  signed char iftmp.1034;
  signed char D.33599;
  guint8 * code.1035;
  unsigned char D.33603;
  guint8 * code.1036;
  guint8 * code.1037;
  guint8 * code.1038;
  guint8 * code.1039;
  guint8 * code.1040;
  guint8 * code.1041;
  guint8 * code.1042;
  guint8 * code.1043;
  guint8 * code.1044;
  unsigned char D.33625;
  guint8 * code.1045;
  unsigned char D.33627;
  guint8 * code.1046;
  unsigned char D.33629;
  guint8 * code.1047;
  unsigned char D.33631;
  guint8 * code.1048;
  guint8 * code.1049;
  guint8 * code.1050;
  guint8 * code.1051;
  unsigned char D.33643;
  guint8 * code.1052;
  unsigned char D.33645;
  guint8 * code.1053;
  unsigned char D.33647;
  guint8 * code.1054;
  unsigned char D.33649;
  signed char iftmp.1055;
  signed char iftmp.1056;
  signed char D.33658;
  signed char D.33659;
  guint8 * code.1057;
  unsigned char D.33663;
  guint8 * code.1058;
  guint8 * code.1059;
  guint8 * code.1060;
  guint8 * code.1061;
  guint8 * code.1062;
  int D.33671;
  int D.33672;
  signed char D.33673;
  signed char D.33674;
  unsigned char D.33675;
  guint8 * code.1063;
  unsigned char D.33677;
  guint8 * code.1064;
  unsigned char D.33679;
  guint8 * code.1065;
  unsigned char D.33681;
  guint8 * code.1066;
  unsigned char D.33683;
  guint8 * code.1067;
  guint8 * code.1068;
  signed char D.33689;
  unsigned char D.33690;
  guint8 * code.1069;
  guint8 * code.1070;
  guint8 * code.1071;
  guint8 * code.1072;
  guint8 * code.1073;
  unsigned char D.33700;
  guint8 * code.1074;
  unsigned char D.33702;
  guint8 * code.1075;
  unsigned char D.33704;
  guint8 * code.1076;
  unsigned char D.33706;
  signed char iftmp.1077;
  signed char D.33711;
  guint8 * code.1078;
  unsigned char D.33715;
  guint8 * code.1079;
  guint8 * code.1080;
  guint8 * code.1081;
  signed char D.33725;
  signed char D.33726;
  unsigned char D.33727;
  signed char iftmp.1082;
  signed char D.33732;
  guint8 * code.1083;
  unsigned char D.33736;
  guint8 * code.1084;
  guint8 * code.1085;
  guint8 * code.1086;
  signed char iftmp.1087;
  signed char D.33750;
  guint8 * code.1088;
  unsigned char D.33754;
  guint8 * code.1089;
  guint8 * code.1090;
  guint8 * code.1091;
  signed char iftmp.1092;
  signed char D.33768;
  guint8 * code.1093;
  unsigned char D.33772;
  guint8 * code.1094;
  guint8 * code.1095;
  guint8 * code.1096;
  signed char iftmp.1097;
  signed char D.33786;
  guint8 * code.1098;
  unsigned char D.33790;
  guint8 * code.1099;
  guint8 * code.1100;
  guint8 * code.1101;
  guint8 * code.1102;
  signed char iftmp.1103;
  signed char D.33799;
  guint8 * code.1104;
  unsigned char D.33803;
  guint8 * code.1105;
  guint8 * code.1106;
  signed char iftmp.1107;
  _Bool D.33810;
  signed char D.33811;
  signed char D.33812;
  guint8 * code.1108;
  unsigned char D.33816;
  guint8 * code.1109;
  guint8 * code.1110;
  signed char D.33819;
  signed char D.33820;
  unsigned char D.33821;
  unsigned int D.33824;
  unsigned int D.33825;
  unsigned char iftmp.1111;
  guint8 * code.1112;
  unsigned char D.33835;
  guint8 * code.1113;
  guint8 * code.1114;
  signed char D.33838;
  unsigned char D.33839;
  guint8 * code.1115;
  unsigned char D.33846;
  guint8 * code.1116;
  guint8 * code.1117;
  unsigned char D.33849;
  guint8 * code.1118;
  unsigned char D.33851;
  guint8 * code.1119;
  unsigned char D.33853;
  guint8 * code.1120;
  unsigned char D.33855;
  unsigned char iftmp.1121;
  guint8 * code.1122;
  unsigned char D.33864;
  guint8 * code.1123;
  guint8 * code.1124;
  guint8 * code.1125;
  unsigned char D.33868;
  guint8 * code.1126;
  unsigned char D.33870;
  guint8 * code.1127;
  unsigned char D.33872;
  guint8 * code.1128;
  unsigned char D.33874;
  signed char iftmp.1129;
  signed char D.33879;
  guint8 * code.1130;
  unsigned char D.33883;
  guint8 * code.1131;
  guint8 * code.1132;
  signed char D.33888;
  unsigned char D.33889;
  guint8 * code.1133;
  unsigned char D.33891;
  guint8 * code.1134;
  unsigned char D.33893;
  guint8 * code.1135;
  unsigned char D.33895;
  guint8 * code.1136;
  unsigned char D.33897;
  guint8 * code.1137;
  guint8 * code.1138;
  guint8 * code.1139;
  guint8 * code.1140;
  guint8 * code.1141;
  guint8 * code.1142;
  guint8 * code.1143;
  unsigned char D.33914;
  guint8 * code.1144;
  unsigned char D.33916;
  guint8 * code.1145;
  unsigned char D.33918;
  guint8 * code.1146;
  unsigned char D.33920;
  guint8 * code.1147;
  signed char D.33926;
  unsigned char D.33927;
  guint8 * code.1148;
  signed char D.33931;
  unsigned char D.33932;
  guint8 * code.1149;
  signed char D.33935;
  unsigned char D.33936;
  guint8 * code.1150;
  unsigned char D.33938;
  guint8 * code.1151;
  unsigned char D.33940;
  guint8 * code.1152;
  unsigned char D.33942;
  guint8 * code.1153;
  unsigned char D.33944;
  signed char iftmp.1154;
  signed char D.33949;
  guint8 * code.1155;
  unsigned char D.33953;
  guint8 * code.1156;
  guint8 * code.1157;
  signed char D.33956;
  unsigned char D.33957;
  signed char iftmp.1158;
  signed char D.33962;
  guint8 * code.1159;
  unsigned char D.33966;
  guint8 * code.1160;
  guint8 * code.1161;
  signed char iftmp.1162;
  signed char D.33973;
  guint8 * code.1163;
  unsigned char D.33977;
  guint8 * code.1164;
  guint8 * code.1165;
  guint8 * code.1166;
  unsigned char D.33983;
  guint8 * code.1167;
  unsigned char D.33985;
  guint8 * code.1168;
  unsigned char D.33987;
  guint8 * code.1169;
  unsigned char D.33989;
  guint8 * code.1170;
  guint8 * code.1171;
  guint8 * code.1172;
  guint8 * code.1173;
  guint8 * code.1174;
  guint8 * code.1175;
  guint8 * code.1176;
  unsigned char D.34006;
  guint8 * code.1177;
  unsigned char D.34008;
  guint8 * code.1178;
  unsigned char D.34010;
  guint8 * code.1179;
  unsigned char D.34012;
  guint8 * code.1180;
  guint8 * code.1181;
  guint8 * code.1182;
  guint8 * code.1183;
  unsigned char D.34024;
  guint8 * code.1184;
  unsigned char D.34026;
  guint8 * code.1185;
  unsigned char D.34028;
  guint8 * code.1186;
  unsigned char D.34030;
  signed char iftmp.1187;
  signed char D.34035;
  guint8 * code.1188;
  unsigned char D.34039;
  guint8 * code.1189;
  guint8 * code.1190;
  guint8 * code.1191;
  unsigned char D.34045;
  guint8 * code.1192;
  unsigned char D.34047;
  guint8 * code.1193;
  unsigned char D.34049;
  guint8 * code.1194;
  unsigned char D.34051;
  guint8 * code.1195;
  guint8 * code.1196;
  guint8 * code.1197;
  guint8 * code.1198;
  guint8 * code.1199;
  guint8 * code.1200;
  guint8 * code.1201;
  unsigned char D.34068;
  guint8 * code.1202;
  unsigned char D.34070;
  guint8 * code.1203;
  unsigned char D.34072;
  guint8 * code.1204;
  unsigned char D.34074;
  guint8 * code.1205;
  guint8 * code.1206;
  guint8 * code.1207;
  guint8 * code.1208;
  unsigned char D.34086;
  guint8 * code.1209;
  unsigned char D.34088;
  guint8 * code.1210;
  unsigned char D.34090;
  guint8 * code.1211;
  unsigned char D.34092;
  signed char iftmp.1212;
  signed char D.34097;
  guint8 * code.1213;
  unsigned char D.34101;
  guint8 * code.1214;
  guint8 * code.1215;
  guint8 * code.1216;
  unsigned char D.34107;
  guint8 * code.1217;
  unsigned char D.34109;
  guint8 * code.1218;
  unsigned char D.34111;
  guint8 * code.1219;
  unsigned char D.34113;
  guint8 * code.1220;
  guint8 * code.1221;
  guint8 * code.1222;
  guint8 * code.1223;
  guint8 * code.1224;
  guint8 * code.1225;
  guint8 * code.1226;
  unsigned char D.34130;
  guint8 * code.1227;
  unsigned char D.34132;
  guint8 * code.1228;
  unsigned char D.34134;
  guint8 * code.1229;
  unsigned char D.34136;
  guint8 * code.1230;
  guint8 * code.1231;
  guint8 * code.1232;
  guint8 * code.1233;
  unsigned char D.34148;
  guint8 * code.1234;
  unsigned char D.34150;
  guint8 * code.1235;
  unsigned char D.34152;
  guint8 * code.1236;
  unsigned char D.34154;
  signed char iftmp.1237;
  signed char D.34159;
  guint8 * code.1238;
  unsigned char D.34163;
  guint8 * code.1239;
  guint8 * code.1240;
  guint8 * code.1241;
  unsigned char D.34169;
  guint8 * code.1242;
  unsigned char D.34171;
  guint8 * code.1243;
  unsigned char D.34173;
  guint8 * code.1244;
  unsigned char D.34175;
  guint8 * code.1245;
  guint8 * code.1246;
  guint8 * code.1247;
  guint8 * code.1248;
  guint8 * code.1249;
  guint8 * code.1250;
  guint8 * code.1251;
  unsigned char D.34192;
  guint8 * code.1252;
  unsigned char D.34194;
  guint8 * code.1253;
  unsigned char D.34196;
  guint8 * code.1254;
  unsigned char D.34198;
  guint8 * code.1255;
  guint8 * code.1256;
  guint8 * code.1257;
  guint8 * code.1258;
  unsigned char D.34210;
  guint8 * code.1259;
  unsigned char D.34212;
  guint8 * code.1260;
  unsigned char D.34214;
  guint8 * code.1261;
  unsigned char D.34216;
  signed char iftmp.1262;
  signed char D.34221;
  guint8 * code.1263;
  unsigned char D.34225;
  guint8 * code.1264;
  guint8 * code.1265;
  guint8 * code.1266;
  unsigned char D.34231;
  guint8 * code.1267;
  unsigned char D.34233;
  guint8 * code.1268;
  unsigned char D.34235;
  guint8 * code.1269;
  unsigned char D.34237;
  guint8 * code.1270;
  guint8 * code.1271;
  guint8 * code.1272;
  guint8 * code.1273;
  guint8 * code.1274;
  guint8 * code.1275;
  guint8 * code.1276;
  unsigned char D.34254;
  guint8 * code.1277;
  unsigned char D.34256;
  guint8 * code.1278;
  unsigned char D.34258;
  guint8 * code.1279;
  unsigned char D.34260;
  guint8 * code.1280;
  guint8 * code.1281;
  guint8 * code.1282;
  guint8 * code.1283;
  unsigned char D.34272;
  guint8 * code.1284;
  unsigned char D.34274;
  guint8 * code.1285;
  unsigned char D.34276;
  guint8 * code.1286;
  unsigned char D.34278;
  guint8 * code.1287;
  unsigned char D.34282;
  guint8 * code.1288;
  guint8 * code.1289;
  guint8 * code.1290;
  guint8 * code.1291;
  guint8 * code.1292;
  guint8 * code.1293;
  guint8 * code.1294;
  guint8 * code.1295;
  unsigned char D.34301;
  guint8 * code.1296;
  unsigned char D.34303;
  guint8 * code.1297;
  unsigned char D.34305;
  guint8 * code.1298;
  unsigned char D.34307;
  guint8 * code.1299;
  guint8 * code.1300;
  guint8 * code.1301;
  guint8 * code.1302;
  unsigned char D.34319;
  guint8 * code.1303;
  unsigned char D.34321;
  guint8 * code.1304;
  unsigned char D.34323;
  guint8 * code.1305;
  unsigned char D.34325;
  guint8 * code.1306;
  guint8 * code.1307;
  guint8 * code.1308;
  guint8 * code.1309;
  guint8 * code.1310;
  guint8 * code.1311;
  guint8 * code.1312;
  guint8 * code.1313;
  unsigned char D.34343;
  guint8 * code.1314;
  unsigned char D.34345;
  guint8 * code.1315;
  unsigned char D.34347;
  guint8 * code.1316;
  unsigned char D.34349;
  guint8 * code.1317;
  guint8 * code.1318;
  guint8 * code.1319;
  guint8 * code.1320;
  unsigned char D.34361;
  guint8 * code.1321;
  unsigned char D.34363;
  guint8 * code.1322;
  unsigned char D.34365;
  guint8 * code.1323;
  unsigned char D.34367;
  guint8 * code.1324;
  unsigned char D.34369;
  guint8 * code.1325;
  unsigned char D.34371;
  guint8 * code.1326;
  unsigned char D.34373;
  guint8 * code.1327;
  unsigned char D.34375;
  guint8 * code.1328;
  unsigned char D.34381;
  guint8 * code.1329;
  guint8 * code.1330;
  guint8 * code.1331;
  guint8 * code.1332;
  guint8 * code.1333;
  guint8 * code.1334;
  guint8 * code.1335;
  guint8 * code.1336;
  unsigned char D.34400;
  guint8 * code.1337;
  unsigned char D.34402;
  guint8 * code.1338;
  unsigned char D.34404;
  guint8 * code.1339;
  unsigned char D.34406;
  guint8 * code.1340;
  signed char D.34412;
  unsigned char D.34413;
  guint8 * code.1341;
  signed char D.34417;
  unsigned char D.34418;
  guint8 * code.1342;
  signed char D.34421;
  unsigned char D.34422;
  guint8 * code.1343;
  unsigned char D.34424;
  guint8 * code.1344;
  unsigned char D.34426;
  guint8 * code.1345;
  unsigned char D.34428;
  guint8 * code.1346;
  unsigned char D.34430;
  guint8 * code.1347;
  guint8 * code.1348;
  guint8 * code.1349;
  guint8 * code.1350;
  guint8 * code.1351;
  guint8 * code.1352;
  guint8 * code.1353;
  guint8 * code.1354;
  unsigned char D.34448;
  guint8 * code.1355;
  unsigned char D.34450;
  guint8 * code.1356;
  unsigned char D.34452;
  guint8 * code.1357;
  unsigned char D.34454;
  guint8 * code.1358;
  guint8 * code.1359;
  guint8 * code.1360;
  guint8 * code.1361;
  unsigned char D.34466;
  guint8 * code.1362;
  unsigned char D.34468;
  guint8 * code.1363;
  unsigned char D.34470;
  guint8 * code.1364;
  unsigned char D.34472;
  guint8 * code.1365;
  unsigned char D.34474;
  guint8 * code.1366;
  unsigned char D.34476;
  guint8 * code.1367;
  unsigned char D.34478;
  guint8 * code.1368;
  unsigned char D.34480;
  guint8 * code.1369;
  unsigned char D.34486;
  guint8 * code.1370;
  guint8 * code.1371;
  guint8 * code.1372;
  guint8 * code.1373;
  guint8 * code.1374;
  guint8 * code.1375;
  guint8 * code.1376;
  guint8 * code.1377;
  unsigned char D.34505;
  guint8 * code.1378;
  unsigned char D.34507;
  guint8 * code.1379;
  unsigned char D.34509;
  guint8 * code.1380;
  unsigned char D.34511;
  guint8 * code.1381;
  signed char D.34517;
  unsigned char D.34518;
  guint8 * code.1382;
  signed char D.34522;
  unsigned char D.34523;
  guint8 * code.1383;
  signed char D.34526;
  unsigned char D.34527;
  guint8 * code.1384;
  unsigned char D.34529;
  guint8 * code.1385;
  unsigned char D.34531;
  guint8 * code.1386;
  unsigned char D.34533;
  guint8 * code.1387;
  unsigned char D.34535;
  guint8 * code.1388;
  guint8 * code.1389;
  guint8 * code.1390;
  guint8 * code.1391;
  guint8 * code.1392;
  guint8 * code.1393;
  guint8 * code.1394;
  guint8 * code.1395;
  unsigned char D.34553;
  guint8 * code.1396;
  unsigned char D.34555;
  guint8 * code.1397;
  unsigned char D.34557;
  guint8 * code.1398;
  unsigned char D.34559;
  guint8 * code.1399;
  guint8 * code.1400;
  guint8 * code.1401;
  guint8 * code.1402;
  unsigned char D.34571;
  guint8 * code.1403;
  unsigned char D.34573;
  guint8 * code.1404;
  unsigned char D.34575;
  guint8 * code.1405;
  unsigned char D.34577;
  guint8 * code.1406;
  unsigned char D.34579;
  guint8 * code.1407;
  unsigned char D.34581;
  guint8 * code.1408;
  unsigned char D.34583;
  guint8 * code.1409;
  unsigned char D.34585;
  guint8 * code.1410;
  unsigned char D.34591;
  guint8 * code.1411;
  guint8 * code.1412;
  guint8 * code.1413;
  guint8 * code.1414;
  guint8 * code.1415;
  guint8 * code.1416;
  guint8 * code.1417;
  guint8 * code.1418;
  unsigned char D.34610;
  guint8 * code.1419;
  unsigned char D.34612;
  guint8 * code.1420;
  unsigned char D.34614;
  guint8 * code.1421;
  unsigned char D.34616;
  guint8 * code.1422;
  signed char D.34622;
  unsigned char D.34623;
  guint8 * code.1423;
  signed char D.34627;
  unsigned char D.34628;
  guint8 * code.1424;
  signed char D.34631;
  unsigned char D.34632;
  guint8 * code.1425;
  unsigned char D.34634;
  guint8 * code.1426;
  unsigned char D.34636;
  guint8 * code.1427;
  unsigned char D.34638;
  guint8 * code.1428;
  unsigned char D.34640;
  guint8 * code.1429;
  guint8 * code.1430;
  guint8 * code.1431;
  guint8 * code.1432;
  guint8 * code.1433;
  guint8 * code.1434;
  guint8 * code.1435;
  guint8 * code.1436;
  unsigned char D.34658;
  guint8 * code.1437;
  unsigned char D.34660;
  guint8 * code.1438;
  unsigned char D.34662;
  guint8 * code.1439;
  unsigned char D.34664;
  guint8 * code.1440;
  guint8 * code.1441;
  guint8 * code.1442;
  guint8 * code.1443;
  unsigned char D.34676;
  guint8 * code.1444;
  unsigned char D.34678;
  guint8 * code.1445;
  unsigned char D.34680;
  guint8 * code.1446;
  unsigned char D.34682;
  guint8 * code.1447;
  unsigned char D.34684;
  guint8 * code.1448;
  unsigned char D.34686;
  guint8 * code.1449;
  unsigned char D.34688;
  guint8 * code.1450;
  unsigned char D.34690;
  guint8 * code.1451;
  unsigned char D.34696;
  guint8 * code.1452;
  guint8 * code.1453;
  guint8 * code.1454;
  guint8 * code.1455;
  guint8 * code.1456;
  guint8 * code.1457;
  guint8 * code.1458;
  guint8 * code.1459;
  unsigned char D.34715;
  guint8 * code.1460;
  unsigned char D.34717;
  guint8 * code.1461;
  unsigned char D.34719;
  guint8 * code.1462;
  unsigned char D.34721;
  guint8 * code.1463;
  signed char D.34727;
  unsigned char D.34728;
  guint8 * code.1464;
  signed char D.34732;
  unsigned char D.34733;
  guint8 * code.1465;
  signed char D.34736;
  unsigned char D.34737;
  guint8 * code.1466;
  unsigned char D.34739;
  guint8 * code.1467;
  unsigned char D.34741;
  guint8 * code.1468;
  unsigned char D.34743;
  guint8 * code.1469;
  unsigned char D.34745;
  guint8 * code.1470;
  guint8 * code.1471;
  guint8 * code.1472;
  guint8 * code.1473;
  guint8 * code.1474;
  guint8 * code.1475;
  guint8 * code.1476;
  guint8 * code.1477;
  unsigned char D.34763;
  guint8 * code.1478;
  unsigned char D.34765;
  guint8 * code.1479;
  unsigned char D.34767;
  guint8 * code.1480;
  unsigned char D.34769;
  guint8 * code.1481;
  guint8 * code.1482;
  guint8 * code.1483;
  guint8 * code.1484;
  unsigned char D.34781;
  guint8 * code.1485;
  unsigned char D.34783;
  guint8 * code.1486;
  unsigned char D.34785;
  guint8 * code.1487;
  unsigned char D.34787;
  guint8 * code.1488;
  unsigned char D.34789;
  guint8 * code.1489;
  unsigned char D.34791;
  guint8 * code.1490;
  unsigned char D.34793;
  guint8 * code.1491;
  unsigned char D.34795;
  signed char iftmp.1492;
  signed char D.34800;
  guint8 * code.1493;
  unsigned char D.34804;
  guint8 * code.1494;
  guint8 * code.1495;
  signed char D.34811;
  unsigned char D.34812;
  guint8 * code.1496;
  guint8 * code.1497;
  signed char D.34818;
  unsigned char D.34819;
  guint8 * code.1498;
  guint8 * code.1499;
  signed char D.34823;
  unsigned char D.34824;
  guint8 * code.1500;
  guint8 * code.1501;
  unsigned char D.34827;
  guint8 * code.1502;
  unsigned char D.34829;
  guint8 * code.1503;
  unsigned char D.34831;
  guint8 * code.1504;
  unsigned char D.34833;
  guint8 * code.1505;
  guint8 * code.1506;
  signed char D.34842;
  signed char D.34843;
  unsigned char D.34844;
  guint8 * code.1507;
  signed char D.34847;
  signed char D.34848;
  unsigned char D.34849;
  guint8 * code.1508;
  unsigned char D.34851;
  guint8 * code.1509;
  unsigned char D.34853;
  guint8 * code.1510;
  unsigned char D.34855;
  guint8 * code.1511;
  unsigned char D.34857;
  signed char iftmp.1512;
  signed char D.34862;
  guint8 * code.1513;
  unsigned char D.34866;
  guint8 * code.1514;
  guint8 * code.1515;
  guint8 * code.1516;
  guint8 * code.1517;
  guint8 * code.1518;
  guint8 * code.1519;
  guint8 * code.1520;
  guint8 * code.1521;
  unsigned char D.34883;
  guint8 * code.1522;
  unsigned char D.34885;
  guint8 * code.1523;
  unsigned char D.34887;
  guint8 * code.1524;
  unsigned char D.34889;
  guint8 * code.1525;
  guint8 * code.1526;
  guint8 * code.1527;
  guint8 * code.1528;
  unsigned char D.34901;
  guint8 * code.1529;
  unsigned char D.34903;
  guint8 * code.1530;
  unsigned char D.34905;
  guint8 * code.1531;
  unsigned char D.34907;
  signed char iftmp.1532;
  signed char D.34912;
  guint8 * code.1533;
  unsigned char D.34916;
  guint8 * code.1534;
  guint8 * code.1535;
  guint8 * code.1536;
  guint8 * code.1537;
  guint8 * code.1538;
  guint8 * code.1539;
  guint8 * code.1540;
  guint8 * code.1541;
  unsigned char D.34933;
  guint8 * code.1542;
  unsigned char D.34935;
  guint8 * code.1543;
  unsigned char D.34937;
  guint8 * code.1544;
  unsigned char D.34939;
  guint8 * code.1545;
  guint8 * code.1546;
  guint8 * code.1547;
  guint8 * code.1548;
  unsigned char D.34951;
  guint8 * code.1549;
  unsigned char D.34953;
  guint8 * code.1550;
  unsigned char D.34955;
  guint8 * code.1551;
  unsigned char D.34957;
  signed char iftmp.1552;
  signed char D.34962;
  guint8 * code.1553;
  unsigned char D.34966;
  guint8 * code.1554;
  guint8 * code.1555;
  guint8 * code.1556;
  guint8 * code.1557;
  guint8 * code.1558;
  guint8 * code.1559;
  guint8 * code.1560;
  guint8 * code.1561;
  unsigned char D.34983;
  guint8 * code.1562;
  unsigned char D.34985;
  guint8 * code.1563;
  unsigned char D.34987;
  guint8 * code.1564;
  unsigned char D.34989;
  guint8 * code.1565;
  guint8 * code.1566;
  guint8 * code.1567;
  guint8 * code.1568;
  unsigned char D.35001;
  guint8 * code.1569;
  unsigned char D.35003;
  guint8 * code.1570;
  unsigned char D.35005;
  guint8 * code.1571;
  unsigned char D.35007;
  signed char iftmp.1572;
  signed char D.35012;
  guint8 * code.1573;
  unsigned char D.35016;
  guint8 * code.1574;
  guint8 * code.1575;
  guint8 * code.1576;
  guint8 * code.1577;
  guint8 * code.1578;
  guint8 * code.1579;
  guint8 * code.1580;
  guint8 * code.1581;
  unsigned char D.35033;
  guint8 * code.1582;
  unsigned char D.35035;
  guint8 * code.1583;
  unsigned char D.35037;
  guint8 * code.1584;
  unsigned char D.35039;
  guint8 * code.1585;
  guint8 * code.1586;
  guint8 * code.1587;
  guint8 * code.1588;
  unsigned char D.35051;
  guint8 * code.1589;
  unsigned char D.35053;
  guint8 * code.1590;
  unsigned char D.35055;
  guint8 * code.1591;
  unsigned char D.35057;
  guint8 * code.1592;
  unsigned char D.35061;
  guint8 * code.1593;
  guint8 * code.1594;
  guint8 * code.1595;
  guint8 * code.1596;
  guint8 * code.1597;
  guint8 * code.1598;
  guint8 * code.1599;
  guint8 * code.1600;
  unsigned char D.35078;
  guint8 * code.1601;
  unsigned char D.35080;
  guint8 * code.1602;
  unsigned char D.35082;
  guint8 * code.1603;
  unsigned char D.35084;
  guint8 * code.1604;
  guint8 * code.1605;
  guint8 * code.1606;
  guint8 * code.1607;
  unsigned char D.35096;
  guint8 * code.1608;
  unsigned char D.35098;
  guint8 * code.1609;
  unsigned char D.35100;
  guint8 * code.1610;
  unsigned char D.35102;
  guint8 * code.1611;
  unsigned char D.35106;
  guint8 * code.1612;
  guint8 * code.1613;
  signed char D.35109;
  unsigned char D.35110;
  guint8 * code.1614;
  unsigned char D.35114;
  guint8 * code.1615;
  guint8 * code.1616;
  guint8 * code.1617;
  guint8 * code.1618;
  guint8 * code.1619;
  guint8 * code.1620;
  guint8 * code.1621;
  guint8 * code.1622;
  unsigned char D.35131;
  guint8 * code.1623;
  unsigned char D.35133;
  guint8 * code.1624;
  unsigned char D.35135;
  guint8 * code.1625;
  unsigned char D.35137;
  guint8 * code.1626;
  guint8 * code.1627;
  guint8 * code.1628;
  guint8 * code.1629;
  unsigned char D.35149;
  guint8 * code.1630;
  unsigned char D.35151;
  guint8 * code.1631;
  unsigned char D.35153;
  guint8 * code.1632;
  unsigned char D.35155;
  guint8 * code.1633;
  unsigned char D.35159;
  guint8 * code.1634;
  guint8 * code.1635;
  signed char D.35162;
  unsigned char D.35163;
  signed char iftmp.1636;
  signed char D.35168;
  guint8 * code.1637;
  unsigned char D.35172;
  guint8 * code.1638;
  guint8 * code.1639;
  guint8 * code.1640;
  guint8 * code.1641;
  guint8 * code.1642;
  guint8 * code.1643;
  guint8 * code.1644;
  guint8 * code.1645;
  guint8 * code.1646;
  unsigned char D.35190;
  guint8 * code.1647;
  unsigned char D.35192;
  guint8 * code.1648;
  unsigned char D.35194;
  guint8 * code.1649;
  unsigned char D.35196;
  guint8 * code.1650;
  guint8 * code.1651;
  guint8 * code.1652;
  guint8 * code.1653;
  unsigned char D.35208;
  guint8 * code.1654;
  unsigned char D.35210;
  guint8 * code.1655;
  unsigned char D.35212;
  guint8 * code.1656;
  unsigned char D.35214;
  signed char iftmp.1657;
  signed char D.35219;
  guint8 * code.1658;
  unsigned char D.35223;
  guint8 * code.1659;
  guint8 * code.1660;
  guint8 * code.1661;
  guint8 * code.1662;
  guint8 * code.1663;
  guint8 * code.1664;
  guint8 * code.1665;
  guint8 * code.1666;
  unsigned char D.35240;
  guint8 * code.1667;
  unsigned char D.35242;
  guint8 * code.1668;
  unsigned char D.35244;
  guint8 * code.1669;
  unsigned char D.35246;
  guint8 * code.1670;
  guint8 * code.1671;
  guint8 * code.1672;
  guint8 * code.1673;
  unsigned char D.35258;
  guint8 * code.1674;
  unsigned char D.35260;
  guint8 * code.1675;
  unsigned char D.35262;
  guint8 * code.1676;
  unsigned char D.35264;
  guint8 * code.1677;
  unsigned char D.35268;
  guint8 * code.1678;
  guint8 * code.1679;
  guint8 * code.1680;
  guint8 * code.1681;
  guint8 * code.1682;
  guint8 * code.1683;
  guint8 * code.1684;
  guint8 * code.1685;
  unsigned char D.35287;
  guint8 * code.1686;
  unsigned char D.35289;
  guint8 * code.1687;
  unsigned char D.35291;
  guint8 * code.1688;
  unsigned char D.35293;
  guint8 * code.1689;
  signed char D.35299;
  unsigned char D.35300;
  guint8 * code.1690;
  signed char D.35304;
  unsigned char D.35305;
  guint8 * code.1691;
  signed char D.35308;
  unsigned char D.35309;
  guint8 * code.1692;
  unsigned char D.35311;
  guint8 * code.1693;
  unsigned char D.35313;
  guint8 * code.1694;
  unsigned char D.35315;
  guint8 * code.1695;
  unsigned char D.35317;
  guint8 * code.1696;
  guint8 * code.1697;
  guint8 * code.1698;
  guint8 * code.1699;
  guint8 * code.1700;
  guint8 * code.1701;
  guint8 * code.1702;
  guint8 * code.1703;
  unsigned char D.35335;
  guint8 * code.1704;
  unsigned char D.35337;
  guint8 * code.1705;
  unsigned char D.35339;
  guint8 * code.1706;
  unsigned char D.35341;
  guint8 * code.1707;
  guint8 * code.1708;
  guint8 * code.1709;
  guint8 * code.1710;
  unsigned char D.35353;
  guint8 * code.1711;
  unsigned char D.35355;
  guint8 * code.1712;
  unsigned char D.35357;
  guint8 * code.1713;
  unsigned char D.35359;
  guint8 * code.1714;
  unsigned char D.35361;
  guint8 * code.1715;
  unsigned char D.35363;
  guint8 * code.1716;
  unsigned char D.35365;
  guint8 * code.1717;
  unsigned char D.35367;
  signed char iftmp.1718;
  signed char D.35372;
  guint8 * code.1719;
  unsigned char D.35376;
  guint8 * code.1720;
  guint8 * code.1721;
  guint8 * code.1722;
  guint8 * code.1723;
  guint8 * code.1724;
  guint8 * code.1725;
  guint8 * code.1726;
  guint8 * code.1727;
  unsigned char D.35393;
  guint8 * code.1728;
  unsigned char D.35395;
  guint8 * code.1729;
  unsigned char D.35397;
  guint8 * code.1730;
  unsigned char D.35399;
  guint8 * code.1731;
  guint8 * code.1732;
  guint8 * code.1733;
  guint8 * code.1734;
  unsigned char D.35411;
  guint8 * code.1735;
  unsigned char D.35413;
  guint8 * code.1736;
  unsigned char D.35415;
  guint8 * code.1737;
  unsigned char D.35417;
  unsigned char iftmp.1738;
  guint8 * code.1739;
  unsigned char D.35427;
  guint8 * code.1740;
  guint8 * code.1741;
  guint8 * code.1742;
  guint8 * code.1743;
  guint8 * code.1744;
  guint8 * code.1745;
  guint8 * code.1746;
  guint8 * code.1747;
  unsigned char D.35446;
  guint8 * code.1748;
  unsigned char D.35448;
  guint8 * code.1749;
  unsigned char D.35450;
  guint8 * code.1750;
  unsigned char D.35452;
  guint8 * code.1751;
  guint8 * code.1752;
  guint8 * code.1753;
  guint8 * code.1754;
  unsigned char D.35464;
  guint8 * code.1755;
  unsigned char D.35466;
  guint8 * code.1756;
  unsigned char D.35468;
  guint8 * code.1757;
  unsigned char D.35470;
  guint8 * code.1758;
  guint8 * code.1759;
  guint8 * code.1760;
  guint8 * code.1761;
  guint8 * code.1762;
  guint8 * code.1763;
  guint8 * code.1764;
  guint8 * code.1765;
  unsigned char D.35488;
  guint8 * code.1766;
  unsigned char D.35490;
  guint8 * code.1767;
  unsigned char D.35492;
  guint8 * code.1768;
  unsigned char D.35494;
  guint8 * code.1769;
  guint8 * code.1770;
  guint8 * code.1771;
  guint8 * code.1772;
  unsigned char D.35506;
  guint8 * code.1773;
  unsigned char D.35508;
  guint8 * code.1774;
  unsigned char D.35510;
  guint8 * code.1775;
  unsigned char D.35512;
  guint8 * code.1776;
  unsigned char D.35514;
  guint8 * code.1777;
  unsigned char D.35516;
  guint8 * code.1778;
  unsigned char D.35518;
  guint8 * code.1779;
  unsigned char D.35520;
  guint8 * code.1780;
  unsigned char D.35524;
  guint8 * code.1781;
  guint8 * code.1782;
  guint8 * code.1783;
  guint8 * code.1784;
  guint8 * code.1785;
  guint8 * code.1786;
  guint8 * code.1787;
  guint8 * code.1788;
  unsigned char D.35541;
  guint8 * code.1789;
  unsigned char D.35543;
  guint8 * code.1790;
  unsigned char D.35545;
  guint8 * code.1791;
  unsigned char D.35547;
  guint8 * code.1792;
  guint8 * code.1793;
  guint8 * code.1794;
  guint8 * code.1795;
  unsigned char D.35559;
  guint8 * code.1796;
  unsigned char D.35561;
  guint8 * code.1797;
  unsigned char D.35563;
  guint8 * code.1798;
  unsigned char D.35565;
  signed char iftmp.1799;
  signed char D.35570;
  guint8 * code.1800;
  unsigned char D.35574;
  guint8 * code.1801;
  guint8 * code.1802;
  guint8 * code.1803;
  unsigned char D.35580;
  guint8 * code.1804;
  unsigned char D.35582;
  guint8 * code.1805;
  unsigned char D.35584;
  guint8 * code.1806;
  unsigned char D.35586;
  guint8 * code.1807;
  guint8 * code.1808;
  guint8 * code.1809;
  guint8 * code.1810;
  guint8 * code.1811;
  guint8 * code.1812;
  guint8 * code.1813;
  unsigned char D.35603;
  guint8 * code.1814;
  unsigned char D.35605;
  guint8 * code.1815;
  unsigned char D.35607;
  guint8 * code.1816;
  unsigned char D.35609;
  guint8 * code.1817;
  guint8 * code.1818;
  guint8 * code.1819;
  guint8 * code.1820;
  unsigned char D.35621;
  guint8 * code.1821;
  unsigned char D.35623;
  guint8 * code.1822;
  unsigned char D.35625;
  guint8 * code.1823;
  unsigned char D.35627;
  signed char iftmp.1824;
  signed char D.35632;
  guint8 * code.1825;
  unsigned char D.35636;
  guint8 * code.1826;
  guint8 * code.1827;
  guint8 * code.1828;
  unsigned char D.35642;
  guint8 * code.1829;
  unsigned char D.35644;
  guint8 * code.1830;
  unsigned char D.35646;
  guint8 * code.1831;
  unsigned char D.35648;
  guint8 * code.1832;
  guint8 * code.1833;
  guint8 * code.1834;
  guint8 * code.1835;
  guint8 * code.1836;
  guint8 * code.1837;
  guint8 * code.1838;
  unsigned char D.35665;
  guint8 * code.1839;
  unsigned char D.35667;
  guint8 * code.1840;
  unsigned char D.35669;
  guint8 * code.1841;
  unsigned char D.35671;
  guint8 * code.1842;
  guint8 * code.1843;
  guint8 * code.1844;
  guint8 * code.1845;
  unsigned char D.35683;
  guint8 * code.1846;
  unsigned char D.35685;
  guint8 * code.1847;
  unsigned char D.35687;
  guint8 * code.1848;
  unsigned char D.35689;
  signed char iftmp.1849;
  signed char D.35694;
  guint8 * code.1850;
  unsigned char D.35698;
  guint8 * code.1851;
  guint8 * code.1852;
  guint8 * code.1853;
  unsigned char D.35704;
  guint8 * code.1854;
  unsigned char D.35706;
  guint8 * code.1855;
  unsigned char D.35708;
  guint8 * code.1856;
  unsigned char D.35710;
  guint8 * code.1857;
  guint8 * code.1858;
  guint8 * code.1859;
  guint8 * code.1860;
  guint8 * code.1861;
  guint8 * code.1862;
  guint8 * code.1863;
  unsigned char D.35727;
  guint8 * code.1864;
  unsigned char D.35729;
  guint8 * code.1865;
  unsigned char D.35731;
  guint8 * code.1866;
  unsigned char D.35733;
  guint8 * code.1867;
  guint8 * code.1868;
  guint8 * code.1869;
  guint8 * code.1870;
  unsigned char D.35745;
  guint8 * code.1871;
  unsigned char D.35747;
  guint8 * code.1872;
  unsigned char D.35749;
  guint8 * code.1873;
  unsigned char D.35751;
  signed char iftmp.1874;
  signed char D.35756;
  guint8 * code.1875;
  unsigned char D.35760;
  guint8 * code.1876;
  guint8 * code.1877;
  guint8 * code.1878;
  unsigned char D.35766;
  guint8 * code.1879;
  unsigned char D.35768;
  guint8 * code.1880;
  unsigned char D.35770;
  guint8 * code.1881;
  unsigned char D.35772;
  guint8 * code.1882;
  guint8 * code.1883;
  guint8 * code.1884;
  guint8 * code.1885;
  guint8 * code.1886;
  guint8 * code.1887;
  guint8 * code.1888;
  unsigned char D.35789;
  guint8 * code.1889;
  unsigned char D.35791;
  guint8 * code.1890;
  unsigned char D.35793;
  guint8 * code.1891;
  unsigned char D.35795;
  guint8 * code.1892;
  guint8 * code.1893;
  guint8 * code.1894;
  guint8 * code.1895;
  unsigned char D.35807;
  guint8 * code.1896;
  unsigned char D.35809;
  guint8 * code.1897;
  unsigned char D.35811;
  guint8 * code.1898;
  unsigned char D.35813;
  signed char iftmp.1899;
  signed char D.35818;
  guint8 * code.1900;
  unsigned char D.35822;
  guint8 * code.1901;
  guint8 * code.1902;
  guint8 * code.1903;
  unsigned char D.35828;
  guint8 * code.1904;
  unsigned char D.35830;
  guint8 * code.1905;
  unsigned char D.35832;
  guint8 * code.1906;
  unsigned char D.35834;
  guint8 * code.1907;
  guint8 * code.1908;
  guint8 * code.1909;
  guint8 * code.1910;
  guint8 * code.1911;
  guint8 * code.1912;
  guint8 * code.1913;
  unsigned char D.35851;
  guint8 * code.1914;
  unsigned char D.35853;
  guint8 * code.1915;
  unsigned char D.35855;
  guint8 * code.1916;
  unsigned char D.35857;
  guint8 * code.1917;
  guint8 * code.1918;
  guint8 * code.1919;
  guint8 * code.1920;
  unsigned char D.35869;
  guint8 * code.1921;
  unsigned char D.35871;
  guint8 * code.1922;
  unsigned char D.35873;
  guint8 * code.1923;
  unsigned char D.35875;
  signed char iftmp.1924;
  signed char D.35880;
  guint8 * code.1925;
  unsigned char D.35884;
  guint8 * code.1926;
  guint8 * code.1927;
  guint8 * code.1928;
  unsigned char D.35890;
  guint8 * code.1929;
  unsigned char D.35892;
  guint8 * code.1930;
  unsigned char D.35894;
  guint8 * code.1931;
  unsigned char D.35896;
  guint8 * code.1932;
  guint8 * code.1933;
  guint8 * code.1934;
  guint8 * code.1935;
  guint8 * code.1936;
  guint8 * code.1937;
  guint8 * code.1938;
  unsigned char D.35913;
  guint8 * code.1939;
  unsigned char D.35915;
  guint8 * code.1940;
  unsigned char D.35917;
  guint8 * code.1941;
  unsigned char D.35919;
  guint8 * code.1942;
  guint8 * code.1943;
  guint8 * code.1944;
  guint8 * code.1945;
  unsigned char D.35931;
  guint8 * code.1946;
  unsigned char D.35933;
  guint8 * code.1947;
  unsigned char D.35935;
  guint8 * code.1948;
  unsigned char D.35937;
  signed char iftmp.1949;
  signed char D.35942;
  guint8 * code.1950;
  unsigned char D.35946;
  guint8 * code.1951;
  guint8 * code.1952;
  guint8 * code.1953;
  unsigned char D.35952;
  guint8 * code.1954;
  unsigned char D.35954;
  guint8 * code.1955;
  unsigned char D.35956;
  guint8 * code.1956;
  unsigned char D.35958;
  guint8 * code.1957;
  guint8 * code.1958;
  guint8 * code.1959;
  guint8 * code.1960;
  guint8 * code.1961;
  guint8 * code.1962;
  guint8 * code.1963;
  unsigned char D.35975;
  guint8 * code.1964;
  unsigned char D.35977;
  guint8 * code.1965;
  unsigned char D.35979;
  guint8 * code.1966;
  unsigned char D.35981;
  guint8 * code.1967;
  guint8 * code.1968;
  guint8 * code.1969;
  guint8 * code.1970;
  unsigned char D.35993;
  guint8 * code.1971;
  unsigned char D.35995;
  guint8 * code.1972;
  unsigned char D.35997;
  guint8 * code.1973;
  unsigned char D.35999;
  signed char iftmp.1974;
  signed char D.36004;
  guint8 * code.1975;
  unsigned char D.36008;
  guint8 * code.1976;
  guint8 * code.1977;
  guint8 * code.1978;
  guint8 * code.1979;
  guint8 * code.1980;
  guint8 * code.1981;
  guint8 * code.1982;
  guint8 * code.1983;
  unsigned char D.36025;
  guint8 * code.1984;
  unsigned char D.36027;
  guint8 * code.1985;
  unsigned char D.36029;
  guint8 * code.1986;
  unsigned char D.36031;
  guint8 * code.1987;
  guint8 * code.1988;
  guint8 * code.1989;
  guint8 * code.1990;
  unsigned char D.36043;
  guint8 * code.1991;
  unsigned char D.36045;
  guint8 * code.1992;
  unsigned char D.36047;
  guint8 * code.1993;
  unsigned char D.36049;
  signed char iftmp.1994;
  signed char D.36054;
  guint8 * code.1995;
  unsigned char D.36058;
  guint8 * code.1996;
  guint8 * code.1997;
  guint8 * code.1998;
  guint8 * code.1999;
  guint8 * code.2000;
  guint8 * code.2001;
  guint8 * code.2002;
  guint8 * code.2003;
  unsigned char D.36075;
  guint8 * code.2004;
  unsigned char D.36077;
  guint8 * code.2005;
  unsigned char D.36079;
  guint8 * code.2006;
  unsigned char D.36081;
  guint8 * code.2007;
  guint8 * code.2008;
  guint8 * code.2009;
  guint8 * code.2010;
  unsigned char D.36093;
  guint8 * code.2011;
  unsigned char D.36095;
  guint8 * code.2012;
  unsigned char D.36097;
  guint8 * code.2013;
  unsigned char D.36099;
  signed char iftmp.2014;
  signed char D.36104;
  guint8 * code.2015;
  unsigned char D.36108;
  guint8 * code.2016;
  guint8 * code.2017;
  guint8 * code.2018;
  guint8 * code.2019;
  guint8 * code.2020;
  guint8 * code.2021;
  guint8 * code.2022;
  guint8 * code.2023;
  unsigned char D.36125;
  guint8 * code.2024;
  unsigned char D.36127;
  guint8 * code.2025;
  unsigned char D.36129;
  guint8 * code.2026;
  unsigned char D.36131;
  guint8 * code.2027;
  guint8 * code.2028;
  guint8 * code.2029;
  guint8 * code.2030;
  unsigned char D.36143;
  guint8 * code.2031;
  unsigned char D.36145;
  guint8 * code.2032;
  unsigned char D.36147;
  guint8 * code.2033;
  unsigned char D.36149;
  signed char iftmp.2034;
  signed char D.36154;
  guint8 * code.2035;
  unsigned char D.36158;
  guint8 * code.2036;
  guint8 * code.2037;
  guint8 * code.2038;
  guint8 * code.2039;
  guint8 * code.2040;
  guint8 * code.2041;
  guint8 * code.2042;
  guint8 * code.2043;
  unsigned char D.36175;
  guint8 * code.2044;
  unsigned char D.36177;
  guint8 * code.2045;
  unsigned char D.36179;
  guint8 * code.2046;
  unsigned char D.36181;
  guint8 * code.2047;
  guint8 * code.2048;
  guint8 * code.2049;
  guint8 * code.2050;
  unsigned char D.36193;
  guint8 * code.2051;
  unsigned char D.36195;
  guint8 * code.2052;
  unsigned char D.36197;
  guint8 * code.2053;
  unsigned char D.36199;
  signed char iftmp.2054;
  signed char D.36204;
  guint8 * code.2055;
  unsigned char D.36208;
  guint8 * code.2056;
  guint8 * code.2057;
  guint8 * code.2058;
  guint8 * code.2059;
  guint8 * code.2060;
  guint8 * code.2061;
  guint8 * code.2062;
  guint8 * code.2063;
  unsigned char D.36225;
  guint8 * code.2064;
  unsigned char D.36227;
  guint8 * code.2065;
  unsigned char D.36229;
  guint8 * code.2066;
  unsigned char D.36231;
  guint8 * code.2067;
  guint8 * code.2068;
  guint8 * code.2069;
  guint8 * code.2070;
  unsigned char D.36243;
  guint8 * code.2071;
  unsigned char D.36245;
  guint8 * code.2072;
  unsigned char D.36247;
  guint8 * code.2073;
  unsigned char D.36249;
  unsigned char iftmp.2074;
  guint8 * code.2075;
  unsigned char D.36259;
  guint8 * code.2076;
  guint8 * code.2077;
  guint8 * code.2078;
  guint8 * code.2079;
  guint8 * code.2080;
  guint8 * code.2081;
  guint8 * code.2082;
  guint8 * code.2083;
  unsigned char D.36278;
  guint8 * code.2084;
  unsigned char D.36280;
  guint8 * code.2085;
  unsigned char D.36282;
  guint8 * code.2086;
  unsigned char D.36284;
  guint8 * code.2087;
  guint8 * code.2088;
  guint8 * code.2089;
  guint8 * code.2090;
  unsigned char D.36296;
  guint8 * code.2091;
  unsigned char D.36298;
  guint8 * code.2092;
  unsigned char D.36300;
  guint8 * code.2093;
  unsigned char D.36302;
  guint8 * code.2094;
  guint8 * code.2095;
  guint8 * code.2096;
  guint8 * code.2097;
  guint8 * code.2098;
  guint8 * code.2099;
  guint8 * code.2100;
  guint8 * code.2101;
  unsigned char D.36320;
  guint8 * code.2102;
  unsigned char D.36322;
  guint8 * code.2103;
  unsigned char D.36324;
  guint8 * code.2104;
  unsigned char D.36326;
  guint8 * code.2105;
  guint8 * code.2106;
  guint8 * code.2107;
  guint8 * code.2108;
  unsigned char D.36338;
  guint8 * code.2109;
  unsigned char D.36340;
  guint8 * code.2110;
  unsigned char D.36342;
  guint8 * code.2111;
  unsigned char D.36344;
  guint8 * code.2112;
  unsigned char D.36346;
  guint8 * code.2113;
  unsigned char D.36348;
  guint8 * code.2114;
  unsigned char D.36350;
  guint8 * code.2115;
  unsigned char D.36352;
  unsigned char iftmp.2116;
  guint8 * code.2117;
  unsigned char D.36362;
  guint8 * code.2118;
  guint8 * code.2119;
  guint8 * code.2120;
  guint8 * code.2121;
  guint8 * code.2122;
  guint8 * code.2123;
  guint8 * code.2124;
  guint8 * code.2125;
  unsigned char D.36381;
  guint8 * code.2126;
  unsigned char D.36383;
  guint8 * code.2127;
  unsigned char D.36385;
  guint8 * code.2128;
  unsigned char D.36387;
  guint8 * code.2129;
  guint8 * code.2130;
  guint8 * code.2131;
  guint8 * code.2132;
  unsigned char D.36399;
  guint8 * code.2133;
  unsigned char D.36401;
  guint8 * code.2134;
  unsigned char D.36403;
  guint8 * code.2135;
  unsigned char D.36405;
  guint8 * code.2136;
  guint8 * code.2137;
  guint8 * code.2138;
  guint8 * code.2139;
  guint8 * code.2140;
  guint8 * code.2141;
  guint8 * code.2142;
  guint8 * code.2143;
  unsigned char D.36423;
  guint8 * code.2144;
  unsigned char D.36425;
  guint8 * code.2145;
  unsigned char D.36427;
  guint8 * code.2146;
  unsigned char D.36429;
  guint8 * code.2147;
  guint8 * code.2148;
  guint8 * code.2149;
  guint8 * code.2150;
  unsigned char D.36441;
  guint8 * code.2151;
  unsigned char D.36443;
  guint8 * code.2152;
  unsigned char D.36445;
  guint8 * code.2153;
  unsigned char D.36447;
  guint8 * code.2154;
  unsigned char D.36449;
  guint8 * code.2155;
  unsigned char D.36451;
  guint8 * code.2156;
  unsigned char D.36453;
  guint8 * code.2157;
  unsigned char D.36455;
  unsigned char iftmp.2158;
  guint8 * code.2159;
  unsigned char D.36465;
  guint8 * code.2160;
  guint8 * code.2161;
  guint8 * code.2162;
  guint8 * code.2163;
  guint8 * code.2164;
  guint8 * code.2165;
  guint8 * code.2166;
  guint8 * code.2167;
  unsigned char D.36484;
  guint8 * code.2168;
  unsigned char D.36486;
  guint8 * code.2169;
  unsigned char D.36488;
  guint8 * code.2170;
  unsigned char D.36490;
  guint8 * code.2171;
  guint8 * code.2172;
  guint8 * code.2173;
  guint8 * code.2174;
  unsigned char D.36502;
  guint8 * code.2175;
  unsigned char D.36504;
  guint8 * code.2176;
  unsigned char D.36506;
  guint8 * code.2177;
  unsigned char D.36508;
  guint8 * code.2178;
  guint8 * code.2179;
  guint8 * code.2180;
  guint8 * code.2181;
  guint8 * code.2182;
  guint8 * code.2183;
  guint8 * code.2184;
  guint8 * code.2185;
  unsigned char D.36526;
  guint8 * code.2186;
  unsigned char D.36528;
  guint8 * code.2187;
  unsigned char D.36530;
  guint8 * code.2188;
  unsigned char D.36532;
  guint8 * code.2189;
  guint8 * code.2190;
  guint8 * code.2191;
  guint8 * code.2192;
  unsigned char D.36544;
  guint8 * code.2193;
  unsigned char D.36546;
  guint8 * code.2194;
  unsigned char D.36548;
  guint8 * code.2195;
  unsigned char D.36550;
  guint8 * code.2196;
  unsigned char D.36552;
  guint8 * code.2197;
  unsigned char D.36554;
  guint8 * code.2198;
  unsigned char D.36556;
  guint8 * code.2199;
  unsigned char D.36558;
  unsigned char iftmp.2200;
  guint8 * code.2201;
  unsigned char D.36568;
  guint8 * code.2202;
  guint8 * code.2203;
  guint8 * code.2204;
  guint8 * code.2205;
  guint8 * code.2206;
  guint8 * code.2207;
  guint8 * code.2208;
  guint8 * code.2209;
  unsigned char D.36587;
  guint8 * code.2210;
  unsigned char D.36589;
  guint8 * code.2211;
  unsigned char D.36591;
  guint8 * code.2212;
  unsigned char D.36593;
  guint8 * code.2213;
  guint8 * code.2214;
  guint8 * code.2215;
  guint8 * code.2216;
  unsigned char D.36605;
  guint8 * code.2217;
  unsigned char D.36607;
  guint8 * code.2218;
  unsigned char D.36609;
  guint8 * code.2219;
  unsigned char D.36611;
  guint8 * code.2220;
  guint8 * code.2221;
  guint8 * code.2222;
  guint8 * code.2223;
  guint8 * code.2224;
  guint8 * code.2225;
  guint8 * code.2226;
  guint8 * code.2227;
  unsigned char D.36629;
  guint8 * code.2228;
  unsigned char D.36631;
  guint8 * code.2229;
  unsigned char D.36633;
  guint8 * code.2230;
  unsigned char D.36635;
  guint8 * code.2231;
  guint8 * code.2232;
  guint8 * code.2233;
  guint8 * code.2234;
  unsigned char D.36647;
  guint8 * code.2235;
  unsigned char D.36649;
  guint8 * code.2236;
  unsigned char D.36651;
  guint8 * code.2237;
  unsigned char D.36653;
  guint8 * code.2238;
  unsigned char D.36655;
  guint8 * code.2239;
  unsigned char D.36657;
  guint8 * code.2240;
  unsigned char D.36659;
  guint8 * code.2241;
  unsigned char D.36661;
  unsigned char iftmp.2242;
  guint8 * code.2243;
  unsigned char D.36671;
  guint8 * code.2244;
  guint8 * code.2245;
  guint8 * code.2246;
  guint8 * code.2247;
  guint8 * code.2248;
  guint8 * code.2249;
  guint8 * code.2250;
  guint8 * code.2251;
  unsigned char D.36690;
  guint8 * code.2252;
  unsigned char D.36692;
  guint8 * code.2253;
  unsigned char D.36694;
  guint8 * code.2254;
  unsigned char D.36696;
  guint8 * code.2255;
  guint8 * code.2256;
  guint8 * code.2257;
  guint8 * code.2258;
  unsigned char D.36708;
  guint8 * code.2259;
  unsigned char D.36710;
  guint8 * code.2260;
  unsigned char D.36712;
  guint8 * code.2261;
  unsigned char D.36714;
  guint8 * code.2262;
  guint8 * code.2263;
  guint8 * code.2264;
  guint8 * code.2265;
  guint8 * code.2266;
  guint8 * code.2267;
  guint8 * code.2268;
  guint8 * code.2269;
  unsigned char D.36732;
  guint8 * code.2270;
  unsigned char D.36734;
  guint8 * code.2271;
  unsigned char D.36736;
  guint8 * code.2272;
  unsigned char D.36738;
  guint8 * code.2273;
  guint8 * code.2274;
  guint8 * code.2275;
  guint8 * code.2276;
  unsigned char D.36750;
  guint8 * code.2277;
  unsigned char D.36752;
  guint8 * code.2278;
  unsigned char D.36754;
  guint8 * code.2279;
  unsigned char D.36756;
  guint8 * code.2280;
  unsigned char D.36758;
  guint8 * code.2281;
  unsigned char D.36760;
  guint8 * code.2282;
  unsigned char D.36762;
  guint8 * code.2283;
  unsigned char D.36764;
  guint8 * code.2284;
  guint8 * code.2285;
  guint8 * code.2286;
  guint8 * code.2287;
  unsigned char D.36769;
  int D.36770;
  int D.36771;
  guint8 * code.2288;
  unsigned char iftmp.2289;
  int D.36778;
  guint8 * code.2290;
  unsigned char D.36785;
  guint8 * code.2291;
  guint8 * code.2292;
  guint8 * code.2293;
  long int D.36791;
  int D.36792;
  guint8 * code.2294;
  unsigned char D.36794;
  guint8 * code.2295;
  unsigned char D.36796;
  guint8 * code.2296;
  unsigned char D.36798;
  guint8 * code.2297;
  unsigned char D.36800;
  int D.36802;
  guint8 * code.2298;
  guint8 * code.2299;
  unsigned int D.36810;
  unsigned int D.36811;
  guint8 * code.2300;
  guint8 * code.2301;
  unsigned char D.36816;
  guint8 * code.2302;
  guint8 * code.2303;
  guint8 * code.2304;
  unsigned char D.36821;
  guint8 * code.2305;
  unsigned char D.36823;
  guint8 * code.2306;
  unsigned char D.36825;
  guint8 * code.2307;
  unsigned char D.36827;
  guint8 * code.2308;
  signed char D.36833;
  signed char D.36834;
  signed char D.36835;
  unsigned char D.36836;
  guint8 * code.2309;
  signed char D.36840;
  unsigned char D.36841;
  guint8 * code.2310;
  signed char D.36844;
  unsigned char D.36845;
  guint8 * code.2311;
  unsigned char D.36847;
  guint8 * code.2312;
  unsigned char D.36849;
  guint8 * code.2313;
  unsigned char D.36851;
  guint8 * code.2314;
  unsigned char D.36853;
  guint8 * code.2315;
  unsigned char D.36857;
  guint8 * code.2316;
  guint8 * code.2317;
  guint8 * code.2318;
  guint8 * code.2319;
  guint8 * code.2320;
  guint8 * code.2321;
  guint8 * code.2322;
  guint8 * code.2323;
  unsigned char D.36876;
  guint8 * code.2324;
  unsigned char D.36878;
  guint8 * code.2325;
  unsigned char D.36880;
  guint8 * code.2326;
  unsigned char D.36882;
  guint8 * code.2327;
  guint8 * code.2328;
  guint8 * code.2329;
  guint8 * code.2330;
  unsigned char D.36892;
  guint8 * code.2331;
  unsigned char D.36894;
  guint8 * code.2332;
  unsigned char D.36896;
  guint8 * code.2333;
  unsigned char D.36898;
  guint8 * code.2334;
  guint8 * code.2335;
  guint8 * code.2336;
  guint8 * code.2337;
  guint8 * code.2338;
  guint8 * code.2339;
  guint8 * code.2340;
  guint8 * code.2341;
  unsigned char D.36916;
  guint8 * code.2342;
  unsigned char D.36918;
  guint8 * code.2343;
  unsigned char D.36920;
  guint8 * code.2344;
  unsigned char D.36922;
  guint8 * code.2345;
  guint8 * code.2346;
  guint8 * code.2347;
  guint8 * code.2348;
  unsigned char D.36932;
  guint8 * code.2349;
  unsigned char D.36934;
  guint8 * code.2350;
  unsigned char D.36936;
  guint8 * code.2351;
  unsigned char D.36938;
  guint8 * code.2352;
  unsigned char D.36940;
  guint8 * code.2353;
  unsigned char D.36942;
  guint8 * code.2354;
  unsigned char D.36944;
  guint8 * code.2355;
  unsigned char D.36946;
  int D.36947;
  guint8 * code.2356;
  unsigned char iftmp.2357;
  int D.36954;
  guint8 * code.2358;
  unsigned char D.36961;
  guint8 * code.2359;
  guint8 * code.2360;
  guint8 * code.2361;
  long int D.36967;
  int D.36968;
  guint8 * code.2362;
  unsigned char D.36970;
  guint8 * code.2363;
  unsigned char D.36972;
  guint8 * code.2364;
  unsigned char D.36974;
  guint8 * code.2365;
  unsigned char D.36976;
  int D.36978;
  guint8 * code.2366;
  guint8 * code.2367;
  unsigned int D.36986;
  unsigned int D.36987;
  guint8 * code.2368;
  guint8 * code.2369;
  unsigned char D.36992;
  guint8 * code.2370;
  guint8 * code.2371;
  guint8 * code.2372;
  unsigned char D.36997;
  guint8 * code.2373;
  unsigned char D.36999;
  guint8 * code.2374;
  unsigned char D.37001;
  guint8 * code.2375;
  unsigned char D.37003;
  guint8 * code.2376;
  signed char D.37009;
  signed char D.37010;
  signed char D.37011;
  unsigned char D.37012;
  guint8 * code.2377;
  signed char D.37016;
  unsigned char D.37017;
  guint8 * code.2378;
  signed char D.37020;
  unsigned char D.37021;
  guint8 * code.2379;
  unsigned char D.37023;
  guint8 * code.2380;
  unsigned char D.37025;
  guint8 * code.2381;
  unsigned char D.37027;
  guint8 * code.2382;
  unsigned char D.37029;
  long unsigned int D.37030;
  long unsigned int D.37031;
  unsigned int D.37032;
  guint8 * code.2383;
  guint8 * code.2384;
  unsigned char D.37039;
  guint8 * code.2385;
  guint8 * code.2386;
  guint8 * code.2387;
  int val.2388;
  guint8 * code.2389;
  unsigned char D.37047;
  guint8 * code.2390;
  unsigned char D.37049;
  guint8 * code.2391;
  unsigned char D.37051;
  guint8 * code.2392;
  unsigned char D.37053;
  guint8 * code.2393;
  guint8 * code.2394;
  _Bool D.37062;
  _Bool D.37063;
  _Bool D.37064;
  guint8 * code.2395;
  guint8 * code.2396;
  unsigned char D.37069;
  guint8 * code.2397;
  guint8 * code.2398;
  guint8 * code.2399;
  unsigned char D.37074;
  guint8 * code.2400;
  unsigned char D.37076;
  guint8 * code.2401;
  unsigned char D.37078;
  guint8 * code.2402;
  unsigned char D.37080;
  guint8 * code.2403;
  guint8 * code.2404;
  guint8 * code.2405;
  guint8 * code.2406;
  unsigned char D.37090;
  guint8 * code.2407;
  unsigned char D.37092;
  guint8 * code.2408;
  unsigned char D.37094;
  guint8 * code.2409;
  unsigned char D.37096;
  guint8 * code.2410;
  guint8 * code.2411;
  unsigned char D.37103;
  guint8 * code.2412;
  guint8 * code.2413;
  guint8 * code.2414;
  guint8 * code.2415;
  unsigned char D.37110;
  guint8 * code.2416;
  unsigned char D.37112;
  guint8 * code.2417;
  unsigned char D.37114;
  guint8 * code.2418;
  unsigned char D.37116;
  guint8 * code.2419;
  guint8 * code.2420;
  guint8 * code.2421;
  guint8 * code.2422;
  guint8 * code.2423;
  guint8 * code.2424;
  guint8 * code.2425;
  unsigned char D.37133;
  guint8 * code.2426;
  unsigned char D.37135;
  guint8 * code.2427;
  unsigned char D.37137;
  guint8 * code.2428;
  unsigned char D.37139;
  guint8 * code.2429;
  guint8 * code.2430;
  guint8 * code.2431;
  guint8 * code.2432;
  unsigned char D.37149;
  guint8 * code.2433;
  unsigned char D.37151;
  guint8 * code.2434;
  unsigned char D.37153;
  guint8 * code.2435;
  unsigned char D.37155;
  guint8 * code.2436;
  int breakpoint_size.2437;
  guint8 * code.2438;
  signed char iftmp.2439;
  signed char D.37164;
  guint8 * code.2440;
  unsigned char D.37168;
  guint8 * code.2441;
  guint8 * code.2442;
  signed char iftmp.2443;
  signed char D.37175;
  guint8 * code.2444;
  unsigned char D.37179;
  guint8 * code.2445;
  guint8 * code.2446;
  unsigned char iftmp.2447;
  guint8 * code.2448;
  unsigned char D.37193;
  guint8 * code.2449;
  guint8 * code.2450;
  guint8 * code.2451;
  unsigned char D.37202;
  guint8 * code.2452;
  guint8 * code.2453;
  unsigned char D.37205;
  guint8 * code.2454;
  unsigned char D.37207;
  guint8 * code.2455;
  unsigned char D.37209;
  guint8 * code.2456;
  unsigned char D.37211;
  unsigned char iftmp.2457;
  guint8 * code.2458;
  unsigned char D.37220;
  guint8 * code.2459;
  guint8 * code.2460;
  guint8 * code.2461;
  unsigned char D.37224;
  guint8 * code.2462;
  unsigned char D.37226;
  guint8 * code.2463;
  unsigned char D.37228;
  guint8 * code.2464;
  unsigned char D.37230;
  unsigned char iftmp.2465;
  guint8 * code.2466;
  unsigned char D.37242;
  guint8 * code.2467;
  guint8 * code.2468;
  signed char D.37245;
  unsigned char D.37246;
  guint8 * code.2469;
  unsigned char D.37253;
  guint8 * code.2470;
  guint8 * code.2471;
  unsigned char D.37256;
  guint8 * code.2472;
  unsigned char D.37258;
  guint8 * code.2473;
  unsigned char D.37260;
  guint8 * code.2474;
  unsigned char D.37262;
  unsigned char iftmp.2475;
  guint8 * code.2476;
  unsigned char D.37271;
  guint8 * code.2477;
  guint8 * code.2478;
  guint8 * code.2479;
  unsigned char D.37275;
  guint8 * code.2480;
  unsigned char D.37277;
  guint8 * code.2481;
  unsigned char D.37279;
  guint8 * code.2482;
  unsigned char D.37281;
  signed char iftmp.2483;
  signed char D.37286;
  guint8 * code.2484;
  unsigned char D.37290;
  guint8 * code.2485;
  guint8 * code.2486;
  signed char iftmp.2487;
  signed char D.37297;
  guint8 * code.2488;
  unsigned char D.37301;
  guint8 * code.2489;
  guint8 * code.2490;
  unsigned char iftmp.2491;
  guint8 * code.2492;
  unsigned char D.37315;
  guint8 * code.2493;
  guint8 * code.2494;
  signed char D.37318;
  unsigned char D.37319;
  guint8 * code.2495;
  unsigned char D.37326;
  guint8 * code.2496;
  guint8 * code.2497;
  unsigned char D.37329;
  guint8 * code.2498;
  unsigned char D.37331;
  guint8 * code.2499;
  unsigned char D.37333;
  guint8 * code.2500;
  unsigned char D.37335;
  unsigned char iftmp.2501;
  guint8 * code.2502;
  unsigned char D.37344;
  guint8 * code.2503;
  guint8 * code.2504;
  guint8 * code.2505;
  unsigned char D.37348;
  guint8 * code.2506;
  unsigned char D.37350;
  guint8 * code.2507;
  unsigned char D.37352;
  guint8 * code.2508;
  unsigned char D.37354;
  unsigned char iftmp.2509;
  guint8 * code.2510;
  unsigned char D.37366;
  guint8 * code.2511;
  guint8 * code.2512;
  signed char D.37369;
  unsigned char D.37370;
  guint8 * code.2513;
  unsigned char D.37377;
  guint8 * code.2514;
  guint8 * code.2515;
  unsigned char D.37380;
  guint8 * code.2516;
  unsigned char D.37382;
  guint8 * code.2517;
  unsigned char D.37384;
  guint8 * code.2518;
  unsigned char D.37386;
  unsigned char iftmp.2519;
  guint8 * code.2520;
  unsigned char D.37395;
  guint8 * code.2521;
  guint8 * code.2522;
  guint8 * code.2523;
  unsigned char D.37399;
  guint8 * code.2524;
  unsigned char D.37401;
  guint8 * code.2525;
  unsigned char D.37403;
  guint8 * code.2526;
  unsigned char D.37405;
  signed char iftmp.2527;
  signed char D.37410;
  guint8 * code.2528;
  unsigned char D.37414;
  guint8 * code.2529;
  guint8 * code.2530;
  unsigned char iftmp.2531;
  guint8 * code.2532;
  unsigned char D.37428;
  guint8 * code.2533;
  guint8 * code.2534;
  signed char D.37431;
  unsigned char D.37432;
  guint8 * code.2535;
  unsigned char D.37439;
  guint8 * code.2536;
  guint8 * code.2537;
  unsigned char D.37442;
  guint8 * code.2538;
  unsigned char D.37444;
  guint8 * code.2539;
  unsigned char D.37446;
  guint8 * code.2540;
  unsigned char D.37448;
  unsigned char iftmp.2541;
  guint8 * code.2542;
  unsigned char D.37457;
  guint8 * code.2543;
  guint8 * code.2544;
  guint8 * code.2545;
  unsigned char D.37461;
  guint8 * code.2546;
  unsigned char D.37463;
  guint8 * code.2547;
  unsigned char D.37465;
  guint8 * code.2548;
  unsigned char D.37467;
  signed char iftmp.2549;
  signed char D.37472;
  guint8 * code.2550;
  unsigned char D.37476;
  guint8 * code.2551;
  guint8 * code.2552;
  guint8 * code.2553;
  guint32 iftmp.2554;
  guint8 * code.2555;
  signed char iftmp.2556;
  signed char iftmp.2557;
  signed char D.37497;
  signed char D.37498;
  _Bool D.37499;
  _Bool D.37500;
  _Bool D.37501;
  guint8 * code.2558;
  unsigned char D.37505;
  guint8 * code.2559;
  guint8 * code.2560;
  guint8 * code.2561;
  signed char iftmp.2562;
  signed char D.37513;
  guint8 * code.2563;
  unsigned char D.37517;
  guint8 * code.2564;
  guint8 * code.2565;
  signed char D.37520;
  unsigned char D.37521;
  signed char iftmp.2566;
  signed char iftmp.2567;
  signed char D.37530;
  signed char D.37531;
  guint8 * code.2568;
  unsigned char D.37535;
  guint8 * code.2569;
  guint8 * code.2570;
  guint8 * code.2571;
  signed char D.37541;
  unsigned char D.37542;
  guint8 * code.2572;
  unsigned char D.37544;
  guint8 * code.2573;
  unsigned char D.37546;
  guint8 * code.2574;
  unsigned char D.37548;
  guint8 * code.2575;
  unsigned char D.37550;
  guint8 * code.2576;
  guint8 * code.2577;
  signed char D.37556;
  unsigned char D.37557;
  guint8 * code.2578;
  guint8 * code.2579;
  guint8 * code.2580;
  guint8 * code.2581;
  guint8 * code.2582;
  unsigned char D.37567;
  guint8 * code.2583;
  unsigned char D.37569;
  guint8 * code.2584;
  unsigned char D.37571;
  guint8 * code.2585;
  unsigned char D.37573;
  signed char iftmp.2586;
  signed char iftmp.2587;
  signed char D.37582;
  signed char D.37583;
  guint8 * code.2588;
  unsigned char D.37587;
  guint8 * code.2589;
  guint8 * code.2590;
  guint8 * code.2591;
  signed char D.37593;
  unsigned char D.37594;
  guint8 * code.2592;
  unsigned char D.37596;
  guint8 * code.2593;
  unsigned char D.37598;
  guint8 * code.2594;
  unsigned char D.37600;
  guint8 * code.2595;
  unsigned char D.37602;
  guint8 * code.2596;
  guint8 * code.2597;
  signed char D.37608;
  unsigned char D.37609;
  guint8 * code.2598;
  guint8 * code.2599;
  guint8 * code.2600;
  guint8 * code.2601;
  guint8 * code.2602;
  unsigned char D.37619;
  guint8 * code.2603;
  unsigned char D.37621;
  guint8 * code.2604;
  unsigned char D.37623;
  guint8 * code.2605;
  unsigned char D.37625;
  signed char iftmp.2606;
  signed char iftmp.2607;
  signed char D.37634;
  signed char D.37635;
  guint8 * code.2608;
  unsigned char D.37639;
  guint8 * code.2609;
  guint8 * code.2610;
  guint8 * code.2611;
  guint8 * code.2612;
  unsigned char D.37646;
  guint8 * code.2613;
  unsigned char D.37648;
  guint8 * code.2614;
  unsigned char D.37650;
  guint8 * code.2615;
  unsigned char D.37652;
  guint8 * code.2616;
  guint8 * code.2617;
  guint8 * code.2618;
  guint8 * code.2619;
  guint8 * code.2620;
  guint8 * code.2621;
  guint8 * code.2622;
  unsigned char D.37667;
  guint8 * code.2623;
  unsigned char D.37669;
  guint8 * code.2624;
  unsigned char D.37671;
  guint8 * code.2625;
  unsigned char D.37673;
  signed char iftmp.2626;
  signed char D.37678;
  guint8 * code.2627;
  unsigned char D.37682;
  guint8 * code.2628;
  guint8 * code.2629;
  signed char iftmp.2630;
  signed char iftmp.2631;
  signed char D.37693;
  signed char D.37694;
  guint8 * code.2632;
  unsigned char D.37698;
  guint8 * code.2633;
  guint8 * code.2634;
  guint8 * code.2635;
  signed char D.37704;
  unsigned char D.37705;
  guint8 * code.2636;
  unsigned char D.37707;
  guint8 * code.2637;
  unsigned char D.37709;
  guint8 * code.2638;
  unsigned char D.37711;
  guint8 * code.2639;
  unsigned char D.37713;
  guint8 * code.2640;
  guint8 * code.2641;
  guint8 * code.2642;
  guint8 * code.2643;
  guint8 * code.2644;
  guint8 * code.2645;
  guint8 * code.2646;
  unsigned char D.37728;
  guint8 * code.2647;
  unsigned char D.37730;
  guint8 * code.2648;
  unsigned char D.37732;
  guint8 * code.2649;
  unsigned char D.37734;
  signed char iftmp.2650;
  signed char iftmp.2651;
  signed char D.37743;
  signed char D.37744;
  guint8 * code.2652;
  unsigned char D.37748;
  guint8 * code.2653;
  guint8 * code.2654;
  guint8 * code.2655;
  guint8 * code.2656;
  unsigned char D.37755;
  guint8 * code.2657;
  unsigned char D.37757;
  guint8 * code.2658;
  unsigned char D.37759;
  guint8 * code.2659;
  unsigned char D.37761;
  guint8 * code.2660;
  guint8 * code.2661;
  guint8 * code.2662;
  guint8 * code.2663;
  guint8 * code.2664;
  guint8 * code.2665;
  guint8 * code.2666;
  unsigned char D.37776;
  guint8 * code.2667;
  unsigned char D.37778;
  guint8 * code.2668;
  unsigned char D.37780;
  guint8 * code.2669;
  unsigned char D.37782;
  signed char iftmp.2670;
  signed char D.37787;
  guint8 * code.2671;
  unsigned char D.37791;
  guint8 * code.2672;
  guint8 * code.2673;
  signed char iftmp.2674;
  signed char iftmp.2675;
  signed char D.37802;
  signed char D.37803;
  guint8 * code.2676;
  unsigned char D.37807;
  guint8 * code.2677;
  guint8 * code.2678;
  guint8 * code.2679;
  guint8 * code.2680;
  unsigned char D.37814;
  guint8 * code.2681;
  unsigned char D.37816;
  guint8 * code.2682;
  unsigned char D.37818;
  guint8 * code.2683;
  unsigned char D.37820;
  guint8 * code.2684;
  guint8 * code.2685;
  guint8 * code.2686;
  guint8 * code.2687;
  guint8 * code.2688;
  guint8 * code.2689;
  guint8 * code.2690;
  unsigned char D.37835;
  guint8 * code.2691;
  unsigned char D.37837;
  guint8 * code.2692;
  unsigned char D.37839;
  guint8 * code.2693;
  unsigned char D.37841;
  unsigned char iftmp.2694;
  guint8 * code.2695;
  unsigned char D.37849;
  guint8 * code.2696;
  guint8 * code.2697;
  signed char D.37854;
  unsigned char D.37855;
  guint8 * code.2698;
  guint8 * code.2699;
  signed char iftmp.2700;
  signed char iftmp.2701;
  signed char D.37867;
  signed char D.37868;
  guint8 * code.2702;
  unsigned char D.37872;
  guint8 * code.2703;
  guint8 * code.2704;
  guint8 * code.2705;
  guint8 * code.2706;
  unsigned char D.37879;
  guint8 * code.2707;
  unsigned char D.37881;
  guint8 * code.2708;
  unsigned char D.37883;
  guint8 * code.2709;
  unsigned char D.37885;
  guint8 * code.2710;
  guint8 * code.2711;
  guint8 * code.2712;
  guint8 * code.2713;
  guint8 * code.2714;
  guint8 * code.2715;
  guint8 * code.2716;
  unsigned char D.37900;
  guint8 * code.2717;
  unsigned char D.37902;
  guint8 * code.2718;
  unsigned char D.37904;
  guint8 * code.2719;
  unsigned char D.37906;
  signed char iftmp.2720;
  signed char iftmp.2721;
  signed char D.37915;
  signed char D.37916;
  guint8 * code.2722;
  unsigned char D.37920;
  guint8 * code.2723;
  guint8 * code.2724;
  guint8 * code.2725;
  signed char D.37926;
  unsigned char D.37927;
  guint8 * code.2726;
  unsigned char D.37929;
  guint8 * code.2727;
  unsigned char D.37931;
  guint8 * code.2728;
  unsigned char D.37933;
  guint8 * code.2729;
  unsigned char D.37935;
  guint8 * code.2730;
  guint8 * code.2731;
  guint8 * code.2732;
  guint8 * code.2733;
  guint8 * code.2734;
  guint8 * code.2735;
  guint8 * code.2736;
  unsigned char D.37950;
  guint8 * code.2737;
  unsigned char D.37952;
  guint8 * code.2738;
  unsigned char D.37954;
  guint8 * code.2739;
  unsigned char D.37956;
  signed char iftmp.2740;
  signed char iftmp.2741;
  signed char D.37965;
  signed char D.37966;
  guint8 * code.2742;
  unsigned char D.37970;
  guint8 * code.2743;
  guint8 * code.2744;
  guint8 * code.2745;
  guint8 * code.2746;
  unsigned char D.37977;
  guint8 * code.2747;
  unsigned char D.37979;
  guint8 * code.2748;
  unsigned char D.37981;
  guint8 * code.2749;
  unsigned char D.37983;
  guint8 * code.2750;
  guint8 * code.2751;
  guint8 * code.2752;
  guint8 * code.2753;
  guint8 * code.2754;
  guint8 * code.2755;
  guint8 * code.2756;
  unsigned char D.37998;
  guint8 * code.2757;
  unsigned char D.38000;
  guint8 * code.2758;
  unsigned char D.38002;
  guint8 * code.2759;
  unsigned char D.38004;
  unsigned char iftmp.2760;
  guint8 * code.2761;
  unsigned char D.38012;
  guint8 * code.2762;
  guint8 * code.2763;
  guint8 * code.2764;
  guint8 * code.2765;
  signed char iftmp.2766;
  signed char iftmp.2767;
  signed char D.38028;
  signed char D.38029;
  guint8 * code.2768;
  unsigned char D.38033;
  guint8 * code.2769;
  guint8 * code.2770;
  guint8 * code.2771;
  guint8 * code.2772;
  unsigned char D.38040;
  guint8 * code.2773;
  unsigned char D.38042;
  guint8 * code.2774;
  unsigned char D.38044;
  guint8 * code.2775;
  unsigned char D.38046;
  guint8 * code.2776;
  guint8 * code.2777;
  guint8 * code.2778;
  guint8 * code.2779;
  guint8 * code.2780;
  guint8 * code.2781;
  guint8 * code.2782;
  unsigned char D.38061;
  guint8 * code.2783;
  unsigned char D.38063;
  guint8 * code.2784;
  unsigned char D.38065;
  guint8 * code.2785;
  unsigned char D.38067;
  signed char iftmp.2786;
  signed char iftmp.2787;
  signed char D.38076;
  signed char D.38077;
  _Bool D.38078;
  _Bool D.38079;
  guint8 * code.2788;
  unsigned char D.38083;
  guint8 * code.2789;
  guint8 * code.2790;
  guint8 * code.2791;
  guint8 * code.2792;
  guint8 * code.2793;
  unsigned char D.38092;
  guint8 * code.2794;
  unsigned char D.38094;
  guint8 * code.2795;
  unsigned char D.38096;
  guint8 * code.2796;
  unsigned char D.38098;
  guint8 * code.2797;
  guint8 * code.2798;
  unsigned char D.38107;
  guint8 * code.2799;
  guint8 * code.2800;
  guint8 * code.2801;
  guint8 * code.2802;
  guint8 * code.2803;
  guint8 * code.2804;
  guint8 * code.2805;
  guint8 * code.2806;
  guint8 * code.2807;
  unsigned char D.38125;
  guint8 * code.2808;
  unsigned char D.38127;
  guint8 * code.2809;
  unsigned char D.38129;
  guint8 * code.2810;
  unsigned char D.38131;
  guint8 * code.2811;
  guint8 * code.2812;
  guint8 * code.2813;
  guint8 * code.2814;
  unsigned char D.38141;
  guint8 * code.2815;
  unsigned char D.38143;
  guint8 * code.2816;
  unsigned char D.38145;
  guint8 * code.2817;
  unsigned char D.38147;
  guint8 * code.2818;
  unsigned char D.38151;
  guint8 * code.2819;
  guint8 * code.2820;
  unsigned char D.38156;
  guint8 * code.2821;
  guint8 * code.2822;
  guint8 * code.2823;
  guint8 * code.2824;
  guint8 * code.2825;
  guint8 * code.2826;
  guint8 * code.2827;
  guint8 * code.2828;
  unsigned char D.38173;
  guint8 * code.2829;
  unsigned char D.38175;
  guint8 * code.2830;
  unsigned char D.38177;
  guint8 * code.2831;
  unsigned char D.38179;
  guint8 * code.2832;
  guint8 * code.2833;
  guint8 * code.2834;
  guint8 * code.2835;
  unsigned char D.38189;
  guint8 * code.2836;
  unsigned char D.38191;
  guint8 * code.2837;
  unsigned char D.38193;
  guint8 * code.2838;
  unsigned char D.38195;
  guint8 * code.2839;
  unsigned char D.38200;
  guint8 * code.2840;
  unsigned char iftmp.2841;
  guint8 * code.2842;
  unsigned char D.38209;
  guint8 * code.2843;
  guint8 * code.2844;
  signed char D.38212;
  unsigned char D.38213;
  guint8 * code.2845;
  guint8 * code.2846;
  unsigned char D.38222;
  guint8 * code.2847;
  guint8 * code.2848;
  guint8 * code.2849;
  guint8 * code.2850;
  guint8 * code.2851;
  guint8 * code.2852;
  guint8 * code.2853;
  guint8 * code.2854;
  guint8 * code.2855;
  unsigned char D.38240;
  guint8 * code.2856;
  unsigned char D.38242;
  guint8 * code.2857;
  unsigned char D.38244;
  guint8 * code.2858;
  unsigned char D.38246;
  guint8 * code.2859;
  guint8 * code.2860;
  guint8 * code.2861;
  guint8 * code.2862;
  unsigned char D.38256;
  guint8 * code.2863;
  unsigned char D.38258;
  guint8 * code.2864;
  unsigned char D.38260;
  guint8 * code.2865;
  unsigned char D.38262;
  guint8 * code.2866;
  unsigned char D.38266;
  guint8 * code.2867;
  guint8 * code.2868;
  guint8 * code.2869;
  unsigned char D.38272;
  guint8 * code.2870;
  guint8 * code.2871;
  guint8 * code.2872;
  guint8 * code.2873;
  guint8 * code.2874;
  guint8 * code.2875;
  guint8 * code.2876;
  guint8 * code.2877;
  unsigned char D.38289;
  guint8 * code.2878;
  unsigned char D.38291;
  guint8 * code.2879;
  unsigned char D.38293;
  guint8 * code.2880;
  unsigned char D.38295;
  guint8 * code.2881;
  guint8 * code.2882;
  guint8 * code.2883;
  guint8 * code.2884;
  unsigned char D.38305;
  guint8 * code.2885;
  unsigned char D.38307;
  guint8 * code.2886;
  unsigned char D.38309;
  guint8 * code.2887;
  unsigned char D.38311;
  guint8 * code.2888;
  unsigned char D.38316;
  guint8 * code.2889;
  guint8 * code.2890;
  unsigned char iftmp.2891;
  guint8 * code.2892;
  unsigned char D.38326;
  guint8 * code.2893;
  guint8 * code.2894;
  signed char D.38329;
  unsigned char D.38330;
  guint8 * code.2895;
  guint8 * code.2896;
  unsigned char D.38339;
  guint8 * code.2897;
  guint8 * code.2898;
  guint8 * code.2899;
  guint8 * code.2900;
  guint8 * code.2901;
  guint8 * code.2902;
  guint8 * code.2903;
  guint8 * code.2904;
  guint8 * code.2905;
  unsigned char D.38357;
  guint8 * code.2906;
  unsigned char D.38359;
  guint8 * code.2907;
  unsigned char D.38361;
  guint8 * code.2908;
  unsigned char D.38363;
  guint8 * code.2909;
  guint8 * code.2910;
  guint8 * code.2911;
  guint8 * code.2912;
  unsigned char D.38373;
  guint8 * code.2913;
  unsigned char D.38375;
  guint8 * code.2914;
  unsigned char D.38377;
  guint8 * code.2915;
  unsigned char D.38379;
  guint8 * code.2916;
  unsigned char D.38383;
  guint8 * code.2917;
  guint8 * code.2918;
  unsigned char D.38388;
  guint8 * code.2919;
  guint8 * code.2920;
  guint8 * code.2921;
  guint8 * code.2922;
  guint8 * code.2923;
  guint8 * code.2924;
  guint8 * code.2925;
  guint8 * code.2926;
  unsigned char D.38405;
  guint8 * code.2927;
  unsigned char D.38407;
  guint8 * code.2928;
  unsigned char D.38409;
  guint8 * code.2929;
  unsigned char D.38411;
  guint8 * code.2930;
  guint8 * code.2931;
  guint8 * code.2932;
  guint8 * code.2933;
  unsigned char D.38421;
  guint8 * code.2934;
  unsigned char D.38423;
  guint8 * code.2935;
  unsigned char D.38425;
  guint8 * code.2936;
  unsigned char D.38427;
  guint8 * code.2937;
  unsigned char D.38432;
  guint8 * code.2938;
  guint8 * code.2939;
  unsigned char D.38437;
  guint8 * code.2940;
  guint8 * code.2941;
  guint8 * code.2942;
  guint8 * code.2943;
  unsigned char D.38448;
  guint8 * code.2944;
  guint8 * code.2945;
  guint8 * code.2946;
  guint8 * code.2947;
  guint8 * code.2948;
  guint8 * code.2949;
  guint8 * code.2950;
  guint8 * code.2951;
  guint8 * code.2952;
  unsigned char D.38466;
  guint8 * code.2953;
  unsigned char D.38468;
  guint8 * code.2954;
  unsigned char D.38470;
  guint8 * code.2955;
  unsigned char D.38472;
  guint8 * code.2956;
  guint8 * code.2957;
  guint8 * code.2958;
  guint8 * code.2959;
  unsigned char D.38482;
  guint8 * code.2960;
  unsigned char D.38484;
  guint8 * code.2961;
  unsigned char D.38486;
  guint8 * code.2962;
  unsigned char D.38488;
  guint8 * code.2963;
  unsigned char D.38492;
  guint8 * code.2964;
  guint8 * code.2965;
  guint8 * code.2966;
  unsigned char D.38498;
  guint8 * code.2967;
  guint8 * code.2968;
  guint8 * code.2969;
  guint8 * code.2970;
  guint8 * code.2971;
  guint8 * code.2972;
  guint8 * code.2973;
  guint8 * code.2974;
  unsigned char D.38515;
  guint8 * code.2975;
  unsigned char D.38517;
  guint8 * code.2976;
  unsigned char D.38519;
  guint8 * code.2977;
  unsigned char D.38521;
  guint8 * code.2978;
  guint8 * code.2979;
  guint8 * code.2980;
  guint8 * code.2981;
  unsigned char D.38531;
  guint8 * code.2982;
  unsigned char D.38533;
  guint8 * code.2983;
  unsigned char D.38535;
  guint8 * code.2984;
  unsigned char D.38537;
  guint8 * code.2985;
  unsigned char D.38542;
  guint8 * code.2986;
  guint8 * code.2987;
  guint8 * code.2988;
  unsigned char D.38548;
  guint8 * code.2989;
  guint8 * code.2990;
  unsigned int D.38551;
  _Bool D.38552;
  long int D.38553;
  long int D.38554;
  _Bool D.38557;
  long int D.38558;
  long int D.38559;
  _Bool D.38562;
  long int D.38563;
  long int D.38564;
  signed char iftmp.2991;
  signed char D.38573;
  guint8 * code.2992;
  unsigned char D.38577;
  guint8 * code.2993;
  guint8 * code.2994;
  unsigned char D.38582;
  guint8 * code.2995;
  unsigned char D.38584;
  guint8 * code.2996;
  unsigned char D.38586;
  guint8 * code.2997;
  unsigned char D.38588;
  guint8 * code.2998;
  unsigned char D.38590;
  guint8 * code.2999;
  unsigned char D.38592;
  guint8 * code.3000;
  unsigned char D.38594;
  guint8 * code.3001;
  unsigned char D.38596;
  guint8 * code.3002;
  unsigned char D.38599;
  guint8 * code.3003;
  unsigned char D.38601;
  guint8 * code.3004;
  unsigned char D.38603;
  guint8 * code.3005;
  unsigned char D.38605;
  guint8 * code.3006;
  unsigned char D.38609;
  guint8 * code.3007;
  guint8 * code.3008;
  guint8 * code.3009;
  guint8 * code.3010;
  guint8 * code.3011;
  unsigned char D.38619;
  guint8 * code.3012;
  guint8 * code.3013;
  guint8 * code.3014;
  guint8 * code.3015;
  guint8 * code.3016;
  unsigned char D.38630;
  int D.38631;
  guint8 * code.3017;
  guint8 * code.3018;
  guint8 * code.3019;
  guint8 * code.3020;
  unsigned char D.38639;
  unsigned char D.38640;
  guint8 * code.3021;
  unsigned char D.38644;
  guint8 * code.3022;
  guint8 * code.3023;
  int D.38647;
  unsigned int D.38648;
  unsigned int D.38649;
  guint8 * code.3024;
  unsigned char D.38655;
  guint8 * code.3025;
  guint8 * code.3026;
  unsigned char D.38658;
  unsigned char D.38659;
  guint8 * code.3027;
  unsigned char D.38666;
  guint8 * code.3028;
  int D.38668;
  guint8 * code.3029;
  unsigned char D.38670;
  guint8 * code.3030;
  unsigned char D.38672;
  guint8 * code.3031;
  unsigned char D.38674;
  guint8 * code.3032;
  unsigned char D.38676;
  guint8 * code.3033;
  unsigned char D.38681;
  guint8 * code.3034;
  guint8 * code.3035;
  guint8 * code.3036;
  unsigned char D.38685;
  guint8 * code.3037;
  unsigned char D.38687;
  guint8 * code.3038;
  unsigned char D.38689;
  guint8 * code.3039;
  unsigned char D.38691;
  guint8 * code.3040;
  unsigned char D.38695;
  guint8 * code.3041;
  guint8 * code.3042;
  signed char iftmp.3043;
  signed char D.38702;
  guint8 * code.3044;
  unsigned char D.38706;
  guint8 * code.3045;
  guint8 * code.3046;
  guint8 * code.3047;
  guint8 * code.3048;
  guint8 * code.3049;
  unsigned char D.38716;
  unsigned char D.38717;
  guint8 * code.3050;
  unsigned char D.38720;
  unsigned char D.38721;
  guint8 * code.3051;
  unsigned char D.38723;
  guint8 * code.3052;
  unsigned char D.38725;
  guint8 * code.3053;
  unsigned char D.38727;
  guint8 * code.3054;
  unsigned char D.38729;
  struct MonoBasicBlock * * D.38731;
  struct MonoBasicBlock * D.38732;
  int D.38733;
  sizetype D.38736;
  unsigned char * D.38737;
  long int D.38738;
  long int D.38739;
  unsigned int D.38740;
  unsigned int D.38741;
  unsigned int offset.3055;
  unsigned int D.38743;
  guint8 * code.3056;
  guint8 * code.3057;
  unsigned char D.38751;
  unsigned int D.38753;
  guint8 * code.3058;
  guint8 * code.3059;
  guint8 * code.3060;
  guint8 * code.3061;
  unsigned char D.38761;
  guint8 * code.3062;
  unsigned char D.38763;
  guint8 * code.3063;
  unsigned char D.38765;
  guint8 * code.3064;
  unsigned char D.38767;
  int D.38772;
  unsigned int D.38773;
  unsigned int D.38774;
  int D.38775;
  guint8 * code.3065;
  guint8 * code.3066;
  guint8 * code.3067;
  guint8 * code.3068;
  guint8 * code.3069;
  guint8 * code.3070;
  unsigned char D.38790;
  guint8 * code.3071;
  unsigned char D.38792;
  guint8 * code.3072;
  unsigned char D.38794;
  guint8 * code.3073;
  unsigned char D.38796;
  signed char iftmp.3074;
  signed char D.38801;
  guint8 * code.3075;
  unsigned char D.38805;
  guint8 * code.3076;
  guint8 * code.3077;
  unsigned char iftmp.3078;
  guint8 * code.3079;
  unsigned char D.38819;
  guint8 * code.3080;
  guint8 * code.3081;
  signed char D.38822;
  unsigned char D.38823;
  guint8 * code.3082;
  unsigned char D.38830;
  guint8 * code.3083;
  guint8 * code.3084;
  unsigned char D.38833;
  guint8 * code.3085;
  unsigned char D.38835;
  guint8 * code.3086;
  unsigned char D.38837;
  guint8 * code.3087;
  unsigned char D.38839;
  unsigned char iftmp.3088;
  guint8 * code.3089;
  unsigned char D.38848;
  guint8 * code.3090;
  guint8 * code.3091;
  guint8 * code.3092;
  unsigned char D.38852;
  guint8 * code.3093;
  unsigned char D.38854;
  guint8 * code.3094;
  unsigned char D.38856;
  guint8 * code.3095;
  unsigned char D.38858;
  signed char iftmp.3096;
  signed char D.38863;
  guint8 * code.3097;
  unsigned char D.38867;
  guint8 * code.3098;
  guint8 * code.3099;
  unsigned char iftmp.3100;
  guint8 * code.3101;
  unsigned char D.38881;
  guint8 * code.3102;
  guint8 * code.3103;
  signed char D.38884;
  unsigned char D.38885;
  guint8 * code.3104;
  unsigned char D.38892;
  guint8 * code.3105;
  guint8 * code.3106;
  unsigned char D.38895;
  guint8 * code.3107;
  unsigned char D.38897;
  guint8 * code.3108;
  unsigned char D.38899;
  guint8 * code.3109;
  unsigned char D.38901;
  unsigned char iftmp.3110;
  guint8 * code.3111;
  unsigned char D.38910;
  guint8 * code.3112;
  guint8 * code.3113;
  guint8 * code.3114;
  unsigned char D.38914;
  guint8 * code.3115;
  unsigned char D.38916;
  guint8 * code.3116;
  unsigned char D.38918;
  guint8 * code.3117;
  unsigned char D.38920;
  _Bool D.38921;
  long int D.38922;
  long int D.38923;
  unsigned char iftmp.3118;
  guint8 * code.3119;
  unsigned char D.38933;
  guint8 * code.3120;
  guint8 * code.3121;
  unsigned char iftmp.3122;
  guint8 * code.3123;
  unsigned char D.38945;
  guint8 * code.3124;
  guint8 * code.3125;
  signed char D.38948;
  unsigned char D.38949;
  guint8 * code.3126;
  unsigned char D.38955;
  guint8 * code.3127;
  guint8 * code.3128;
  guint8 * code.3129;
  guint8 * code.3130;
  unsigned char iftmp.3131;
  guint8 * code.3132;
  unsigned char D.38972;
  guint8 * code.3133;
  guint8 * code.3134;
  guint8 * code.3135;
  guint8 * code.3136;
  guint8 * code.3137;
  unsigned char D.38985;
  guint8 * code.3138;
  guint8 * code.3139;
  guint8 * code.3140;
  guint8 * code.3141;
  unsigned char iftmp.3142;
  guint8 * code.3143;
  unsigned char D.39002;
  guint8 * code.3144;
  guint8 * code.3145;
  guint8 * code.3146;
  guint8 * code.3147;
  unsigned char iftmp.3148;
  guint8 * code.3149;
  unsigned char D.39019;
  guint8 * code.3150;
  guint8 * code.3151;
  guint8 * code.3152;
  unsigned char D.39027;
  guint8 * code.3153;
  guint8 * code.3154;
  guint8 * code.3155;
  guint8 * code.3156;
  unsigned char iftmp.3157;
  guint8 * code.3158;
  unsigned char D.39044;
  guint8 * code.3159;
  guint8 * code.3160;
  guint8 * code.3161;
  guint8 * code.3162;
  signed char iftmp.3163;
  signed char D.39056;
  guint8 * code.3164;
  unsigned char D.39060;
  guint8 * code.3165;
  guint8 * code.3166;
  signed char iftmp.3167;
  signed char D.39067;
  guint8 * code.3168;
  unsigned char D.39071;
  guint8 * code.3169;
  guint8 * code.3170;
  guint8 * code.3171;
  unsigned char D.39079;
  guint8 * code.3172;
  guint8 * code.3173;
  guint8 * code.3174;
  unsigned char D.39088;
  guint8 * code.3175;
  guint8 * code.3176;
  unsigned char D.39091;
  guint8 * code.3177;
  unsigned char D.39093;
  guint8 * code.3178;
  unsigned char D.39095;
  guint8 * code.3179;
  unsigned char D.39097;
  guint8 * code.3180;
  unsigned char D.39102;
  guint8 * code.3181;
  guint8 * code.3182;
  guint8 * code.3183;
  unsigned char D.39106;
  guint8 * code.3184;
  unsigned char D.39108;
  guint8 * code.3185;
  unsigned char D.39110;
  guint8 * code.3186;
  unsigned char D.39112;
  guint8 * code.3187;
  unsigned char D.39118;
  guint8 * code.3188;
  guint8 * code.3189;
  guint8 * code.3190;
  unsigned char D.39127;
  guint8 * code.3191;
  guint8 * code.3192;
  unsigned char D.39130;
  guint8 * code.3193;
  unsigned char D.39132;
  guint8 * code.3194;
  unsigned char D.39134;
  guint8 * code.3195;
  unsigned char D.39136;
  guint8 * code.3196;
  unsigned char D.39141;
  guint8 * code.3197;
  guint8 * code.3198;
  guint8 * code.3199;
  unsigned char D.39145;
  guint8 * code.3200;
  unsigned char D.39147;
  guint8 * code.3201;
  unsigned char D.39149;
  guint8 * code.3202;
  unsigned char D.39151;
  signed char iftmp.3203;
  signed char D.39156;
  guint8 * code.3204;
  unsigned char D.39160;
  guint8 * code.3205;
  guint8 * code.3206;
  signed char iftmp.3207;
  signed char D.39167;
  guint8 * code.3208;
  unsigned char D.39171;
  guint8 * code.3209;
  guint8 * code.3210;
  guint8 * code.3211;
  unsigned char D.39179;
  guint8 * code.3212;
  guint8 * code.3213;
  guint8 * code.3214;
  unsigned char D.39188;
  guint8 * code.3215;
  guint8 * code.3216;
  unsigned char D.39191;
  guint8 * code.3217;
  unsigned char D.39193;
  guint8 * code.3218;
  unsigned char D.39195;
  guint8 * code.3219;
  unsigned char D.39197;
  guint8 * code.3220;
  unsigned char D.39202;
  guint8 * code.3221;
  guint8 * code.3222;
  guint8 * code.3223;
  unsigned char D.39206;
  guint8 * code.3224;
  unsigned char D.39208;
  guint8 * code.3225;
  unsigned char D.39210;
  guint8 * code.3226;
  unsigned char D.39212;
  guint8 * code.3227;
  unsigned char D.39218;
  guint8 * code.3228;
  guint8 * code.3229;
  guint8 * code.3230;
  unsigned char D.39227;
  guint8 * code.3231;
  guint8 * code.3232;
  unsigned char D.39230;
  guint8 * code.3233;
  unsigned char D.39232;
  guint8 * code.3234;
  unsigned char D.39234;
  guint8 * code.3235;
  unsigned char D.39236;
  guint8 * code.3236;
  unsigned char D.39241;
  guint8 * code.3237;
  guint8 * code.3238;
  guint8 * code.3239;
  unsigned char D.39245;
  guint8 * code.3240;
  unsigned char D.39247;
  guint8 * code.3241;
  unsigned char D.39249;
  guint8 * code.3242;
  unsigned char D.39251;
  signed char iftmp.3243;
  signed char D.39256;
  guint8 * code.3244;
  unsigned char D.39260;
  guint8 * code.3245;
  guint8 * code.3246;
  guint8 * code.3247;
  unsigned char D.39268;
  guint8 * code.3248;
  guint8 * code.3249;
  guint8 * code.3250;
  unsigned char D.39277;
  guint8 * code.3251;
  guint8 * code.3252;
  unsigned char D.39280;
  guint8 * code.3253;
  unsigned char D.39282;
  guint8 * code.3254;
  unsigned char D.39284;
  guint8 * code.3255;
  unsigned char D.39286;
  guint8 * code.3256;
  unsigned char D.39291;
  guint8 * code.3257;
  guint8 * code.3258;
  guint8 * code.3259;
  unsigned char D.39295;
  guint8 * code.3260;
  unsigned char D.39297;
  guint8 * code.3261;
  unsigned char D.39299;
  guint8 * code.3262;
  unsigned char D.39301;
  signed char iftmp.3263;
  signed char D.39306;
  guint8 * code.3264;
  unsigned char D.39310;
  guint8 * code.3265;
  guint8 * code.3266;
  guint8 * code.3267;
  unsigned char D.39318;
  guint8 * code.3268;
  guint8 * code.3269;
  guint8 * code.3270;
  unsigned char D.39327;
  guint8 * code.3271;
  guint8 * code.3272;
  unsigned char D.39330;
  guint8 * code.3273;
  unsigned char D.39332;
  guint8 * code.3274;
  unsigned char D.39334;
  guint8 * code.3275;
  unsigned char D.39336;
  guint8 * code.3276;
  unsigned char D.39341;
  guint8 * code.3277;
  guint8 * code.3278;
  guint8 * code.3279;
  unsigned char D.39345;
  guint8 * code.3280;
  unsigned char D.39347;
  guint8 * code.3281;
  unsigned char D.39349;
  guint8 * code.3282;
  unsigned char D.39351;
  signed char iftmp.3283;
  signed char D.39356;
  guint8 * code.3284;
  unsigned char D.39360;
  guint8 * code.3285;
  guint8 * code.3286;
  guint8 * code.3287;
  unsigned char D.39368;
  guint8 * code.3288;
  guint8 * code.3289;
  guint8 * code.3290;
  unsigned char D.39377;
  guint8 * code.3291;
  guint8 * code.3292;
  unsigned char D.39380;
  guint8 * code.3293;
  unsigned char D.39382;
  guint8 * code.3294;
  unsigned char D.39384;
  guint8 * code.3295;
  unsigned char D.39386;
  guint8 * code.3296;
  unsigned char D.39391;
  guint8 * code.3297;
  guint8 * code.3298;
  guint8 * code.3299;
  unsigned char D.39395;
  guint8 * code.3300;
  unsigned char D.39397;
  guint8 * code.3301;
  unsigned char D.39399;
  guint8 * code.3302;
  unsigned char D.39401;
  guint8 * code.3303;
  unsigned char D.39405;
  guint8 * code.3304;
  guint8 * code.3305;
  signed char D.39408;
  unsigned char D.39409;
  guint8 * code.3306;
  unsigned char D.39413;
  guint8 * code.3307;
  guint8 * code.3308;
  signed char D.39416;
  unsigned char D.39417;
  guint8 * code.3309;
  unsigned char D.39423;
  guint8 * code.3310;
  guint8 * code.3311;
  guint8 * code.3312;
  unsigned char D.39431;
  guint8 * code.3313;
  guint8 * code.3314;
  guint8 * code.3315;
  unsigned char D.39437;
  guint8 * code.3316;
  guint8 * code.3317;
  guint8 * code.3318;
  guint8 * code.3319;
  guint8 * code.3320;
  unsigned char D.39448;
  guint8 * code.3321;
  guint8 * code.3322;
  guint8 * code.3323;
  guint8 * code.3324;
  guint8 * code.3325;
  unsigned char D.39461;
  guint8 * code.3326;
  guint8 * code.3327;
  guint8 * code.3328;
  unsigned char D.39467;
  guint8 * code.3329;
  guint8 * code.3330;
  guint8 * code.3331;
  guint8 * code.3332;
  signed char iftmp.3333;
  signed char D.39479;
  guint8 * code.3334;
  unsigned char D.39483;
  guint8 * code.3335;
  guint8 * code.3336;
  guint8 * code.3337;
  signed char iftmp.3338;
  signed char D.39491;
  guint8 * code.3339;
  unsigned char D.39495;
  guint8 * code.3340;
  guint8 * code.3341;
  guint8 * code.3342;
  guint8 * code.3343;
  guint8 * code.3344;
  guint8 * code.3345;
  guint8 * code.3346;
  unsigned char D.39508;
  guint8 * code.3347;
  unsigned char D.39510;
  guint8 * code.3348;
  unsigned char D.39512;
  guint8 * code.3349;
  unsigned char D.39514;
  struct MonoBasicBlock * * D.39516;
  struct MonoBasicBlock * D.39517;
  int D.39518;
  sizetype D.39521;
  unsigned char * D.39522;
  long int D.39523;
  long int D.39524;
  unsigned int D.39525;
  unsigned int D.39526;
  unsigned int offset.3350;
  unsigned int D.39528;
  guint8 * code.3351;
  guint8 * code.3352;
  unsigned char D.39536;
  unsigned int D.39538;
  guint8 * code.3353;
  guint8 * code.3354;
  guint8 * code.3355;
  guint8 * code.3356;
  unsigned char D.39546;
  guint8 * code.3357;
  unsigned char D.39548;
  guint8 * code.3358;
  unsigned char D.39550;
  guint8 * code.3359;
  unsigned char D.39552;
  int D.39557;
  unsigned int D.39558;
  unsigned int D.39559;
  int D.39560;
  guint8 * code.3360;
  guint8 * code.3361;
  guint8 * code.3362;
  guint8 * code.3363;
  guint8 * code.3364;
  guint8 * code.3365;
  unsigned char D.39575;
  guint8 * code.3366;
  unsigned char D.39577;
  guint8 * code.3367;
  unsigned char D.39579;
  guint8 * code.3368;
  unsigned char D.39581;
  int iftmp.3369;
  guint8 * code.3370;
  unsigned char D.39597;
  guint8 * code.3371;
  guint8 * code.3372;
  signed char iftmp.3373;
  signed char D.39606;
  _Bool D.39607;
  _Bool D.39608;
  _Bool D.39609;
  guint8 * code.3374;
  unsigned char D.39613;
  guint8 * code.3375;
  guint8 * code.3376;
  guint8 * code.3377;
  signed char D.39617;
  unsigned char D.39618;
  guint8 * code.3378;
  unsigned char D.39626;
  guint8 * code.3379;
  guint8 * code.3380;
  unsigned char D.39632;
  guint8 * code.3381;
  signed char iftmp.3382;
  _Bool D.39638;
  signed char D.39639;
  signed char D.39640;
  _Bool D.39641;
  _Bool D.39642;
  guint8 * code.3383;
  unsigned char D.39646;
  guint8 * code.3384;
  guint8 * code.3385;
  signed char D.39649;
  signed char D.39650;
  signed char D.39651;
  unsigned char D.39652;
  guint8 * code.3386;
  signed char iftmp.3387;
  signed char iftmp.3388;
  signed char D.39666;
  _Bool D.39667;
  _Bool D.39668;
  guint8 * code.3389;
  unsigned char D.39672;
  guint8 * code.3390;
  guint8 * code.3391;
  guint8 * code.3392;
  unsigned char D.39676;
  guint8 * code.3393;
  unsigned char D.39682;
  guint8 * code.3394;
  guint8 * code.3395;
  unsigned char D.39689;
  guint8 * code.3396;
  guint8 * code.3397;
  guint8 * code.3398;
  guint8 * code.3399;
  guint8 * code.3400;
  unsigned char D.39700;
  guint8 * code.3401;
  unsigned char D.39702;
  guint8 * code.3402;
  unsigned char D.39704;
  guint8 * code.3403;
  unsigned char D.39706;
  struct MonoBasicBlock * * D.39708;
  struct MonoBasicBlock * D.39709;
  int D.39710;
  sizetype D.39713;
  unsigned char * D.39714;
  long int D.39715;
  long int D.39716;
  unsigned int D.39717;
  unsigned int D.39718;
  unsigned int offset.3404;
  unsigned int D.39720;
  guint8 * code.3405;
  guint8 * code.3406;
  unsigned char D.39728;
  unsigned int D.39730;
  guint8 * code.3407;
  guint8 * code.3408;
  guint8 * code.3409;
  guint8 * code.3410;
  unsigned char D.39738;
  guint8 * code.3411;
  unsigned char D.39740;
  guint8 * code.3412;
  unsigned char D.39742;
  guint8 * code.3413;
  unsigned char D.39744;
  int D.39749;
  unsigned int D.39750;
  unsigned int D.39751;
  int D.39752;
  guint8 * code.3414;
  guint8 * code.3415;
  guint8 * code.3416;
  guint8 * code.3417;
  guint8 * code.3418;
  guint8 * code.3419;
  unsigned char D.39767;
  guint8 * code.3420;
  unsigned char D.39769;
  guint8 * code.3421;
  unsigned char D.39771;
  guint8 * code.3422;
  unsigned char D.39773;
  signed char iftmp.3423;
  signed char D.39778;
  guint8 * code.3424;
  unsigned char D.39782;
  guint8 * code.3425;
  guint8 * code.3426;
  guint8 * code.3427;
  unsigned char D.39790;
  guint8 * code.3428;
  guint8 * code.3429;
  guint8 * code.3430;
  unsigned char D.39799;
  guint8 * code.3431;
  guint8 * code.3432;
  unsigned char D.39802;
  guint8 * code.3433;
  unsigned char D.39804;
  guint8 * code.3434;
  unsigned char D.39806;
  guint8 * code.3435;
  unsigned char D.39808;
  guint8 * code.3436;
  unsigned char D.39813;
  guint8 * code.3437;
  guint8 * code.3438;
  guint8 * code.3439;
  unsigned char D.39817;
  guint8 * code.3440;
  unsigned char D.39819;
  guint8 * code.3441;
  unsigned char D.39821;
  guint8 * code.3442;
  unsigned char D.39823;
  struct MonoBasicBlock * * D.39824;
  struct MonoBasicBlock * D.39825;
  int D.39826;
  sizetype D.39829;
  unsigned char * D.39830;
  long int D.39831;
  long int D.39832;
  unsigned int D.39833;
  unsigned int D.39834;
  unsigned int offset.3443;
  unsigned int D.39836;
  <unnamed type> D.39839;
  int D.39840;
  guint8 * code.3444;
  <unnamed type> D.39844;
  int D.39845;
  unsigned char D.39846;
  guint8 * code.3445;
  <unnamed type> D.39849;
  int D.39850;
  unsigned char D.39851;
  unsigned char D.39852;
  unsigned int D.39854;
  guint8 * code.3446;
  <unnamed type> D.39856;
  int D.39857;
  guint8 * code.3447;
  <unnamed type> D.39861;
  int D.39862;
  unsigned char D.39863;
  unsigned char D.39864;
  guint8 * code.3448;
  <unnamed type> D.39867;
  int D.39868;
  unsigned char D.39869;
  unsigned char D.39870;
  guint8 * code.3449;
  unsigned char D.39872;
  guint8 * code.3450;
  unsigned char D.39874;
  guint8 * code.3451;
  unsigned char D.39876;
  guint8 * code.3452;
  unsigned char D.39878;
  int D.39883;
  unsigned int D.39884;
  unsigned int D.39885;
  int D.39886;
  <unnamed type> D.39889;
  int D.39890;
  guint8 * code.3453;
  <unnamed type> D.39894;
  int D.39895;
  unsigned char D.39896;
  guint8 * code.3454;
  <unnamed type> D.39899;
  int D.39900;
  unsigned char D.39901;
  guint8 * code.3455;
  <unnamed type> D.39903;
  int D.39904;
  guint8 * code.3456;
  <unnamed type> D.39908;
  int D.39909;
  unsigned char D.39910;
  unsigned char D.39911;
  guint8 * code.3457;
  <unnamed type> D.39914;
  int D.39915;
  unsigned char D.39916;
  unsigned char D.39917;
  guint8 * code.3458;
  unsigned char D.39919;
  guint8 * code.3459;
  unsigned char D.39921;
  guint8 * code.3460;
  unsigned char D.39923;
  guint8 * code.3461;
  unsigned char D.39925;
  _Bool D.39926;
  long int D.39927;
  long int D.39928;
  signed char iftmp.3462;
  signed char D.39935;
  guint8 * code.3463;
  unsigned char D.39939;
  guint8 * code.3464;
  <unnamed type> D.39941;
  int D.39942;
  guint8 * code.3465;
  <unnamed type> D.39946;
  int D.39947;
  unsigned char D.39948;
  unsigned char D.39949;
  guint8 * code.3466;
  <unnamed type> D.39952;
  int D.39953;
  unsigned char D.39954;
  unsigned char D.39955;
  guint8 * code.3467;
  signed char D.39957;
  unsigned char D.39958;
  unsigned char iftmp.3468;
  guint8 * code.3469;
  unsigned char D.39966;
  guint8 * code.3470;
  guint8 * code.3471;
  unsigned char iftmp.3472;
  guint8 * code.3473;
  unsigned char D.39976;
  guint8 * code.3474;
  guint8 * code.3475;
  long unsigned int D.39979;
  long unsigned int D.39980;
  guint8 * code.3476;
  unsigned char D.39986;
  guint8 * code.3477;
  guint8 * code.3478;
  unsigned char D.39991;
  guint8 * code.3479;
  unsigned char D.39993;
  guint8 * code.3480;
  unsigned char D.39995;
  guint8 * code.3481;
  unsigned char D.39997;
  guint8 * code.3482;
  unsigned char D.39999;
  guint8 * code.3483;
  unsigned char D.40001;
  guint8 * code.3484;
  unsigned char D.40003;
  guint8 * code.3485;
  unsigned char D.40005;
  guint8 * code.3486;
  unsigned char D.40008;
  guint8 * code.3487;
  unsigned char D.40010;
  guint8 * code.3488;
  unsigned char D.40012;
  guint8 * code.3489;
  unsigned char D.40014;
  unsigned char iftmp.3490;
  guint8 * code.3491;
  unsigned char D.40023;
  guint8 * code.3492;
  guint8 * code.3493;
  unsigned char D.40028;
  guint8 * code.3494;
  unsigned char D.40030;
  guint8 * code.3495;
  unsigned char D.40032;
  guint8 * code.3496;
  unsigned char D.40034;
  guint8 * code.3497;
  unsigned char D.40036;
  guint8 * code.3498;
  unsigned char D.40038;
  guint8 * code.3499;
  unsigned char D.40040;
  guint8 * code.3500;
  unsigned char D.40042;
  guint8 * code.3501;
  unsigned char D.40045;
  guint8 * code.3502;
  unsigned char D.40047;
  guint8 * code.3503;
  unsigned char D.40049;
  guint8 * code.3504;
  unsigned char D.40051;
  void * D.40052;
  struct MonoInst * D.40053;
  long int D.40054;
  <unnamed type> D.40055;
  int offset.3505;
  guint8 * code.3506;
  unsigned char iftmp.3507;
  guint8 * code.3508;
  unsigned char D.40067;
  guint8 * code.3509;
  guint8 * code.3510;
  guint8 * code.3511;
  guint8 * code.3512;
  unsigned char D.40074;
  guint8 * code.3513;
  unsigned char D.40076;
  guint8 * code.3514;
  unsigned char D.40078;
  guint8 * code.3515;
  unsigned char D.40080;
  guint8 * code.3516;
  guint8 * code.3517;
  guint8 * code.3518;
  guint8 * code.3519;
  guint8 * code.3520;
  guint8 * code.3521;
  guint8 * code.3522;
  unsigned char D.40097;
  guint8 * code.3523;
  unsigned char D.40099;
  guint8 * code.3524;
  unsigned char D.40101;
  guint8 * code.3525;
  unsigned char D.40103;
  guint8 * code.3526;
  unsigned char D.40107;
  guint8 * code.3527;
  unsigned char D.40111;
  guint8 * code.3528;
  unsigned char D.40114;
  guint8 * code.3529;
  unsigned char D.40116;
  guint8 * code.3530;
  unsigned char D.40118;
  guint8 * code.3531;
  unsigned char D.40120;
  guint8 * code.3532;
  unsigned char D.40122;
  unsigned char iftmp.3533;
  guint8 * code.3534;
  unsigned char D.40130;
  guint8 * code.3535;
  guint8 * code.3536;
  unsigned char D.40135;
  guint8 * code.3537;
  unsigned char D.40137;
  guint8 * code.3538;
  unsigned char D.40139;
  guint8 * code.3539;
  unsigned char D.40141;
  guint8 * code.3540;
  unsigned char D.40143;
  guint8 * code.3541;
  unsigned char D.40145;
  guint8 * code.3542;
  unsigned char D.40147;
  guint8 * code.3543;
  unsigned char D.40149;
  guint8 * code.3544;
  unsigned char D.40152;
  guint8 * code.3545;
  unsigned char D.40154;
  guint8 * code.3546;
  unsigned char D.40156;
  guint8 * code.3547;
  unsigned char D.40158;
  guint8 * code.3548;
  signed char iftmp.3549;
  signed char D.40166;
  guint8 * code.3550;
  unsigned char D.40170;
  guint8 * code.3551;
  guint8 * code.3552;
  guint8 * code.3553;
  guint8 * code.3554;
  signed char iftmp.3555;
  signed char D.40179;
  guint8 * code.3556;
  unsigned char D.40183;
  guint8 * code.3557;
  guint8 * code.3558;
  guint8 * code.3559;
  guint8 * code.3560;
  signed char iftmp.3561;
  signed char D.40194;
  guint8 * code.3562;
  unsigned char D.40198;
  guint8 * code.3563;
  guint8 * code.3564;
  guint8 * code.3565;
  unsigned int D.40202;
  unsigned char D.40205;
  unsigned char D.40206;
  _Bool D.40207;
  long int D.40208;
  long int D.40209;
  int D.40212;
  int D.40213;
  long unsigned int D.40216;
  int D.40217;
  long unsigned int D.40218;
  long unsigned int D.40219;
  guint8 * code.3566;
  signed char iftmp.3567;
  unsigned int D.40229;
  _Bool D.40230;
  signed char D.40231;
  signed char D.40232;
  guint8 * code.3568;
  unsigned char D.40236;
  guint8 * code.3569;
  guint8 * code.3570;
  guint8 * code.3571;
  int D.40242;
  int D.40243;
  signed char D.40244;
  signed char D.40245;
  unsigned char D.40246;
  guint8 * code.3572;
  unsigned char D.40248;
  guint8 * code.3573;
  unsigned char D.40250;
  guint8 * code.3574;
  unsigned char D.40252;
  guint8 * code.3575;
  unsigned char D.40254;
  unsigned int D.40256;
  guint8 * code.3576;
  signed char D.40262;
  unsigned char D.40263;
  guint8 * code.3577;
  unsigned int save_area_offset.3578;
  unsigned int D.40267;
  guint8 * code.3579;
  signed char D.40271;
  unsigned char D.40272;
  guint8 * code.3580;
  unsigned char D.40274;
  guint8 * code.3581;
  signed char D.40277;
  unsigned char D.40278;
  guint8 * code.3582;
  guint8 * code.3583;
  unsigned char D.40281;
  guint8 * code.3584;
  unsigned char D.40283;
  guint8 * code.3585;
  unsigned char D.40285;
  guint8 * code.3586;
  unsigned char D.40287;
  guint8 * code.3587;
  unsigned char D.40293;
  unsigned char D.40294;
  unsigned char D.40295;
  unsigned char D.40296;
  unsigned char D.40297;
  unsigned char D.40298;
  guint8 * code.3588;
  unsigned char D.40302;
  guint8 * code.3589;
  unsigned char D.40305;
  guint8 * code.3590;
  unsigned char D.40307;
  guint8 * code.3591;
  unsigned char D.40309;
  guint8 * code.3592;
  unsigned char D.40311;
  guint8 * code.3593;
  unsigned char D.40313;
  int D.40314;
  int D.40317;
  unsigned int D.40320;
  unsigned int D.40321;
  guint8 * code.3594;
  unsigned char D.40327;
  guint8 * code.3595;
  guint8 * code.3596;
  unsigned char D.40330;
  guint8 * code.3597;
  unsigned char D.40337;
  guint8 * code.3598;
  guint8 * code.3599;
  unsigned char D.40340;
  guint8 * code.3600;
  unsigned char D.40342;
  guint8 * code.3601;
  unsigned char D.40344;
  guint8 * code.3602;
  unsigned char D.40346;
  guint8 * code.3603;
  unsigned char D.40351;
  guint8 * code.3604;
  guint8 * code.3605;
  guint8 * code.3606;
  unsigned char D.40355;
  guint8 * code.3607;
  unsigned char D.40357;
  guint8 * code.3608;
  unsigned char D.40359;
  guint8 * code.3609;
  unsigned char D.40361;
  unsigned int D.40362;
  guint8 * code.3610;
  guint8 * code.3611;
  unsigned char D.40372;
  guint8 * code.3612;
  guint8 * code.3613;
  guint8 * code.3614;
  guint8 * code.3615;
  unsigned char D.40379;
  guint8 * code.3616;
  unsigned char D.40381;
  guint8 * code.3617;
  unsigned char D.40383;
  guint8 * code.3618;
  unsigned char D.40385;
  guint8 * code.3619;
  guint8 * code.3620;
  unsigned int i.3621;
  unsigned int D.40395;
  guint8 * code.3622;
  guint8 * code.3623;
  unsigned char D.40400;
  guint8 * code.3624;
  guint8 * code.3625;
  guint8 * code.3626;
  unsigned char D.40405;
  guint8 * code.3627;
  unsigned char D.40407;
  guint8 * code.3628;
  unsigned char D.40409;
  guint8 * code.3629;
  unsigned char D.40411;
  guint8 * code.3630;
  guint8 * code.3631;
  guint8 * code.3632;
  guint8 * code.3633;
  unsigned char D.40421;
  guint8 * code.3634;
  unsigned char D.40423;
  guint8 * code.3635;
  unsigned char D.40425;
  guint8 * code.3636;
  unsigned char D.40427;
  guint8 * code.3637;
  guint8 * code.3638;
  unsigned char D.40434;
  guint8 * code.3639;
  guint8 * code.3640;
  guint8 * code.3641;
  guint8 * code.3642;
  unsigned int D.40444;
  guint8 * code.3643;
  guint8 * code.3644;
  unsigned char D.40449;
  unsigned char D.40450;
  guint8 * code.3645;
  guint8 * code.3646;
  int D.40454;
  guint8 * code.3647;
  unsigned char D.40456;
  guint8 * code.3648;
  unsigned char D.40458;
  guint8 * code.3649;
  unsigned char D.40460;
  guint8 * code.3650;
  unsigned char D.40462;
  guint8 * code.3651;
  guint8 * code.3652;
  guint8 * code.3653;
  guint8 * code.3654;
  unsigned char D.40472;
  guint8 * code.3655;
  unsigned char D.40474;
  guint8 * code.3656;
  unsigned char D.40476;
  guint8 * code.3657;
  unsigned char D.40478;
  unsigned int D.40479;
  unsigned int i.3658;
  guint8 * code.3659;
  struct MonoMethod * D.40482;
  guint8 * code.3660;
  guint8 * code.3661;
  unsigned char D.40491;
  guint8 * code.3662;
  guint8 * code.3663;
  guint8 * code.3664;
  guint8 * code.3665;
  unsigned char D.40498;
  guint8 * code.3666;
  unsigned char D.40500;
  guint8 * code.3667;
  unsigned char D.40502;
  guint8 * code.3668;
  unsigned char D.40504;
  guint8 * code.3669;
  guint8 * code.3670;
  guint8 * code.3671;
  guint8 * code.3672;
  guint8 * code.3673;
  guint8 * code.3674;
  guint8 * code.3675;
  unsigned char D.40521;
  guint8 * code.3676;
  unsigned char D.40523;
  guint8 * code.3677;
  unsigned char D.40525;
  guint8 * code.3678;
  unsigned char D.40527;
  guint8 * code.3679;
  guint8 * code.3680;
  guint8 * code.3681;
  guint8 * code.3682;
  unsigned char D.40537;
  guint8 * code.3683;
  unsigned char D.40539;
  guint8 * code.3684;
  unsigned char D.40541;
  guint8 * code.3685;
  unsigned char D.40543;
  guint8 * code.3686;
  unsigned char D.40548;
  guint8 * code.3687;
  guint8 * code.3688;
  unsigned char D.40553;
  guint8 * code.3689;
  unsigned char D.40555;
  guint8 * code.3690;
  unsigned char D.40557;
  guint8 * code.3691;
  unsigned char D.40559;
  guint8 * code.3692;
  unsigned char D.40561;
  guint8 * code.3693;
  unsigned char D.40563;
  guint8 * code.3694;
  unsigned char D.40565;
  guint8 * code.3695;
  unsigned char D.40567;
  guint8 * code.3696;
  unsigned char D.40570;
  guint8 * code.3697;
  unsigned char D.40572;
  guint8 * code.3698;
  unsigned char D.40574;
  guint8 * code.3699;
  unsigned char D.40576;
  guint8 * code.3700;
  unsigned char D.40580;
  guint8 * code.3701;
  guint8 * code.3702;
  unsigned char D.40583;
  guint8 * code.3703;
  unsigned char D.40587;
  guint8 * code.3704;
  guint8 * code.3705;
  guint8 * code.3706;
  guint8 * code.3707;
  guint8 * code.3708;
  guint8 * code.3709;
  guint8 * code.3710;
  guint8 * code.3711;
  unsigned char D.40606;
  guint8 * code.3712;
  unsigned char D.40608;
  guint8 * code.3713;
  unsigned char D.40610;
  guint8 * code.3714;
  unsigned char D.40612;
  guint8 * code.3715;
  guint8 * code.3716;
  guint8 * code.3717;
  guint8 * code.3718;
  unsigned char D.40622;
  guint8 * code.3719;
  unsigned char D.40624;
  guint8 * code.3720;
  unsigned char D.40626;
  guint8 * code.3721;
  unsigned char D.40628;
  guint8 * code.3722;
  guint8 * code.3723;
  guint8 * code.3724;
  guint8 * code.3725;
  guint8 * code.3726;
  guint8 * code.3727;
  guint8 * code.3728;
  guint8 * code.3729;
  unsigned char D.40646;
  guint8 * code.3730;
  unsigned char D.40648;
  guint8 * code.3731;
  unsigned char D.40650;
  guint8 * code.3732;
  unsigned char D.40652;
  guint8 * code.3733;
  guint8 * code.3734;
  guint8 * code.3735;
  guint8 * code.3736;
  unsigned char D.40662;
  guint8 * code.3737;
  unsigned char D.40664;
  guint8 * code.3738;
  unsigned char D.40666;
  guint8 * code.3739;
  unsigned char D.40668;
  guint8 * code.3740;
  unsigned char D.40670;
  guint8 * code.3741;
  unsigned char D.40672;
  guint8 * code.3742;
  unsigned char D.40674;
  guint8 * code.3743;
  unsigned char D.40676;
  unsigned char iftmp.3744;
  guint8 * code.3745;
  unsigned char D.40684;
  guint8 * code.3746;
  guint8 * code.3747;
  int D.40689;
  guint8 * code.3748;
  unsigned char D.40691;
  guint8 * code.3749;
  unsigned char D.40693;
  guint8 * code.3750;
  unsigned char D.40695;
  guint8 * code.3751;
  unsigned char D.40697;
  guint8 * code.3752;
  guint8 * code.3753;
  unsigned int D.40706;
  unsigned int D.40707;
  guint8 * code.3754;
  guint8 * code.3755;
  unsigned char D.40712;
  guint8 * code.3756;
  guint8 * code.3757;
  guint8 * code.3758;
  unsigned char D.40717;
  guint8 * code.3759;
  unsigned char D.40719;
  guint8 * code.3760;
  unsigned char D.40721;
  guint8 * code.3761;
  unsigned char D.40723;
  guint8 * code.3762;
  unsigned char D.40729;
  guint8 * code.3763;
  unsigned char D.40733;
  guint8 * code.3764;
  unsigned char D.40736;
  guint8 * code.3765;
  unsigned char D.40738;
  guint8 * code.3766;
  unsigned char D.40740;
  guint8 * code.3767;
  unsigned char D.40742;
  guint8 * code.3768;
  unsigned char D.40744;
  guint8 * code.3769;
  unsigned char iftmp.3770;
  guint8 * code.3771;
  unsigned char D.40755;
  guint8 * code.3772;
  guint8 * code.3773;
  guint8 * code.3774;
  guint8 * code.3775;
  guint8 * code.3776;
  guint8 * code.3777;
  guint8 * code.3778;
  guint8 * code.3779;
  guint8 * code.3780;
  unsigned char D.40773;
  guint8 * code.3781;
  unsigned char D.40775;
  guint8 * code.3782;
  unsigned char D.40777;
  guint8 * code.3783;
  unsigned char D.40779;
  guint8 * code.3784;
  signed char D.40783;
  unsigned char D.40784;
  guint8 * code.3785;
  signed char D.40788;
  unsigned char D.40789;
  guint8 * code.3786;
  signed char D.40792;
  unsigned char D.40793;
  guint8 * code.3787;
  unsigned char D.40795;
  guint8 * code.3788;
  unsigned char D.40797;
  guint8 * code.3789;
  unsigned char D.40799;
  guint8 * code.3790;
  unsigned char D.40801;
  struct MonoMethodSignature * D.40802;
  short unsigned int D.40803;
  short unsigned int D.40804;
  guint8 * code.3791;
  unsigned char D.40810;
  guint8 * code.3792;
  guint8 * code.3793;
  unsigned char D.40814;
  unsigned char D.40815;
  struct MonoClass * D.40818;
  struct MonoImage * D.40819;
  struct MonoImage * D.40820;
  long unsigned int D.40823;
  int i.3794;
  int D.40825;
  long unsigned int D.40826;
  long unsigned int D.40827;
  guint8 * code.3795;
  unsigned char D.40835;
  guint8 * code.3796;
  guint8 * code.3797;
  long unsigned int D.40839;
  int nregs.3798;
  long unsigned int D.40841;
  _Bool D.40842;
  unsigned char iftmp.3799;
  guint8 * code.3800;
  unsigned char D.40850;
  guint8 * code.3801;
  guint8 * code.3802;
  unsigned char D.40855;
  guint8 * code.3803;
  unsigned char D.40857;
  guint8 * code.3804;
  unsigned char D.40859;
  guint8 * code.3805;
  unsigned char D.40861;
  guint8 * code.3806;
  unsigned char D.40863;
  guint8 * code.3807;
  unsigned char D.40865;
  guint8 * code.3808;
  unsigned char D.40867;
  guint8 * code.3809;
  unsigned char D.40869;
  guint8 * code.3810;
  unsigned char D.40872;
  guint8 * code.3811;
  unsigned char D.40874;
  guint8 * code.3812;
  unsigned char D.40876;
  guint8 * code.3813;
  unsigned char D.40878;
  struct MonoMethod * D.40881;
  const void * D.40883;
  unsigned int D.40884;
  unsigned char D.40887;
  unsigned char D.40888;
  int D.40891;
  int D.40896;
  guint8 * code.3814;
  unsigned char D.40902;
  guint8 * code.3815;
  guint8 * code.3816;
  unsigned char D.40905;
  guint8 * code.3817;
  unsigned char D.40911;
  guint8 * code.3818;
  guint8 * code.3819;
  unsigned char D.40914;
  guint8 * code.3820;
  unsigned char D.40916;
  guint8 * code.3821;
  unsigned char D.40918;
  guint8 * code.3822;
  unsigned char D.40920;
  guint8 * code.3823;
  unsigned char D.40925;
  guint8 * code.3824;
  guint8 * code.3825;
  guint8 * code.3826;
  unsigned char D.40929;
  guint8 * code.3827;
  unsigned char D.40931;
  guint8 * code.3828;
  unsigned char D.40933;
  guint8 * code.3829;
  unsigned char D.40935;
  int D.40936;
  int D.40937;
  guint8 * code.3830;
  unsigned char iftmp.3831;
  guint8 * code.3832;
  unsigned char D.40950;
  guint8 * code.3833;
  guint8 * code.3834;
  guint8 * code.3835;
  guint8 * code.3836;
  guint8 * code.3837;
  unsigned char D.40964;
  guint8 * code.3838;
  guint8 * code.3839;
  guint8 * code.3840;
  guint8 * code.3841;
  unsigned char D.40971;
  guint8 * code.3842;
  guint8 * code.3843;
  int i.3844;
  int D.40980;
  long unsigned int D.40981;
  long unsigned int D.40982;
  guint8 * code.3845;
  guint8 * code.3846;
  unsigned char D.40993;
  guint8 * code.3847;
  guint8 * code.3848;
  guint8 * code.3849;
  guint8 * code.3850;
  unsigned char D.41002;
  guint8 * code.3851;
  guint8 * code.3852;
  long unsigned int D.41006;
  int nregs.3853;
  long unsigned int D.41008;
  _Bool D.41009;
  unsigned char iftmp.3854;
  guint8 * code.3855;
  unsigned char D.41017;
  guint8 * code.3856;
  guint8 * code.3857;
  unsigned char D.41022;
  guint8 * code.3858;
  unsigned char D.41024;
  guint8 * code.3859;
  unsigned char D.41026;
  guint8 * code.3860;
  unsigned char D.41028;
  guint8 * code.3861;
  unsigned char D.41030;
  guint8 * code.3862;
  unsigned char D.41032;
  guint8 * code.3863;
  unsigned char D.41034;
  guint8 * code.3864;
  unsigned char D.41036;
  guint8 * code.3865;
  unsigned char D.41039;
  guint8 * code.3866;
  unsigned char D.41041;
  guint8 * code.3867;
  unsigned char D.41043;
  guint8 * code.3868;
  unsigned char D.41045;
  guint8 * code.3869;
  unsigned char D.41049;
  guint8 * code.3870;
  guint8 * code.3871;
  guint8 * code.3872;
  unsigned char D.41065;
  guint8 * code.3873;
  guint8 * code.3874;
  guint8 * code.3875;
  unsigned char D.41073;
  guint8 * code.3876;
  guint8 * code.3877;
  unsigned char D.41076;
  guint8 * code.3878;
  unsigned char D.41078;
  guint8 * code.3879;
  unsigned char D.41080;
  guint8 * code.3880;
  unsigned char D.41082;
  guint8 * code.3881;
  unsigned char D.41087;
  guint8 * code.3882;
  guint8 * code.3883;
  guint8 * code.3884;
  unsigned char D.41091;
  guint8 * code.3885;
  unsigned char D.41093;
  guint8 * code.3886;
  unsigned char D.41095;
  guint8 * code.3887;
  unsigned char D.41097;
  guint8 * code.3888;
  unsigned char D.41101;
  guint8 * code.3889;
  guint8 * code.3890;
  guint8 * code.3891;
  unsigned char D.41107;
  guint8 * code.3892;
  unsigned char D.41109;
  guint8 * code.3893;
  unsigned char D.41111;
  guint8 * code.3894;
  unsigned char D.41113;
  guint8 * code.3895;
  guint8 * code.3896;
  guint8 * code.3897;
  guint8 * code.3898;
  guint8 * code.3899;
  guint8 * code.3900;
  guint8 * code.3901;
  unsigned char D.41130;
  guint8 * code.3902;
  unsigned char D.41132;
  guint8 * code.3903;
  unsigned char D.41134;
  guint8 * code.3904;
  unsigned char D.41136;
  guint8 * code.3905;
  signed char D.41142;
  unsigned char D.41143;
  guint8 * code.3906;
  signed char D.41147;
  unsigned char D.41148;
  guint8 * code.3907;
  signed char D.41151;
  unsigned char D.41152;
  guint8 * code.3908;
  unsigned char D.41154;
  guint8 * code.3909;
  unsigned char D.41156;
  guint8 * code.3910;
  unsigned char D.41158;
  guint8 * code.3911;
  unsigned char D.41160;
  guint8 * code.3912;
  unsigned char D.41174;
  guint8 * code.3913;
  guint8 * code.3914;
  guint8 * code.3915;
  unsigned char D.41182;
  guint8 * code.3916;
  guint8 * code.3917;
  unsigned char D.41185;
  guint8 * code.3918;
  unsigned char D.41187;
  guint8 * code.3919;
  unsigned char D.41189;
  guint8 * code.3920;
  unsigned char D.41191;
  guint8 * code.3921;
  unsigned char D.41196;
  guint8 * code.3922;
  guint8 * code.3923;
  guint8 * code.3924;
  unsigned char D.41200;
  guint8 * code.3925;
  unsigned char D.41202;
  guint8 * code.3926;
  unsigned char D.41204;
  guint8 * code.3927;
  unsigned char D.41206;
  short unsigned int D.41207;
  _Bool D.41208;
  long int D.41209;
  long int D.41210;
  guint8 * code.3928;
  unsigned char iftmp.3929;
  guint8 * code.3930;
  unsigned char D.41223;
  guint8 * code.3931;
  guint8 * code.3932;
  guint8 * code.3933;
  guint8 * code.3934;
  unsigned char iftmp.3935;
  guint8 * code.3936;
  unsigned char D.41237;
  guint8 * code.3937;
  guint8 * code.3938;
  guint8 * code.3939;
  signed char D.41241;
  unsigned char D.41242;
  guint8 * code.3940;
  unsigned char iftmp.3941;
  int D.41247;
  guint8 * code.3942;
  unsigned char D.41254;
  guint8 * code.3943;
  guint8 * code.3944;
  int D.41257;
  long int D.41260;
  guint8 * code.3945;
  guint8 * code.3946;
  unsigned int D.41266;
  unsigned int D.41267;
  guint8 * code.3947;
  guint8 * code.3948;
  unsigned char D.41272;
  guint8 * code.3949;
  guint8 * code.3950;
  int D.41276;
  guint8 * code.3951;
  unsigned char D.41278;
  guint8 * code.3952;
  unsigned char D.41280;
  guint8 * code.3953;
  unsigned char D.41282;
  guint8 * code.3954;
  unsigned char D.41284;
  guint8 * code.3955;
  signed char D.41290;
  signed char D.41291;
  signed char D.41292;
  unsigned char D.41293;
  guint8 * code.3956;
  signed char D.41297;
  unsigned char D.41298;
  guint8 * code.3957;
  signed char D.41301;
  unsigned char D.41302;
  guint8 * code.3958;
  unsigned char D.41304;
  guint8 * code.3959;
  unsigned char D.41306;
  guint8 * code.3960;
  unsigned char D.41308;
  guint8 * code.3961;
  unsigned char D.41310;
  guint8 * code.3962;
  unsigned char iftmp.3963;
  <unnamed type> D.41315;
  guint8 * code.3964;
  unsigned char D.41322;
  guint8 * code.3965;
  guint8 * code.3966;
  guint8 * code.3967;
  unsigned char D.41328;
  unsigned char D.41329;
  unsigned char D.41330;
  unsigned char D.41331;
  unsigned int i.3968;
  unsigned int D.41333;
  int D.41334;
  guint8 * code.3969;
  unsigned char D.41336;
  guint8 * code.3970;
  unsigned char D.41338;
  guint8 * code.3971;
  unsigned char D.41340;
  guint8 * code.3972;
  unsigned char D.41342;
  long unsigned int D.41346;
  long unsigned int D.41347;
  guint8 * code.3973;
  unsigned char D.41351;
  guint8 * code.3974;
  guint8 * code.3975;
  unsigned char D.41359;
  guint8 * code.3976;
  unsigned char D.41361;
  unsigned char D.41362;
  guint8 * code.3977;
  unsigned char D.41364;
  guint8 * code.3978;
  guint8 * code.3979;
  unsigned char D.41367;
  guint8 * code.3980;
  unsigned char D.41369;
  guint8 * code.3981;
  unsigned char D.41371;
  guint8 * code.3982;
  unsigned char D.41373;
  guint8 * code.3983;
  unsigned char D.41377;
  guint8 * code.3984;
  unsigned char D.41383;
  guint8 * code.3985;
  unsigned char D.41385;
  guint8 * code.3986;
  unsigned char D.41387;
  guint8 * code.3987;
  unsigned char D.41389;
  guint8 * code.3988;
  unsigned char D.41391;
  guint8 * code.3989;
  unsigned char D.41393;
  guint8 * code.3990;
  unsigned char D.41397;
  guint8 * code.3991;
  guint8 * code.3992;
  guint8 * code.3993;
  unsigned char iftmp.3994;
  guint8 * code.3995;
  unsigned char D.41410;
  guint8 * code.3996;
  guint8 * code.3997;
  guint8 * code.3998;
  guint8 * code.3999;
  unsigned char D.41417;
  guint8 * code.4000;
  unsigned char D.41419;
  guint8 * code.4001;
  unsigned char D.41421;
  guint8 * code.4002;
  unsigned char D.41423;
  guint8 * code.4003;
  guint8 * code.4004;
  guint8 * code.4005;
  guint8 * code.4006;
  guint8 * code.4007;
  guint8 * code.4008;
  guint8 * code.4009;
  unsigned char D.41440;
  guint8 * code.4010;
  unsigned char D.41442;
  guint8 * code.4011;
  unsigned char D.41444;
  guint8 * code.4012;
  unsigned char D.41446;
  guint8 * code.4013;
  guint8 * code.4014;
  guint8 * code.4015;
  guint8 * code.4016;
  unsigned char D.41458;
  guint8 * code.4017;
  unsigned char D.41460;
  guint8 * code.4018;
  unsigned char D.41462;
  guint8 * code.4019;
  unsigned char D.41464;
  guint8 * code.4020;
  guint8 * code.4021;
  unsigned char D.41471;
  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;
  unsigned char D.41489;
  guint8 * code.4031;
  unsigned char D.41491;
  guint8 * code.4032;
  unsigned char D.41493;
  guint8 * code.4033;
  unsigned char D.41495;
  guint8 * code.4034;
  guint8 * code.4035;
  guint8 * code.4036;
  guint8 * code.4037;
  unsigned char D.41505;
  guint8 * code.4038;
  unsigned char D.41507;
  guint8 * code.4039;
  unsigned char D.41509;
  guint8 * code.4040;
  unsigned char D.41511;
  guint8 * code.4041;
  unsigned char iftmp.4042;
  int D.41516;
  guint8 * code.4043;
  unsigned char D.41523;
  guint8 * code.4044;
  guint8 * code.4045;
  int D.41526;
  long int D.41529;
  guint8 * code.4046;
  guint8 * code.4047;
  unsigned int D.41537;
  unsigned int D.41538;
  int D.41539;
  guint8 * code.4048;
  guint8 * code.4049;
  unsigned char D.41544;
  unsigned char D.41545;
  guint8 * code.4050;
  guint8 * code.4051;
  guint8 * code.4052;
  unsigned char D.41549;
  guint8 * code.4053;
  unsigned char D.41551;
  guint8 * code.4054;
  unsigned char D.41553;
  guint8 * code.4055;
  unsigned char D.41555;
  guint8 * code.4056;
  signed char D.41561;
  signed char D.41562;
  signed char D.41563;
  unsigned char D.41564;
  guint8 * code.4057;
  signed char D.41570;
  unsigned char D.41571;
  guint8 * code.4058;
  signed char D.41573;
  unsigned char D.41574;
  guint8 * code.4059;
  unsigned char D.41576;
  guint8 * code.4060;
  unsigned char D.41578;
  guint8 * code.4061;
  unsigned char D.41580;
  guint8 * code.4062;
  unsigned char D.41582;
  _Bool D.41583;
  long int D.41584;
  long int D.41585;
  guint8 * code.4063;
  unsigned char D.41591;
  guint8 * code.4064;
  unsigned char D.41593;
  guint8 * code.4065;
  unsigned char D.41601;
  unsigned int _imm.4066;
  unsigned int D.41603;
  guint8 * code.4067;
  unsigned char D.41607;
  guint8 * code.4068;
  guint8 * code.4069;
  unsigned char D.41611;
  guint8 * code.4070;
  unsigned char D.41613;
  guint8 * code.4071;
  unsigned char D.41615;
  guint8 * code.4072;
  unsigned char D.41617;
  guint8 * code.4073;
  unsigned char D.41623;
  guint8 * code.4074;
  guint8 * code.4075;
  guint8 * code.4076;
  guint8 * code.4077;
  guint8 * code.4078;
  guint8 * code.4079;
  guint8 * code.4080;
  guint8 * code.4081;
  unsigned char D.41640;
  guint8 * code.4082;
  unsigned char D.41642;
  guint8 * code.4083;
  unsigned char D.41644;
  guint8 * code.4084;
  unsigned char D.41646;
  guint8 * code.4085;
  guint8 * code.4086;
  guint8 * code.4087;
  guint8 * code.4088;
  unsigned char D.41658;
  guint8 * code.4089;
  unsigned char D.41660;
  guint8 * code.4090;
  unsigned char D.41662;
  guint8 * code.4091;
  unsigned char D.41664;
  unsigned int D.41665;
  unsigned int D.41666;
  int D.41667;
  unsigned int size.4092;
  unsigned int D.41671;
  guint8 * code.4093;
  unsigned char D.41677;
  guint8 * code.4094;
  guint8 * code.4095;
  unsigned char D.41680;
  guint8 * code.4096;
  unsigned char D.41687;
  guint8 * code.4097;
  guint8 * code.4098;
  unsigned char D.41690;
  guint8 * code.4099;
  unsigned char D.41692;
  guint8 * code.4100;
  unsigned char D.41694;
  guint8 * code.4101;
  unsigned char D.41696;
  guint8 * code.4102;
  unsigned char D.41701;
  guint8 * code.4103;
  guint8 * code.4104;
  guint8 * code.4105;
  unsigned char D.41705;
  guint8 * code.4106;
  unsigned char D.41707;
  guint8 * code.4107;
  unsigned char D.41709;
  guint8 * code.4108;
  unsigned char D.41711;
  guint8 * code.4109;
  unsigned char D.41715;
  guint8 * code.4110;
  guint8 * code.4111;
  unsigned char D.41720;
  guint8 * code.4112;
  guint8 * code.4113;
  unsigned char D.41725;
  guint8 * code.4114;
  unsigned char iftmp.4115;
  guint8 * code.4116;
  unsigned char D.41736;
  guint8 * code.4117;
  guint8 * code.4118;
  guint8 * code.4119;
  unsigned char D.41742;
  guint8 * code.4120;
  unsigned char D.41744;
  guint8 * code.4121;
  unsigned char D.41746;
  guint8 * code.4122;
  unsigned char D.41748;
  guint8 * code.4123;
  guint8 * code.4124;
  guint8 * code.4125;
  guint8 * code.4126;
  guint8 * code.4127;
  guint8 * code.4128;
  guint8 * code.4129;
  unsigned char D.41765;
  guint8 * code.4130;
  unsigned char D.41767;
  guint8 * code.4131;
  unsigned char D.41769;
  guint8 * code.4132;
  unsigned char D.41771;
  guint8 * code.4133;
  guint8 * code.4134;
  guint8 * code.4135;
  guint8 * code.4136;
  unsigned char D.41783;
  guint8 * code.4137;
  unsigned char D.41785;
  guint8 * code.4138;
  unsigned char D.41787;
  guint8 * code.4139;
  unsigned char D.41789;
  guint8 * code.4140;
  unsigned char iftmp.4141;
  guint8 * code.4142;
  unsigned char D.41801;
  guint8 * code.4143;
  guint8 * code.4144;
  guint8 * code.4145;
  guint8 * code.4146;
  unsigned char D.41808;
  guint8 * code.4147;
  guint8 * code.4148;
  guint8 * code.4149;
  unsigned char D.41814;
  guint8 * code.4150;
  unsigned char D.41816;
  guint8 * code.4151;
  unsigned char D.41818;
  guint8 * code.4152;
  unsigned char D.41820;
  guint8 * code.4153;
  guint8 * code.4154;
  guint8 * code.4155;
  guint8 * code.4156;
  guint8 * code.4157;
  guint8 * code.4158;
  guint8 * code.4159;
  unsigned char D.41837;
  guint8 * code.4160;
  unsigned char D.41839;
  guint8 * code.4161;
  unsigned char D.41841;
  guint8 * code.4162;
  unsigned char D.41843;
  guint8 * code.4163;
  guint8 * code.4164;
  guint8 * code.4165;
  guint8 * code.4166;
  unsigned char D.41853;
  guint8 * code.4167;
  unsigned char D.41855;
  guint8 * code.4168;
  unsigned char D.41857;
  guint8 * code.4169;
  unsigned char D.41859;
  unsigned char iftmp.4170;
  guint8 * code.4171;
  unsigned char D.41867;
  guint8 * code.4172;
  int D.41871;
  long unsigned int D.41872;
  guint8 * code.4173;
  unsigned char D.41874;
  guint8 * code.4174;
  unsigned char D.41876;
  guint8 * code.4175;
  unsigned char D.41878;
  guint8 * code.4176;
  unsigned char D.41880;
  guint8 * code.4177;
  unsigned char D.41882;
  guint8 * code.4178;
  unsigned char D.41884;
  guint8 * code.4179;
  unsigned char D.41886;
  guint8 * code.4180;
  unsigned char D.41888;
  guint8 * code.4181;
  unsigned char D.41891;
  guint8 * code.4182;
  unsigned char D.41893;
  guint8 * code.4183;
  unsigned char D.41895;
  guint8 * code.4184;
  unsigned char D.41897;
  guint8 * code.4185;
  unsigned char D.41901;
  guint8 * code.4186;
  guint8 * code.4187;
  guint8 * code.4188;
  unsigned char D.41907;
  guint8 * code.4189;
  guint8 * code.4190;
  unsigned char D.41912;
  guint8 * code.4191;
  guint8 * code.4192;
  unsigned char D.41917;
  guint8 * code.4193;
  guint8 * code.4194;
  unsigned char D.41922;
  guint8 * code.4195;
  signed char iftmp.4196;
  signed char iftmp.4197;
  signed char D.41932;
  signed char D.41933;
  guint8 * code.4198;
  unsigned char D.41937;
  guint8 * code.4199;
  guint8 * code.4200;
  guint8 * code.4201;
  int D.41943;
  int D.41944;
  signed char D.41945;
  signed char D.41946;
  signed char D.41947;
  unsigned char D.41948;
  guint8 * code.4202;
  unsigned char D.41950;
  guint8 * code.4203;
  unsigned char D.41952;
  guint8 * code.4204;
  unsigned char D.41954;
  guint8 * code.4205;
  unsigned char D.41956;
  guint8 * code.4206;
  guint8 * code.4207;
  signed char D.41964;
  unsigned char D.41965;
  guint8 * code.4208;
  guint8 * code.4209;
  guint8 * code.4210;
  guint8 * code.4211;
  guint8 * code.4212;
  unsigned char D.41974;
  guint8 * code.4213;
  unsigned char D.41976;
  guint8 * code.4214;
  unsigned char D.41978;
  guint8 * code.4215;
  unsigned char D.41980;
  signed char iftmp.4216;
  signed char D.41985;
  guint8 * code.4217;
  unsigned char D.41989;
  guint8 * code.4218;
  guint8 * code.4219;
  guint8 * code.4220;
  unsigned char D.41995;
  guint8 * code.4221;
  unsigned char D.41997;
  guint8 * code.4222;
  unsigned char D.41999;
  guint8 * code.4223;
  unsigned char D.42001;
  guint8 * code.4224;
  guint8 * code.4225;
  guint8 * code.4226;
  guint8 * code.4227;
  guint8 * code.4228;
  guint8 * code.4229;
  guint8 * code.4230;
  unsigned char D.42018;
  guint8 * code.4231;
  unsigned char D.42020;
  guint8 * code.4232;
  unsigned char D.42022;
  guint8 * code.4233;
  unsigned char D.42024;
  guint8 * code.4234;
  guint8 * code.4235;
  guint8 * code.4236;
  guint8 * code.4237;
  unsigned char D.42036;
  guint8 * code.4238;
  unsigned char D.42038;
  guint8 * code.4239;
  unsigned char D.42040;
  guint8 * code.4240;
  unsigned char D.42042;
  signed char iftmp.4241;
  signed char D.42047;
  guint8 * code.4242;
  unsigned char D.42051;
  guint8 * code.4243;
  guint8 * code.4244;
  guint8 * code.4245;
  signed char D.42058;
  signed char D.42059;
  unsigned char D.42060;
  unsigned char iftmp.4246;
  guint8 * code.4247;
  unsigned char D.42070;
  guint8 * code.4248;
  guint8 * code.4249;
  guint8 * code.4250;
  unsigned char D.42079;
  guint8 * code.4251;
  guint8 * code.4252;
  unsigned char D.42082;
  guint8 * code.4253;
  unsigned char D.42084;
  guint8 * code.4254;
  unsigned char D.42086;
  guint8 * code.4255;
  unsigned char D.42088;
  unsigned char iftmp.4256;
  guint8 * code.4257;
  unsigned char D.42097;
  guint8 * code.4258;
  guint8 * code.4259;
  guint8 * code.4260;
  unsigned char D.42101;
  guint8 * code.4261;
  unsigned char D.42103;
  guint8 * code.4262;
  unsigned char D.42105;
  guint8 * code.4263;
  unsigned char D.42107;
  unsigned char iftmp.4264;
  guint8 * code.4265;
  unsigned char D.42117;
  guint8 * code.4266;
  guint8 * code.4267;
  guint8 * code.4268;
  unsigned char D.42126;
  guint8 * code.4269;
  guint8 * code.4270;
  unsigned char D.42129;
  guint8 * code.4271;
  unsigned char D.42131;
  guint8 * code.4272;
  unsigned char D.42133;
  guint8 * code.4273;
  unsigned char D.42135;
  unsigned char iftmp.4274;
  guint8 * code.4275;
  unsigned char D.42144;
  guint8 * code.4276;
  guint8 * code.4277;
  guint8 * code.4278;
  unsigned char D.42148;
  guint8 * code.4279;
  unsigned char D.42150;
  guint8 * code.4280;
  unsigned char D.42152;
  guint8 * code.4281;
  unsigned char D.42154;
  guint8 * code.4282;
  unsigned char iftmp.4283;
  guint8 * code.4284;
  unsigned char D.42165;
  guint8 * code.4285;
  guint8 * code.4286;
  guint8 * code.4287;
  signed char D.42169;
  unsigned char D.42170;
  unsigned int D.42171;
  int D.42178;
  unsigned char iftmp.4288;
  guint8 * code.4289;
  unsigned char D.42188;
  guint8 * code.4290;
  guint8 * code.4291;
  unsigned char D.42191;
  guint8 * code.4292;
  unsigned char D.42197;
  guint8 * code.4293;
  guint8 * code.4294;
  unsigned char D.42200;
  guint8 * code.4295;
  unsigned char D.42202;
  guint8 * code.4296;
  unsigned char D.42204;
  guint8 * code.4297;
  unsigned char D.42206;
  unsigned char iftmp.4298;
  guint8 * code.4299;
  unsigned char D.42215;
  guint8 * code.4300;
  guint8 * code.4301;
  guint8 * code.4302;
  unsigned char D.42219;
  guint8 * code.4303;
  unsigned char D.42221;
  guint8 * code.4304;
  unsigned char D.42223;
  guint8 * code.4305;
  unsigned char D.42225;
  unsigned int D.42226;
  int size.4306;
  _Bool D.42232;
  _Bool D.42233;
  _Bool D.42234;
  guint8 * code.4307;
  unsigned char D.42240;
  guint8 * code.4308;
  guint8 * code.4309;
  unsigned char D.42243;
  guint8 * code.4310;
  unsigned char D.42250;
  guint8 * code.4311;
  guint8 * code.4312;
  unsigned char D.42253;
  guint8 * code.4313;
  unsigned char D.42255;
  guint8 * code.4314;
  unsigned char D.42257;
  guint8 * code.4315;
  unsigned char D.42259;
  guint8 * code.4316;
  unsigned char D.42264;
  guint8 * code.4317;
  guint8 * code.4318;
  guint8 * code.4319;
  unsigned char D.42268;
  guint8 * code.4320;
  unsigned char D.42270;
  guint8 * code.4321;
  unsigned char D.42272;
  guint8 * code.4322;
  unsigned char D.42274;
  signed char iftmp.4323;
  signed char D.42279;
  guint8 * code.4324;
  unsigned char D.42283;
  guint8 * code.4325;
  guint8 * code.4326;
  guint8 * code.4327;
  unsigned char iftmp.4328;
  guint8 * code.4329;
  unsigned char D.42296;
  guint8 * code.4330;
  guint8 * code.4331;
  guint8 * code.4332;
  guint8 * code.4333;
  unsigned int i.4334;
  unsigned int D.42307;
  guint8 * code.4335;
  guint8 * code.4336;
  unsigned char D.42312;
  guint8 * code.4337;
  guint8 * code.4338;
  guint8 * code.4339;
  unsigned char D.42317;
  guint8 * code.4340;
  unsigned char D.42319;
  guint8 * code.4341;
  unsigned char D.42321;
  guint8 * code.4342;
  unsigned char D.42323;
  guint8 * code.4343;
  guint8 * code.4344;
  guint8 * code.4345;
  guint8 * code.4346;
  unsigned char D.42333;
  guint8 * code.4347;
  unsigned char D.42335;
  guint8 * code.4348;
  unsigned char D.42337;
  guint8 * code.4349;
  unsigned char D.42339;
  unsigned int i.4350;
  guint8 * code.4351;
  unsigned char iftmp.4352;
  guint8 * code.4353;
  unsigned char D.42351;
  guint8 * code.4354;
  guint8 * code.4355;
  guint8 * code.4356;
  long unsigned int D.42356;
  long unsigned int D.42357;
  _Bool D.42358;
  signed char iftmp.4357;
  signed char D.42363;
  guint8 * code.4358;
  unsigned char D.42367;
  guint8 * code.4359;
  guint8 * code.4360;
  unsigned char D.42372;
  guint8 * code.4361;
  unsigned char D.42374;
  guint8 * code.4362;
  unsigned char D.42376;
  guint8 * code.4363;
  unsigned char D.42378;
  guint8 * code.4364;
  unsigned char D.42380;
  guint8 * code.4365;
  unsigned char D.42382;
  guint8 * code.4366;
  unsigned char D.42384;
  guint8 * code.4367;
  unsigned char D.42386;
  guint8 * code.4368;
  unsigned char D.42389;
  guint8 * code.4369;
  unsigned char D.42391;
  guint8 * code.4370;
  unsigned char D.42393;
  guint8 * code.4371;
  unsigned char D.42395;
  guint8 * code.4372;
  unsigned char iftmp.4373;
  guint8 * code.4374;
  unsigned char D.42406;
  guint8 * code.4375;
  guint8 * code.4376;
  guint8 * code.4377;
  guint8 * code.4378;
  unsigned char D.42416;
  guint8 * code.4379;
  guint8 * code.4380;
  guint8 * code.4381;
  unsigned char D.42425;
  guint8 * code.4382;
  guint8 * code.4383;
  unsigned char D.42428;
  guint8 * code.4384;
  unsigned char D.42430;
  guint8 * code.4385;
  unsigned char D.42432;
  guint8 * code.4386;
  unsigned char D.42434;
  guint8 * code.4387;
  unsigned char D.42439;
  guint8 * code.4388;
  guint8 * code.4389;
  guint8 * code.4390;
  unsigned char D.42443;
  guint8 * code.4391;
  unsigned char D.42445;
  guint8 * code.4392;
  unsigned char D.42447;
  guint8 * code.4393;
  unsigned char D.42449;
  guint8 * code.4394;
  unsigned char iftmp.4395;
  guint8 * code.4396;
  unsigned char D.42460;
  guint8 * code.4397;
  guint8 * code.4398;
  guint8 * code.4399;
  unsigned char iftmp.4400;
  guint8 * code.4401;
  unsigned char D.42479;
  guint8 * code.4402;
  guint8 * code.4403;
  guint8 * code.4404;
  unsigned char D.42487;
  guint8 * code.4405;
  guint8 * code.4406;
  unsigned char D.42490;
  guint8 * code.4407;
  unsigned char D.42492;
  guint8 * code.4408;
  unsigned char D.42494;
  guint8 * code.4409;
  unsigned char D.42496;
  unsigned char iftmp.4410;
  guint8 * code.4411;
  unsigned char D.42505;
  guint8 * code.4412;
  guint8 * code.4413;
  guint8 * code.4414;
  unsigned char D.42509;
  guint8 * code.4415;
  unsigned char D.42511;
  guint8 * code.4416;
  unsigned char D.42513;
  guint8 * code.4417;
  unsigned char D.42515;
  guint8 * code.4418;
  unsigned char iftmp.4419;
  guint8 * code.4420;
  unsigned char D.42526;
  guint8 * code.4421;
  guint8 * code.4422;
  guint8 * code.4423;
  guint8 * code.4424;
  unsigned char iftmp.4425;
  guint8 * code.4426;
  unsigned char D.42540;
  guint8 * code.4427;
  guint8 * code.4428;
  guint8 * code.4429;
  guint8 * code.4430;
  unsigned char D.42549;
  guint8 * code.4431;
  guint8 * code.4432;
  guint8 * code.4433;
  unsigned char D.42558;
  guint8 * code.4434;
  guint8 * code.4435;
  unsigned char D.42561;
  guint8 * code.4436;
  unsigned char D.42563;
  guint8 * code.4437;
  unsigned char D.42565;
  guint8 * code.4438;
  unsigned char D.42567;
  guint8 * code.4439;
  unsigned char D.42572;
  guint8 * code.4440;
  guint8 * code.4441;
  guint8 * code.4442;
  unsigned char D.42576;
  guint8 * code.4443;
  unsigned char D.42578;
  guint8 * code.4444;
  unsigned char D.42580;
  guint8 * code.4445;
  unsigned char D.42582;
  struct MonoBasicBlock * D.42583;
  guint8 * code.4446;
  guint8 * code.4447;
  unsigned char D.42586;
  guint8 * code.4448;
  unsigned char D.42588;
  guint8 * code.4449;
  unsigned char D.42590;
  guint8 * code.4450;
  unsigned char D.42592;
  struct MonoExceptionClause * D.42593;
  guint8 * code.4451;
  unsigned char D.42599;
  guint8 * code.4452;
  guint8 * code.4453;
  guint8 * code.4454;
  unsigned char D.42608;
  guint8 * code.4455;
  guint8 * code.4456;
  unsigned char D.42611;
  guint8 * code.4457;
  unsigned char D.42613;
  guint8 * code.4458;
  unsigned char D.42615;
  guint8 * code.4459;
  unsigned char D.42617;
  guint8 * code.4460;
  unsigned char D.42622;
  guint8 * code.4461;
  guint8 * code.4462;
  guint8 * code.4463;
  unsigned char D.42626;
  guint8 * code.4464;
  unsigned char D.42628;
  guint8 * code.4465;
  unsigned char D.42630;
  guint8 * code.4466;
  unsigned char D.42632;
  unsigned int D.42633;
  int D.42634;
  guint8 * code.4467;
  unsigned char iftmp.4468;
  int D.42639;
  guint8 * code.4469;
  unsigned char D.42646;
  guint8 * code.4470;
  guint8 * code.4471;
  int D.42649;
  long int D.42652;
  guint8 * code.4472;
  guint8 * code.4473;
  unsigned int D.42658;
  unsigned int D.42659;
  guint8 * code.4474;
  guint8 * code.4475;
  unsigned char D.42664;
  guint8 * code.4476;
  guint8 * code.4477;
  int D.42668;
  guint8 * code.4478;
  unsigned char D.42670;
  guint8 * code.4479;
  unsigned char D.42672;
  guint8 * code.4480;
  unsigned char D.42674;
  guint8 * code.4481;
  unsigned char D.42676;
  guint8 * code.4482;
  signed char D.42682;
  signed char D.42683;
  signed char D.42684;
  unsigned char D.42685;
  guint8 * code.4483;
  signed char D.42689;
  unsigned char D.42690;
  guint8 * code.4484;
  signed char D.42693;
  unsigned char D.42694;
  guint8 * code.4485;
  unsigned char D.42696;
  guint8 * code.4486;
  unsigned char D.42698;
  guint8 * code.4487;
  unsigned char D.42700;
  guint8 * code.4488;
  unsigned char D.42702;
  unsigned int D.42703;
  unsigned int D.42710;
  unsigned int D.42711;
  unsigned int D.42712;
  guint8 * code.4489;
  unsigned char D.42718;
  guint8 * code.4490;
  guint8 * code.4491;
  unsigned char D.42721;
  unsigned char D.42722;
  guint8 * code.4492;
  unsigned char D.42729;
  guint8 * code.4493;
  int D.42731;
  int D.42732;
  guint8 * code.4494;
  unsigned char D.42734;
  guint8 * code.4495;
  unsigned char D.42736;
  guint8 * code.4496;
  unsigned char D.42738;
  guint8 * code.4497;
  unsigned char D.42740;
  guint8 * code.4498;
  unsigned char D.42745;
  guint8 * code.4499;
  guint8 * code.4500;
  guint8 * code.4501;
  unsigned char D.42749;
  guint8 * code.4502;
  unsigned char D.42751;
  guint8 * code.4503;
  unsigned char D.42753;
  guint8 * code.4504;
  unsigned char D.42755;
  guint8 * code.4505;
  unsigned char iftmp.4506;
  int D.42760;
  guint8 * code.4507;
  unsigned char D.42767;
  guint8 * code.4508;
  guint8 * code.4509;
  guint8 * code.4510;
  long int D.42773;
  int D.42774;
  guint8 * code.4511;
  unsigned char D.42776;
  guint8 * code.4512;
  unsigned char D.42778;
  guint8 * code.4513;
  unsigned char D.42780;
  guint8 * code.4514;
  unsigned char D.42782;
  int D.42784;
  guint8 * code.4515;
  guint8 * code.4516;
  unsigned int D.42792;
  unsigned int D.42793;
  guint8 * code.4517;
  guint8 * code.4518;
  unsigned char D.42798;
  guint8 * code.4519;
  guint8 * code.4520;
  guint8 * code.4521;
  unsigned char D.42803;
  guint8 * code.4522;
  unsigned char D.42805;
  guint8 * code.4523;
  unsigned char D.42807;
  guint8 * code.4524;
  unsigned char D.42809;
  guint8 * code.4525;
  signed char D.42815;
  signed char D.42816;
  signed char D.42817;
  unsigned char D.42818;
  guint8 * code.4526;
  signed char D.42822;
  unsigned char D.42823;
  guint8 * code.4527;
  signed char D.42826;
  unsigned char D.42827;
  guint8 * code.4528;
  unsigned char D.42829;
  guint8 * code.4529;
  unsigned char D.42831;
  guint8 * code.4530;
  unsigned char D.42833;
  guint8 * code.4531;
  unsigned char D.42835;
  guint8 * code.4532;
  guint8 * code.4533;
  unsigned char iftmp.4534;
  int D.42841;
  guint8 * code.4535;
  unsigned char D.42848;
  guint8 * code.4536;
  guint8 * code.4537;
  guint8 * code.4538;
  long int D.42854;
  int D.42855;
  guint8 * code.4539;
  unsigned char D.42857;
  guint8 * code.4540;
  unsigned char D.42859;
  guint8 * code.4541;
  unsigned char D.42861;
  guint8 * code.4542;
  unsigned char D.42863;
  int D.42865;
  guint8 * code.4543;
  guint8 * code.4544;
  unsigned int D.42873;
  unsigned int D.42874;
  guint8 * code.4545;
  guint8 * code.4546;
  unsigned char D.42879;
  guint8 * code.4547;
  guint8 * code.4548;
  guint8 * code.4549;
  unsigned char D.42884;
  guint8 * code.4550;
  unsigned char D.42886;
  guint8 * code.4551;
  unsigned char D.42888;
  guint8 * code.4552;
  unsigned char D.42890;
  guint8 * code.4553;
  signed char D.42896;
  signed char D.42897;
  signed char D.42898;
  unsigned char D.42899;
  guint8 * code.4554;
  signed char D.42903;
  unsigned char D.42904;
  guint8 * code.4555;
  signed char D.42907;
  unsigned char D.42908;
  guint8 * code.4556;
  unsigned char D.42910;
  guint8 * code.4557;
  unsigned char D.42912;
  guint8 * code.4558;
  unsigned char D.42914;
  guint8 * code.4559;
  unsigned char D.42916;
  guint8 * code.4560;
  int D.42918;
  sizetype D.42921;
  unsigned char * D.42922;
  long int D.42923;
  long int D.42924;
  unsigned long D.42925;
  unsigned long D.42926;
  unsigned int D.42929;
  unsigned int D.42930;
  unsigned int t.4561;
  unsigned int D.42932;
  guint8 * code.4562;
  unsigned char D.42936;
  unsigned int D.42938;
  guint8 * code.4563;
  guint8 * code.4564;
  unsigned char D.42941;
  guint8 * code.4565;
  unsigned char D.42943;
  guint8 * code.4566;
  unsigned char D.42945;
  guint8 * code.4567;
  unsigned char D.42947;
  guint8 * code.4568;
  unsigned char D.42952;
  guint8 * code.4569;
  guint8 * code.4570;
  guint8 * code.4571;
  unsigned char D.42958;
  guint8 * code.4572;
  unsigned char D.42960;
  guint8 * code.4573;
  unsigned char D.42962;
  guint8 * code.4574;
  unsigned char D.42964;
  guint8 * code.4575;
  guint8 * code.4576;
  guint8 * code.4577;
  guint8 * code.4578;
  guint8 * code.4579;
  guint8 * code.4580;
  guint8 * code.4581;
  unsigned char D.42981;
  guint8 * code.4582;
  unsigned char D.42983;
  guint8 * code.4583;
  unsigned char D.42985;
  guint8 * code.4584;
  unsigned char D.42987;
  guint8 * code.4585;
  guint8 * code.4586;
  guint8 * code.4587;
  guint8 * code.4588;
  unsigned char D.42997;
  guint8 * code.4589;
  unsigned char D.42999;
  guint8 * code.4590;
  unsigned char D.43001;
  guint8 * code.4591;
  unsigned char D.43003;
  long unsigned int D.43004;
  int D.43009;
  unsigned int D.43010;
  unsigned int D.43011;
  int D.43012;
  guint8 * code.4592;
  guint8 * code.4593;
  guint8 * code.4594;
  unsigned char D.43018;
  guint8 * code.4595;
  unsigned char D.43020;
  guint8 * code.4596;
  unsigned char D.43022;
  guint8 * code.4597;
  unsigned char D.43024;
  guint8 * code.4598;
  unsigned char D.43028;
  guint8 * code.4599;
  guint8 * code.4600;
  guint8 * code.4601;
  unsigned char D.43034;
  guint8 * code.4602;
  <unnamed type> D.43038;
  int D.43039;
  guint8 * code.4603;
  <unnamed type> D.43043;
  int D.43044;
  unsigned char D.43045;
  unsigned char D.43046;
  guint8 * code.4604;
  <unnamed type> D.43049;
  int D.43050;
  unsigned char D.43051;
  unsigned char D.43052;
  guint8 * code.4605;
  signed char iftmp.4606;
  signed char D.43058;
  guint8 * code.4607;
  unsigned char D.43062;
  guint8 * code.4608;
  guint8 * code.4609;
  guint8 * code.4610;
  void * D.43072;
  guint8 * code.4611;
  <unnamed type> D.43076;
  int D.43077;
  guint8 * code.4612;
  <unnamed type> D.43081;
  int D.43082;
  unsigned char D.43083;
  unsigned char D.43084;
  guint8 * code.4613;
  <unnamed type> D.43087;
  int D.43088;
  unsigned char D.43089;
  unsigned char D.43090;
  guint8 * code.4614;
  unsigned char D.43092;
  guint8 * code.4615;
  unsigned char D.43094;
  guint8 * code.4616;
  unsigned char D.43096;
  guint8 * code.4617;
  unsigned char D.43098;
  struct MonoBasicBlock * * D.43100;
  struct MonoBasicBlock * D.43101;
  int D.43102;
  sizetype D.43105;
  unsigned char * D.43106;
  long int D.43107;
  long int D.43108;
  unsigned int D.43109;
  unsigned int D.43110;
  unsigned int offset.4618;
  unsigned int D.43112;
  <unnamed type> D.43115;
  int D.43116;
  guint8 * code.4619;
  <unnamed type> D.43120;
  int D.43121;
  unsigned char D.43122;
  guint8 * code.4620;
  <unnamed type> D.43125;
  int D.43126;
  unsigned char D.43127;
  unsigned char D.43128;
  unsigned int D.43130;
  guint8 * code.4621;
  <unnamed type> D.43132;
  int D.43133;
  guint8 * code.4622;
  <unnamed type> D.43137;
  int D.43138;
  unsigned char D.43139;
  unsigned char D.43140;
  guint8 * code.4623;
  <unnamed type> D.43143;
  int D.43144;
  unsigned char D.43145;
  unsigned char D.43146;
  guint8 * code.4624;
  unsigned char D.43148;
  guint8 * code.4625;
  unsigned char D.43150;
  guint8 * code.4626;
  unsigned char D.43152;
  guint8 * code.4627;
  unsigned char D.43154;
  int D.43159;
  unsigned int D.43160;
  unsigned int D.43161;
  int D.43162;
  <unnamed type> D.43165;
  int D.43166;
  guint8 * code.4628;
  <unnamed type> D.43170;
  int D.43171;
  unsigned char D.43172;
  guint8 * code.4629;
  <unnamed type> D.43175;
  int D.43176;
  unsigned char D.43177;
  guint8 * code.4630;
  <unnamed type> D.43179;
  int D.43180;
  guint8 * code.4631;
  <unnamed type> D.43184;
  int D.43185;
  unsigned char D.43186;
  unsigned char D.43187;
  guint8 * code.4632;
  <unnamed type> D.43190;
  int D.43191;
  unsigned char D.43192;
  unsigned char D.43193;
  guint8 * code.4633;
  unsigned char D.43195;
  guint8 * code.4634;
  unsigned char D.43197;
  guint8 * code.4635;
  unsigned char D.43199;
  guint8 * code.4636;
  unsigned char D.43201;
  guint8 * code.4637;
  guint8 * code.4638;
  int D.43208;
  int D.43209;
  unsigned char D.43210;
  unsigned char D.43211;
  guint8 * code.4639;
  unsigned char D.43214;
  unsigned char D.43215;
  guint8 * code.4640;
  unsigned char D.43217;
  guint8 * code.4641;
  unsigned char D.43219;
  guint8 * code.4642;
  unsigned char D.43221;
  guint8 * code.4643;
  unsigned char D.43223;
  struct MonoBasicBlock * * D.43225;
  struct MonoBasicBlock * D.43226;
  int D.43227;
  sizetype D.43230;
  unsigned char * D.43231;
  long int D.43232;
  long int D.43233;
  unsigned int D.43234;
  unsigned int D.43235;
  unsigned int offset.4644;
  unsigned int D.43237;
  guint8 * code.4645;
  guint8 * code.4646;
  unsigned char D.43245;
  unsigned int D.43247;
  guint8 * code.4647;
  guint8 * code.4648;
  guint8 * code.4649;
  guint8 * code.4650;
  unsigned char D.43255;
  guint8 * code.4651;
  unsigned char D.43257;
  guint8 * code.4652;
  unsigned char D.43259;
  guint8 * code.4653;
  unsigned char D.43261;
  int D.43266;
  unsigned int D.43267;
  unsigned int D.43268;
  int D.43269;
  guint8 * code.4654;
  guint8 * code.4655;
  guint8 * code.4656;
  guint8 * code.4657;
  guint8 * code.4658;
  guint8 * code.4659;
  unsigned char D.43284;
  guint8 * code.4660;
  unsigned char D.43286;
  guint8 * code.4661;
  unsigned char D.43288;
  guint8 * code.4662;
  unsigned char D.43290;
  guint8 * code.4663;
  guint8 * code.4664;
  int D.43297;
  int D.43298;
  unsigned char D.43299;
  unsigned char D.43300;
  guint8 * code.4665;
  unsigned char D.43303;
  unsigned char D.43304;
  guint8 * code.4666;
  unsigned char D.43306;
  guint8 * code.4667;
  unsigned char D.43308;
  guint8 * code.4668;
  unsigned char D.43310;
  guint8 * code.4669;
  unsigned char D.43312;
  struct MonoBasicBlock * * D.43314;
  struct MonoBasicBlock * D.43315;
  int D.43316;
  sizetype D.43319;
  unsigned char * D.43320;
  long int D.43321;
  long int D.43322;
  unsigned int D.43323;
  unsigned int D.43324;
  unsigned int offset.4670;
  unsigned int D.43326;
  guint8 * code.4671;
  guint8 * code.4672;
  unsigned char D.43334;
  unsigned int D.43336;
  guint8 * code.4673;
  guint8 * code.4674;
  guint8 * code.4675;
  guint8 * code.4676;
  unsigned char D.43344;
  guint8 * code.4677;
  unsigned char D.43346;
  guint8 * code.4678;
  unsigned char D.43348;
  guint8 * code.4679;
  unsigned char D.43350;
  int D.43355;
  unsigned int D.43356;
  unsigned int D.43357;
  int D.43358;
  guint8 * code.4680;
  guint8 * code.4681;
  guint8 * code.4682;
  guint8 * code.4683;
  guint8 * code.4684;
  guint8 * code.4685;
  unsigned char D.43373;
  guint8 * code.4686;
  unsigned char D.43375;
  guint8 * code.4687;
  unsigned char D.43377;
  guint8 * code.4688;
  unsigned char D.43379;
  int D.43383;
  guint8 * code.4689;
  signed char iftmp.4690;
  signed char D.43390;
  guint8 * code.4691;
  unsigned char D.43394;
  guint8 * code.4692;
  guint8 * code.4693;
  guint8 * code.4694;
  guint8 * code.4695;
  unsigned char iftmp.4696;
  guint8 * code.4697;
  unsigned char D.43406;
  guint8 * code.4698;
  guint8 * code.4699;
  guint8 * code.4700;
  guint8 * code.4701;
  unsigned char D.43413;
  guint8 * code.4702;
  unsigned char D.43415;
  guint8 * code.4703;
  unsigned char D.43417;
  guint8 * code.4704;
  unsigned char D.43419;
  guint8 * code.4705;
  guint8 * code.4706;
  guint8 * code.4707;
  guint8 * code.4708;
  guint8 * code.4709;
  guint8 * code.4710;
  guint8 * code.4711;
  unsigned char D.43436;
  guint8 * code.4712;
  unsigned char D.43438;
  guint8 * code.4713;
  unsigned char D.43440;
  guint8 * code.4714;
  unsigned char D.43442;
  guint8 * code.4715;
  guint8 * code.4716;
  guint8 * code.4717;
  guint8 * code.4718;
  unsigned char D.43452;
  guint8 * code.4719;
  unsigned char D.43454;
  guint8 * code.4720;
  unsigned char D.43456;
  guint8 * code.4721;
  unsigned char D.43458;
  int D.43462;
  guint8 * code.4722;
  signed char iftmp.4723;
  signed char D.43469;
  guint8 * code.4724;
  unsigned char D.43473;
  guint8 * code.4725;
  guint8 * code.4726;
  guint8 * code.4727;
  guint8 * code.4728;
  unsigned char iftmp.4729;
  guint8 * code.4730;
  unsigned char D.43485;
  guint8 * code.4731;
  guint8 * code.4732;
  guint8 * code.4733;
  guint8 * code.4734;
  unsigned char D.43492;
  guint8 * code.4735;
  unsigned char D.43494;
  guint8 * code.4736;
  unsigned char D.43496;
  guint8 * code.4737;
  unsigned char D.43498;
  guint8 * code.4738;
  guint8 * code.4739;
  guint8 * code.4740;
  guint8 * code.4741;
  guint8 * code.4742;
  guint8 * code.4743;
  guint8 * code.4744;
  unsigned char D.43515;
  guint8 * code.4745;
  unsigned char D.43517;
  guint8 * code.4746;
  unsigned char D.43519;
  guint8 * code.4747;
  unsigned char D.43521;
  guint8 * code.4748;
  guint8 * code.4749;
  guint8 * code.4750;
  guint8 * code.4751;
  unsigned char D.43531;
  guint8 * code.4752;
  unsigned char D.43533;
  guint8 * code.4753;
  unsigned char D.43535;
  guint8 * code.4754;
  unsigned char D.43537;
  guint8 * code.4755;
  signed char iftmp.4756;
  signed char D.43543;
  guint8 * code.4757;
  unsigned char D.43547;
  guint8 * code.4758;
  guint8 * code.4759;
  guint8 * code.4760;
  guint8 * code.4761;
  signed char iftmp.4762;
  signed char D.43556;
  guint8 * code.4763;
  unsigned char D.43560;
  guint8 * code.4764;
  guint8 * code.4765;
  guint8 * code.4766;
  guint8 * code.4767;
  unsigned char D.43567;
  guint8 * code.4768;
  unsigned char D.43569;
  guint8 * code.4769;
  unsigned char D.43571;
  guint8 * code.4770;
  unsigned char D.43573;
  guint8 * code.4771;
  guint8 * code.4772;
  guint8 * code.4773;
  guint8 * code.4774;
  guint8 * code.4775;
  guint8 * code.4776;
  guint8 * code.4777;
  unsigned char D.43590;
  guint8 * code.4778;
  unsigned char D.43592;
  guint8 * code.4779;
  unsigned char D.43594;
  guint8 * code.4780;
  unsigned char D.43596;
  guint8 * code.4781;
  guint8 * code.4782;
  guint8 * code.4783;
  guint8 * code.4784;
  unsigned char D.43608;
  guint8 * code.4785;
  unsigned char D.43610;
  guint8 * code.4786;
  unsigned char D.43612;
  guint8 * code.4787;
  unsigned char D.43614;
  guint8 * code.4788;
  signed char iftmp.4789;
  int D.43620;
  _Bool D.43621;
  _Bool D.43622;
  _Bool D.43623;
  int D.43624;
  signed char D.43625;
  signed char D.43626;
  guint8 * code.4790;
  unsigned char D.43630;
  guint8 * code.4791;
  guint8 * code.4792;
  guint8 * code.4793;
  guint8 * code.4794;
  unsigned char D.43637;
  guint8 * code.4795;
  unsigned char D.43639;
  guint8 * code.4796;
  unsigned char D.43641;
  guint8 * code.4797;
  unsigned char D.43643;
  guint8 * code.4798;
  guint8 * code.4799;
  guint8 * code.4800;
  guint8 * code.4801;
  guint8 * code.4802;
  guint8 * code.4803;
  guint8 * code.4804;
  unsigned char D.43660;
  guint8 * code.4805;
  unsigned char D.43662;
  guint8 * code.4806;
  unsigned char D.43664;
  guint8 * code.4807;
  unsigned char D.43666;
  guint8 * code.4808;
  guint8 * code.4809;
  guint8 * code.4810;
  guint8 * code.4811;
  unsigned char D.43678;
  guint8 * code.4812;
  unsigned char D.43680;
  guint8 * code.4813;
  unsigned char D.43682;
  guint8 * code.4814;
  unsigned char D.43684;
  guint8 * code.4815;
  unsigned char iftmp.4816;
  guint8 * code.4817;
  unsigned char D.43693;
  guint8 * code.4818;
  guint8 * code.4819;
  guint8 * code.4820;
  guint8 * code.4821;
  unsigned char iftmp.4822;
  guint8 * code.4823;
  unsigned char D.43705;
  guint8 * code.4824;
  guint8 * code.4825;
  guint8 * code.4826;
  guint8 * code.4827;
  unsigned char D.43712;
  guint8 * code.4828;
  unsigned char D.43714;
  guint8 * code.4829;
  unsigned char D.43716;
  guint8 * code.4830;
  unsigned char D.43718;
  guint8 * code.4831;
  guint8 * code.4832;
  guint8 * code.4833;
  guint8 * code.4834;
  guint8 * code.4835;
  guint8 * code.4836;
  guint8 * code.4837;
  unsigned char D.43735;
  guint8 * code.4838;
  unsigned char D.43737;
  guint8 * code.4839;
  unsigned char D.43739;
  guint8 * code.4840;
  unsigned char D.43741;
  guint8 * code.4841;
  signed char D.43747;
  unsigned char D.43748;
  guint8 * code.4842;
  signed char D.43752;
  unsigned char D.43753;
  guint8 * code.4843;
  signed char D.43756;
  unsigned char D.43757;
  guint8 * code.4844;
  unsigned char D.43759;
  guint8 * code.4845;
  unsigned char D.43761;
  guint8 * code.4846;
  unsigned char D.43763;
  guint8 * code.4847;
  unsigned char D.43765;
  guint8 * code.4848;
  signed char iftmp.4849;
  int D.43771;
  _Bool D.43772;
  _Bool D.43773;
  _Bool D.43774;
  int D.43775;
  signed char D.43776;
  signed char D.43777;
  guint8 * code.4850;
  unsigned char D.43781;
  guint8 * code.4851;
  guint8 * code.4852;
  guint8 * code.4853;
  guint8 * code.4854;
  unsigned char D.43788;
  guint8 * code.4855;
  unsigned char D.43790;
  guint8 * code.4856;
  unsigned char D.43792;
  guint8 * code.4857;
  unsigned char D.43794;
  guint8 * code.4858;
  guint8 * code.4859;
  guint8 * code.4860;
  guint8 * code.4861;
  guint8 * code.4862;
  guint8 * code.4863;
  guint8 * code.4864;
  unsigned char D.43811;
  guint8 * code.4865;
  unsigned char D.43813;
  guint8 * code.4866;
  unsigned char D.43815;
  guint8 * code.4867;
  unsigned char D.43817;
  guint8 * code.4868;
  guint8 * code.4869;
  guint8 * code.4870;
  guint8 * code.4871;
  unsigned char D.43829;
  guint8 * code.4872;
  unsigned char D.43831;
  guint8 * code.4873;
  unsigned char D.43833;
  guint8 * code.4874;
  unsigned char D.43835;
  guint8 * code.4875;
  signed char iftmp.4876;
  signed char D.43841;
  guint8 * code.4877;
  unsigned char D.43845;
  guint8 * code.4878;
  guint8 * code.4879;
  guint8 * code.4880;
  guint8 * code.4881;
  signed char iftmp.4882;
  signed char D.43854;
  guint8 * code.4883;
  unsigned char D.43858;
  guint8 * code.4884;
  guint8 * code.4885;
  guint8 * code.4886;
  guint8 * code.4887;
  signed char iftmp.4888;
  signed char D.43867;
  guint8 * code.4889;
  unsigned char D.43871;
  guint8 * code.4890;
  guint8 * code.4891;
  guint8 * code.4892;
  guint8 * code.4893;
  signed char iftmp.4894;
  signed char D.43880;
  guint8 * code.4895;
  unsigned char D.43884;
  guint8 * code.4896;
  guint8 * code.4897;
  guint8 * code.4898;
  guint8 * code.4899;
  signed char iftmp.4900;
  signed char D.43893;
  guint8 * code.4901;
  unsigned char D.43897;
  guint8 * code.4902;
  guint8 * code.4903;
  guint8 * code.4904;
  guint8 * code.4905;
  signed char iftmp.4906;
  signed char D.43906;
  guint8 * code.4907;
  unsigned char D.43910;
  guint8 * code.4908;
  guint8 * code.4909;
  guint8 * code.4910;
  guint8 * code.4911;
  signed char iftmp.4912;
  signed char D.43919;
  guint8 * code.4913;
  unsigned char D.43923;
  guint8 * code.4914;
  guint8 * code.4915;
  guint8 * code.4916;
  guint8 * code.4917;
  signed char iftmp.4918;
  signed char D.43932;
  guint8 * code.4919;
  unsigned char D.43936;
  guint8 * code.4920;
  guint8 * code.4921;
  guint8 * code.4922;
  guint8 * code.4923;
  signed char iftmp.4924;
  signed char D.43945;
  guint8 * code.4925;
  unsigned char D.43949;
  guint8 * code.4926;
  guint8 * code.4927;
  guint8 * code.4928;
  signed char iftmp.4929;
  signed char D.43957;
  guint8 * code.4930;
  unsigned char D.43961;
  guint8 * code.4931;
  guint8 * code.4932;
  guint8 * code.4933;
  unsigned char D.43967;
  guint8 * code.4934;
  unsigned char D.43970;
  guint8 * code.4935;
  signed char iftmp.4936;
  signed char D.43976;
  guint8 * code.4937;
  unsigned char D.43980;
  guint8 * code.4938;
  guint8 * code.4939;
  guint8 * code.4940;
  guint8 * code.4941;
  guint8 * D.43985;
  guint8 * code.4942;
  guint8 * code.4943;
  unsigned char D.43992;
  guint8 * code.4944;
  guint8 * code.4945;
  guint8 * code.4946;
  guint8 * code.4947;
  guint8 * code.4948;
  guint8 * code.4949;
  guint8 * code.4950;
  guint8 * code.4951;
  guint8 * code.4952;
  unsigned char D.44010;
  guint8 * code.4953;
  unsigned char D.44012;
  guint8 * code.4954;
  unsigned char D.44014;
  guint8 * code.4955;
  unsigned char D.44016;
  guint8 * code.4956;
  guint8 * code.4957;
  guint8 * code.4958;
  guint8 * code.4959;
  unsigned char D.44026;
  guint8 * code.4960;
  unsigned char D.44028;
  guint8 * code.4961;
  unsigned char D.44030;
  guint8 * code.4962;
  unsigned char D.44032;
  guint8 * code.4963;
  guint8 * code.4964;
  unsigned char D.44039;
  guint8 * code.4965;
  guint8 * code.4966;
  guint8 * code.4967;
  guint8 * code.4968;
  guint8 * code.4969;
  guint8 * code.4970;
  guint8 * code.4971;
  guint8 * code.4972;
  guint8 * code.4973;
  unsigned char D.44057;
  guint8 * code.4974;
  unsigned char D.44059;
  guint8 * code.4975;
  unsigned char D.44061;
  guint8 * code.4976;
  unsigned char D.44063;
  guint8 * code.4977;
  guint8 * code.4978;
  guint8 * code.4979;
  guint8 * code.4980;
  unsigned char D.44073;
  guint8 * code.4981;
  unsigned char D.44075;
  guint8 * code.4982;
  unsigned char D.44077;
  guint8 * code.4983;
  unsigned char D.44079;
  guint8 * code.4984;
  unsigned char iftmp.4985;
  guint8 * code.4986;
  unsigned char D.44090;
  guint8 * code.4987;
  guint8 * code.4988;
  guint8 * code.4989;
  guint8 * code.4990;
  unsigned char iftmp.4991;
  guint8 * code.4992;
  unsigned char D.44104;
  guint8 * code.4993;
  guint8 * code.4994;
  guint8 * code.4995;
  guint8 * code.4996;
  unsigned char D.44113;
  guint8 * code.4997;
  guint8 * code.4998;
  guint8 * code.4999;
  unsigned char D.44122;
  guint8 * code.5000;
  guint8 * code.5001;
  unsigned char D.44125;
  guint8 * code.5002;
  unsigned char D.44127;
  guint8 * code.5003;
  unsigned char D.44129;
  guint8 * code.5004;
  unsigned char D.44131;
  guint8 * code.5005;
  unsigned char D.44136;
  guint8 * code.5006;
  guint8 * code.5007;
  guint8 * code.5008;
  unsigned char D.44140;
  guint8 * code.5009;
  unsigned char D.44142;
  guint8 * code.5010;
  unsigned char D.44144;
  guint8 * code.5011;
  unsigned char D.44146;
  guint8 * code.5012;
  unsigned char D.44150;
  guint8 * code.5013;
  guint8 * code.5014;
  guint8 * code.5015;
  guint8 * code.5016;
  guint8 * code.5017;
  unsigned char D.44163;
  guint8 * code.5018;
  guint8 * code.5019;
  guint8 * code.5020;
  unsigned char D.44172;
  guint8 * code.5021;
  guint8 * code.5022;
  unsigned char D.44175;
  guint8 * code.5023;
  unsigned char D.44177;
  guint8 * code.5024;
  unsigned char D.44179;
  guint8 * code.5025;
  unsigned char D.44181;
  guint8 * code.5026;
  unsigned char D.44186;
  guint8 * code.5027;
  guint8 * code.5028;
  guint8 * code.5029;
  unsigned char D.44190;
  guint8 * code.5030;
  unsigned char D.44192;
  guint8 * code.5031;
  unsigned char D.44194;
  guint8 * code.5032;
  unsigned char D.44196;
  guint8 * code.5033;
  unsigned char iftmp.5034;
  guint8 * code.5035;
  unsigned char D.44205;
  guint8 * code.5036;
  guint8 * code.5037;
  guint8 * code.5038;
  guint8 * code.5039;
  signed char iftmp.5040;
  signed char D.44214;
  guint8 * code.5041;
  unsigned char D.44218;
  guint8 * code.5042;
  guint8 * code.5043;
  guint8 * code.5044;
  guint8 * code.5045;
  guint8 * code.5046;
  unsigned char D.44228;
  guint8 * code.5047;
  guint8 * code.5048;
  guint8 * code.5049;
  guint8 * code.5050;
  unsigned char D.44235;
  guint8 * code.5051;
  unsigned char D.44237;
  guint8 * code.5052;
  unsigned char D.44239;
  guint8 * code.5053;
  unsigned char D.44241;
  guint8 * code.5054;
  guint8 * code.5055;
  guint8 * code.5056;
  guint8 * code.5057;
  guint8 * code.5058;
  guint8 * code.5059;
  guint8 * code.5060;
  unsigned char D.44258;
  guint8 * code.5061;
  unsigned char D.44260;
  guint8 * code.5062;
  unsigned char D.44262;
  guint8 * code.5063;
  unsigned char D.44264;
  guint8 * code.5064;
  guint8 * code.5065;
  guint8 * code.5066;
  guint8 * code.5067;
  unsigned char D.44274;
  guint8 * code.5068;
  unsigned char D.44276;
  guint8 * code.5069;
  unsigned char D.44278;
  guint8 * code.5070;
  unsigned char D.44280;
  guint8 * code.5071;
  guint8 * code.5072;
  unsigned char D.44287;
  guint8 * code.5073;
  guint8 * code.5074;
  guint8 * code.5075;
  guint8 * code.5076;
  unsigned char D.44294;
  guint8 * code.5077;
  unsigned char D.44296;
  guint8 * code.5078;
  unsigned char D.44298;
  guint8 * code.5079;
  unsigned char D.44300;
  guint8 * code.5080;
  guint8 * code.5081;
  guint8 * code.5082;
  guint8 * code.5083;
  guint8 * code.5084;
  guint8 * code.5085;
  guint8 * code.5086;
  unsigned char D.44317;
  guint8 * code.5087;
  unsigned char D.44319;
  guint8 * code.5088;
  unsigned char D.44321;
  guint8 * code.5089;
  unsigned char D.44323;
  guint8 * code.5090;
  guint8 * code.5091;
  guint8 * code.5092;
  guint8 * code.5093;
  unsigned char D.44333;
  guint8 * code.5094;
  unsigned char D.44335;
  guint8 * code.5095;
  unsigned char D.44337;
  guint8 * code.5096;
  unsigned char D.44339;
  guint8 * D.44340;
  unsigned char iftmp.5097;
  guint8 * code.5098;
  unsigned char D.44350;
  guint8 * code.5099;
  guint8 * code.5100;
  guint8 * code.5101;
  unsigned char D.44359;
  guint8 * code.5102;
  guint8 * code.5103;
  unsigned char D.44362;
  guint8 * code.5104;
  unsigned char D.44364;
  guint8 * code.5105;
  unsigned char D.44366;
  guint8 * code.5106;
  unsigned char D.44368;
  unsigned char iftmp.5107;
  guint8 * code.5108;
  unsigned char D.44377;
  guint8 * code.5109;
  guint8 * code.5110;
  guint8 * code.5111;
  unsigned char D.44381;
  guint8 * code.5112;
  unsigned char D.44383;
  guint8 * code.5113;
  unsigned char D.44385;
  guint8 * code.5114;
  unsigned char D.44387;
  guint8 * code.5115;
  guint8 * code.5116;
  unsigned char D.44394;
  unsigned char D.44395;
  guint8 * code.5117;
  unsigned char D.44398;
  unsigned char D.44399;
  guint8 * code.5118;
  unsigned char D.44401;
  guint8 * code.5119;
  unsigned char D.44403;
  guint8 * code.5120;
  unsigned char D.44405;
  guint8 * code.5121;
  unsigned char D.44407;
  struct MonoBasicBlock * * D.44409;
  struct MonoBasicBlock * D.44410;
  int D.44411;
  sizetype D.44414;
  unsigned char * D.44415;
  long int D.44416;
  long int D.44417;
  unsigned int D.44418;
  unsigned int D.44419;
  unsigned int offset.5122;
  unsigned int D.44421;
  guint8 * code.5123;
  guint8 * code.5124;
  unsigned char D.44429;
  unsigned int D.44431;
  guint8 * code.5125;
  guint8 * code.5126;
  guint8 * code.5127;
  guint8 * code.5128;
  unsigned char D.44439;
  guint8 * code.5129;
  unsigned char D.44441;
  guint8 * code.5130;
  unsigned char D.44443;
  guint8 * code.5131;
  unsigned char D.44445;
  int D.44450;
  unsigned int D.44451;
  unsigned int D.44452;
  int D.44453;
  guint8 * code.5132;
  guint8 * code.5133;
  guint8 * code.5134;
  guint8 * code.5135;
  guint8 * code.5136;
  guint8 * code.5137;
  unsigned char D.44468;
  guint8 * code.5138;
  unsigned char D.44470;
  guint8 * code.5139;
  unsigned char D.44472;
  guint8 * code.5140;
  unsigned char D.44474;
  guint8 * code.5141;
  signed char iftmp.5142;
  signed char D.44482;
  guint8 * code.5143;
  unsigned char D.44486;
  guint8 * code.5144;
  guint8 * code.5145;
  guint8 * code.5146;
  unsigned char iftmp.5147;
  guint8 * code.5148;
  unsigned char D.44499;
  guint8 * code.5149;
  guint8 * code.5150;
  guint8 * code.5151;
  unsigned char D.44508;
  guint8 * code.5152;
  guint8 * code.5153;
  unsigned char D.44511;
  guint8 * code.5154;
  unsigned char D.44513;
  guint8 * code.5155;
  unsigned char D.44515;
  guint8 * code.5156;
  unsigned char D.44517;
  unsigned char iftmp.5157;
  guint8 * code.5158;
  unsigned char D.44526;
  guint8 * code.5159;
  guint8 * code.5160;
  guint8 * code.5161;
  unsigned char D.44530;
  guint8 * code.5162;
  unsigned char D.44532;
  guint8 * code.5163;
  unsigned char D.44534;
  guint8 * code.5164;
  unsigned char D.44536;
  guint8 * code.5165;
  guint8 * code.5166;
  unsigned char D.44543;
  unsigned char D.44544;
  guint8 * code.5167;
  unsigned char D.44547;
  unsigned char D.44548;
  guint8 * code.5168;
  unsigned char D.44550;
  guint8 * code.5169;
  unsigned char D.44552;
  guint8 * code.5170;
  unsigned char D.44554;
  guint8 * code.5171;
  unsigned char D.44556;
  struct MonoBasicBlock * * D.44558;
  struct MonoBasicBlock * D.44559;
  int D.44560;
  sizetype D.44563;
  unsigned char * D.44564;
  long int D.44565;
  long int D.44566;
  unsigned int D.44567;
  unsigned int D.44568;
  unsigned int offset.5172;
  unsigned int D.44570;
  guint8 * code.5173;
  guint8 * code.5174;
  unsigned char D.44578;
  unsigned int D.44580;
  guint8 * code.5175;
  guint8 * code.5176;
  guint8 * code.5177;
  guint8 * code.5178;
  unsigned char D.44588;
  guint8 * code.5179;
  unsigned char D.44590;
  guint8 * code.5180;
  unsigned char D.44592;
  guint8 * code.5181;
  unsigned char D.44594;
  int D.44599;
  unsigned int D.44600;
  unsigned int D.44601;
  int D.44602;
  guint8 * code.5182;
  guint8 * code.5183;
  guint8 * code.5184;
  guint8 * code.5185;
  guint8 * code.5186;
  guint8 * code.5187;
  unsigned char D.44617;
  guint8 * code.5188;
  unsigned char D.44619;
  guint8 * code.5189;
  unsigned char D.44621;
  guint8 * code.5190;
  unsigned char D.44623;
  guint8 * code.5191;
  signed char iftmp.5192;
  signed char D.44631;
  guint8 * code.5193;
  unsigned char D.44635;
  guint8 * code.5194;
  guint8 * code.5195;
  guint8 * code.5196;
  guint8 * code.5197;
  signed char iftmp.5198;
  signed char D.44646;
  guint8 * code.5199;
  unsigned char D.44650;
  guint8 * code.5200;
  guint8 * code.5201;
  guint8 * code.5202;
  guint8 * code.5203;
  signed char iftmp.5204;
  signed char D.44659;
  guint8 * code.5205;
  unsigned char D.44663;
  guint8 * code.5206;
  guint8 * code.5207;
  guint8 * code.5208;
  guint8 * code.5209;
  signed char iftmp.5210;
  signed char D.44672;
  guint8 * code.5211;
  unsigned char D.44676;
  guint8 * code.5212;
  guint8 * code.5213;
  guint8 * code.5214;
  guint8 * code.5215;
  signed char iftmp.5216;
  signed char D.44685;
  guint8 * code.5217;
  unsigned char D.44689;
  guint8 * code.5218;
  guint8 * code.5219;
  guint8 * code.5220;
  guint8 * code.5221;
  signed char iftmp.5222;
  signed char D.44698;
  guint8 * code.5223;
  unsigned char D.44702;
  guint8 * code.5224;
  guint8 * code.5225;
  guint8 * code.5226;
  guint8 * code.5227;
  unsigned char iftmp.5228;
  guint8 * code.5229;
  unsigned char D.44716;
  guint8 * code.5230;
  guint8 * code.5231;
  guint8 * code.5232;
  guint8 * code.5233;
  unsigned char D.44723;
  guint8 * code.5234;
  unsigned char D.44725;
  guint8 * code.5235;
  unsigned char D.44727;
  guint8 * code.5236;
  unsigned char D.44729;
  guint8 * code.5237;
  guint8 * code.5238;
  guint8 * code.5239;
  guint8 * code.5240;
  guint8 * code.5241;
  guint8 * code.5242;
  guint8 * code.5243;
  unsigned char D.44746;
  guint8 * code.5244;
  unsigned char D.44748;
  guint8 * code.5245;
  unsigned char D.44750;
  guint8 * code.5246;
  unsigned char D.44752;
  guint8 * code.5247;
  guint8 * code.5248;
  guint8 * code.5249;
  guint8 * code.5250;
  unsigned char D.44762;
  guint8 * code.5251;
  unsigned char D.44764;
  guint8 * code.5252;
  unsigned char D.44766;
  guint8 * code.5253;
  unsigned char D.44768;
  guint8 * code.5254;
  unsigned char iftmp.5255;
  guint8 * code.5256;
  unsigned char D.44777;
  guint8 * code.5257;
  guint8 * code.5258;
  guint8 * code.5259;
  guint8 * code.5260;
  guint8 * code.5261;
  guint8 * code.5262;
  guint8 * code.5263;
  guint8 * code.5264;
  guint8 * code.5265;
  unsigned char D.44795;
  guint8 * code.5266;
  unsigned char D.44797;
  guint8 * code.5267;
  unsigned char D.44799;
  guint8 * code.5268;
  unsigned char D.44801;
  guint8 * code.5269;
  guint8 * code.5270;
  guint8 * code.5271;
  guint8 * code.5272;
  unsigned char D.44811;
  guint8 * code.5273;
  unsigned char D.44813;
  guint8 * code.5274;
  unsigned char D.44815;
  guint8 * code.5275;
  unsigned char D.44817;
  guint8 * code.5276;
  unsigned char D.44821;
  guint8 * code.5277;
  guint8 * code.5278;
  guint8 * code.5279;
  unsigned char D.44827;
  guint8 * code.5280;
  unsigned char D.44829;
  guint8 * code.5281;
  unsigned char D.44831;
  guint8 * code.5282;
  unsigned char D.44833;
  guint8 * code.5283;
  guint8 * code.5284;
  guint8 * code.5285;
  guint8 * code.5286;
  guint8 * code.5287;
  guint8 * code.5288;
  guint8 * code.5289;
  unsigned char D.44850;
  guint8 * code.5290;
  unsigned char D.44852;
  guint8 * code.5291;
  unsigned char D.44854;
  guint8 * code.5292;
  unsigned char D.44856;
  guint8 * code.5293;
  guint8 * code.5294;
  guint8 * code.5295;
  guint8 * code.5296;
  unsigned char D.44866;
  guint8 * code.5297;
  unsigned char D.44868;
  guint8 * code.5298;
  unsigned char D.44870;
  guint8 * code.5299;
  unsigned char D.44872;
  guint8 * code.5300;
  guint8 * code.5301;
  guint8 * code.5302;
  unsigned char D.44878;
  guint8 * code.5303;
  guint8 * code.5304;
  guint8 * code.5305;
  guint8 * code.5306;
  guint8 * code.5307;
  guint8 * code.5308;
  guint8 * code.5309;
  guint8 * code.5310;
  unsigned char D.44895;
  guint8 * code.5311;
  unsigned char D.44897;
  guint8 * code.5312;
  unsigned char D.44899;
  guint8 * code.5313;
  unsigned char D.44901;
  guint8 * code.5314;
  guint8 * code.5315;
  guint8 * code.5316;
  guint8 * code.5317;
  unsigned char D.44911;
  guint8 * code.5318;
  unsigned char D.44913;
  guint8 * code.5319;
  unsigned char D.44915;
  guint8 * code.5320;
  unsigned char D.44917;
  guint8 * code.5321;
  unsigned char iftmp.5322;
  guint8 * code.5323;
  unsigned char D.44926;
  guint8 * code.5324;
  guint8 * code.5325;
  guint8 * code.5326;
  guint8 * code.5327;
  guint8 * code.5328;
  guint8 * code.5329;
  guint8 * code.5330;
  guint8 * code.5331;
  guint8 * code.5332;
  unsigned char D.44944;
  guint8 * code.5333;
  unsigned char D.44946;
  guint8 * code.5334;
  unsigned char D.44948;
  guint8 * code.5335;
  unsigned char D.44950;
  guint8 * code.5336;
  guint8 * code.5337;
  guint8 * code.5338;
  guint8 * code.5339;
  unsigned char D.44960;
  guint8 * code.5340;
  unsigned char D.44962;
  guint8 * code.5341;
  unsigned char D.44964;
  guint8 * code.5342;
  unsigned char D.44966;
  guint8 * code.5343;
  unsigned char iftmp.5344;
  guint8 * code.5345;
  unsigned char D.44975;
  guint8 * code.5346;
  guint8 * code.5347;
  guint8 * code.5348;
  guint8 * code.5349;
  guint8 * code.5350;
  guint8 * code.5351;
  guint8 * code.5352;
  guint8 * code.5353;
  guint8 * code.5354;
  unsigned char D.44993;
  guint8 * code.5355;
  unsigned char D.44995;
  guint8 * code.5356;
  unsigned char D.44997;
  guint8 * code.5357;
  unsigned char D.44999;
  guint8 * code.5358;
  guint8 * code.5359;
  guint8 * code.5360;
  guint8 * code.5361;
  unsigned char D.45009;
  guint8 * code.5362;
  unsigned char D.45011;
  guint8 * code.5363;
  unsigned char D.45013;
  guint8 * code.5364;
  unsigned char D.45015;
  guint8 * code.5365;
  unsigned char D.45019;
  guint8 * code.5366;
  guint8 * code.5367;
  guint8 * code.5368;
  unsigned char D.45025;
  guint8 * code.5369;
  unsigned char D.45027;
  guint8 * code.5370;
  unsigned char D.45029;
  guint8 * code.5371;
  unsigned char D.45031;
  guint8 * code.5372;
  guint8 * code.5373;
  guint8 * code.5374;
  guint8 * code.5375;
  guint8 * code.5376;
  guint8 * code.5377;
  guint8 * code.5378;
  unsigned char D.45048;
  guint8 * code.5379;
  unsigned char D.45050;
  guint8 * code.5380;
  unsigned char D.45052;
  guint8 * code.5381;
  unsigned char D.45054;
  guint8 * code.5382;
  guint8 * code.5383;
  guint8 * code.5384;
  guint8 * code.5385;
  unsigned char D.45064;
  guint8 * code.5386;
  unsigned char D.45066;
  guint8 * code.5387;
  unsigned char D.45068;
  guint8 * code.5388;
  unsigned char D.45070;
  guint8 * code.5389;
  guint8 * code.5390;
  guint8 * code.5391;
  unsigned char D.45076;
  guint8 * code.5392;
  guint8 * code.5393;
  guint8 * code.5394;
  guint8 * code.5395;
  guint8 * code.5396;
  guint8 * code.5397;
  guint8 * code.5398;
  guint8 * code.5399;
  unsigned char D.45093;
  guint8 * code.5400;
  unsigned char D.45095;
  guint8 * code.5401;
  unsigned char D.45097;
  guint8 * code.5402;
  unsigned char D.45099;
  guint8 * code.5403;
  guint8 * code.5404;
  guint8 * code.5405;
  guint8 * code.5406;
  unsigned char D.45109;
  guint8 * code.5407;
  unsigned char D.45111;
  guint8 * code.5408;
  unsigned char D.45113;
  guint8 * code.5409;
  unsigned char D.45115;
  guint8 * code.5410;
  unsigned char iftmp.5411;
  guint8 * code.5412;
  unsigned char D.45124;
  guint8 * code.5413;
  guint8 * code.5414;
  guint8 * code.5415;
  guint8 * code.5416;
  guint8 * code.5417;
  guint8 * code.5418;
  guint8 * code.5419;
  guint8 * code.5420;
  guint8 * code.5421;
  unsigned char D.45142;
  guint8 * code.5422;
  unsigned char D.45144;
  guint8 * code.5423;
  unsigned char D.45146;
  guint8 * code.5424;
  unsigned char D.45148;
  guint8 * code.5425;
  guint8 * code.5426;
  guint8 * code.5427;
  guint8 * code.5428;
  unsigned char D.45158;
  guint8 * code.5429;
  unsigned char D.45160;
  guint8 * code.5430;
  unsigned char D.45162;
  guint8 * code.5431;
  unsigned char D.45164;
  guint8 * code.5432;
  unsigned char iftmp.5433;
  guint8 * code.5434;
  unsigned char D.45175;
  guint8 * code.5435;
  guint8 * code.5436;
  guint8 * code.5437;
  guint8 * code.5438;
  unsigned char D.45182;
  guint8 * code.5439;
  unsigned char D.45184;
  guint8 * code.5440;
  unsigned char D.45186;
  guint8 * code.5441;
  unsigned char D.45188;
  guint8 * code.5442;
  guint8 * code.5443;
  guint8 * code.5444;
  guint8 * code.5445;
  guint8 * code.5446;
  guint8 * code.5447;
  guint8 * code.5448;
  unsigned char D.45205;
  guint8 * code.5449;
  unsigned char D.45207;
  guint8 * code.5450;
  unsigned char D.45209;
  guint8 * code.5451;
  unsigned char D.45211;
  guint8 * code.5452;
  guint8 * code.5453;
  guint8 * code.5454;
  guint8 * code.5455;
  unsigned char D.45221;
  guint8 * code.5456;
  unsigned char D.45223;
  guint8 * code.5457;
  unsigned char D.45225;
  guint8 * code.5458;
  unsigned char D.45227;
  guint8 * code.5459;
  unsigned char iftmp.5460;
  guint8 * code.5461;
  unsigned char D.45236;
  guint8 * code.5462;
  guint8 * code.5463;
  guint8 * code.5464;
  guint8 * code.5465;
  guint8 * code.5466;
  guint8 * code.5467;
  guint8 * code.5468;
  guint8 * code.5469;
  guint8 * code.5470;
  unsigned char D.45254;
  guint8 * code.5471;
  unsigned char D.45256;
  guint8 * code.5472;
  unsigned char D.45258;
  guint8 * code.5473;
  unsigned char D.45260;
  guint8 * code.5474;
  guint8 * code.5475;
  guint8 * code.5476;
  guint8 * code.5477;
  unsigned char D.45270;
  guint8 * code.5478;
  unsigned char D.45272;
  guint8 * code.5479;
  unsigned char D.45274;
  guint8 * code.5480;
  unsigned char D.45276;
  guint8 * code.5481;
  unsigned char D.45280;
  guint8 * code.5482;
  guint8 * code.5483;
  guint8 * code.5484;
  unsigned char D.45286;
  guint8 * code.5485;
  unsigned char D.45288;
  guint8 * code.5486;
  unsigned char D.45290;
  guint8 * code.5487;
  unsigned char D.45292;
  guint8 * code.5488;
  guint8 * code.5489;
  guint8 * code.5490;
  guint8 * code.5491;
  guint8 * code.5492;
  guint8 * code.5493;
  guint8 * code.5494;
  unsigned char D.45309;
  guint8 * code.5495;
  unsigned char D.45311;
  guint8 * code.5496;
  unsigned char D.45313;
  guint8 * code.5497;
  unsigned char D.45315;
  guint8 * code.5498;
  guint8 * code.5499;
  guint8 * code.5500;
  guint8 * code.5501;
  unsigned char D.45325;
  guint8 * code.5502;
  unsigned char D.45327;
  guint8 * code.5503;
  unsigned char D.45329;
  guint8 * code.5504;
  unsigned char D.45331;
  guint8 * code.5505;
  guint8 * code.5506;
  guint8 * code.5507;
  unsigned char D.45337;
  guint8 * code.5508;
  guint8 * code.5509;
  guint8 * code.5510;
  guint8 * code.5511;
  guint8 * code.5512;
  guint8 * code.5513;
  guint8 * code.5514;
  guint8 * code.5515;
  unsigned char D.45354;
  guint8 * code.5516;
  unsigned char D.45356;
  guint8 * code.5517;
  unsigned char D.45358;
  guint8 * code.5518;
  unsigned char D.45360;
  guint8 * code.5519;
  guint8 * code.5520;
  guint8 * code.5521;
  guint8 * code.5522;
  unsigned char D.45370;
  guint8 * code.5523;
  unsigned char D.45372;
  guint8 * code.5524;
  unsigned char D.45374;
  guint8 * code.5525;
  unsigned char D.45376;
  guint8 * code.5526;
  unsigned char iftmp.5527;
  guint8 * code.5528;
  unsigned char D.45385;
  guint8 * code.5529;
  guint8 * code.5530;
  guint8 * code.5531;
  guint8 * code.5532;
  guint8 * code.5533;
  guint8 * code.5534;
  guint8 * code.5535;
  guint8 * code.5536;
  guint8 * code.5537;
  unsigned char D.45403;
  guint8 * code.5538;
  unsigned char D.45405;
  guint8 * code.5539;
  unsigned char D.45407;
  guint8 * code.5540;
  unsigned char D.45409;
  guint8 * code.5541;
  guint8 * code.5542;
  guint8 * code.5543;
  guint8 * code.5544;
  unsigned char D.45419;
  guint8 * code.5545;
  unsigned char D.45421;
  guint8 * code.5546;
  unsigned char D.45423;
  guint8 * code.5547;
  unsigned char D.45425;
  unsigned int D.45426;
  _Bool D.45427;
  long int D.45428;
  long int D.45429;
  signed char iftmp.5548;
  signed char D.45438;
  guint8 * code.5549;
  unsigned char D.45442;
  guint8 * code.5550;
  guint8 * code.5551;
  signed char iftmp.5552;
  signed char D.45449;
  guint8 * code.5553;
  unsigned char D.45453;
  guint8 * code.5554;
  guint8 * code.5555;
  unsigned char D.45458;
  guint8 * code.5556;
  unsigned char D.45461;
  guint8 * code.5557;
  signed char iftmp.5558;
  signed char D.45471;
  guint8 * code.5559;
  unsigned char D.45475;
  guint8 * code.5560;
  guint8 * code.5561;
  signed char iftmp.5562;
  signed char D.45482;
  guint8 * code.5563;
  unsigned char D.45486;
  guint8 * code.5564;
  guint8 * code.5565;
  guint8 * code.5566;
  guint8 * code.5567;
  signed char iftmp.5568;
  signed char D.45502;
  guint8 * code.5569;
  unsigned char D.45506;
  guint8 * code.5570;
  guint8 * code.5571;
  signed char iftmp.5572;
  signed char D.45513;
  guint8 * code.5573;
  unsigned char D.45517;
  guint8 * code.5574;
  guint8 * code.5575;
  unsigned char D.45522;
  guint8 * code.5576;
  unsigned char D.45525;
  guint8 * code.5577;
  signed char iftmp.5578;
  signed char D.45535;
  guint8 * code.5579;
  unsigned char D.45539;
  guint8 * code.5580;
  guint8 * code.5581;
  signed char iftmp.5582;
  signed char D.45546;
  guint8 * code.5583;
  unsigned char D.45550;
  guint8 * code.5584;
  guint8 * code.5585;
  guint8 * code.5586;
  guint8 * code.5587;
  signed char iftmp.5588;
  signed char D.45566;
  guint8 * code.5589;
  unsigned char D.45570;
  guint8 * code.5590;
  guint8 * code.5591;
  signed char iftmp.5592;
  signed char D.45577;
  guint8 * code.5593;
  unsigned char D.45581;
  guint8 * code.5594;
  guint8 * code.5595;
  guint8 * code.5596;
  guint8 * code.5597;
  signed char iftmp.5598;
  signed char D.45597;
  guint8 * code.5599;
  unsigned char D.45601;
  guint8 * code.5600;
  guint8 * code.5601;
  signed char iftmp.5602;
  signed char D.45608;
  guint8 * code.5603;
  unsigned char D.45612;
  guint8 * code.5604;
  guint8 * code.5605;
  guint8 * code.5606;
  guint8 * code.5607;
  signed char iftmp.5608;
  signed char D.45628;
  guint8 * code.5609;
  unsigned char D.45632;
  guint8 * code.5610;
  guint8 * code.5611;
  signed char iftmp.5612;
  signed char D.45639;
  guint8 * code.5613;
  unsigned char D.45643;
  guint8 * code.5614;
  guint8 * code.5615;
  guint8 * code.5616;
  guint8 * code.5617;
  signed char iftmp.5618;
  signed char D.45659;
  guint8 * code.5619;
  unsigned char D.45663;
  guint8 * code.5620;
  guint8 * code.5621;
  signed char iftmp.5622;
  signed char D.45670;
  guint8 * code.5623;
  unsigned char D.45674;
  guint8 * code.5624;
  guint8 * code.5625;
  guint8 * code.5626;
  guint8 * code.5627;
  guint8 * code.5628;
  signed char iftmp.5629;
  signed char D.45687;
  guint8 * code.5630;
  unsigned char D.45691;
  guint8 * code.5631;
  guint8 * code.5632;
  guint8 * code.5633;
  signed char iftmp.5634;
  signed char D.45699;
  guint8 * code.5635;
  unsigned char D.45703;
  guint8 * code.5636;
  guint8 * code.5637;
  guint8 * code.5638;
  signed char iftmp.5639;
  signed char D.45711;
  guint8 * code.5640;
  unsigned char D.45715;
  guint8 * code.5641;
  guint8 * code.5642;
  guint8 * code.5643;
  guint8 * code.5644;
  unsigned char D.45722;
  guint8 * code.5645;
  unsigned char D.45725;
  guint8 * code.5646;
  unsigned char D.45731;
  guint8 * code.5647;
  guint8 * code.5648;
  guint8 * code.5649;
  guint8 * code.5650;
  guint8 * code.5651;
  unsigned char D.45745;
  guint8 * code.5652;
  guint8 * code.5653;
  unsigned char D.45752;
  unsigned char D.45753;
  guint8 * code.5654;
  unsigned char D.45756;
  unsigned char D.45757;
  guint8 * code.5655;
  guint8 * code.5656;
  unsigned char iftmp.5657;
  guint8 * code.5658;
  unsigned char D.45767;
  guint8 * code.5659;
  guint8 * code.5660;
  signed char iftmp.5661;
  signed char D.45774;
  guint8 * code.5662;
  unsigned char D.45778;
  guint8 * code.5663;
  guint8 * code.5664;
  guint8 * code.5665;
  signed char iftmp.5666;
  signed char D.45786;
  guint8 * code.5667;
  unsigned char D.45790;
  guint8 * code.5668;
  guint8 * code.5669;
  guint8 * code.5670;
  guint8 * code.5671;
  guint8 * code.5672;
  guint8 * code.5673;
  unsigned char D.45804;
  guint8 * code.5674;
  guint8 * code.5675;
  unsigned char D.45811;
  guint8 * code.5676;
  unsigned char D.45814;
  guint8 * code.5677;
  guint8 * code.5678;
  unsigned char iftmp.5679;
  guint8 * code.5680;
  unsigned char D.45824;
  guint8 * code.5681;
  guint8 * code.5682;
  guint8 * code.5683;
  unsigned char D.45831;
  guint8 * code.5684;
  guint8 * code.5685;
  guint8 * code.5686;
  guint8 * code.5687;
  signed char iftmp.5688;
  signed char D.45845;
  guint8 * code.5689;
  unsigned char D.45849;
  guint8 * code.5690;
  guint8 * code.5691;
  guint8 * code.5692;
  signed char iftmp.5693;
  signed char D.45857;
  guint8 * code.5694;
  unsigned char D.45861;
  guint8 * code.5695;
  guint8 * code.5696;
  guint8 * code.5697;
  guint8 * code.5698;
  guint8 * code.5699;
  guint8 * code.5700;
  unsigned char D.45873;
  guint8 * code.5701;
  guint8 * code.5702;
  unsigned char D.45880;
  unsigned char D.45881;
  guint8 * code.5703;
  unsigned char D.45884;
  unsigned char D.45885;
  guint8 * code.5704;
  signed char iftmp.5705;
  signed char D.45891;
  guint8 * code.5706;
  unsigned char D.45895;
  guint8 * code.5707;
  guint8 * code.5708;
  guint8 * code.5709;
  signed char iftmp.5710;
  signed char D.45903;
  guint8 * code.5711;
  unsigned char D.45907;
  guint8 * code.5712;
  guint8 * code.5713;
  guint8 * code.5714;
  guint8 * code.5715;
  guint8 * code.5716;
  guint8 * code.5717;
  unsigned char D.45921;
  guint8 * code.5718;
  guint8 * code.5719;
  unsigned char D.45928;
  guint8 * code.5720;
  unsigned char D.45931;
  guint8 * code.5721;
  guint8 * code.5722;
  unsigned char D.45937;
  guint8 * code.5723;
  guint8 * code.5724;
  guint8 * code.5725;
  guint8 * code.5726;
  signed char iftmp.5727;
  signed char D.45951;
  guint8 * code.5728;
  unsigned char D.45955;
  guint8 * code.5729;
  guint8 * code.5730;
  guint8 * code.5731;
  signed char iftmp.5732;
  signed char D.45963;
  guint8 * code.5733;
  unsigned char D.45967;
  guint8 * code.5734;
  guint8 * code.5735;
  guint8 * code.5736;
  guint8 * code.5737;
  guint8 * code.5738;
  guint8 * code.5739;
  unsigned char D.45979;
  guint8 * code.5740;
  guint8 * code.5741;
  unsigned char D.45986;
  unsigned char D.45987;
  guint8 * code.5742;
  unsigned char D.45990;
  unsigned char D.45991;
  guint8 * code.5743;
  signed char iftmp.5744;
  signed char D.45997;
  guint8 * code.5745;
  unsigned char D.46001;
  guint8 * code.5746;
  guint8 * code.5747;
  guint8 * code.5748;
  signed char iftmp.5749;
  int D.46009;
  _Bool D.46010;
  _Bool D.46011;
  _Bool D.46012;
  int D.46013;
  signed char D.46014;
  signed char D.46015;
  guint8 * code.5750;
  unsigned char D.46019;
  guint8 * code.5751;
  guint8 * code.5752;
  guint8 * code.5753;
  guint8 * code.5754;
  unsigned char D.46026;
  guint8 * code.5755;
  unsigned char D.46028;
  guint8 * code.5756;
  unsigned char D.46030;
  guint8 * code.5757;
  unsigned char D.46032;
  guint8 * code.5758;
  guint8 * code.5759;
  guint8 * code.5760;
  guint8 * code.5761;
  guint8 * code.5762;
  guint8 * code.5763;
  guint8 * code.5764;
  unsigned char D.46049;
  guint8 * code.5765;
  unsigned char D.46051;
  guint8 * code.5766;
  unsigned char D.46053;
  guint8 * code.5767;
  unsigned char D.46055;
  guint8 * code.5768;
  guint8 * code.5769;
  guint8 * code.5770;
  guint8 * code.5771;
  unsigned char D.46067;
  guint8 * code.5772;
  unsigned char D.46069;
  guint8 * code.5773;
  unsigned char D.46071;
  guint8 * code.5774;
  unsigned char D.46073;
  guint8 * code.5775;
  guint8 * code.5776;
  guint8 * code.5777;
  unsigned char D.46082;
  guint8 * code.5778;
  guint8 * code.5779;
  unsigned char D.46089;
  unsigned char D.46090;
  guint8 * code.5780;
  unsigned char D.46093;
  unsigned char D.46094;
  guint8 * code.5781;
  guint8 * code.5782;
  unsigned char iftmp.5783;
  guint8 * code.5784;
  unsigned char D.46104;
  guint8 * code.5785;
  guint8 * code.5786;
  guint8 * code.5787;
  guint8 * code.5788;
  unsigned int offset.5789;
  unsigned int D.46115;
  guint8 * code.5790;
  guint8 * code.5791;
  unsigned char D.46123;
  guint8 * code.5792;
  guint8 * code.5793;
  unsigned char D.46129;
  guint8 * code.5794;
  unsigned char D.46132;
  guint8 * code.5795;
  unsigned char D.46134;
  guint8 * code.5796;
  unsigned char D.46136;
  guint8 * code.5797;
  unsigned char D.46138;
  guint8 * code.5798;
  unsigned char D.46140;
  guint8 * code.5799;
  guint8 * code.5800;
  guint8 * code.5801;
  guint8 * code.5802;
  guint8 * code.5803;
  guint8 * code.5804;
  unsigned char D.46159;
  guint8 * code.5805;
  unsigned char D.46161;
  guint8 * code.5806;
  unsigned char D.46163;
  guint8 * code.5807;
  unsigned char D.46165;
  unsigned int offset.5808;
  unsigned int D.46169;
  guint8 * code.5809;
  guint8 * code.5810;
  unsigned char D.46177;
  guint8 * code.5811;
  guint8 * code.5812;
  unsigned char D.46183;
  guint8 * code.5813;
  unsigned char D.46186;
  guint8 * code.5814;
  unsigned char D.46188;
  guint8 * code.5815;
  unsigned char D.46190;
  guint8 * code.5816;
  unsigned char D.46192;
  guint8 * code.5817;
  unsigned char D.46194;
  guint8 * code.5818;
  guint8 * code.5819;
  guint8 * code.5820;
  guint8 * code.5821;
  guint8 * code.5822;
  guint8 * code.5823;
  unsigned char D.46213;
  guint8 * code.5824;
  unsigned char D.46215;
  guint8 * code.5825;
  unsigned char D.46217;
  guint8 * code.5826;
  unsigned char D.46219;
  unsigned int offset.5827;
  unsigned int D.46223;
  guint8 * code.5828;
  guint8 * code.5829;
  unsigned char D.46231;
  guint8 * code.5830;
  guint8 * code.5831;
  unsigned char D.46237;
  guint8 * code.5832;
  unsigned char D.46240;
  guint8 * code.5833;
  unsigned char D.46242;
  guint8 * code.5834;
  unsigned char D.46244;
  guint8 * code.5835;
  unsigned char D.46246;
  guint8 * code.5836;
  unsigned char D.46248;
  guint8 * code.5837;
  guint8 * code.5838;
  guint8 * code.5839;
  guint8 * code.5840;
  guint8 * code.5841;
  guint8 * code.5842;
  unsigned char D.46267;
  guint8 * code.5843;
  unsigned char D.46269;
  guint8 * code.5844;
  unsigned char D.46271;
  guint8 * code.5845;
  unsigned char D.46273;
  unsigned int offset.5846;
  unsigned int D.46277;
  guint8 * code.5847;
  guint8 * code.5848;
  unsigned char D.46285;
  guint8 * code.5849;
  guint8 * code.5850;
  guint8 * code.5851;
  guint8 * code.5852;
  unsigned char D.46294;
  guint8 * code.5853;
  unsigned char D.46296;
  guint8 * code.5854;
  unsigned char D.46298;
  guint8 * code.5855;
  unsigned char D.46300;
  guint8 * code.5856;
  guint8 * code.5857;
  guint8 * code.5858;
  guint8 * code.5859;
  guint8 * code.5860;
  guint8 * code.5861;
  unsigned char D.46319;
  guint8 * code.5862;
  unsigned char D.46321;
  guint8 * code.5863;
  unsigned char D.46323;
  guint8 * code.5864;
  unsigned char D.46325;
  unsigned int offset.5865;
  unsigned int D.46329;
  guint8 * code.5866;
  guint8 * code.5867;
  unsigned char D.46337;
  guint8 * code.5868;
  guint8 * code.5869;
  guint8 * code.5870;
  guint8 * code.5871;
  unsigned char D.46346;
  guint8 * code.5872;
  unsigned char D.46348;
  guint8 * code.5873;
  unsigned char D.46350;
  guint8 * code.5874;
  unsigned char D.46352;
  guint8 * code.5875;
  guint8 * code.5876;
  guint8 * code.5877;
  guint8 * code.5878;
  guint8 * code.5879;
  guint8 * code.5880;
  unsigned char D.46371;
  guint8 * code.5881;
  unsigned char D.46373;
  guint8 * code.5882;
  unsigned char D.46375;
  guint8 * code.5883;
  unsigned char D.46377;
  unsigned int offset.5884;
  unsigned int D.46381;
  guint8 * code.5885;
  guint8 * code.5886;
  unsigned char D.46389;
  guint8 * code.5887;
  guint8 * code.5888;
  guint8 * code.5889;
  guint8 * code.5890;
  unsigned char D.46398;
  guint8 * code.5891;
  unsigned char D.46400;
  guint8 * code.5892;
  unsigned char D.46402;
  guint8 * code.5893;
  unsigned char D.46404;
  guint8 * code.5894;
  guint8 * code.5895;
  guint8 * code.5896;
  guint8 * code.5897;
  guint8 * code.5898;
  guint8 * code.5899;
  unsigned char D.46423;
  guint8 * code.5900;
  unsigned char D.46425;
  guint8 * code.5901;
  unsigned char D.46427;
  guint8 * code.5902;
  unsigned char D.46429;
  unsigned int offset.5903;
  unsigned int D.46433;
  guint8 * code.5904;
  guint8 * code.5905;
  unsigned char D.46441;
  guint8 * code.5906;
  guint8 * code.5907;
  guint8 * code.5908;
  guint8 * code.5909;
  unsigned char D.46450;
  guint8 * code.5910;
  unsigned char D.46452;
  guint8 * code.5911;
  unsigned char D.46454;
  guint8 * code.5912;
  unsigned char D.46456;
  guint8 * code.5913;
  guint8 * code.5914;
  guint8 * code.5915;
  guint8 * code.5916;
  guint8 * code.5917;
  guint8 * code.5918;
  unsigned char D.46475;
  guint8 * code.5919;
  unsigned char D.46477;
  guint8 * code.5920;
  unsigned char D.46479;
  guint8 * code.5921;
  unsigned char D.46481;
  guint8 * code.5922;
  guint8 * code.5923;
  unsigned int offset.5924;
  unsigned int D.46492;
  guint8 * code.5925;
  guint8 * code.5926;
  unsigned char D.46500;
  guint8 * code.5927;
  guint8 * code.5928;
  guint8 * code.5929;
  guint8 * code.5930;
  unsigned char D.46509;
  guint8 * code.5931;
  unsigned char D.46511;
  guint8 * code.5932;
  unsigned char D.46513;
  guint8 * code.5933;
  unsigned char D.46515;
  guint8 * code.5934;
  guint8 * code.5935;
  guint8 * code.5936;
  guint8 * code.5937;
  guint8 * code.5938;
  guint8 * code.5939;
  unsigned char D.46534;
  guint8 * code.5940;
  unsigned char D.46536;
  guint8 * code.5941;
  unsigned char D.46538;
  guint8 * code.5942;
  unsigned char D.46540;
  unsigned int offset.5943;
  unsigned int D.46544;
  guint8 * code.5944;
  guint8 * code.5945;
  unsigned char D.46552;
  guint8 * code.5946;
  guint8 * code.5947;
  guint8 * code.5948;
  guint8 * code.5949;
  unsigned char D.46561;
  guint8 * code.5950;
  unsigned char D.46563;
  guint8 * code.5951;
  unsigned char D.46565;
  guint8 * code.5952;
  unsigned char D.46567;
  guint8 * code.5953;
  guint8 * code.5954;
  guint8 * code.5955;
  guint8 * code.5956;
  guint8 * code.5957;
  guint8 * code.5958;
  unsigned char D.46586;
  guint8 * code.5959;
  unsigned char D.46588;
  guint8 * code.5960;
  unsigned char D.46590;
  guint8 * code.5961;
  unsigned char D.46592;
  guint8 * code.5962;
  guint8 * code.5963;
  unsigned int offset.5964;
  unsigned int D.46601;
  guint8 * code.5965;
  guint8 * code.5966;
  unsigned char D.46609;
  guint8 * code.5967;
  guint8 * code.5968;
  unsigned char D.46615;
  guint8 * code.5969;
  unsigned char D.46618;
  guint8 * code.5970;
  unsigned char D.46620;
  guint8 * code.5971;
  unsigned char D.46622;
  guint8 * code.5972;
  unsigned char D.46624;
  guint8 * code.5973;
  unsigned char D.46626;
  guint8 * code.5974;
  guint8 * code.5975;
  guint8 * code.5976;
  guint8 * code.5977;
  guint8 * code.5978;
  guint8 * code.5979;
  unsigned char D.46645;
  guint8 * code.5980;
  unsigned char D.46647;
  guint8 * code.5981;
  unsigned char D.46649;
  guint8 * code.5982;
  unsigned char D.46651;
  unsigned int offset.5983;
  unsigned int D.46655;
  guint8 * code.5984;
  guint8 * code.5985;
  unsigned char D.46663;
  guint8 * code.5986;
  guint8 * code.5987;
  guint8 * code.5988;
  guint8 * code.5989;
  unsigned char D.46672;
  guint8 * code.5990;
  unsigned char D.46674;
  guint8 * code.5991;
  unsigned char D.46676;
  guint8 * code.5992;
  unsigned char D.46678;
  guint8 * code.5993;
  guint8 * code.5994;
  guint8 * code.5995;
  guint8 * code.5996;
  guint8 * code.5997;
  guint8 * code.5998;
  unsigned char D.46697;
  guint8 * code.5999;
  unsigned char D.46699;
  guint8 * code.6000;
  unsigned char D.46701;
  guint8 * code.6001;
  unsigned char D.46703;
  guint8 * code.6002;
  guint8 * code.6003;
  unsigned int offset.6004;
  unsigned int D.46712;
  guint8 * code.6005;
  guint8 * code.6006;
  unsigned char D.46720;
  guint8 * code.6007;
  guint8 * code.6008;
  unsigned char D.46726;
  guint8 * code.6009;
  unsigned char D.46729;
  guint8 * code.6010;
  unsigned char D.46731;
  guint8 * code.6011;
  unsigned char D.46733;
  guint8 * code.6012;
  unsigned char D.46735;
  guint8 * code.6013;
  unsigned char D.46737;
  guint8 * code.6014;
  guint8 * code.6015;
  guint8 * code.6016;
  guint8 * code.6017;
  guint8 * code.6018;
  guint8 * code.6019;
  unsigned char D.46756;
  guint8 * code.6020;
  unsigned char D.46758;
  guint8 * code.6021;
  unsigned char D.46760;
  guint8 * code.6022;
  unsigned char D.46762;
  unsigned int offset.6023;
  unsigned int D.46766;
  guint8 * code.6024;
  guint8 * code.6025;
  unsigned char D.46774;
  guint8 * code.6026;
  guint8 * code.6027;
  guint8 * code.6028;
  guint8 * code.6029;
  unsigned char D.46783;
  guint8 * code.6030;
  unsigned char D.46785;
  guint8 * code.6031;
  unsigned char D.46787;
  guint8 * code.6032;
  unsigned char D.46789;
  guint8 * code.6033;
  guint8 * code.6034;
  guint8 * code.6035;
  guint8 * code.6036;
  guint8 * code.6037;
  guint8 * code.6038;
  unsigned char D.46808;
  guint8 * code.6039;
  unsigned char D.46810;
  guint8 * code.6040;
  unsigned char D.46812;
  guint8 * code.6041;
  unsigned char D.46814;
  unsigned int offset.6042;
  unsigned int D.46818;
  guint8 * code.6043;
  guint8 * code.6044;
  unsigned char D.46826;
  guint8 * code.6045;
  guint8 * code.6046;
  guint8 * code.6047;
  guint8 * code.6048;
  unsigned char D.46835;
  guint8 * code.6049;
  unsigned char D.46837;
  guint8 * code.6050;
  unsigned char D.46839;
  guint8 * code.6051;
  unsigned char D.46841;
  guint8 * code.6052;
  guint8 * code.6053;
  guint8 * code.6054;
  guint8 * code.6055;
  guint8 * code.6056;
  guint8 * code.6057;
  unsigned char D.46860;
  guint8 * code.6058;
  unsigned char D.46862;
  guint8 * code.6059;
  unsigned char D.46864;
  guint8 * code.6060;
  unsigned char D.46866;
  guint8 * code.6061;
  unsigned char D.46872;
  guint8 * code.6062;
  guint8 * code.6063;
  guint8 * code.6064;
  unsigned char D.46881;
  guint8 * code.6065;
  guint8 * code.6066;
  unsigned char D.46884;
  guint8 * code.6067;
  unsigned char D.46886;
  guint8 * code.6068;
  unsigned char D.46888;
  guint8 * code.6069;
  unsigned char D.46890;
  guint8 * code.6070;
  unsigned char D.46895;
  guint8 * code.6071;
  guint8 * code.6072;
  guint8 * code.6073;
  unsigned char D.46899;
  guint8 * code.6074;
  unsigned char D.46901;
  guint8 * code.6075;
  unsigned char D.46903;
  guint8 * code.6076;
  unsigned char D.46905;
  guint8 * code.6077;
  unsigned char iftmp.6078;
  guint8 * code.6079;
  unsigned char D.46914;
  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;
  unsigned char D.46932;
  guint8 * code.6089;
  unsigned char D.46934;
  guint8 * code.6090;
  unsigned char D.46936;
  guint8 * code.6091;
  unsigned char D.46938;
  guint8 * code.6092;
  guint8 * code.6093;
  guint8 * code.6094;
  guint8 * code.6095;
  unsigned char D.46948;
  guint8 * code.6096;
  unsigned char D.46950;
  guint8 * code.6097;
  unsigned char D.46952;
  guint8 * code.6098;
  unsigned char D.46954;
  guint8 * code.6099;
  unsigned char D.46958;
  guint8 * code.6100;
  guint8 * code.6101;
  guint8 * code.6102;
  unsigned char D.46964;
  guint8 * code.6103;
  unsigned char D.46966;
  guint8 * code.6104;
  unsigned char D.46968;
  guint8 * code.6105;
  unsigned char D.46970;
  guint8 * code.6106;
  guint8 * code.6107;
  guint8 * code.6108;
  guint8 * code.6109;
  guint8 * code.6110;
  guint8 * code.6111;
  guint8 * code.6112;
  unsigned char D.46987;
  guint8 * code.6113;
  unsigned char D.46989;
  guint8 * code.6114;
  unsigned char D.46991;
  guint8 * code.6115;
  unsigned char D.46993;
  guint8 * code.6116;
  guint8 * code.6117;
  guint8 * code.6118;
  guint8 * code.6119;
  unsigned char D.47003;
  guint8 * code.6120;
  unsigned char D.47005;
  guint8 * code.6121;
  unsigned char D.47007;
  guint8 * code.6122;
  unsigned char D.47009;
  guint8 * code.6123;
  unsigned char D.47013;
  guint8 * code.6124;
  guint8 * code.6125;
  guint8 * code.6126;
  guint8 * code.6127;
  unsigned char D.47020;
  guint8 * code.6128;
  guint8 * code.6129;
  guint8 * code.6130;
  unsigned char D.47028;
  guint8 * code.6131;
  guint8 * code.6132;
  guint8 * code.6133;
  unsigned char D.47037;
  guint8 * code.6134;
  guint8 * code.6135;
  unsigned char D.47040;
  guint8 * code.6136;
  unsigned char D.47042;
  guint8 * code.6137;
  unsigned char D.47044;
  guint8 * code.6138;
  unsigned char D.47046;
  guint8 * code.6139;
  unsigned char D.47051;
  guint8 * code.6140;
  guint8 * code.6141;
  guint8 * code.6142;
  unsigned char D.47055;
  guint8 * code.6143;
  unsigned char D.47057;
  guint8 * code.6144;
  unsigned char D.47059;
  guint8 * code.6145;
  unsigned char D.47061;
  guint8 * code.6146;
  unsigned char D.47067;
  guint8 * code.6147;
  guint8 * code.6148;
  guint8 * code.6149;
  unsigned char D.47076;
  guint8 * code.6150;
  guint8 * code.6151;
  unsigned char D.47079;
  guint8 * code.6152;
  unsigned char D.47081;
  guint8 * code.6153;
  unsigned char D.47083;
  guint8 * code.6154;
  unsigned char D.47085;
  guint8 * code.6155;
  unsigned char D.47090;
  guint8 * code.6156;
  guint8 * code.6157;
  guint8 * code.6158;
  unsigned char D.47094;
  guint8 * code.6159;
  unsigned char D.47096;
  guint8 * code.6160;
  unsigned char D.47098;
  guint8 * code.6161;
  unsigned char D.47100;
  guint8 * code.6162;
  unsigned char D.47104;
  guint8 * code.6163;
  guint8 * code.6164;
  unsigned char D.47109;
  guint8 * code.6165;
  guint8 * code.6166;
  guint8 * code.6167;
  guint8 * code.6168;
  guint8 * code.6169;
  guint8 * code.6170;
  unsigned char D.47121;
  guint8 * code.6171;
  unsigned char D.47123;
  guint8 * code.6172;
  unsigned char D.47125;
  guint8 * code.6173;
  unsigned char D.47127;
  struct MonoBasicBlock * * D.47129;
  struct MonoBasicBlock * D.47130;
  int D.47131;
  sizetype D.47134;
  unsigned char * D.47135;
  long int D.47136;
  long int D.47137;
  unsigned int D.47138;
  unsigned int D.47139;
  unsigned int offset.6174;
  unsigned int D.47141;
  guint8 * code.6175;
  guint8 * code.6176;
  unsigned char D.47149;
  unsigned int D.47151;
  guint8 * code.6177;
  guint8 * code.6178;
  guint8 * code.6179;
  guint8 * code.6180;
  unsigned char D.47159;
  guint8 * code.6181;
  unsigned char D.47161;
  guint8 * code.6182;
  unsigned char D.47163;
  guint8 * code.6183;
  unsigned char D.47165;
  int D.47170;
  unsigned int D.47171;
  unsigned int D.47172;
  int D.47173;
  guint8 * code.6184;
  guint8 * code.6185;
  guint8 * code.6186;
  guint8 * code.6187;
  guint8 * code.6188;
  guint8 * code.6189;
  unsigned char D.47188;
  guint8 * code.6190;
  unsigned char D.47190;
  guint8 * code.6191;
  unsigned char D.47192;
  guint8 * code.6192;
  unsigned char D.47194;
  guint8 * code.6193;
  unsigned char D.47200;
  guint8 * code.6194;
  guint8 * code.6195;
  guint8 * code.6196;
  unsigned char D.47209;
  guint8 * code.6197;
  guint8 * code.6198;
  unsigned char D.47212;
  guint8 * code.6199;
  unsigned char D.47214;
  guint8 * code.6200;
  unsigned char D.47216;
  guint8 * code.6201;
  unsigned char D.47218;
  guint8 * code.6202;
  unsigned char D.47223;
  guint8 * code.6203;
  guint8 * code.6204;
  guint8 * code.6205;
  unsigned char D.47227;
  guint8 * code.6206;
  unsigned char D.47229;
  guint8 * code.6207;
  unsigned char D.47231;
  guint8 * code.6208;
  unsigned char D.47233;
  int D.47234;
  guint8 * code.6209;
  guint8 * code.6210;
  unsigned char D.47239;
  guint8 * code.6211;
  guint8 * code.6212;
  guint8 * code.6213;
  guint8 * code.6214;
  guint8 * code.6215;
  guint8 * code.6216;
  guint8 * code.6217;
  guint8 * code.6218;
  unsigned char D.47258;
  guint8 * code.6219;
  unsigned char D.47260;
  guint8 * code.6220;
  unsigned char D.47262;
  guint8 * code.6221;
  unsigned char D.47264;
  guint8 * code.6222;
  guint8 * code.6223;
  guint8 * code.6224;
  guint8 * code.6225;
  unsigned char D.47274;
  guint8 * code.6226;
  unsigned char D.47276;
  guint8 * code.6227;
  unsigned char D.47278;
  guint8 * code.6228;
  unsigned char D.47280;
  guint8 * code.6229;
  guint8 * code.6230;
  guint8 * code.6231;
  guint8 * code.6232;
  guint8 * code.6233;
  guint8 * code.6234;
  guint8 * code.6235;
  guint8 * code.6236;
  unsigned char D.47298;
  guint8 * code.6237;
  unsigned char D.47300;
  guint8 * code.6238;
  unsigned char D.47302;
  guint8 * code.6239;
  unsigned char D.47304;
  guint8 * code.6240;
  guint8 * code.6241;
  guint8 * code.6242;
  guint8 * code.6243;
  unsigned char D.47314;
  guint8 * code.6244;
  unsigned char D.47316;
  guint8 * code.6245;
  unsigned char D.47318;
  guint8 * code.6246;
  unsigned char D.47320;
  guint8 * code.6247;
  unsigned char D.47322;
  guint8 * code.6248;
  unsigned char D.47324;
  guint8 * code.6249;
  unsigned char D.47326;
  guint8 * code.6250;
  unsigned char D.47328;
  guint32 iftmp.6251;
  guint8 * code.6252;
  signed char iftmp.6253;
  signed char iftmp.6254;
  signed char D.47349;
  signed char D.47350;
  _Bool D.47351;
  _Bool D.47352;
  _Bool D.47353;
  guint8 * code.6255;
  unsigned char D.47357;
  guint8 * code.6256;
  guint8 * code.6257;
  guint8 * code.6258;
  guint8 * code.6259;
  signed char iftmp.6260;
  signed char iftmp.6261;
  signed char D.47370;
  signed char D.47371;
  _Bool D.47372;
  _Bool D.47373;
  guint8 * code.6262;
  unsigned char D.47377;
  guint8 * code.6263;
  guint8 * code.6264;
  guint8 * code.6265;
  guint8 * code.6266;
  int D.47389;
  int D.47390;
  signed char D.47391;
  signed char D.47392;
  unsigned char D.47393;
  guint8 * code.6267;
  guint8 * code.6268;
  signed char D.47399;
  unsigned char D.47400;
  guint8 * code.6269;
  guint8 * code.6270;
  signed char D.47404;
  unsigned char D.47405;
  guint8 * code.6271;
  guint8 * code.6272;
  unsigned char D.47408;
  guint8 * code.6273;
  unsigned char D.47410;
  guint8 * code.6274;
  unsigned char D.47412;
  guint8 * code.6275;
  unsigned char D.47414;
  guint8 * code.6276;
  signed char D.47420;
  unsigned char D.47421;
  guint8 * code.6277;
  signed char D.47425;
  signed char D.47426;
  unsigned char D.47427;
  guint8 * code.6278;
  signed char D.47430;
  signed char D.47431;
  unsigned char D.47432;
  guint8 * code.6279;
  unsigned char D.47434;
  guint8 * code.6280;
  unsigned char D.47436;
  guint8 * code.6281;
  unsigned char D.47438;
  guint8 * code.6282;
  unsigned char D.47440;
  guint8 * code.6283;
  signed char iftmp.6284;
  signed char iftmp.6285;
  signed char D.47454;
  _Bool D.47455;
  signed char D.47456;
  signed char D.47457;
  _Bool D.47458;
  _Bool D.47459;
  guint8 * code.6286;
  unsigned char D.47463;
  guint8 * code.6287;
  guint8 * code.6288;
  guint8 * code.6289;
  signed char D.47467;
  signed char D.47468;
  signed char D.47469;
  unsigned char D.47470;
  guint32 iftmp.6290;
  guint8 * code.6291;
  signed char iftmp.6292;
  signed char iftmp.6293;
  signed char D.47489;
  signed char D.47490;
  _Bool D.47491;
  _Bool D.47492;
  _Bool D.47493;
  guint8 * code.6294;
  unsigned char D.47497;
  guint8 * code.6295;
  guint8 * code.6296;
  guint8 * code.6297;
  int D.47501;
  int D.47502;
  signed char D.47503;
  signed char D.47504;
  signed char D.47505;
  unsigned char D.47506;
  guint8 * code.6298;
  signed char iftmp.6299;
  signed char iftmp.6300;
  signed char D.47516;
  signed char D.47517;
  _Bool D.47518;
  _Bool D.47519;
  guint8 * code.6301;
  unsigned char D.47523;
  guint8 * code.6302;
  guint8 * code.6303;
  guint8 * code.6304;
  guint8 * code.6305;
  signed char D.47535;
  unsigned char D.47536;
  guint8 * code.6306;
  guint8 * code.6307;
  signed char D.47542;
  unsigned char D.47543;
  guint8 * code.6308;
  guint8 * code.6309;
  signed char D.47547;
  unsigned char D.47548;
  guint8 * code.6310;
  guint8 * code.6311;
  unsigned char D.47551;
  guint8 * code.6312;
  unsigned char D.47553;
  guint8 * code.6313;
  unsigned char D.47555;
  guint8 * code.6314;
  unsigned char D.47557;
  guint8 * code.6315;
  signed char D.47563;
  unsigned char D.47564;
  guint8 * code.6316;
  signed char D.47568;
  signed char D.47569;
  unsigned char D.47570;
  guint8 * code.6317;
  signed char D.47573;
  signed char D.47574;
  unsigned char D.47575;
  guint8 * code.6318;
  unsigned char D.47577;
  guint8 * code.6319;
  unsigned char D.47579;
  guint8 * code.6320;
  unsigned char D.47581;
  guint8 * code.6321;
  unsigned char D.47583;
  signed char iftmp.6322;
  signed char iftmp.6323;
  signed char D.47592;
  signed char D.47593;
  _Bool D.47594;
  _Bool D.47595;
  guint8 * code.6324;
  unsigned char D.47599;
  guint8 * code.6325;
  guint8 * code.6326;
  guint8 * code.6327;
  signed char iftmp.6328;
  signed char iftmp.6329;
  signed char D.47615;
  _Bool D.47616;
  signed char D.47617;
  signed char D.47618;
  _Bool D.47619;
  _Bool D.47620;
  guint8 * code.6330;
  unsigned char D.47624;
  guint8 * code.6331;
  guint8 * code.6332;
  guint8 * code.6333;
  signed char D.47628;
  signed char D.47629;
  signed char D.47630;
  unsigned char D.47631;
  _Bool D.47641;
  _Bool D.47642;
  _Bool D.47643;
  guint8 * code.6334;
  unsigned char iftmp.6335;
  guint8 * code.6336;
  unsigned char D.47656;
  guint8 * code.6337;
  guint8 * code.6338;
  guint8 * code.6339;
  signed char D.47660;
  signed char D.47661;
  signed char D.47662;
  unsigned char D.47663;
  guint8 * code.6340;
  guint8 * code.6341;
  unsigned char D.47674;
  guint8 * code.6342;
  guint8 * code.6343;
  guint8 * code.6344;
  _Bool D.47679;
  long int D.47680;
  long int D.47681;
  guint8 * code.6345;
  unsigned char D.47687;
  guint8 * code.6346;
  guint8 * code.6347;
  unsigned char iftmp.6348;
  _Bool D.47696;
  _Bool D.47697;
  _Bool D.47698;
  guint8 * code.6349;
  unsigned char D.47702;
  guint8 * code.6350;
  guint8 * code.6351;
  guint8 * code.6352;
  guint8 * code.6353;
  signed char iftmp.6354;
  _Bool D.47713;
  signed char D.47714;
  signed char D.47715;
  _Bool D.47716;
  _Bool D.47717;
  guint8 * code.6355;
  unsigned char D.47721;
  guint8 * code.6356;
  guint8 * code.6357;
  guint8 * code.6358;
  guint8 * code.6359;
  unsigned char D.47728;
  guint8 * code.6360;
  unsigned char D.47730;
  guint8 * code.6361;
  unsigned char D.47732;
  guint8 * code.6362;
  unsigned char D.47734;
  int D.47736;
  guint8 * code.6363;
  guint8 * code.6364;
  guint8 * code.6365;
  guint8 * code.6366;
  guint8 * code.6367;
  guint8 * code.6368;
  guint8 * code.6369;
  unsigned char D.47752;
  guint8 * code.6370;
  unsigned char D.47754;
  guint8 * code.6371;
  unsigned char D.47756;
  guint8 * code.6372;
  unsigned char D.47758;
  guint8 * code.6373;
  unsigned char D.47764;
  unsigned char D.47765;
  guint8 * code.6374;
  signed char D.47769;
  unsigned char D.47770;
  guint8 * code.6375;
  signed char D.47773;
  unsigned char D.47774;
  guint8 * code.6376;
  unsigned char D.47776;
  guint8 * code.6377;
  unsigned char D.47778;
  guint8 * code.6378;
  unsigned char D.47780;
  guint8 * code.6379;
  unsigned char D.47782;
  guint8 * code.6380;
  signed char iftmp.6381;
  signed char iftmp.6382;
  signed char D.47792;
  signed char D.47793;
  _Bool D.47794;
  _Bool D.47795;
  guint8 * code.6383;
  unsigned char D.47799;
  guint8 * code.6384;
  guint8 * code.6385;
  guint8 * code.6386;
  int D.47807;
  int D.47808;
  signed char D.47809;
  signed char D.47810;
  unsigned char D.47811;
  guint8 * code.6387;
  guint8 * code.6388;
  signed char D.47817;
  unsigned char D.47818;
  guint8 * code.6389;
  guint8 * code.6390;
  signed char D.47822;
  unsigned char D.47823;
  guint8 * code.6391;
  guint8 * code.6392;
  unsigned char D.47826;
  guint8 * code.6393;
  unsigned char D.47828;
  guint8 * code.6394;
  unsigned char D.47830;
  guint8 * code.6395;
  unsigned char D.47832;
  guint8 * code.6396;
  signed char D.47838;
  unsigned char D.47839;
  guint8 * code.6397;
  signed char D.47843;
  signed char D.47844;
  unsigned char D.47845;
  guint8 * code.6398;
  signed char D.47848;
  signed char D.47849;
  unsigned char D.47850;
  guint8 * code.6399;
  unsigned char D.47852;
  guint8 * code.6400;
  unsigned char D.47854;
  guint8 * code.6401;
  unsigned char D.47856;
  guint8 * code.6402;
  unsigned char D.47858;
  guint8 * code.6403;
  guint8 * code.6404;
  guchar * D.47864;
  guchar * D.47865;
  guint8 * code.6405;
  unsigned char D.47871;
  guint8 * code.6406;
  int D.47876;
  _Bool D.47877;
  long int D.47878;
  long int D.47879;
  _Bool D.47882;
  long int D.47883;
  long int D.47884;
  _Bool D.47887;
  long int D.47888;
  long int D.47889;
  guint8 * code.6407;
  signed char iftmp.6408;
  signed char iftmp.6409;
  signed char D.47901;
  signed char D.47902;
  _Bool D.47903;
  _Bool D.47904;
  _Bool D.47905;
  guint8 * code.6410;
  unsigned char D.47909;
  guint8 * code.6411;
  guint8 * code.6412;
  guint8 * code.6413;
  guint8 * code.6414;
  guint8 * code.6415;
  guint8 * code.6416;
  guint8 * code.6417;
  guint8 * code.6418;
  guint8 * code.6419;
  unsigned char D.47927;
  guint8 * code.6420;
  unsigned char D.47929;
  guint8 * code.6421;
  unsigned char D.47931;
  guint8 * code.6422;
  unsigned char D.47933;
  guint8 * code.6423;
  guint8 * code.6424;
  guint8 * code.6425;
  guint8 * code.6426;
  unsigned char D.47945;
  guint8 * code.6427;
  unsigned char D.47947;
  guint8 * code.6428;
  unsigned char D.47949;
  guint8 * code.6429;
  unsigned char D.47951;
  guint8 * code.6430;
  signed char iftmp.6431;
  signed char iftmp.6432;
  signed char D.47965;
  _Bool D.47966;
  _Bool D.47967;
  guint8 * code.6433;
  unsigned char D.47971;
  guint8 * code.6434;
  guint8 * code.6435;
  guint8 * code.6436;
  void * D.47975;
  int nursery_shift.6437;
  int D.47982;
  guint8 * code.6438;
  unsigned char iftmp.6439;
  guint8 * code.6440;
  unsigned char D.47997;
  guint8 * code.6441;
  guint8 * code.6442;
  guint8 * code.6443;
  signed char D.48001;
  signed char D.48002;
  signed char D.48003;
  unsigned char D.48004;
  guint8 * code.6444;
  unsigned char D.48008;
  guint8 * code.6445;
  guint8 * code.6446;
  guint8 * code.6447;
  guint8 * code.6448;
  unsigned char D.48016;
  long unsigned int D.48017;
  guint8 * code.6449;
  guint8 * code.6450;
  unsigned char D.48026;
  guint8 * code.6451;
  guint8 * code.6452;
  guint8 * code.6453;
  guint8 * code.6454;
  guint8 * code.6455;
  guint8 * code.6456;
  guint8 * code.6457;
  guint8 * code.6458;
  guint8 * code.6459;
  unsigned char D.48044;
  guint8 * code.6460;
  unsigned char D.48046;
  guint8 * code.6461;
  unsigned char D.48048;
  guint8 * code.6462;
  unsigned char D.48050;
  guint8 * code.6463;
  guint8 * code.6464;
  guint8 * code.6465;
  guint8 * code.6466;
  unsigned char D.48060;
  guint8 * code.6467;
  unsigned char D.48062;
  guint8 * code.6468;
  unsigned char D.48064;
  guint8 * code.6469;
  unsigned char D.48066;
  int D.48067;
  long unsigned int D.48068;
  _Bool D.48069;
  unsigned char iftmp.6470;
  guint8 * code.6471;
  unsigned char D.48077;
  guint8 * code.6472;
  guint8 * code.6473;
  unsigned char D.48082;
  guint8 * code.6474;
  unsigned char D.48084;
  guint8 * code.6475;
  unsigned char D.48086;
  guint8 * code.6476;
  unsigned char D.48088;
  guint8 * code.6477;
  unsigned char D.48090;
  guint8 * code.6478;
  unsigned char D.48092;
  guint8 * code.6479;
  unsigned char D.48094;
  guint8 * code.6480;
  unsigned char D.48096;
  guint8 * code.6481;
  unsigned char D.48099;
  guint8 * code.6482;
  unsigned char D.48101;
  guint8 * code.6483;
  unsigned char D.48103;
  guint8 * code.6484;
  unsigned char D.48105;
  guint8 * code.6485;
  unsigned char D.48109;
  guint8 * code.6486;
  guint8 * code.6487;
  guint8 * code.6488;
  guint8 * code.6489;
  unsigned char D.48118;
  guint8 * code.6490;
  guint8 * code.6491;
  guint8 * code.6492;
  guint8 * code.6493;
  unsigned char D.48125;
  guint8 * code.6494;
  unsigned char D.48127;
  guint8 * code.6495;
  unsigned char D.48129;
  guint8 * code.6496;
  unsigned char D.48131;
  guint8 * code.6497;
  guint8 * code.6498;
  guint8 * code.6499;
  guint8 * code.6500;
  guint8 * code.6501;
  guint8 * code.6502;
  guint8 * code.6503;
  unsigned char D.48148;
  guint8 * code.6504;
  unsigned char D.48150;
  guint8 * code.6505;
  unsigned char D.48152;
  guint8 * code.6506;
  unsigned char D.48154;
  guint8 * code.6507;
  guint8 * code.6508;
  guint8 * code.6509;
  guint8 * code.6510;
  unsigned char D.48164;
  guint8 * code.6511;
  unsigned char D.48166;
  guint8 * code.6512;
  unsigned char D.48168;
  guint8 * code.6513;
  unsigned char D.48170;
  unsigned int D.48172;
  unsigned int D.48173;
  guint8 * code.6514;
  unsigned char D.48179;
  guint8 * code.6515;
  guint8 * code.6516;
  unsigned char D.48182;
  guint8 * code.6517;
  unsigned char D.48189;
  guint8 * code.6518;
  guint8 * code.6519;
  unsigned char D.48192;
  guint8 * code.6520;
  unsigned char D.48194;
  guint8 * code.6521;
  unsigned char D.48196;
  guint8 * code.6522;
  unsigned char D.48198;
  guint8 * code.6523;
  unsigned char D.48203;
  guint8 * code.6524;
  guint8 * code.6525;
  guint8 * code.6526;
  unsigned char D.48207;
  guint8 * code.6527;
  unsigned char D.48209;
  guint8 * code.6528;
  unsigned char D.48211;
  guint8 * code.6529;
  unsigned char D.48213;
  guint8 * code.6530;
  guint8 * code.6531;
  guint8 * code.6532;
  unsigned char iftmp.6533;
  guint8 * code.6534;
  unsigned char D.48229;
  guint8 * code.6535;
  guint8 * code.6536;
  guint8 * code.6537;
  signed char D.48233;
  signed char D.48234;
  signed char D.48235;
  unsigned char D.48236;
  guint8 * code.6538;
  unsigned char D.48240;
  int card_table_shift.6539;
  guint8 * code.6540;
  guint8 * code.6541;
  guint8 * code.6542;
  guint8 * code.6543;
  unsigned char D.48249;
  void * card_table_mask.6544;
  long int card_table_mask.6545;
  unsigned int D.48254;
  unsigned int D.48255;
  guint8 * code.6546;
  unsigned char D.48261;
  guint8 * code.6547;
  guint8 * code.6548;
  unsigned char D.48264;
  guint8 * code.6549;
  unsigned char D.48271;
  guint8 * code.6550;
  int D.48273;
  guint8 * code.6551;
  unsigned char D.48275;
  guint8 * code.6552;
  unsigned char D.48277;
  guint8 * code.6553;
  unsigned char D.48279;
  guint8 * code.6554;
  unsigned char D.48281;
  guint8 * code.6555;
  unsigned char D.48286;
  guint8 * code.6556;
  guint8 * code.6557;
  guint8 * code.6558;
  unsigned char D.48290;
  guint8 * code.6559;
  unsigned char D.48292;
  guint8 * code.6560;
  unsigned char D.48294;
  guint8 * code.6561;
  unsigned char D.48296;
  guint8 * code.6562;
  unsigned char D.48300;
  guint8 * code.6563;
  guint8 * code.6564;
  guint8 * code.6565;
  unsigned char D.48306;
  guint8 * code.6566;
  unsigned char D.48308;
  guint8 * code.6567;
  unsigned char D.48310;
  guint8 * code.6568;
  unsigned char D.48312;
  guint8 * code.6569;
  guint8 * code.6570;
  guint8 * code.6571;
  guint8 * code.6572;
  guint8 * code.6573;
  guint8 * code.6574;
  guint8 * code.6575;
  unsigned char D.48329;
  guint8 * code.6576;
  unsigned char D.48331;
  guint8 * code.6577;
  unsigned char D.48333;
  guint8 * code.6578;
  unsigned char D.48335;
  guint8 * code.6579;
  guint8 * code.6580;
  guint8 * code.6581;
  guint8 * code.6582;
  unsigned char D.48345;
  guint8 * code.6583;
  unsigned char D.48347;
  guint8 * code.6584;
  unsigned char D.48349;
  guint8 * code.6585;
  unsigned char D.48351;
  guint8 * code.6586;
  guint8 * code.6587;
  unsigned char D.48358;
  guint8 * code.6588;
  guint8 * code.6589;
  guint8 * code.6590;
  guint8 * code.6591;
  guint8 * code.6592;
  guint8 * code.6593;
  guint8 * code.6594;
  guint8 * code.6595;
  unsigned char D.48377;
  guint8 * code.6596;
  unsigned char D.48379;
  guint8 * code.6597;
  unsigned char D.48381;
  guint8 * code.6598;
  unsigned char D.48383;
  guint8 * code.6599;
  guint8 * code.6600;
  guint8 * code.6601;
  guint8 * code.6602;
  unsigned char D.48393;
  guint8 * code.6603;
  unsigned char D.48395;
  guint8 * code.6604;
  unsigned char D.48397;
  guint8 * code.6605;
  unsigned char D.48399;
  guint8 * code.6606;
  guint8 * code.6607;
  guint8 * code.6608;
  guint8 * code.6609;
  guint8 * code.6610;
  guint8 * code.6611;
  guint8 * code.6612;
  guint8 * code.6613;
  unsigned char D.48419;
  guint8 * code.6614;
  unsigned char D.48421;
  guint8 * code.6615;
  unsigned char D.48423;
  guint8 * code.6616;
  unsigned char D.48425;
  guint8 * code.6617;
  guint8 * code.6618;
  guint8 * code.6619;
  guint8 * code.6620;
  unsigned char D.48435;
  guint8 * code.6621;
  unsigned char D.48437;
  guint8 * code.6622;
  unsigned char D.48439;
  guint8 * code.6623;
  unsigned char D.48441;
  guint8 * code.6624;
  guint8 * code.6625;
  guint8 * code.6626;
  guint8 * code.6627;
  guint8 * code.6628;
  guint8 * code.6629;
  guint8 * code.6630;
  guint8 * code.6631;
  unsigned char D.48459;
  guint8 * code.6632;
  unsigned char D.48461;
  guint8 * code.6633;
  unsigned char D.48463;
  guint8 * code.6634;
  unsigned char D.48465;
  guint8 * code.6635;
  guint8 * code.6636;
  guint8 * code.6637;
  guint8 * code.6638;
  unsigned char D.48475;
  guint8 * code.6639;
  unsigned char D.48477;
  guint8 * code.6640;
  unsigned char D.48479;
  guint8 * code.6641;
  unsigned char D.48481;
  guint8 * code.6642;
  unsigned char D.48483;
  guint8 * code.6643;
  unsigned char D.48485;
  guint8 * code.6644;
  unsigned char D.48487;
  guint8 * code.6645;
  unsigned char D.48489;
  int D.48490;
  unsigned char D.48493;
  int D.48494;
  unsigned char D.48495;
  unsigned char D.48496;
  long int pos.6646;
  long int D.48500;
  int D.48503;
  unsigned char * pos.6647;
  unsigned char D.48505;
  unsigned char * pos.6648;
  unsigned char D.48507;
  unsigned char * pos.6649;
  unsigned char D.48509;
  unsigned char * pos.6650;
  unsigned char D.48511;
  unsigned int disp.6651;
  unsigned int D.48514;
  unsigned char D.48517;
  unsigned char D.48518;
  signed char iftmp.6652;
  signed char D.48524;
  guint8 * code.6653;
  unsigned char D.48528;
  guint8 * code.6654;
  guint8 * code.6655;
  guint8 * code.6656;
  signed char iftmp.6657;
  signed char D.48536;
  guint8 * code.6658;
  unsigned char D.48540;
  guint8 * code.6659;
  guint8 * code.6660;
  guint8 * code.6661;
  signed char iftmp.6662;
  signed char D.48548;
  guint8 * code.6663;
  unsigned char D.48552;
  guint8 * code.6664;
  guint8 * code.6665;
  guint8 * code.6666;
  signed char iftmp.6667;
  signed char D.48560;
  guint8 * code.6668;
  unsigned char D.48564;
  guint8 * code.6669;
  guint8 * code.6670;
  guint8 * code.6671;
  signed char iftmp.6672;
  signed char D.48572;
  guint8 * code.6673;
  unsigned char D.48576;
  guint8 * code.6674;
  guint8 * code.6675;
  guint8 * code.6676;
  signed char iftmp.6677;
  signed char D.48584;
  guint8 * code.6678;
  unsigned char D.48588;
  guint8 * code.6679;
  guint8 * code.6680;
  guint8 * code.6681;
  _Bool D.48592;
  long int D.48593;
  long int D.48594;
  signed char iftmp.6682;
  signed char D.48601;
  guint8 * code.6683;
  unsigned char D.48605;
  guint8 * code.6684;
  guint8 * code.6685;
  guint8 * code.6686;
  signed char iftmp.6687;
  signed char D.48613;
  guint8 * code.6688;
  unsigned char D.48617;
  guint8 * code.6689;
  guint8 * code.6690;
  guint8 * code.6691;
  signed char iftmp.6692;
  signed char D.48625;
  guint8 * code.6693;
  unsigned char D.48629;
  guint8 * code.6694;
  guint8 * code.6695;
  guint8 * code.6696;
  signed char iftmp.6697;
  signed char D.48637;
  guint8 * code.6698;
  unsigned char D.48641;
  guint8 * code.6699;
  guint8 * code.6700;
  guint8 * code.6701;
  signed char iftmp.6702;
  signed char D.48649;
  guint8 * code.6703;
  unsigned char D.48653;
  guint8 * code.6704;
  guint8 * code.6705;
  guint8 * code.6706;
  signed char iftmp.6707;
  signed char D.48661;
  guint8 * code.6708;
  unsigned char D.48665;
  guint8 * code.6709;
  guint8 * code.6710;
  guint8 * code.6711;
  signed char iftmp.6712;
  signed char D.48673;
  guint8 * code.6713;
  unsigned char D.48677;
  guint8 * code.6714;
  guint8 * code.6715;
  guint8 * code.6716;
  signed char iftmp.6717;
  signed char D.48685;
  guint8 * code.6718;
  unsigned char D.48689;
  guint8 * code.6719;
  guint8 * code.6720;
  guint8 * code.6721;
  guint8 * code.6722;
  signed char iftmp.6723;
  signed char D.48698;
  guint8 * code.6724;
  unsigned char D.48702;
  guint8 * code.6725;
  guint8 * code.6726;
  guint8 * code.6727;
  guint8 * code.6728;
  signed char iftmp.6729;
  signed char D.48711;
  guint8 * code.6730;
  unsigned char D.48715;
  guint8 * code.6731;
  guint8 * code.6732;
  guint8 * code.6733;
  guint8 * code.6734;
  signed char iftmp.6735;
  signed char D.48724;
  guint8 * code.6736;
  unsigned char D.48728;
  guint8 * code.6737;
  guint8 * code.6738;
  guint8 * code.6739;
  guint8 * code.6740;
  signed char iftmp.6741;
  signed char D.48737;
  guint8 * code.6742;
  unsigned char D.48741;
  guint8 * code.6743;
  guint8 * code.6744;
  guint8 * code.6745;
  guint8 * code.6746;
  signed char iftmp.6747;
  signed char D.48750;
  guint8 * code.6748;
  unsigned char D.48754;
  guint8 * code.6749;
  guint8 * code.6750;
  guint8 * code.6751;
  _Bool D.48758;
  long int D.48759;
  long int D.48760;
  guint8 * code.6752;
  signed char iftmp.6753;
  signed char D.48768;
  guint8 * code.6754;
  unsigned char D.48772;
  guint8 * code.6755;
  guint8 * code.6756;
  guint8 * code.6757;
  guint8 * code.6758;
  signed char iftmp.6759;
  signed char D.48783;
  guint8 * code.6760;
  unsigned char D.48787;
  guint8 * code.6761;
  guint8 * code.6762;
  guint8 * code.6763;
  guint8 * code.6764;
  signed char iftmp.6765;
  signed char D.48798;
  guint8 * code.6766;
  unsigned char D.48802;
  guint8 * code.6767;
  guint8 * code.6768;
  guint8 * code.6769;
  signed char iftmp.6770;
  signed char D.48812;
  guint8 * code.6771;
  unsigned char D.48816;
  guint8 * code.6772;
  guint8 * code.6773;
  guint8 * code.6774;
  _Bool D.48820;
  long int D.48821;
  long int D.48822;
  guint8 * code.6775;
  signed char iftmp.6776;
  signed char D.48830;
  guint8 * code.6777;
  unsigned char D.48834;
  guint8 * code.6778;
  guint8 * code.6779;
  guint8 * code.6780;
  guint8 * code.6781;
  signed char iftmp.6782;
  signed char D.48843;
  guint8 * code.6783;
  unsigned char D.48847;
  guint8 * code.6784;
  guint8 * code.6785;
  guint8 * code.6786;
  guint8 * code.6787;
  signed char iftmp.6788;
  signed char D.48856;
  guint8 * code.6789;
  unsigned char D.48860;
  guint8 * code.6790;
  guint8 * code.6791;
  guint8 * code.6792;
  guint8 * code.6793;
  signed char iftmp.6794;
  signed char D.48869;
  guint8 * code.6795;
  unsigned char D.48873;
  guint8 * code.6796;
  guint8 * code.6797;
  guint8 * code.6798;
  guint8 * code.6799;
  signed char iftmp.6800;
  signed char D.48882;
  guint8 * code.6801;
  unsigned char D.48886;
  guint8 * code.6802;
  guint8 * code.6803;
  guint8 * code.6804;
  guint8 * code.6805;
  signed char iftmp.6806;
  signed char D.48895;
  guint8 * code.6807;
  unsigned char D.48899;
  guint8 * code.6808;
  guint8 * code.6809;
  guint8 * code.6810;
  guint8 * code.6811;
  signed char iftmp.6812;
  signed char D.48908;
  guint8 * code.6813;
  unsigned char D.48912;
  guint8 * code.6814;
  guint8 * code.6815;
  guint8 * code.6816;
  guint8 * code.6817;
  signed char iftmp.6818;
  signed char D.48923;
  guint8 * code.6819;
  unsigned char D.48927;
  guint8 * code.6820;
  guint8 * code.6821;
  guint8 * code.6822;
  guint8 * code.6823;
  signed char iftmp.6824;
  signed char D.48936;
  guint8 * code.6825;
  unsigned char D.48940;
  guint8 * code.6826;
  guint8 * code.6827;
  guint8 * code.6828;
  guint8 * code.6829;
  signed char iftmp.6830;
  signed char D.48949;
  guint8 * code.6831;
  unsigned char D.48953;
  guint8 * code.6832;
  guint8 * code.6833;
  guint8 * code.6834;
  guint8 * code.6835;
  signed char iftmp.6836;
  signed char D.48962;
  guint8 * code.6837;
  unsigned char D.48966;
  guint8 * code.6838;
  guint8 * code.6839;
  guint8 * code.6840;
  guint8 * code.6841;
  signed char iftmp.6842;
  signed char D.48975;
  guint8 * code.6843;
  unsigned char D.48979;
  guint8 * code.6844;
  guint8 * code.6845;
  guint8 * code.6846;
  guint8 * code.6847;
  signed char iftmp.6848;
  signed char D.48988;
  guint8 * code.6849;
  unsigned char D.48992;
  guint8 * code.6850;
  guint8 * code.6851;
  guint8 * code.6852;
  guint8 * code.6853;
  signed char iftmp.6854;
  signed char D.49001;
  guint8 * code.6855;
  unsigned char D.49005;
  guint8 * code.6856;
  guint8 * code.6857;
  guint8 * code.6858;
  guint8 * code.6859;
  signed char iftmp.6860;
  signed char D.49014;
  guint8 * code.6861;
  unsigned char D.49018;
  guint8 * code.6862;
  guint8 * code.6863;
  guint8 * code.6864;
  guint8 * code.6865;
  signed char iftmp.6866;
  signed char D.49027;
  guint8 * code.6867;
  unsigned char D.49031;
  guint8 * code.6868;
  guint8 * code.6869;
  guint8 * code.6870;
  guint8 * code.6871;
  signed char iftmp.6872;
  signed char D.49040;
  guint8 * code.6873;
  unsigned char D.49044;
  guint8 * code.6874;
  guint8 * code.6875;
  guint8 * code.6876;
  guint8 * code.6877;
  signed char iftmp.6878;
  signed char D.49053;
  guint8 * code.6879;
  unsigned char D.49057;
  guint8 * code.6880;
  guint8 * code.6881;
  guint8 * code.6882;
  guint8 * code.6883;
  signed char iftmp.6884;
  signed char D.49066;
  guint8 * code.6885;
  unsigned char D.49070;
  guint8 * code.6886;
  guint8 * code.6887;
  guint8 * code.6888;
  guint8 * code.6889;
  signed char iftmp.6890;
  signed char D.49079;
  guint8 * code.6891;
  unsigned char D.49083;
  guint8 * code.6892;
  guint8 * code.6893;
  guint8 * code.6894;
  guint8 * code.6895;
  signed char iftmp.6896;
  signed char D.49092;
  guint8 * code.6897;
  unsigned char D.49096;
  guint8 * code.6898;
  guint8 * code.6899;
  guint8 * code.6900;
  guint8 * code.6901;
  signed char iftmp.6902;
  signed char D.49105;
  guint8 * code.6903;
  unsigned char D.49109;
  guint8 * code.6904;
  guint8 * code.6905;
  guint8 * code.6906;
  guint8 * code.6907;
  signed char iftmp.6908;
  signed char D.49118;
  guint8 * code.6909;
  unsigned char D.49122;
  guint8 * code.6910;
  guint8 * code.6911;
  guint8 * code.6912;
  guint8 * code.6913;
  signed char iftmp.6914;
  signed char D.49131;
  guint8 * code.6915;
  unsigned char D.49135;
  guint8 * code.6916;
  guint8 * code.6917;
  guint8 * code.6918;
  guint8 * code.6919;
  signed char iftmp.6920;
  signed char D.49144;
  guint8 * code.6921;
  unsigned char D.49148;
  guint8 * code.6922;
  guint8 * code.6923;
  guint8 * code.6924;
  guint8 * code.6925;
  signed char iftmp.6926;
  signed char D.49157;
  guint8 * code.6927;
  unsigned char D.49161;
  guint8 * code.6928;
  guint8 * code.6929;
  guint8 * code.6930;
  guint8 * code.6931;
  signed char iftmp.6932;
  signed char D.49170;
  guint8 * code.6933;
  unsigned char D.49174;
  guint8 * code.6934;
  guint8 * code.6935;
  guint8 * code.6936;
  guint8 * code.6937;
  signed char iftmp.6938;
  signed char D.49183;
  guint8 * code.6939;
  unsigned char D.49187;
  guint8 * code.6940;
  guint8 * code.6941;
  guint8 * code.6942;
  guint8 * code.6943;
  signed char iftmp.6944;
  signed char D.49196;
  guint8 * code.6945;
  unsigned char D.49200;
  guint8 * code.6946;
  guint8 * code.6947;
  guint8 * code.6948;
  guint8 * code.6949;
  signed char iftmp.6950;
  signed char D.49209;
  guint8 * code.6951;
  unsigned char D.49213;
  guint8 * code.6952;
  guint8 * code.6953;
  guint8 * code.6954;
  guint8 * code.6955;
  signed char iftmp.6956;
  signed char D.49222;
  guint8 * code.6957;
  unsigned char D.49226;
  guint8 * code.6958;
  guint8 * code.6959;
  guint8 * code.6960;
  guint8 * code.6961;
  guint8 * code.6962;
  signed char iftmp.6963;
  signed char D.49236;
  guint8 * code.6964;
  unsigned char D.49240;
  guint8 * code.6965;
  guint8 * code.6966;
  guint8 * code.6967;
  guint8 * code.6968;
  guint8 * code.6969;
  signed char iftmp.6970;
  signed char D.49250;
  guint8 * code.6971;
  unsigned char D.49254;
  guint8 * code.6972;
  guint8 * code.6973;
  guint8 * code.6974;
  guint8 * code.6975;
  guint8 * code.6976;
  signed char iftmp.6977;
  signed char D.49264;
  guint8 * code.6978;
  unsigned char D.49268;
  guint8 * code.6979;
  guint8 * code.6980;
  guint8 * code.6981;
  guint8 * code.6982;
  signed char iftmp.6983;
  signed char D.49277;
  guint8 * code.6984;
  unsigned char D.49281;
  guint8 * code.6985;
  guint8 * code.6986;
  guint8 * code.6987;
  guint8 * code.6988;
  guint8 * code.6989;
  signed char iftmp.6990;
  signed char D.49291;
  guint8 * code.6991;
  unsigned char D.49295;
  guint8 * code.6992;
  guint8 * code.6993;
  guint8 * code.6994;
  guint8 * code.6995;
  signed char iftmp.6996;
  signed char D.49304;
  guint8 * code.6997;
  unsigned char D.49308;
  guint8 * code.6998;
  guint8 * code.6999;
  guint8 * code.7000;
  guint8 * code.7001;
  signed char iftmp.7002;
  signed char D.49317;
  guint8 * code.7003;
  unsigned char D.49321;
  guint8 * code.7004;
  guint8 * code.7005;
  guint8 * code.7006;
  guint8 * code.7007;
  signed char iftmp.7008;
  signed char D.49330;
  guint8 * code.7009;
  unsigned char D.49334;
  guint8 * code.7010;
  guint8 * code.7011;
  guint8 * code.7012;
  guint8 * code.7013;
  guint8 * code.7014;
  signed char iftmp.7015;
  signed char D.49344;
  guint8 * code.7016;
  unsigned char D.49348;
  guint8 * code.7017;
  guint8 * code.7018;
  guint8 * code.7019;
  guint8 * code.7020;
  guint8 * code.7021;
  signed char iftmp.7022;
  signed char D.49358;
  guint8 * code.7023;
  unsigned char D.49362;
  guint8 * code.7024;
  guint8 * code.7025;
  guint8 * code.7026;
  guint8 * code.7027;
  guint8 * code.7028;
  signed char iftmp.7029;
  signed char D.49372;
  guint8 * code.7030;
  unsigned char D.49376;
  guint8 * code.7031;
  guint8 * code.7032;
  guint8 * code.7033;
  guint8 * code.7034;
  signed char iftmp.7035;
  signed char D.49385;
  guint8 * code.7036;
  unsigned char D.49389;
  guint8 * code.7037;
  guint8 * code.7038;
  guint8 * code.7039;
  guint8 * code.7040;
  guint8 * code.7041;
  signed char iftmp.7042;
  signed char D.49399;
  guint8 * code.7043;
  unsigned char D.49403;
  guint8 * code.7044;
  guint8 * code.7045;
  guint8 * code.7046;
  guint8 * code.7047;
  signed char iftmp.7048;
  signed char D.49412;
  guint8 * code.7049;
  unsigned char D.49416;
  guint8 * code.7050;
  guint8 * code.7051;
  guint8 * code.7052;
  guint8 * code.7053;
  signed char iftmp.7054;
  signed char D.49425;
  guint8 * code.7055;
  unsigned char D.49429;
  guint8 * code.7056;
  guint8 * code.7057;
  guint8 * code.7058;
  guint8 * code.7059;
  signed char iftmp.7060;
  signed char D.49438;
  guint8 * code.7061;
  unsigned char D.49442;
  guint8 * code.7062;
  guint8 * code.7063;
  guint8 * code.7064;
  guint8 * code.7065;
  guint8 * code.7066;
  signed char iftmp.7067;
  signed char D.49452;
  guint8 * code.7068;
  unsigned char D.49456;
  guint8 * code.7069;
  guint8 * code.7070;
  guint8 * code.7071;
  guint8 * code.7072;
  signed char iftmp.7073;
  signed char D.49465;
  guint8 * code.7074;
  unsigned char D.49469;
  guint8 * code.7075;
  guint8 * code.7076;
  guint8 * code.7077;
  guint8 * code.7078;
  signed char iftmp.7079;
  signed char D.49478;
  guint8 * code.7080;
  unsigned char D.49482;
  guint8 * code.7081;
  guint8 * code.7082;
  guint8 * code.7083;
  guint8 * code.7084;
  signed char iftmp.7085;
  signed char D.49491;
  guint8 * code.7086;
  unsigned char D.49495;
  guint8 * code.7087;
  guint8 * code.7088;
  guint8 * code.7089;
  guint8 * code.7090;
  guint8 * code.7091;
  signed char iftmp.7092;
  signed char D.49505;
  guint8 * code.7093;
  unsigned char D.49509;
  guint8 * code.7094;
  guint8 * code.7095;
  guint8 * code.7096;
  guint8 * code.7097;
  signed char iftmp.7098;
  signed char D.49518;
  guint8 * code.7099;
  unsigned char D.49522;
  guint8 * code.7100;
  guint8 * code.7101;
  guint8 * code.7102;
  guint8 * code.7103;
  signed char iftmp.7104;
  signed char D.49531;
  guint8 * code.7105;
  unsigned char D.49535;
  guint8 * code.7106;
  guint8 * code.7107;
  guint8 * code.7108;
  guint8 * code.7109;
  signed char iftmp.7110;
  signed char D.49544;
  guint8 * code.7111;
  unsigned char D.49548;
  guint8 * code.7112;
  guint8 * code.7113;
  guint8 * code.7114;
  guint8 * code.7115;
  signed char iftmp.7116;
  signed char D.49557;
  guint8 * code.7117;
  unsigned char D.49561;
  guint8 * code.7118;
  guint8 * code.7119;
  guint8 * code.7120;
  signed char iftmp.7121;
  signed char D.49569;
  guint8 * code.7122;
  unsigned char D.49573;
  guint8 * code.7123;
  guint8 * code.7124;
  guint8 * code.7125;
  guint8 * code.7126;
  signed char iftmp.7127;
  signed char D.49582;
  guint8 * code.7128;
  unsigned char D.49586;
  guint8 * code.7129;
  guint8 * code.7130;
  guint8 * code.7131;
  guint8 * code.7132;
  signed char iftmp.7133;
  signed char D.49595;
  guint8 * code.7134;
  unsigned char D.49599;
  guint8 * code.7135;
  guint8 * code.7136;
  guint8 * code.7137;
  guint8 * code.7138;
  signed char iftmp.7139;
  signed char D.49608;
  guint8 * code.7140;
  unsigned char D.49612;
  guint8 * code.7141;
  guint8 * code.7142;
  guint8 * code.7143;
  guint8 * code.7144;
  signed char iftmp.7145;
  signed char D.49621;
  guint8 * code.7146;
  unsigned char D.49625;
  guint8 * code.7147;
  guint8 * code.7148;
  guint8 * code.7149;
  guint8 * code.7150;
  signed char iftmp.7151;
  signed char D.49634;
  guint8 * code.7152;
  unsigned char D.49638;
  guint8 * code.7153;
  guint8 * code.7154;
  guint8 * code.7155;
  signed char iftmp.7156;
  signed char D.49646;
  guint8 * code.7157;
  unsigned char D.49650;
  guint8 * code.7158;
  guint8 * code.7159;
  guint8 * code.7160;
  guint8 * code.7161;
  signed char iftmp.7162;
  signed char D.49659;
  guint8 * code.7163;
  unsigned char D.49663;
  guint8 * code.7164;
  guint8 * code.7165;
  guint8 * code.7166;
  guint8 * code.7167;
  signed char iftmp.7168;
  signed char D.49672;
  guint8 * code.7169;
  unsigned char D.49676;
  guint8 * code.7170;
  guint8 * code.7171;
  guint8 * code.7172;
  guint8 * code.7173;
  signed char iftmp.7174;
  signed char D.49685;
  guint8 * code.7175;
  unsigned char D.49689;
  guint8 * code.7176;
  guint8 * code.7177;
  guint8 * code.7178;
  guint8 * code.7179;
  signed char iftmp.7180;
  signed char D.49698;
  guint8 * code.7181;
  unsigned char D.49702;
  guint8 * code.7182;
  guint8 * code.7183;
  guint8 * code.7184;
  guint8 * code.7185;
  signed char iftmp.7186;
  signed char D.49711;
  guint8 * code.7187;
  unsigned char D.49715;
  guint8 * code.7188;
  guint8 * code.7189;
  guint8 * code.7190;
  guint8 * code.7191;
  guint8 * code.7192;
  signed char iftmp.7193;
  signed char D.49725;
  guint8 * code.7194;
  unsigned char D.49729;
  guint8 * code.7195;
  guint8 * code.7196;
  guint8 * code.7197;
  guint8 * code.7198;
  signed char iftmp.7199;
  signed char D.49738;
  guint8 * code.7200;
  unsigned char D.49742;
  guint8 * code.7201;
  guint8 * code.7202;
  guint8 * code.7203;
  guint8 * code.7204;
  signed char iftmp.7205;
  signed char D.49751;
  guint8 * code.7206;
  unsigned char D.49755;
  guint8 * code.7207;
  guint8 * code.7208;
  guint8 * code.7209;
  guint8 * code.7210;
  signed char iftmp.7211;
  signed char D.49764;
  guint8 * code.7212;
  unsigned char D.49768;
  guint8 * code.7213;
  guint8 * code.7214;
  guint8 * code.7215;
  guint8 * code.7216;
  signed char iftmp.7217;
  signed char D.49777;
  guint8 * code.7218;
  unsigned char D.49781;
  guint8 * code.7219;
  guint8 * code.7220;
  guint8 * code.7221;
  guint8 * code.7222;
  signed char iftmp.7223;
  signed char D.49790;
  guint8 * code.7224;
  unsigned char D.49794;
  guint8 * code.7225;
  guint8 * code.7226;
  guint8 * code.7227;
  guint8 * code.7228;
  signed char iftmp.7229;
  signed char D.49803;
  guint8 * code.7230;
  unsigned char D.49807;
  guint8 * code.7231;
  guint8 * code.7232;
  guint8 * code.7233;
  guint8 * code.7234;
  signed char iftmp.7235;
  signed char D.49816;
  guint8 * code.7236;
  unsigned char D.49820;
  guint8 * code.7237;
  guint8 * code.7238;
  guint8 * code.7239;
  guint8 * code.7240;
  signed char iftmp.7241;
  signed char D.49829;
  guint8 * code.7242;
  unsigned char D.49833;
  guint8 * code.7243;
  guint8 * code.7244;
  guint8 * code.7245;
  guint8 * code.7246;
  signed char iftmp.7247;
  signed char D.49842;
  guint8 * code.7248;
  unsigned char D.49846;
  guint8 * code.7249;
  guint8 * code.7250;
  guint8 * code.7251;
  guint8 * code.7252;
  guint8 * code.7253;
  signed char iftmp.7254;
  signed char D.49856;
  guint8 * code.7255;
  unsigned char D.49860;
  guint8 * code.7256;
  guint8 * code.7257;
  guint8 * code.7258;
  guint8 * code.7259;
  signed char iftmp.7260;
  signed char D.49869;
  guint8 * code.7261;
  unsigned char D.49873;
  guint8 * code.7262;
  guint8 * code.7263;
  guint8 * code.7264;
  guint8 * code.7265;
  signed char iftmp.7266;
  signed char D.49882;
  guint8 * code.7267;
  unsigned char D.49886;
  guint8 * code.7268;
  guint8 * code.7269;
  guint8 * code.7270;
  guint8 * code.7271;
  guint8 * code.7272;
  unsigned char D.49894;
  guint8 * code.7273;
  guint8 * code.7274;
  guint8 * code.7275;
  guint8 * code.7276;
  signed char iftmp.7277;
  signed char D.49903;
  guint8 * code.7278;
  unsigned char D.49907;
  guint8 * code.7279;
  guint8 * code.7280;
  guint8 * code.7281;
  guint8 * code.7282;
  guint8 * code.7283;
  unsigned char D.49915;
  guint8 * code.7284;
  guint8 * code.7285;
  guint8 * code.7286;
  guint8 * code.7287;
  signed char iftmp.7288;
  signed char D.49924;
  guint8 * code.7289;
  unsigned char D.49928;
  guint8 * code.7290;
  guint8 * code.7291;
  guint8 * code.7292;
  guint8 * code.7293;
  guint8 * code.7294;
  unsigned char D.49936;
  guint8 * code.7295;
  guint8 * code.7296;
  guint8 * code.7297;
  signed char D.49940;
  unsigned char D.49941;
  guint8 * code.7298;
  signed char iftmp.7299;
  signed char D.49947;
  guint8 * code.7300;
  unsigned char D.49951;
  guint8 * code.7301;
  guint8 * code.7302;
  guint8 * code.7303;
  guint8 * code.7304;
  guint8 * code.7305;
  unsigned char D.49959;
  guint8 * code.7306;
  guint8 * code.7307;
  guint8 * code.7308;
  guint8 * code.7309;
  signed char iftmp.7310;
  signed char D.49968;
  guint8 * code.7311;
  unsigned char D.49972;
  guint8 * code.7312;
  guint8 * code.7313;
  guint8 * code.7314;
  guint8 * code.7315;
  guint8 * code.7316;
  unsigned char D.49980;
  guint8 * code.7317;
  guint8 * code.7318;
  guint8 * code.7319;
  guint8 * code.7320;
  signed char iftmp.7321;
  signed char D.49989;
  guint8 * code.7322;
  unsigned char D.49993;
  guint8 * code.7323;
  guint8 * code.7324;
  guint8 * code.7325;
  guint8 * code.7326;
  guint8 * code.7327;
  unsigned char D.50001;
  guint8 * code.7328;
  guint8 * code.7329;
  guint8 * code.7330;
  guint8 * code.7331;
  signed char iftmp.7332;
  signed char D.50010;
  guint8 * code.7333;
  unsigned char D.50014;
  guint8 * code.7334;
  guint8 * code.7335;
  guint8 * code.7336;
  guint8 * code.7337;
  guint8 * code.7338;
  unsigned char D.50022;
  guint8 * code.7339;
  guint8 * code.7340;
  guint8 * code.7341;
  guint8 * code.7342;
  signed char iftmp.7343;
  signed char D.50031;
  guint8 * code.7344;
  unsigned char D.50035;
  guint8 * code.7345;
  guint8 * code.7346;
  guint8 * code.7347;
  guint8 * code.7348;
  guint8 * code.7349;
  unsigned char D.50043;
  guint8 * code.7350;
  guint8 * code.7351;
  guint8 * code.7352;
  guint8 * code.7353;
  signed char iftmp.7354;
  signed char D.50052;
  guint8 * code.7355;
  unsigned char D.50056;
  guint8 * code.7356;
  guint8 * code.7357;
  guint8 * code.7358;
  guint8 * code.7359;
  signed char iftmp.7360;
  signed char D.50065;
  guint8 * code.7361;
  unsigned char D.50069;
  guint8 * code.7362;
  guint8 * code.7363;
  guint8 * code.7364;
  signed char iftmp.7365;
  signed char D.50077;
  guint8 * code.7366;
  unsigned char D.50081;
  guint8 * code.7367;
  guint8 * code.7368;
  guint8 * code.7369;
  guint8 * code.7370;
  signed char iftmp.7371;
  signed char D.50090;
  guint8 * code.7372;
  unsigned char D.50094;
  guint8 * code.7373;
  guint8 * code.7374;
  guint8 * code.7375;
  guint8 * code.7376;
  signed char iftmp.7377;
  signed char D.50103;
  guint8 * code.7378;
  unsigned char D.50107;
  guint8 * code.7379;
  guint8 * code.7380;
  guint8 * code.7381;
  guint8 * code.7382;
  signed char iftmp.7383;
  signed char D.50116;
  guint8 * code.7384;
  unsigned char D.50120;
  guint8 * code.7385;
  guint8 * code.7386;
  guint8 * code.7387;
  signed char iftmp.7388;
  signed char D.50128;
  guint8 * code.7389;
  unsigned char D.50132;
  guint8 * code.7390;
  guint8 * code.7391;
  guint8 * code.7392;
  guint8 * code.7393;
  signed char iftmp.7394;
  signed char D.50141;
  guint8 * code.7395;
  unsigned char D.50145;
  guint8 * code.7396;
  guint8 * code.7397;
  guint8 * code.7398;
  guint8 * code.7399;
  signed char iftmp.7400;
  signed char D.50154;
  guint8 * code.7401;
  unsigned char D.50158;
  guint8 * code.7402;
  guint8 * code.7403;
  guint8 * code.7404;
  guint8 * code.7405;
  signed char iftmp.7406;
  signed char D.50167;
  guint8 * code.7407;
  unsigned char D.50171;
  guint8 * code.7408;
  guint8 * code.7409;
  guint8 * code.7410;
  guint8 * code.7411;
  signed char iftmp.7412;
  signed char D.50180;
  guint8 * code.7413;
  unsigned char D.50184;
  guint8 * code.7414;
  guint8 * code.7415;
  guint8 * code.7416;
  signed char D.50188;
  unsigned char D.50189;
  unsigned char iftmp.7417;
  guint8 * code.7418;
  unsigned char D.50199;
  guint8 * code.7419;
  guint8 * code.7420;
  guint8 * code.7421;
  guint8 * code.7422;
  unsigned char iftmp.7423;
  guint8 * code.7424;
  unsigned char D.50211;
  guint8 * code.7425;
  guint8 * code.7426;
  guint8 * code.7427;
  guint8 * code.7428;
  signed char iftmp.7429;
  signed char D.50221;
  guint8 * code.7430;
  unsigned char D.50225;
  guint8 * code.7431;
  guint8 * code.7432;
  guint8 * code.7433;
  guint8 * code.7434;
  signed char iftmp.7435;
  signed char D.50234;
  guint8 * code.7436;
  unsigned char D.50238;
  guint8 * code.7437;
  guint8 * code.7438;
  guint8 * code.7439;
  unsigned char iftmp.7440;
  guint8 * code.7441;
  unsigned char D.50251;
  long int D.50252;
  guint8 * code.7442;
  guint8 * code.7443;
  guint8 * code.7444;
  guint8 * code.7445;
  unsigned char D.50260;
  unsigned char D.50261;
  signed char iftmp.7446;
  signed char D.50266;
  guint8 * code.7447;
  unsigned char D.50270;
  guint8 * code.7448;
  guint8 * code.7449;
  guint8 * code.7450;
  guint8 * code.7451;
  signed char iftmp.7452;
  signed char D.50285;
  guint8 * code.7453;
  unsigned char D.50289;
  guint8 * code.7454;
  guint8 * code.7455;
  guint8 * code.7456;
  signed char iftmp.7457;
  signed char D.50297;
  guint8 * code.7458;
  unsigned char D.50301;
  guint8 * code.7459;
  guint8 * code.7460;
  guint8 * code.7461;
  signed char iftmp.7462;
  signed char D.50317;
  guint8 * code.7463;
  unsigned char D.50321;
  guint8 * code.7464;
  guint8 * code.7465;
  guint8 * code.7466;
  guint8 * code.7467;
  signed char iftmp.7468;
  signed char D.50331;
  guint8 * code.7469;
  unsigned char D.50335;
  guint8 * code.7470;
  guint8 * code.7471;
  guint8 * code.7472;
  guint8 * code.7473;
  signed char iftmp.7474;
  signed char D.50344;
  guint8 * code.7475;
  unsigned char D.50348;
  guint8 * code.7476;
  guint8 * code.7477;
  guint8 * code.7478;
  guint8 * code.7479;
  signed char iftmp.7480;
  signed char D.50357;
  guint8 * code.7481;
  unsigned char D.50361;
  guint8 * code.7482;
  guint8 * code.7483;
  guint8 * code.7484;
  unsigned char iftmp.7485;
  guint8 * code.7486;
  unsigned char D.50374;
  guint8 * code.7487;
  guint8 * code.7488;
  unsigned char iftmp.7489;
  long int D.50378;
  guint8 * code.7490;
  unsigned char D.50388;
  guint8 * code.7491;
  int iftmp.7492;
  guint8 * code.7493;
  unsigned char D.50395;
  guint8 * code.7494;
  unsigned char D.50397;
  guint8 * code.7495;
  unsigned char D.50399;
  guint8 * code.7496;
  unsigned char D.50401;
  unsigned char iftmp.7497;
  guint8 * code.7498;
  unsigned char D.50410;
  guint8 * code.7499;
  guint8 * code.7500;
  int iftmp.7501;
  guint8 * code.7502;
  unsigned char D.50418;
  guint8 * code.7503;
  unsigned char D.50420;
  guint8 * code.7504;
  unsigned char D.50422;
  guint8 * code.7505;
  unsigned char D.50424;
  guint8 * code.7506;
  unsigned char D.50430;
  guint8 * code.7507;
  guint8 * code.7508;
  guint8 * code.7509;
  guint8 * code.7510;
  signed char iftmp.7511;
  signed char D.50442;
  guint8 * code.7512;
  unsigned char D.50446;
  guint8 * code.7513;
  guint8 * code.7514;
  guint8 * code.7515;
  signed char iftmp.7516;
  signed char D.50454;
  guint8 * code.7517;
  unsigned char D.50458;
  guint8 * code.7518;
  guint8 * code.7519;
  guint8 * code.7520;
  long int D.50462;
  unsigned char D.50463;
  guint8 * code.7521;
  signed char iftmp.7522;
  signed char D.50469;
  guint8 * code.7523;
  unsigned char D.50473;
  guint8 * code.7524;
  guint8 * code.7525;
  guint8 * code.7526;
  unsigned char D.50477;
  unsigned char iftmp.7527;
  guint8 * code.7528;
  unsigned char D.50485;
  guint8 * code.7529;
  guint8 * code.7530;
  guint8 * code.7531;
  guint8 * code.7532;
  guint8 * code.7533;
  signed char iftmp.7534;
  signed char D.50498;
  guint8 * code.7535;
  unsigned char D.50502;
  guint8 * code.7536;
  guint8 * code.7537;
  guint8 * code.7538;
  unsigned char D.50506;
  guint8 * code.7539;
  unsigned char iftmp.7540;
  guint8 * code.7541;
  unsigned char D.50515;
  guint8 * code.7542;
  guint8 * code.7543;
  guint8 * code.7544;
  unsigned char iftmp.7545;
  guint8 * code.7546;
  unsigned char D.50528;
  guint8 * code.7547;
  guint8 * code.7548;
  guint8 * code.7549;
  signed char D.50532;
  unsigned char D.50533;
  guint8 * code.7550;
  unsigned char iftmp.7551;
  guint8 * code.7552;
  unsigned char D.50543;
  guint8 * code.7553;
  guint8 * code.7554;
  guint8 * code.7555;
  guint8 * code.7556;
  signed char iftmp.7557;
  signed char D.50552;
  guint8 * code.7558;
  unsigned char D.50556;
  guint8 * code.7559;
  guint8 * code.7560;
  guint8 * code.7561;
  guint8 * code.7562;
  signed char iftmp.7563;
  signed char D.50565;
  guint8 * code.7564;
  unsigned char D.50569;
  guint8 * code.7565;
  guint8 * code.7566;
  guint8 * code.7567;
  guint8 * code.7568;
  signed char iftmp.7569;
  signed char D.50578;
  guint8 * code.7570;
  unsigned char D.50582;
  guint8 * code.7571;
  guint8 * code.7572;
  guint8 * code.7573;
  guint8 * code.7574;
  signed char iftmp.7575;
  signed char D.50591;
  guint8 * code.7576;
  unsigned char D.50595;
  guint8 * code.7577;
  guint8 * code.7578;
  guint8 * code.7579;
  guint8 * code.7580;
  signed char iftmp.7581;
  signed char D.50604;
  guint8 * code.7582;
  unsigned char D.50608;
  guint8 * code.7583;
  guint8 * code.7584;
  guint8 * code.7585;
  guint8 * code.7586;
  signed char iftmp.7587;
  signed char D.50617;
  guint8 * code.7588;
  unsigned char D.50621;
  guint8 * code.7589;
  guint8 * code.7590;
  guint8 * code.7591;
  guint8 * code.7592;
  signed char iftmp.7593;
  signed char D.50630;
  guint8 * code.7594;
  unsigned char D.50634;
  guint8 * code.7595;
  guint8 * code.7596;
  guint8 * code.7597;
  guint8 * code.7598;
  signed char iftmp.7599;
  signed char D.50643;
  guint8 * code.7600;
  unsigned char D.50647;
  guint8 * code.7601;
  guint8 * code.7602;
  guint8 * code.7603;
  guint8 * code.7604;
  signed char iftmp.7605;
  signed char D.50656;
  guint8 * code.7606;
  unsigned char D.50660;
  guint8 * code.7607;
  guint8 * code.7608;
  guint8 * code.7609;
  guint8 * code.7610;
  signed char iftmp.7611;
  signed char D.50669;
  guint8 * code.7612;
  unsigned char D.50673;
  guint8 * code.7613;
  guint8 * code.7614;
  guint8 * code.7615;
  signed char iftmp.7616;
  signed char D.50684;
  guint8 * code.7617;
  unsigned char D.50688;
  guint8 * code.7618;
  guint8 * code.7619;
  guint8 * code.7620;
  guint8 * code.7621;
  signed char iftmp.7622;
  signed char D.50698;
  guint8 * code.7623;
  unsigned char D.50702;
  guint8 * code.7624;
  guint8 * code.7625;
  guint8 * code.7626;
  signed char iftmp.7627;
  signed char D.50710;
  guint8 * code.7628;
  unsigned char D.50714;
  guint8 * code.7629;
  guint8 * code.7630;
  guint8 * code.7631;
  guint8 * code.7632;
  unsigned char D.50721;
  guint8 * code.7633;
  unsigned char D.50723;
  guint8 * code.7634;
  unsigned char D.50725;
  guint8 * code.7635;
  unsigned char D.50727;
  guint8 * code.7636;
  guint8 * code.7637;
  guint8 * code.7638;
  guint8 * code.7639;
  guint8 * code.7640;
  guint8 * code.7641;
  guint8 * code.7642;
  unsigned char D.50744;
  guint8 * code.7643;
  unsigned char D.50746;
  guint8 * code.7644;
  unsigned char D.50748;
  guint8 * code.7645;
  unsigned char D.50750;
  guint8 * code.7646;
  guint8 * code.7647;
  guint8 * code.7648;
  guint8 * code.7649;
  unsigned char D.50762;
  guint8 * code.7650;
  unsigned char D.50764;
  guint8 * code.7651;
  unsigned char D.50766;
  guint8 * code.7652;
  unsigned char D.50768;
  signed char iftmp.7653;
  int D.50773;
  _Bool D.50774;
  _Bool D.50775;
  _Bool D.50776;
  int D.50777;
  signed char D.50778;
  signed char D.50779;
  guint8 * code.7654;
  unsigned char D.50783;
  guint8 * code.7655;
  guint8 * code.7656;
  guint8 * code.7657;
  guint8 * code.7658;
  unsigned char D.50790;
  guint8 * code.7659;
  unsigned char D.50792;
  guint8 * code.7660;
  unsigned char D.50794;
  guint8 * code.7661;
  unsigned char D.50796;
  guint8 * code.7662;
  guint8 * code.7663;
  guint8 * code.7664;
  guint8 * code.7665;
  guint8 * code.7666;
  guint8 * code.7667;
  guint8 * code.7668;
  unsigned char D.50813;
  guint8 * code.7669;
  unsigned char D.50815;
  guint8 * code.7670;
  unsigned char D.50817;
  guint8 * code.7671;
  unsigned char D.50819;
  guint8 * code.7672;
  guint8 * code.7673;
  guint8 * code.7674;
  guint8 * code.7675;
  unsigned char D.50831;
  guint8 * code.7676;
  unsigned char D.50833;
  guint8 * code.7677;
  unsigned char D.50835;
  guint8 * code.7678;
  unsigned char D.50837;
  signed char iftmp.7679;
  int D.50842;
  _Bool D.50843;
  _Bool D.50844;
  _Bool D.50845;
  int D.50846;
  signed char D.50847;
  signed char D.50848;
  guint8 * code.7680;
  unsigned char D.50852;
  guint8 * code.7681;
  guint8 * code.7682;
  guint8 * code.7683;
  guint8 * code.7684;
  unsigned char D.50859;
  guint8 * code.7685;
  unsigned char D.50861;
  guint8 * code.7686;
  unsigned char D.50863;
  guint8 * code.7687;
  unsigned char D.50865;
  guint8 * code.7688;
  guint8 * code.7689;
  guint8 * code.7690;
  guint8 * code.7691;
  guint8 * code.7692;
  guint8 * code.7693;
  guint8 * code.7694;
  unsigned char D.50882;
  guint8 * code.7695;
  unsigned char D.50884;
  guint8 * code.7696;
  unsigned char D.50886;
  guint8 * code.7697;
  unsigned char D.50888;
  guint8 * code.7698;
  guint8 * code.7699;
  guint8 * code.7700;
  guint8 * code.7701;
  unsigned char D.50900;
  guint8 * code.7702;
  unsigned char D.50902;
  guint8 * code.7703;
  unsigned char D.50904;
  guint8 * code.7704;
  unsigned char D.50906;
  signed char iftmp.7705;
  signed char D.50911;
  guint8 * code.7706;
  unsigned char D.50915;
  guint8 * code.7707;
  guint8 * code.7708;
  guint8 * code.7709;
  guint8 * code.7710;
  unsigned char D.50922;
  guint8 * code.7711;
  unsigned char D.50924;
  guint8 * code.7712;
  unsigned char D.50926;
  guint8 * code.7713;
  unsigned char D.50928;
  guint8 * code.7714;
  guint8 * code.7715;
  guint8 * code.7716;
  guint8 * code.7717;
  guint8 * code.7718;
  guint8 * code.7719;
  guint8 * code.7720;
  unsigned char D.50945;
  guint8 * code.7721;
  unsigned char D.50947;
  guint8 * code.7722;
  unsigned char D.50949;
  guint8 * code.7723;
  unsigned char D.50951;
  guint8 * code.7724;
  guint8 * code.7725;
  guint8 * code.7726;
  guint8 * code.7727;
  unsigned char D.50963;
  guint8 * code.7728;
  unsigned char D.50965;
  guint8 * code.7729;
  unsigned char D.50967;
  guint8 * code.7730;
  unsigned char D.50969;
  signed char iftmp.7731;
  int D.50974;
  _Bool D.50975;
  _Bool D.50976;
  _Bool D.50977;
  int D.50978;
  signed char D.50979;
  signed char D.50980;
  guint8 * code.7732;
  unsigned char D.50984;
  guint8 * code.7733;
  guint8 * code.7734;
  guint8 * code.7735;
  guint8 * code.7736;
  unsigned char D.50991;
  guint8 * code.7737;
  unsigned char D.50993;
  guint8 * code.7738;
  unsigned char D.50995;
  guint8 * code.7739;
  unsigned char D.50997;
  guint8 * code.7740;
  guint8 * code.7741;
  guint8 * code.7742;
  guint8 * code.7743;
  guint8 * code.7744;
  guint8 * code.7745;
  guint8 * code.7746;
  unsigned char D.51014;
  guint8 * code.7747;
  unsigned char D.51016;
  guint8 * code.7748;
  unsigned char D.51018;
  guint8 * code.7749;
  unsigned char D.51020;
  guint8 * code.7750;
  guint8 * code.7751;
  guint8 * code.7752;
  guint8 * code.7753;
  unsigned char D.51032;
  guint8 * code.7754;
  unsigned char D.51034;
  guint8 * code.7755;
  unsigned char D.51036;
  guint8 * code.7756;
  unsigned char D.51038;
  signed char iftmp.7757;
  int D.51040;
  int D.51044;
  _Bool D.51045;
  _Bool D.51046;
  _Bool D.51047;
  int D.51048;
  signed char D.51049;
  signed char D.51050;
  guint8 * code.7758;
  unsigned char D.51054;
  guint8 * code.7759;
  guint8 * code.7760;
  guint8 * code.7761;
  int D.51060;
  int D.51061;
  signed char D.51062;
  signed char D.51063;
  unsigned char D.51064;
  guint8 * code.7762;
  unsigned char D.51066;
  guint8 * code.7763;
  unsigned char D.51068;
  guint8 * code.7764;
  unsigned char D.51070;
  guint8 * code.7765;
  unsigned char D.51072;
  guint8 * code.7766;
  signed char D.51079;
  unsigned char D.51080;
  guint8 * code.7767;
  guint8 * code.7768;
  signed char D.51086;
  unsigned char D.51087;
  guint8 * code.7769;
  guint8 * code.7770;
  signed char D.51091;
  unsigned char D.51092;
  guint8 * code.7771;
  guint8 * code.7772;
  unsigned char D.51095;
  guint8 * code.7773;
  unsigned char D.51097;
  guint8 * code.7774;
  unsigned char D.51099;
  guint8 * code.7775;
  unsigned char D.51101;
  guint8 * code.7776;
  signed char D.51107;
  unsigned char D.51108;
  guint8 * code.7777;
  signed char D.51112;
  signed char D.51113;
  unsigned char D.51114;
  guint8 * code.7778;
  signed char D.51117;
  signed char D.51118;
  unsigned char D.51119;
  guint8 * code.7779;
  unsigned char D.51121;
  guint8 * code.7780;
  unsigned char D.51123;
  guint8 * code.7781;
  unsigned char D.51125;
  guint8 * code.7782;
  unsigned char D.51127;
  signed char iftmp.7783;
  signed char D.51134;
  guint8 * code.7784;
  unsigned char D.51138;
  guint8 * code.7785;
  guint8 * code.7786;
  guint8 * code.7787;
  guint8 * code.7788;
  signed char iftmp.7789;
  signed char D.51147;
  guint8 * code.7790;
  unsigned char D.51151;
  guint8 * code.7791;
  guint8 * code.7792;
  guint8 * code.7793;
  guint8 * code.7794;
  signed char iftmp.7795;
  signed char D.51160;
  guint8 * code.7796;
  unsigned char D.51164;
  guint8 * code.7797;
  guint8 * code.7798;
  guint8 * code.7799;
  guint8 * code.7800;
  signed char iftmp.7801;
  signed char D.51173;
  guint8 * code.7802;
  unsigned char D.51177;
  guint8 * code.7803;
  guint8 * code.7804;
  guint8 * code.7805;
  guint8 * code.7806;
  signed char iftmp.7807;
  signed char D.51186;
  guint8 * code.7808;
  unsigned char D.51190;
  guint8 * code.7809;
  guint8 * code.7810;
  guint8 * code.7811;
  guint8 * code.7812;
  signed char iftmp.7813;
  signed char D.51199;
  guint8 * code.7814;
  unsigned char D.51203;
  guint8 * code.7815;
  guint8 * code.7816;
  guint8 * code.7817;
  short unsigned int D.51207;
  int D.51208;
  signed char iftmp.7818;
  signed char D.51213;
  guint8 * code.7819;
  unsigned char D.51217;
  guint8 * code.7820;
  guint8 * code.7821;
  guint8 * code.7822;
  signed char iftmp.7823;
  signed char D.51231;
  guint8 * code.7824;
  unsigned char D.51235;
  guint8 * code.7825;
  guint8 * code.7826;
  guint8 * code.7827;
  signed char iftmp.7828;
  signed char D.51249;
  guint8 * code.7829;
  unsigned char D.51253;
  guint8 * code.7830;
  guint8 * code.7831;
  guint8 * code.7832;
  signed char iftmp.7833;
  signed char D.51267;
  guint8 * code.7834;
  unsigned char D.51271;
  guint8 * code.7835;
  guint8 * code.7836;
  guint8 * code.7837;
  guint8 * code.7838;
  signed char iftmp.7839;
  signed char D.51287;
  guint8 * code.7840;
  unsigned char D.51291;
  guint8 * code.7841;
  guint8 * code.7842;
  guint8 * code.7843;
  guint8 * code.7844;
  signed char iftmp.7845;
  signed char D.51300;
  guint8 * code.7846;
  unsigned char D.51304;
  guint8 * code.7847;
  guint8 * code.7848;
  guint8 * code.7849;
  guint8 * code.7850;
  signed char iftmp.7851;
  signed char D.51313;
  guint8 * code.7852;
  unsigned char D.51317;
  guint8 * code.7853;
  guint8 * code.7854;
  guint8 * code.7855;
  guint8 * code.7856;
  signed char iftmp.7857;
  signed char D.51326;
  guint8 * code.7858;
  unsigned char D.51330;
  guint8 * code.7859;
  guint8 * code.7860;
  guint8 * code.7861;
  guint8 * code.7862;
  signed char iftmp.7863;
  signed char D.51339;
  guint8 * code.7864;
  unsigned char D.51343;
  guint8 * code.7865;
  guint8 * code.7866;
  guint8 * code.7867;
  guint8 * code.7868;
  signed char iftmp.7869;
  signed char D.51352;
  guint8 * code.7870;
  unsigned char D.51356;
  guint8 * code.7871;
  guint8 * code.7872;
  guint8 * code.7873;
  guint8 * code.7874;
  signed char iftmp.7875;
  signed char D.51365;
  guint8 * code.7876;
  unsigned char D.51369;
  guint8 * code.7877;
  guint8 * code.7878;
  guint8 * code.7879;
  guint8 * code.7880;
  signed char iftmp.7881;
  signed char D.51378;
  guint8 * code.7882;
  unsigned char D.51382;
  guint8 * code.7883;
  guint8 * code.7884;
  guint8 * code.7885;
  guint8 * code.7886;
  signed char iftmp.7887;
  signed char D.51391;
  guint8 * code.7888;
  unsigned char D.51395;
  guint8 * code.7889;
  guint8 * code.7890;
  guint8 * code.7891;
  guint8 * code.7892;
  signed char iftmp.7893;
  signed char D.51404;
  guint8 * code.7894;
  unsigned char D.51408;
  guint8 * code.7895;
  guint8 * code.7896;
  guint8 * code.7897;
  guint8 * code.7898;
  signed char iftmp.7899;
  signed char D.51417;
  guint8 * code.7900;
  unsigned char D.51421;
  guint8 * code.7901;
  guint8 * code.7902;
  guint8 * code.7903;
  guint8 * code.7904;
  signed char iftmp.7905;
  signed char D.51430;
  guint8 * code.7906;
  unsigned char D.51434;
  guint8 * code.7907;
  guint8 * code.7908;
  guint8 * code.7909;
  struct MonoMethodVar * D.51440;
  long unsigned int D.51441;
  struct MonoMethodVar * D.51442;
  int D.51443;
  int D.51444;
  struct GSList * D.51447;
  struct MonoMemPool * D.51448;
  struct GSList * D.51449;
  const char * D.51450;
  long int D.51451;
  long int D.51452;
  long int D.51453;
  const char * D.51456;
  unsigned int D.51457;
  struct MonoInst * ins;
  struct MonoCallInst * call;
  guint offset;
  guint8 * code;
  struct MonoInst * last_ins;
  guint last_offset;
  int max_len;
  static const char __PRETTY_FUNCTION__[29] = "mono_arch_output_basic_block";
  static const char __FUNCTION__[29] = "mono_arch_output_basic_block";

  D.31283 = cfg->native_code;
  D.31284 = cfg->code_len;
  D.31285 = (sizetype) D.31284;
  code = D.31283 + D.31285;
  last_ins = 0B;
  last_offset = 0;
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.31288>; else goto <D.31289>;
  <D.31288>:
  {
    int current_offset;
    struct MonoBasicBlock * current_bb;

    D.31284 = cfg->code_len;
    current_offset = (int) D.31284;
    current_bb = bb;
    goto <D.25166>;
    <D.25165>:
    current_bb->max_offset = current_offset;
    D.31290 = current_bb->max_length;
    current_offset = D.31290 + current_offset;
    current_bb = current_bb->next_bb;
    <D.25166>:
    if (current_bb != 0B) goto <D.25165>; else goto <D.25167>;
    <D.25167>:
  }
  <D.31289>:
  D.31286 = cfg->opt;
  D.31291 = D.31286 & 8192;
  if (D.31291 != 0) goto <D.31292>; else goto <D.31293>;
  <D.31292>:
  {
    int pad;
    int align;

    align = 8;
    D.31294 = bb->loop_body_start;
    if (D.31294 != 0) goto <D.31295>; else goto <D.31296>;
    <D.31295>:
    D.31297 = bb->nesting;
    if (D.31297 != 0) goto <D.31298>; else goto <D.31299>;
    <D.31298>:
    D.31284 = cfg->code_len;
    D.31300 = align + -1;
    D.31301 = (unsigned int) D.31300;
    D.31302 = D.31284 & D.31301;
    pad = (int) D.31302;
    if (pad != 0) goto <D.31303>; else goto <D.31304>;
    <D.31303>:
    pad = align - pad;
    switch (pad) <default: <D.25174>, case 1: <D.25170>, case 2: <D.25172>, case 3: <D.25173>>
    <D.25170>:
    code.141 = code;
    code = code.141 + 1;
    *code.141 = 144;
    goto <D.25171>;
    <D.25172>:
    code.142 = code;
    code = code.142 + 1;
    *code.142 = 102;
    code.143 = code;
    code = code.143 + 1;
    *code.143 = 144;
    goto <D.25171>;
    <D.25173>:
    code.144 = code;
    code = code.144 + 1;
    *code.144 = 102;
    code.145 = code;
    code = code.145 + 1;
    *code.145 = 102;
    code.146 = code;
    code = code.146 + 1;
    *code.146 = 144;
    goto <D.25171>;
    <D.25174>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.31311>; else goto <D.31312>;
      <D.31311>:
      code.147 = code;
      code = code.147 + 1;
      D.31314 = _amd64_rex_bits | 64;
      *code.147 = D.31314;
      <D.31312>:
    }
    D.31315 = pad + -1;
    switch (D.31315) <default: <D.25184>, case 1: <D.25176>, case 2: <D.25178>, case 3: <D.25179>, case 4: <D.25180>, case 5: <D.25181>, case 6: <D.25182>, case 7: <D.25183>>
    <D.25176>:
    code.148 = code;
    code = code.148 + 1;
    *code.148 = 144;
    goto <D.25177>;
    <D.25178>:
    code.149 = code;
    code = code.149 + 1;
    *code.149 = 139;
    code.150 = code;
    code = code.150 + 1;
    *code.150 = 192;
    goto <D.25177>;
    <D.25179>:
    code.151 = code;
    code = code.151 + 1;
    *code.151 = 141;
    code.152 = code;
    code = code.152 + 1;
    *code.152 = 109;
    code.153 = code;
    code = code.153 + 1;
    *code.153 = 0;
    goto <D.25177>;
    <D.25180>:
    code.154 = code;
    code = code.154 + 1;
    *code.154 = 141;
    code.155 = code;
    code = code.155 + 1;
    *code.155 = 100;
    code.156 = code;
    code = code.156 + 1;
    *code.156 = 36;
    code.157 = code;
    code = code.157 + 1;
    *code.157 = 0;
    goto <D.25177>;
    <D.25181>:
    code.158 = code;
    code = code.158 + 1;
    *code.158 = 141;
    code.159 = code;
    code = code.159 + 1;
    *code.159 = 100;
    code.160 = code;
    code = code.160 + 1;
    *code.160 = 36;
    code.161 = code;
    code = code.161 + 1;
    *code.161 = 0;
    code.162 = code;
    code = code.162 + 1;
    *code.162 = 144;
    goto <D.25177>;
    <D.25182>:
    code.163 = code;
    code = code.163 + 1;
    *code.163 = 141;
    code.164 = code;
    code = code.164 + 1;
    *code.164 = 173;
    code.165 = code;
    code = code.165 + 1;
    *code.165 = 0;
    code.166 = code;
    code = code.166 + 1;
    *code.166 = 0;
    code.167 = code;
    code = code.167 + 1;
    *code.167 = 0;
    code.168 = code;
    code = code.168 + 1;
    *code.168 = 0;
    goto <D.25177>;
    <D.25183>:
    code.169 = code;
    code = code.169 + 1;
    *code.169 = 141;
    code.170 = code;
    code = code.170 + 1;
    *code.170 = 164;
    code.171 = code;
    code = code.171 + 1;
    *code.171 = 36;
    code.172 = code;
    code = code.172 + 1;
    *code.172 = 0;
    code.173 = code;
    code = code.173 + 1;
    *code.173 = 0;
    code.174 = code;
    code = code.174 + 1;
    *code.174 = 0;
    code.175 = code;
    code = code.175 + 1;
    *code.175 = 0;
    goto <D.25177>;
    <D.25184>:
    __assert_fail ("0", "mini-amd64.c", 3921, &__PRETTY_FUNCTION__);
    <D.25177>:
    <D.25171>:
    D.31284 = cfg->code_len;
    pad.176 = (unsigned int) pad;
    D.31345 = D.31284 + pad.176;
    cfg->code_len = D.31345;
    D.31284 = cfg->code_len;
    D.31346 = (int) D.31284;
    bb->native_offset = D.31346;
    <D.31304>:
    <D.31299>:
    <D.31296>:
  }
  <D.31293>:
  D.31347 = cfg->verbose_level;
  if (D.31347 > 2) goto <D.31348>; else goto <D.31349>;
  <D.31348>:
  D.31350 = bb->native_offset;
  D.31351 = bb->block_num;
  monoeg_g_print ("Basic block %d starting at offset 0x%x\n", D.31351, D.31350);
  <D.31349>:
  D.31352 = cfg->prof_options;
  D.31353 = D.31352 & 8192;
  if (D.31353 != 0) goto <D.31354>; else goto <D.31355>;
  <D.31354>:
  {
    struct MonoProfileCoverageInfo * cov;

    cov = cfg->coverage_info;
    D.31356 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.31357 = D.31356 & 64;
    D.31358 = D.31357 != 0;
    D.31359 = (long int) D.31358;
    D.31360 = __builtin_expect (D.31359, 0);
    if (D.31360 != 0) goto <D.31361>; else goto <D.31362>;
    <D.31361>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 3947, "!cfg->compile_aot");
    <D.31362>:
    D.31363 = bb->dfn;
    D.31364 = bb->cil_code;
    cov->data[D.31363].cil_code = D.31364;
    {
      int _amd64_width_temp;

      D.31363 = bb->dfn;
      D.31365 = &cov->data[D.31363].count;
      D.31366 = (long unsigned int) D.31365;
      D.31363 = bb->dfn;
      D.31365 = &cov->data[D.31363].count;
      D.31367 = (long int) D.31365;
      D.31368 = (int) D.31367;
      D.31369 = (long unsigned int) D.31368;
      D.31370 = D.31366 == D.31369;
      _amd64_width_temp = (int) D.31370;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.31372>; else goto <D.31373>;
        <D.31372>:
        iftmp.177 = 9;
        goto <D.31374>;
        <D.31373>:
        iftmp.177 = 1;
        <D.31374>:
        _amd64_rex_bits = iftmp.177;
        if (_amd64_rex_bits != 0) goto <D.31375>; else goto <D.31376>;
        <D.31375>:
        code.178 = code;
        code = code.178 + 1;
        D.31378 = _amd64_rex_bits | 64;
        *code.178 = D.31378;
        <D.31376>:
      }
      code.179 = code;
      code = code.179 + 1;
      *code.179 = 187;
      if (_amd64_width_temp == 0) goto <D.31380>; else goto <D.31381>;
      <D.31380>:
      {
        union amd64_imm_buf imb;

        try
          {
            D.31363 = bb->dfn;
            D.31365 = &cov->data[D.31363].count;
            D.31366 = (long unsigned int) D.31365;
            imb.val = D.31366;
            code.180 = code;
            code = code.180 + 1;
            D.31383 = imb.b[0];
            *code.180 = D.31383;
            code.181 = code;
            code = code.181 + 1;
            D.31385 = imb.b[1];
            *code.181 = D.31385;
            code.182 = code;
            code = code.182 + 1;
            D.31387 = imb.b[2];
            *code.182 = D.31387;
            code.183 = code;
            code = code.183 + 1;
            D.31389 = imb.b[3];
            *code.183 = D.31389;
            code.184 = code;
            code = code.184 + 1;
            D.31391 = imb.b[4];
            *code.184 = D.31391;
            code.185 = code;
            code = code.185 + 1;
            D.31393 = imb.b[5];
            *code.185 = D.31393;
            code.186 = code;
            code = code.186 + 1;
            D.31395 = imb.b[6];
            *code.186 = D.31395;
            code.187 = code;
            code = code.187 + 1;
            D.31397 = imb.b[7];
            *code.187 = D.31397;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.31398>;
      <D.31381>:
      {
        union x86_imm_buf imb;

        try
          {
            D.31363 = bb->dfn;
            D.31365 = &cov->data[D.31363].count;
            D.31367 = (long int) D.31365;
            D.31368 = (int) D.31367;
            imb.val = D.31368;
            code.188 = code;
            code = code.188 + 1;
            D.31400 = imb.b[0];
            *code.188 = D.31400;
            code.189 = code;
            code = code.189 + 1;
            D.31402 = imb.b[1];
            *code.189 = D.31402;
            code.190 = code;
            code = code.190 + 1;
            D.31404 = imb.b[2];
            *code.190 = D.31404;
            code.191 = code;
            code = code.191 + 1;
            D.31406 = imb.b[3];
            *code.191 = D.31406;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.31398>:
    }
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 9;
      if (_amd64_rex_bits != 0) goto <D.31407>; else goto <D.31408>;
      <D.31407>:
      code.192 = code;
      code = code.192 + 1;
      D.31410 = _amd64_rex_bits | 64;
      *code.192 = D.31410;
      <D.31408>:
    }
    code.193 = code;
    code = code.193 + 1;
    *code.193 = 255;
    if (0 != 0) goto <D.31412>; else goto <D.31413>;
    <D.31412>:
    if (1 != 0) goto <D.31414>; else goto <D.31415>;
    <D.31414>:
    code.194 = code;
    code = code.194 + 1;
    *code.194 = 4;
    code.195 = code;
    code = code.195 + 1;
    *code.195 = 36;
    goto <D.31418>;
    <D.31415>:
    if (1 != 0) goto <D.31419>; else goto <D.31420>;
    <D.31419>:
    code.196 = code;
    code = code.196 + 1;
    *code.196 = 68;
    code.197 = code;
    code = code.197 + 1;
    *code.197 = 36;
    *code = 0;
    code = code + 1;
    goto <D.31423>;
    <D.31420>:
    code.198 = code;
    code = code.198 + 1;
    *code.198 = 132;
    code.199 = code;
    code = code.199 + 1;
    *code.199 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.200 = code;
          code = code.200 + 1;
          D.31427 = imb.b[0];
          *code.200 = D.31427;
          code.201 = code;
          code = code.201 + 1;
          D.31429 = imb.b[1];
          *code.201 = D.31429;
          code.202 = code;
          code = code.202 + 1;
          D.31431 = imb.b[2];
          *code.202 = D.31431;
          code.203 = code;
          code = code.203 + 1;
          D.31433 = imb.b[3];
          *code.203 = D.31433;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.31423>:
    <D.31418>:
    goto <D.25193>;
    <D.31413>:
    if (1 != 0) goto <D.31434>; else goto <D.31435>;
    <D.31434>:
    code.204 = code;
    code = code.204 + 1;
    *code.204 = 3;
    goto <D.25193>;
    <D.31435>:
    if (1 != 0) goto <D.31437>; else goto <D.31438>;
    <D.31437>:
    code.205 = code;
    code = code.205 + 1;
    *code.205 = 67;
    *code = 0;
    code = code + 1;
    goto <D.31440>;
    <D.31438>:
    code.206 = code;
    code = code.206 + 1;
    *code.206 = 131;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.207 = code;
          code = code.207 + 1;
          D.31443 = imb.b[0];
          *code.207 = D.31443;
          code.208 = code;
          code = code.208 + 1;
          D.31445 = imb.b[1];
          *code.208 = D.31445;
          code.209 = code;
          code = code.209 + 1;
          D.31447 = imb.b[2];
          *code.209 = D.31447;
          code.210 = code;
          code = code.210 + 1;
          D.31449 = imb.b[3];
          *code.210 = D.31449;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.31440>:
    <D.25193>:
  }
  <D.31355>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  offset = (guint) D.31452;
  mono_debug_open_block (cfg, bb, offset);
  mono_break_at_bb_method.212 = mono_break_at_bb_method;
  if (mono_break_at_bb_method.212 != 0B) goto <D.31454>; else goto <D.31455>;
  <D.31454>:
  D.31456 = cfg->method;
  mono_break_at_bb_method.212 = mono_break_at_bb_method;
  D.31457 = mono_method_desc_full_match (mono_break_at_bb_method.212, D.31456);
  if (D.31457 != 0) goto <D.31458>; else goto <D.31459>;
  <D.31458>:
  D.31351 = bb->block_num;
  mono_break_at_bb_bb_num.213 = mono_break_at_bb_bb_num;
  if (D.31351 == mono_break_at_bb_bb_num.213) goto <D.31461>; else goto <D.31462>;
  <D.31461>:
  code.214 = code;
  code = code.214 + 1;
  *code.214 = 204;
  <D.31462>:
  <D.31459>:
  <D.31455>:
  ins = bb->code;
  goto <D.27913>;
  <D.27912>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  offset = (guint) D.31452;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.31466 = D.31465 + -313;
  D.31467 = amd64_desc_idx[D.31466];
  D.31468 = (sizetype) D.31467;
  D.31469 = D.31468 + 4;
  D.31470 = &amd64_desc + D.31469;
  D.31471 = *D.31470;
  max_len = (int) D.31471;
  D.31472 = cfg->code_size;
  max_len.215 = (unsigned int) max_len;
  D.31474 = D.31472 - max_len.215;
  D.31475 = D.31474 + 4294967280;
  D.31476 = D.31475 < offset;
  D.31477 = (long int) D.31476;
  D.31478 = __builtin_expect (D.31477, 0);
  if (D.31478 != 0) goto <D.31479>; else goto <D.31480>;
  <D.31479>:
  D.31472 = cfg->code_size;
  D.31481 = D.31472 * 2;
  cfg->code_size = D.31481;
  D.31482 = mono_realloc_native_code (cfg);
  cfg->native_code = D.31482;
  D.31283 = cfg->native_code;
  D.31483 = (sizetype) offset;
  code = D.31283 + D.31483;
  D.31484 = cfg->stat_code_reallocs;
  D.31485 = D.31484 + 1;
  cfg->stat_code_reallocs = D.31485;
  <D.31480>:
  D.31486 = cfg->debug_info;
  if (D.31486 != 0B) goto <D.31487>; else goto <D.31488>;
  <D.31487>:
  mono_debug_record_line_number (cfg, ins, offset);
  <D.31488>:
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  switch (D.31465) <default: <D.27910>, case 316: <D.25787>, case 317: <D.25786>, case 318: <D.25785>, case 322: <D.25499>, case 323: <D.25502>, case 324: <D.27115>, case 325: <D.25500>, case 326: <D.26215>, case 327: <D.26217>, case 328: <D.25503>, case 338: <D.26610>, case 339: <D.26633>, case 340: <D.26369>, case 341: <D.25792>, case 343: <D.26399>, case 344: <D.26420>, case 345: <D.26464>, case 346: <D.26394>, case 347: <D.26421>, case 348: <D.26465>, case 349: <D.26395>, case 350: <D.26416>, case 351: <D.26460>, case 352: <D.26396>, case 353: <D.26417>, case 354: <D.26461>, case 355: <D.26397>, case 356: <D.26418>, case 357: <D.26462>, case 358: <D.26398>, case 359: <D.26419>, case 360: <D.26463>, case 361: <D.26476>, case 362: <D.26271>, case 363: <D.26272>, case 364: <D.26847>, case 365: <D.26839>, case 369: <D.26761>, case 371: <D.26690>, case 372: <D.26698>, case 373: <D.26378>, case 374: <D.25263>, case 375: <D.25241>, case 376: <D.25252>, case 377: <D.25285>, case 378: <D.25274>, case 379: <D.26868>, case 380: <D.26856>, case 381: <D.27825>, case 382: <D.27844>, case 383: <D.27850>, case 384: <D.25296>, case 385: <D.25205>, case 386: <D.25217>, case 387: <D.25229>, case 388: <D.25308>, case 389: <D.27826>, case 391: <D.25398>, case 392: <D.25445>, case 393: <D.25439>, case 394: <D.25457>, case 395: <D.25451>, case 396: <D.25422>, case 397: <D.25427>, case 398: <D.25410>, case 399: <D.26875>, case 400: <D.26862>, case 401: <D.27832>, case 402: <D.27838>, case 421: <D.25320>, case 422: <D.25378>, case 423: <D.25388>, case 424: <D.25345>, case 425: <D.25354>, case 426: <D.25321>, case 428: <D.26295>, case 430: <D.27012>, case 433: <D.25859>, case 434: <D.25878>, case 435: <D.25902>, case 440: <D.25893>, case 441: <D.26067>, case 442: <D.26076>, case 443: <D.26097>, case 444: <D.26087>, case 445: <D.26091>, case 446: <D.26762>, case 448: <D.26307>, case 449: <D.25784>, case 450: <D.26778>, case 451: <D.26784>, case 452: <D.26790>, case 453: <D.26781>, case 454: <D.26787>, case 455: <D.26796>, case 456: <D.26802>, case 457: <D.26800>, case 458: <D.26804>, case 459: <D.26798>, case 460: <D.26797>, case 461: <D.26803>, case 462: <D.26801>, case 463: <D.26805>, case 464: <D.26799>, case 465: <D.26821>, case 466: <D.26822>, case 467: <D.26823>, case 468: <D.26824>, case 469: <D.26806>, case 470: <D.26812>, case 471: <D.26810>, case 472: <D.26814>, case 473: <D.26808>, case 474: <D.26807>, case 475: <D.26813>, case 476: <D.26811>, case 477: <D.26815>, case 478: <D.26809>, case 479: <D.26830>, case 480: <D.26831>, case 481: <D.26832>, case 482: <D.26833>, case 483: <D.25855>, case 484: <D.25874>, case 485: <D.25900>, case 486: <D.25961>, case 487: <D.25980>, case 488: <D.25962>, case 489: <D.25981>, case 490: <D.25891>, case 491: <D.26065>, case 492: <D.26074>, case 493: <D.26083>, case 494: <D.26085>, case 495: <D.26095>, case 496: <D.26269>, case 497: <D.26267>, case 498: <D.25472>, case 499: <D.25477>, case 502: <D.26887>, case 503: <D.26890>, case 506: <D.25486>, case 507: <D.25482>, case 513: <D.26058>, case 514: <D.26185>, case 519: <D.26994>, case 532: <D.26976>, case 535: <D.26779>, case 536: <D.26786>, case 537: <D.26791>, case 538: <D.26782>, case 539: <D.26788>, case 540: <D.26903>, case 542: <D.25860>, case 543: <D.25879>, case 544: <D.25903>, case 545: <D.25894>, case 546: <D.26068>, case 547: <D.26077>, case 548: <D.26099>, case 549: <D.26089>, case 550: <D.26093>, case 555: <D.26228>, case 556: <D.26231>, case 557: <D.26230>, case 558: <D.26232>, case 559: <D.26229>, case 560: <D.26238>, case 561: <D.26241>, case 562: <D.26240>, case 563: <D.26242>, case 564: <D.26239>, case 569: <D.26102>, case 570: <D.26119>, case 571: <D.26175>, case 572: <D.25999>, case 573: <D.26018>, case 574: <D.26000>, case 575: <D.26019>, case 576: <D.26135>, case 577: <D.26143>, case 578: <D.26151>, case 579: <D.26163>, case 580: <D.26165>, case 581: <D.26171>, case 582: <D.26159>, case 583: <D.26161>, case 584: <D.25473>, case 585: <D.25478>, case 588: <D.26882>, case 589: <D.26885>, case 594: <D.25487>, case 595: <D.25483>, case 601: <D.26177>, case 602: <D.26184>, case 623: <D.26104>, case 624: <D.26112>, case 625: <D.26121>, case 626: <D.26129>, case 627: <D.26101>, case 628: <D.26118>, case 629: <D.26106>, case 630: <D.26123>, case 631: <D.25904>, case 634: <D.26037>, case 636: <D.26137>, case 637: <D.26145>, case 638: <D.26153>, case 639: <D.26173>, case 640: <D.26167>, case 641: <D.26169>, case 642: <D.26780>, case 643: <D.26785>, case 644: <D.26792>, case 645: <D.26783>, case 646: <D.26789>, case 647: <D.26773>, case 648: <D.26774>, case 649: <D.26775>, case 650: <D.26776>, case 651: <D.26777>, case 652: <D.26223>, case 653: <D.26226>, case 654: <D.26225>, case 655: <D.26227>, case 656: <D.26224>, case 657: <D.26233>, case 658: <D.26236>, case 659: <D.26235>, case 660: <D.26237>, case 661: <D.26234>, case 662: <D.27182>, case 663: <D.27217>, case 664: <D.27208>, case 665: <D.27226>, case 666: <D.27197>, case 667: <D.27187>, case 668: <D.27222>, case 669: <D.27209>, case 670: <D.27231>, case 671: <D.27201>, case 672: <D.27014>, case 673: <D.27016>, case 674: <D.27018>, case 675: <D.27020>, case 679: <D.27022>, case 681: <D.26895>, case 682: <D.26897>, case 683: <D.26900>, case 684: <D.26902>, case 685: <D.26892>, case 687: <D.26899>, case 689: <D.26898>, case 690: <D.26896>, case 691: <D.26901>, case 718: <D.27118>, case 719: <D.27140>, case 720: <D.27141>, case 721: <D.27126>, case 722: <D.27127>, case 723: <D.27117>, case 724: <D.27147>, case 725: <D.27135>, case 726: <D.27156>, case 727: <D.27153>, case 728: <D.27155>, case 729: <D.27152>, case 730: <D.27154>, case 732: <D.27238>, case 735: <D.26291>, case 736: <D.26279>, case 739: <D.26706>, case 740: <D.26718>, case 741: <D.26748>, case 742: <D.26735>, case 743: <D.25195>, case 744: <D.25198>, case 745: <D.27093>, case 746: <D.27099>, case 747: <D.27105>, case 748: <D.27111>, case 751: <D.27090>, case 752: <D.27096>, case 753: <D.27102>, case 754: <D.27108>, case 755: <D.25857>, case 756: <D.25866>, case 757: <D.25876>, case 758: <D.25885>, case 759: <D.25853>, case 761: <D.25872>, case 763: <D.26771>, case 764: <D.25474>, case 765: <D.25479>, case 766: <D.25497>, case 769: <D.25490>, case 776: <D.25854>, case 777: <D.25873>, case 778: <D.27029>, case 779: <D.27047>, case 780: <D.27065>, case 783: <D.27072>, case 794: <D.27398>, case 795: <D.27277>, case 796: <D.27278>, case 797: <D.27279>, case 798: <D.27280>, case 800: <D.25788>, case 801: <D.25789>, case 802: <D.25790>, case 803: <D.25791>, case 804: <D.27507>, case 805: <D.27509>, case 806: <D.27511>, case 807: <D.27513>, case 808: <D.27515>, case 809: <D.27517>, case 810: <D.27519>, case 811: <D.27521>, case 812: <D.27523>, case 813: <D.27525>, case 814: <D.27527>, case 815: <D.27537>, case 816: <D.27539>, case 817: <D.27535>, case 818: <D.27543>, case 819: <D.27541>, case 820: <D.27531>, case 821: <D.27529>, case 822: <D.27533>, case 823: <D.27545>, case 824: <D.27547>, case 825: <D.27549>, case 826: <D.27551>, case 827: <D.27553>, case 828: <D.27555>, case 829: <D.27557>, case 830: <D.27559>, case 831: <D.27561>, case 832: <D.27563>, case 833: <D.27565>, case 834: <D.27567>, case 835: <D.27569>, case 836: <D.27571>, case 837: <D.27573>, case 838: <D.27575>, case 839: <D.27581>, case 840: <D.27583>, case 841: <D.27579>, case 842: <D.27585>, case 843: <D.27577>, case 844: <D.27587>, case 845: <D.27589>, case 846: <D.27591>, case 847: <D.27593>, case 848: <D.27595>, case 849: <D.27597>, case 850: <D.27599>, case 851: <D.27601>, case 852: <D.27603>, case 853: <D.27605>, case 854: <D.27607>, case 855: <D.27609>, case 856: <D.27611>, case 857: <D.27613>, case 858: <D.27615>, case 859: <D.27617>, case 860: <D.27619>, case 861: <D.27621>, case 862: <D.27623>, case 863: <D.27625>, case 864: <D.27627>, case 865: <D.27629>, case 866: <D.27631>, case 867: <D.27633>, case 868: <D.27635>, case 869: <D.27637>, case 870: <D.27639>, case 871: <D.27641>, case 872: <D.27643>, case 873: <D.27645>, case 874: <D.27647>, case 875: <D.27649>, case 876: <D.27651>, case 877: <D.27653>, case 878: <D.27655>, case 879: <D.27657>, case 880: <D.27659>, case 881: <D.27661>, case 882: <D.27663>, case 883: <D.27665>, case 884: <D.27667>, case 885: <D.27669>, case 886: <D.27671>, case 887: <D.27673>, case 888: <D.27675>, case 889: <D.27677>, case 890: <D.27679>, case 891: <D.27681>, case 892: <D.27683>, case 893: <D.27685>, case 894: <D.27687>, case 895: <D.27697>, case 896: <D.27689>, case 897: <D.27701>, case 898: <D.27693>, case 899: <D.27699>, case 900: <D.27691>, case 901: <D.27703>, case 902: <D.27695>, case 903: <D.27705>, case 904: <D.27707>, case 905: <D.27709>, case 906: <D.27711>, case 907: <D.27713>, case 908: <D.27715>, case 909: <D.27717>, case 910: <D.27719>, case 911: <D.27721>, case 912: <D.27723>, case 913: <D.27725>, case 914: <D.27727>, case 915: <D.27729>, case 916: <D.27739>, case 917: <D.27741>, case 918: <D.27731>, case 919: <D.27733>, case 920: <D.27735>, case 921: <D.27737>, case 922: <D.27743>, case 923: <D.27745>, case 924: <D.27765>, case 925: <D.27866>, case 926: <D.27777>, case 927: <D.27778>, case 928: <D.27771>, case 929: <D.27772>, case 930: <D.27782>, case 931: <D.27767>, case 937: <D.27785>, case 938: <D.27787>, case 939: <D.27789>, case 940: <D.27798>, case 941: <D.27806>, case 942: <D.27822>, case 943: <D.27802>, case 944: <D.27869>, case 945: <D.27871>, case 946: <D.27763>, case 948: <D.27886>, case 949: <D.27890>, case 950: <D.27896>, case 951: <D.27893>, case 952: <D.27900>, case 953: <D.27856>, case 954: <D.27747>, case 955: <D.27749>, case 956: <D.27751>, case 957: <D.27753>, case 958: <D.27755>, case 959: <D.27757>, case 960: <D.27759>, case 961: <D.27761>, case 962: <D.27862>, case 963: <D.27864>, case 965: <D.27293>, case 966: <D.27315>, case 969: <D.27338>, case 970: <D.27294>, case 971: <D.27316>, case 974: <D.27339>, case 975: <D.27281>, case 976: <D.27384>, case 977: <D.27385>, case 978: <D.26246>, case 979: <D.26247>, case 980: <D.26248>, case 981: <D.26249>, case 982: <D.26250>, case 983: <D.26251>, case 984: <D.26252>, case 985: <D.26253>, case 986: <D.26254>, case 987: <D.26255>, case 988: <D.26256>, case 989: <D.26257>, case 990: <D.26258>, case 991: <D.26259>, case 992: <D.26260>, case 993: <D.26261>, case 994: <D.26262>, case 995: <D.26263>, case 996: <D.26264>, case 997: <D.26265>, case 998: <D.27903>, case 999: <D.27904>, case 1000: <D.27906>, case 1001: <D.27907>, case 1002: <D.27909>, case 1003: <D.27908>, case 1004: <D.27905>, case 1005: <D.25515>, case 1009: <D.25667>, case 1010: <D.25509>, case 1011: <D.25624>, case 1012: <D.25619>, case 1013: <D.25631>, case 1014: <D.25626>, case 1015: <D.25549>, case 1016: <D.25558>, case 1017: <D.25567>, case 1018: <D.25576>, case 1019: <D.25585>, case 1020: <D.25594>, case 1021: <D.25599>, case 1022: <D.25604>, case 1023: <D.25609>, case 1024: <D.25614>, case 1025: <D.25634>, case 1026: <D.25519>, case 1027: <D.25525>, case 1028: <D.25633>, case 1029: <D.25531>, case 1030: <D.25537>, case 1031: <D.25543>, case 1032: <D.26557>, case 1033: <D.26553>, case 1034: <D.26551>, case 1035: <D.26562>, case 1037: <D.26598>, case 1038: <D.26602>, case 1039: <D.26608>, case 1040: <D.27114>, case 1043: <D.25200>, case 1046: <D.25517>, case 1047: <D.26303>, case 1048: <D.26305>, case 1049: <D.25639>, case 1050: <D.25644>, case 1051: <D.25672>, case 1052: <D.25653>, case 1053: <D.25658>, case 1054: <D.25678>, case 1055: <D.25714>, case 1056: <D.25719>, case 1057: <D.25724>, case 1058: <D.25729>, case 1059: <D.25734>, case 1061: <D.25739>, case 1062: <D.25748>, case 1063: <D.25757>, case 1064: <D.25766>, case 1065: <D.25775>, case 1067: <D.25684>, case 1068: <D.25690>, case 1069: <D.25696>, case 1070: <D.25702>, case 1071: <D.25708>, case 1073: <D.25463>, case 1074: <D.26539>>
  <D.25195>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.31491>; else goto <D.31492>;
    <D.31491>:
    iftmp.216 = 9;
    goto <D.31493>;
    <D.31492>:
    iftmp.216 = 8;
    <D.31493>:
    _amd64_rex_bits = iftmp.216;
    if (_amd64_rex_bits != 0) goto <D.31494>; else goto <D.31495>;
    <D.31494>:
    code.217 = code;
    code = code.217 + 1;
    D.31497 = _amd64_rex_bits | 64;
    *code.217 = D.31497;
    <D.31495>:
  }
  code.218 = code;
  code = code.218 + 1;
  *code.218 = 247;
  code.219 = code;
  code = code.219 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.31502 = D.31501 | -24;
  D.31503 = (unsigned char) D.31502;
  *code.219 = D.31503;
  goto <D.25197>;
  <D.25198>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.31505>; else goto <D.31506>;
    <D.31505>:
    iftmp.220 = 9;
    goto <D.31507>;
    <D.31506>:
    iftmp.220 = 8;
    <D.31507>:
    _amd64_rex_bits = iftmp.220;
    if (_amd64_rex_bits != 0) goto <D.31508>; else goto <D.31509>;
    <D.31508>:
    code.221 = code;
    code = code.221 + 1;
    D.31511 = _amd64_rex_bits | 64;
    *code.221 = D.31511;
    <D.31509>:
  }
  code.222 = code;
  code = code.222 + 1;
  *code.222 = 247;
  code.223 = code;
  code = code.223 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.31514 = D.31501 | -32;
  D.31515 = (unsigned char) D.31514;
  *code.223 = D.31515;
  goto <D.25197>;
  <D.25200>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.31518>; else goto <D.31519>;
    <D.31518>:
    code.224 = code;
    code = code.224 + 1;
    D.31521 = _amd64_rex_bits | 64;
    *code.224 = D.31521;
    <D.31519>:
  }
  code.225 = code;
  code = code.225 + 1;
  *code.225 = 15;
  if (1 != 0) goto <D.31523>; else goto <D.31524>;
  <D.31523>:
  code.226 = code;
  code = code.226 + 1;
  D.31526 = 116;
  D.31527 = D.31526 + 32;
  *code.226 = D.31527;
  goto <D.31528>;
  <D.31524>:
  code.227 = code;
  code = code.227 + 1;
  D.31530 = 116;
  D.31531 = D.31530 + 32;
  *code.227 = D.31531;
  <D.31528>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.31533>; else goto <D.31534>;
  <D.31533>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31536>; else goto <D.31537>;
  <D.31536>:
  code.228 = code;
  code = code.228 + 1;
  *code.228 = 4;
  code.229 = code;
  code = code.229 + 1;
  *code.229 = 36;
  goto <D.31540>;
  <D.31537>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31543>; else goto <D.31544>;
  <D.31543>:
  code.230 = code;
  code = code.230 + 1;
  *code.230 = 68;
  code.231 = code;
  code = code.231 + 1;
  *code.231 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31548>;
  <D.31544>:
  code.232 = code;
  code = code.232 + 1;
  *code.232 = 132;
  code.233 = code;
  code = code.233 + 1;
  *code.233 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.234 = code;
        code = code.234 + 1;
        D.31553 = imb.b[0];
        *code.234 = D.31553;
        code.235 = code;
        code = code.235 + 1;
        D.31555 = imb.b[1];
        *code.235 = D.31555;
        code.236 = code;
        code = code.236 + 1;
        D.31557 = imb.b[2];
        *code.236 = D.31557;
        code.237 = code;
        code = code.237 + 1;
        D.31559 = imb.b[3];
        *code.237 = D.31559;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31548>:
  <D.31540>:
  goto <D.25203>;
  <D.31534>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31560>; else goto <D.31561>;
  <D.31560>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.31562>; else goto <D.31563>;
  <D.31562>:
  code.238 = code;
  code = code.238 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  *code.238 = D.31566;
  goto <D.25203>;
  <D.31563>:
  <D.31561>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31567>; else goto <D.31568>;
  <D.31567>:
  code.239 = code;
  code = code.239 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31572 = D.31571 | 64;
  D.31573 = (unsigned char) D.31572;
  *code.239 = D.31573;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31574>;
  <D.31568>:
  code.240 = code;
  code = code.240 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31576 = D.31571 | -128;
  D.31577 = (unsigned char) D.31576;
  *code.240 = D.31577;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.241 = code;
        code = code.241 + 1;
        D.31579 = imb.b[0];
        *code.241 = D.31579;
        code.242 = code;
        code = code.242 + 1;
        D.31581 = imb.b[1];
        *code.242 = D.31581;
        code.243 = code;
        code = code.243 + 1;
        D.31583 = imb.b[2];
        *code.243 = D.31583;
        code.244 = code;
        code = code.244 + 1;
        D.31585 = imb.b[3];
        *code.244 = D.31585;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31574>:
  <D.25203>:
  goto <D.25197>;
  <D.25205>:
  if (0 != 0) goto <D.31586>; else goto <D.31587>;
  <D.31586>:
  code.245 = code;
  code = code.245 + 1;
  *code.245 = 102;
  <D.31587>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.31591>; else goto <D.31592>;
    <D.31591>:
    code.246 = code;
    code = code.246 + 1;
    D.31594 = _amd64_rex_bits | 64;
    *code.246 = D.31594;
    <D.31592>:
  }
  if (1 != 0) goto <D.31595>; else goto <D.31596>;
  <D.31595>:
  code.247 = code;
  code = code.247 + 1;
  *code.247 = 198;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31599>; else goto <D.31600>;
  <D.31599>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31601>; else goto <D.31602>;
  <D.31601>:
  code.248 = code;
  code = code.248 + 1;
  *code.248 = 4;
  code.249 = code;
  code = code.249 + 1;
  *code.249 = 36;
  goto <D.31605>;
  <D.31602>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31606>; else goto <D.31607>;
  <D.31606>:
  code.250 = code;
  code = code.250 + 1;
  *code.250 = 68;
  code.251 = code;
  code = code.251 + 1;
  *code.251 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31610>;
  <D.31607>:
  code.252 = code;
  code = code.252 + 1;
  *code.252 = 132;
  code.253 = code;
  code = code.253 + 1;
  *code.253 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.254 = code;
        code = code.254 + 1;
        D.31614 = imb.b[0];
        *code.254 = D.31614;
        code.255 = code;
        code = code.255 + 1;
        D.31616 = imb.b[1];
        *code.255 = D.31616;
        code.256 = code;
        code = code.256 + 1;
        D.31618 = imb.b[2];
        *code.256 = D.31618;
        code.257 = code;
        code = code.257 + 1;
        D.31620 = imb.b[3];
        *code.257 = D.31620;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31610>:
  <D.31605>:
  goto <D.25208>;
  <D.31600>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31621>; else goto <D.31622>;
  <D.31621>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31623>; else goto <D.31624>;
  <D.31623>:
  code.258 = code;
  code = code.258 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.258 = D.31627;
  goto <D.25208>;
  <D.31624>:
  <D.31622>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31628>; else goto <D.31629>;
  <D.31628>:
  code.259 = code;
  code = code.259 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.259 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31635>;
  <D.31629>:
  code.260 = code;
  code = code.260 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.260 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.261 = code;
        code = code.261 + 1;
        D.31640 = imb.b[0];
        *code.261 = D.31640;
        code.262 = code;
        code = code.262 + 1;
        D.31642 = imb.b[1];
        *code.262 = D.31642;
        code.263 = code;
        code = code.263 + 1;
        D.31644 = imb.b[2];
        *code.263 = D.31644;
        code.264 = code;
        code = code.264 + 1;
        D.31646 = imb.b[3];
        *code.264 = D.31646;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31635>:
  <D.25208>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.31649>;
  <D.31596>:
  if (0 != 0) goto <D.31650>; else goto <D.31651>;
  <D.31650>:
  code.265 = code;
  code = code.265 + 1;
  *code.265 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31653>; else goto <D.31654>;
  <D.31653>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31655>; else goto <D.31656>;
  <D.31655>:
  code.266 = code;
  code = code.266 + 1;
  *code.266 = 4;
  code.267 = code;
  code = code.267 + 1;
  *code.267 = 36;
  goto <D.31659>;
  <D.31656>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31660>; else goto <D.31661>;
  <D.31660>:
  code.268 = code;
  code = code.268 + 1;
  *code.268 = 68;
  code.269 = code;
  code = code.269 + 1;
  *code.269 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31664>;
  <D.31661>:
  code.270 = code;
  code = code.270 + 1;
  *code.270 = 132;
  code.271 = code;
  code = code.271 + 1;
  *code.271 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.272 = code;
        code = code.272 + 1;
        D.31668 = imb.b[0];
        *code.272 = D.31668;
        code.273 = code;
        code = code.273 + 1;
        D.31670 = imb.b[1];
        *code.273 = D.31670;
        code.274 = code;
        code = code.274 + 1;
        D.31672 = imb.b[2];
        *code.274 = D.31672;
        code.275 = code;
        code = code.275 + 1;
        D.31674 = imb.b[3];
        *code.275 = D.31674;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31664>:
  <D.31659>:
  goto <D.25211>;
  <D.31654>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31675>; else goto <D.31676>;
  <D.31675>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31677>; else goto <D.31678>;
  <D.31677>:
  code.276 = code;
  code = code.276 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.276 = D.31627;
  goto <D.25211>;
  <D.31678>:
  <D.31676>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31680>; else goto <D.31681>;
  <D.31680>:
  code.277 = code;
  code = code.277 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.277 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31683>;
  <D.31681>:
  code.278 = code;
  code = code.278 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.278 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.279 = code;
        code = code.279 + 1;
        D.31686 = imb.b[0];
        *code.279 = D.31686;
        code.280 = code;
        code = code.280 + 1;
        D.31688 = imb.b[1];
        *code.280 = D.31688;
        code.281 = code;
        code = code.281 + 1;
        D.31690 = imb.b[2];
        *code.281 = D.31690;
        code.282 = code;
        code = code.282 + 1;
        D.31692 = imb.b[3];
        *code.282 = D.31692;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31683>:
  <D.25211>:
  D.31647 = ins->data.op[1].const_val;
  D.31693 = (short int) D.31647;
  MEM[(short int *)code] = D.31693;
  code = code + 2;
  goto <D.31694>;
  <D.31651>:
  code.283 = code;
  code = code.283 + 1;
  *code.283 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31696>; else goto <D.31697>;
  <D.31696>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31698>; else goto <D.31699>;
  <D.31698>:
  code.284 = code;
  code = code.284 + 1;
  *code.284 = 4;
  code.285 = code;
  code = code.285 + 1;
  *code.285 = 36;
  goto <D.31702>;
  <D.31699>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31703>; else goto <D.31704>;
  <D.31703>:
  code.286 = code;
  code = code.286 + 1;
  *code.286 = 68;
  code.287 = code;
  code = code.287 + 1;
  *code.287 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31707>;
  <D.31704>:
  code.288 = code;
  code = code.288 + 1;
  *code.288 = 132;
  code.289 = code;
  code = code.289 + 1;
  *code.289 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.290 = code;
        code = code.290 + 1;
        D.31711 = imb.b[0];
        *code.290 = D.31711;
        code.291 = code;
        code = code.291 + 1;
        D.31713 = imb.b[1];
        *code.291 = D.31713;
        code.292 = code;
        code = code.292 + 1;
        D.31715 = imb.b[2];
        *code.292 = D.31715;
        code.293 = code;
        code = code.293 + 1;
        D.31717 = imb.b[3];
        *code.293 = D.31717;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31707>:
  <D.31702>:
  goto <D.25214>;
  <D.31697>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31718>; else goto <D.31719>;
  <D.31718>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31720>; else goto <D.31721>;
  <D.31720>:
  code.294 = code;
  code = code.294 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.294 = D.31627;
  goto <D.25214>;
  <D.31721>:
  <D.31719>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31723>; else goto <D.31724>;
  <D.31723>:
  code.295 = code;
  code = code.295 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.295 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31726>;
  <D.31724>:
  code.296 = code;
  code = code.296 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.296 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.297 = code;
        code = code.297 + 1;
        D.31729 = imb.b[0];
        *code.297 = D.31729;
        code.298 = code;
        code = code.298 + 1;
        D.31731 = imb.b[1];
        *code.298 = D.31731;
        code.299 = code;
        code = code.299 + 1;
        D.31733 = imb.b[2];
        *code.299 = D.31733;
        code.300 = code;
        code = code.300 + 1;
        D.31735 = imb.b[3];
        *code.300 = D.31735;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31726>:
  <D.25214>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.301 = code;
        code = code.301 + 1;
        D.31738 = imb.b[0];
        *code.301 = D.31738;
        code.302 = code;
        code = code.302 + 1;
        D.31740 = imb.b[1];
        *code.302 = D.31740;
        code.303 = code;
        code = code.303 + 1;
        D.31742 = imb.b[2];
        *code.303 = D.31742;
        code.304 = code;
        code = code.304 + 1;
        D.31744 = imb.b[3];
        *code.304 = D.31744;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31694>:
  <D.31649>:
  goto <D.25197>;
  <D.25217>:
  if (1 != 0) goto <D.31745>; else goto <D.31746>;
  <D.31745>:
  code.305 = code;
  code = code.305 + 1;
  *code.305 = 102;
  <D.31746>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.31748>; else goto <D.31749>;
    <D.31748>:
    code.306 = code;
    code = code.306 + 1;
    D.31751 = _amd64_rex_bits | 64;
    *code.306 = D.31751;
    <D.31749>:
  }
  if (0 != 0) goto <D.31752>; else goto <D.31753>;
  <D.31752>:
  code.307 = code;
  code = code.307 + 1;
  *code.307 = 198;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31755>; else goto <D.31756>;
  <D.31755>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31757>; else goto <D.31758>;
  <D.31757>:
  code.308 = code;
  code = code.308 + 1;
  *code.308 = 4;
  code.309 = code;
  code = code.309 + 1;
  *code.309 = 36;
  goto <D.31761>;
  <D.31758>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31762>; else goto <D.31763>;
  <D.31762>:
  code.310 = code;
  code = code.310 + 1;
  *code.310 = 68;
  code.311 = code;
  code = code.311 + 1;
  *code.311 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31766>;
  <D.31763>:
  code.312 = code;
  code = code.312 + 1;
  *code.312 = 132;
  code.313 = code;
  code = code.313 + 1;
  *code.313 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.314 = code;
        code = code.314 + 1;
        D.31770 = imb.b[0];
        *code.314 = D.31770;
        code.315 = code;
        code = code.315 + 1;
        D.31772 = imb.b[1];
        *code.315 = D.31772;
        code.316 = code;
        code = code.316 + 1;
        D.31774 = imb.b[2];
        *code.316 = D.31774;
        code.317 = code;
        code = code.317 + 1;
        D.31776 = imb.b[3];
        *code.317 = D.31776;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31766>:
  <D.31761>:
  goto <D.25220>;
  <D.31756>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31777>; else goto <D.31778>;
  <D.31777>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31779>; else goto <D.31780>;
  <D.31779>:
  code.318 = code;
  code = code.318 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.318 = D.31627;
  goto <D.25220>;
  <D.31780>:
  <D.31778>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31782>; else goto <D.31783>;
  <D.31782>:
  code.319 = code;
  code = code.319 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.319 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31785>;
  <D.31783>:
  code.320 = code;
  code = code.320 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.320 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.321 = code;
        code = code.321 + 1;
        D.31788 = imb.b[0];
        *code.321 = D.31788;
        code.322 = code;
        code = code.322 + 1;
        D.31790 = imb.b[1];
        *code.322 = D.31790;
        code.323 = code;
        code = code.323 + 1;
        D.31792 = imb.b[2];
        *code.323 = D.31792;
        code.324 = code;
        code = code.324 + 1;
        D.31794 = imb.b[3];
        *code.324 = D.31794;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31785>:
  <D.25220>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.31795>;
  <D.31753>:
  if (1 != 0) goto <D.31796>; else goto <D.31797>;
  <D.31796>:
  code.325 = code;
  code = code.325 + 1;
  *code.325 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31799>; else goto <D.31800>;
  <D.31799>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31801>; else goto <D.31802>;
  <D.31801>:
  code.326 = code;
  code = code.326 + 1;
  *code.326 = 4;
  code.327 = code;
  code = code.327 + 1;
  *code.327 = 36;
  goto <D.31805>;
  <D.31802>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31806>; else goto <D.31807>;
  <D.31806>:
  code.328 = code;
  code = code.328 + 1;
  *code.328 = 68;
  code.329 = code;
  code = code.329 + 1;
  *code.329 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31810>;
  <D.31807>:
  code.330 = code;
  code = code.330 + 1;
  *code.330 = 132;
  code.331 = code;
  code = code.331 + 1;
  *code.331 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.332 = code;
        code = code.332 + 1;
        D.31814 = imb.b[0];
        *code.332 = D.31814;
        code.333 = code;
        code = code.333 + 1;
        D.31816 = imb.b[1];
        *code.333 = D.31816;
        code.334 = code;
        code = code.334 + 1;
        D.31818 = imb.b[2];
        *code.334 = D.31818;
        code.335 = code;
        code = code.335 + 1;
        D.31820 = imb.b[3];
        *code.335 = D.31820;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31810>:
  <D.31805>:
  goto <D.25223>;
  <D.31800>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31821>; else goto <D.31822>;
  <D.31821>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31823>; else goto <D.31824>;
  <D.31823>:
  code.336 = code;
  code = code.336 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.336 = D.31627;
  goto <D.25223>;
  <D.31824>:
  <D.31822>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31826>; else goto <D.31827>;
  <D.31826>:
  code.337 = code;
  code = code.337 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.337 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31829>;
  <D.31827>:
  code.338 = code;
  code = code.338 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.338 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.339 = code;
        code = code.339 + 1;
        D.31832 = imb.b[0];
        *code.339 = D.31832;
        code.340 = code;
        code = code.340 + 1;
        D.31834 = imb.b[1];
        *code.340 = D.31834;
        code.341 = code;
        code = code.341 + 1;
        D.31836 = imb.b[2];
        *code.341 = D.31836;
        code.342 = code;
        code = code.342 + 1;
        D.31838 = imb.b[3];
        *code.342 = D.31838;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31829>:
  <D.25223>:
  D.31647 = ins->data.op[1].const_val;
  D.31693 = (short int) D.31647;
  MEM[(short int *)code] = D.31693;
  code = code + 2;
  goto <D.31839>;
  <D.31797>:
  code.343 = code;
  code = code.343 + 1;
  *code.343 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31841>; else goto <D.31842>;
  <D.31841>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31843>; else goto <D.31844>;
  <D.31843>:
  code.344 = code;
  code = code.344 + 1;
  *code.344 = 4;
  code.345 = code;
  code = code.345 + 1;
  *code.345 = 36;
  goto <D.31847>;
  <D.31844>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31848>; else goto <D.31849>;
  <D.31848>:
  code.346 = code;
  code = code.346 + 1;
  *code.346 = 68;
  code.347 = code;
  code = code.347 + 1;
  *code.347 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31852>;
  <D.31849>:
  code.348 = code;
  code = code.348 + 1;
  *code.348 = 132;
  code.349 = code;
  code = code.349 + 1;
  *code.349 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.350 = code;
        code = code.350 + 1;
        D.31856 = imb.b[0];
        *code.350 = D.31856;
        code.351 = code;
        code = code.351 + 1;
        D.31858 = imb.b[1];
        *code.351 = D.31858;
        code.352 = code;
        code = code.352 + 1;
        D.31860 = imb.b[2];
        *code.352 = D.31860;
        code.353 = code;
        code = code.353 + 1;
        D.31862 = imb.b[3];
        *code.353 = D.31862;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31852>:
  <D.31847>:
  goto <D.25226>;
  <D.31842>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31863>; else goto <D.31864>;
  <D.31863>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31865>; else goto <D.31866>;
  <D.31865>:
  code.354 = code;
  code = code.354 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.354 = D.31627;
  goto <D.25226>;
  <D.31866>:
  <D.31864>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31868>; else goto <D.31869>;
  <D.31868>:
  code.355 = code;
  code = code.355 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.355 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31871>;
  <D.31869>:
  code.356 = code;
  code = code.356 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.356 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.357 = code;
        code = code.357 + 1;
        D.31874 = imb.b[0];
        *code.357 = D.31874;
        code.358 = code;
        code = code.358 + 1;
        D.31876 = imb.b[1];
        *code.358 = D.31876;
        code.359 = code;
        code = code.359 + 1;
        D.31878 = imb.b[2];
        *code.359 = D.31878;
        code.360 = code;
        code = code.360 + 1;
        D.31880 = imb.b[3];
        *code.360 = D.31880;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31871>:
  <D.25226>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.361 = code;
        code = code.361 + 1;
        D.31882 = imb.b[0];
        *code.361 = D.31882;
        code.362 = code;
        code = code.362 + 1;
        D.31884 = imb.b[1];
        *code.362 = D.31884;
        code.363 = code;
        code = code.363 + 1;
        D.31886 = imb.b[2];
        *code.363 = D.31886;
        code.364 = code;
        code = code.364 + 1;
        D.31888 = imb.b[3];
        *code.364 = D.31888;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31839>:
  <D.31795>:
  goto <D.25197>;
  <D.25229>:
  if (0 != 0) goto <D.31889>; else goto <D.31890>;
  <D.31889>:
  code.365 = code;
  code = code.365 + 1;
  *code.365 = 102;
  <D.31890>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.31892>; else goto <D.31893>;
    <D.31892>:
    code.366 = code;
    code = code.366 + 1;
    D.31895 = _amd64_rex_bits | 64;
    *code.366 = D.31895;
    <D.31893>:
  }
  if (0 != 0) goto <D.31896>; else goto <D.31897>;
  <D.31896>:
  code.367 = code;
  code = code.367 + 1;
  *code.367 = 198;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31899>; else goto <D.31900>;
  <D.31899>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31901>; else goto <D.31902>;
  <D.31901>:
  code.368 = code;
  code = code.368 + 1;
  *code.368 = 4;
  code.369 = code;
  code = code.369 + 1;
  *code.369 = 36;
  goto <D.31905>;
  <D.31902>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31906>; else goto <D.31907>;
  <D.31906>:
  code.370 = code;
  code = code.370 + 1;
  *code.370 = 68;
  code.371 = code;
  code = code.371 + 1;
  *code.371 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31910>;
  <D.31907>:
  code.372 = code;
  code = code.372 + 1;
  *code.372 = 132;
  code.373 = code;
  code = code.373 + 1;
  *code.373 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.374 = code;
        code = code.374 + 1;
        D.31914 = imb.b[0];
        *code.374 = D.31914;
        code.375 = code;
        code = code.375 + 1;
        D.31916 = imb.b[1];
        *code.375 = D.31916;
        code.376 = code;
        code = code.376 + 1;
        D.31918 = imb.b[2];
        *code.376 = D.31918;
        code.377 = code;
        code = code.377 + 1;
        D.31920 = imb.b[3];
        *code.377 = D.31920;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31910>:
  <D.31905>:
  goto <D.25232>;
  <D.31900>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31921>; else goto <D.31922>;
  <D.31921>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31923>; else goto <D.31924>;
  <D.31923>:
  code.378 = code;
  code = code.378 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.378 = D.31627;
  goto <D.25232>;
  <D.31924>:
  <D.31922>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31926>; else goto <D.31927>;
  <D.31926>:
  code.379 = code;
  code = code.379 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.379 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31929>;
  <D.31927>:
  code.380 = code;
  code = code.380 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.380 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.381 = code;
        code = code.381 + 1;
        D.31932 = imb.b[0];
        *code.381 = D.31932;
        code.382 = code;
        code = code.382 + 1;
        D.31934 = imb.b[1];
        *code.382 = D.31934;
        code.383 = code;
        code = code.383 + 1;
        D.31936 = imb.b[2];
        *code.383 = D.31936;
        code.384 = code;
        code = code.384 + 1;
        D.31938 = imb.b[3];
        *code.384 = D.31938;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31929>:
  <D.25232>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.31939>;
  <D.31897>:
  if (0 != 0) goto <D.31940>; else goto <D.31941>;
  <D.31940>:
  code.385 = code;
  code = code.385 + 1;
  *code.385 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31943>; else goto <D.31944>;
  <D.31943>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31945>; else goto <D.31946>;
  <D.31945>:
  code.386 = code;
  code = code.386 + 1;
  *code.386 = 4;
  code.387 = code;
  code = code.387 + 1;
  *code.387 = 36;
  goto <D.31949>;
  <D.31946>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31950>; else goto <D.31951>;
  <D.31950>:
  code.388 = code;
  code = code.388 + 1;
  *code.388 = 68;
  code.389 = code;
  code = code.389 + 1;
  *code.389 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31954>;
  <D.31951>:
  code.390 = code;
  code = code.390 + 1;
  *code.390 = 132;
  code.391 = code;
  code = code.391 + 1;
  *code.391 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.392 = code;
        code = code.392 + 1;
        D.31958 = imb.b[0];
        *code.392 = D.31958;
        code.393 = code;
        code = code.393 + 1;
        D.31960 = imb.b[1];
        *code.393 = D.31960;
        code.394 = code;
        code = code.394 + 1;
        D.31962 = imb.b[2];
        *code.394 = D.31962;
        code.395 = code;
        code = code.395 + 1;
        D.31964 = imb.b[3];
        *code.395 = D.31964;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31954>:
  <D.31949>:
  goto <D.25235>;
  <D.31944>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31965>; else goto <D.31966>;
  <D.31965>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.31967>; else goto <D.31968>;
  <D.31967>:
  code.396 = code;
  code = code.396 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.396 = D.31627;
  goto <D.25235>;
  <D.31968>:
  <D.31966>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31970>; else goto <D.31971>;
  <D.31970>:
  code.397 = code;
  code = code.397 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.397 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31973>;
  <D.31971>:
  code.398 = code;
  code = code.398 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.398 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.399 = code;
        code = code.399 + 1;
        D.31976 = imb.b[0];
        *code.399 = D.31976;
        code.400 = code;
        code = code.400 + 1;
        D.31978 = imb.b[1];
        *code.400 = D.31978;
        code.401 = code;
        code = code.401 + 1;
        D.31980 = imb.b[2];
        *code.401 = D.31980;
        code.402 = code;
        code = code.402 + 1;
        D.31982 = imb.b[3];
        *code.402 = D.31982;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31973>:
  <D.25235>:
  D.31647 = ins->data.op[1].const_val;
  D.31693 = (short int) D.31647;
  MEM[(short int *)code] = D.31693;
  code = code + 2;
  goto <D.31983>;
  <D.31941>:
  code.403 = code;
  code = code.403 + 1;
  *code.403 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.31985>; else goto <D.31986>;
  <D.31985>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.31987>; else goto <D.31988>;
  <D.31987>:
  code.404 = code;
  code = code.404 + 1;
  *code.404 = 4;
  code.405 = code;
  code = code.405 + 1;
  *code.405 = 36;
  goto <D.31991>;
  <D.31988>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.31992>; else goto <D.31993>;
  <D.31992>:
  code.406 = code;
  code = code.406 + 1;
  *code.406 = 68;
  code.407 = code;
  code = code.407 + 1;
  *code.407 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.31996>;
  <D.31993>:
  code.408 = code;
  code = code.408 + 1;
  *code.408 = 132;
  code.409 = code;
  code = code.409 + 1;
  *code.409 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.410 = code;
        code = code.410 + 1;
        D.32000 = imb.b[0];
        *code.410 = D.32000;
        code.411 = code;
        code = code.411 + 1;
        D.32002 = imb.b[1];
        *code.411 = D.32002;
        code.412 = code;
        code = code.412 + 1;
        D.32004 = imb.b[2];
        *code.412 = D.32004;
        code.413 = code;
        code = code.413 + 1;
        D.32006 = imb.b[3];
        *code.413 = D.32006;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31996>:
  <D.31991>:
  goto <D.25238>;
  <D.31986>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32007>; else goto <D.32008>;
  <D.32007>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32009>; else goto <D.32010>;
  <D.32009>:
  code.414 = code;
  code = code.414 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.414 = D.31627;
  goto <D.25238>;
  <D.32010>:
  <D.32008>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32012>; else goto <D.32013>;
  <D.32012>:
  code.415 = code;
  code = code.415 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.415 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32015>;
  <D.32013>:
  code.416 = code;
  code = code.416 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.416 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.417 = code;
        code = code.417 + 1;
        D.32018 = imb.b[0];
        *code.417 = D.32018;
        code.418 = code;
        code = code.418 + 1;
        D.32020 = imb.b[1];
        *code.418 = D.32020;
        code.419 = code;
        code = code.419 + 1;
        D.32022 = imb.b[2];
        *code.419 = D.32022;
        code.420 = code;
        code = code.420 + 1;
        D.32024 = imb.b[3];
        *code.420 = D.32024;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32015>:
  <D.25238>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.421 = code;
        code = code.421 + 1;
        D.32026 = imb.b[0];
        *code.421 = D.32026;
        code.422 = code;
        code = code.422 + 1;
        D.32028 = imb.b[1];
        *code.422 = D.32028;
        code.423 = code;
        code = code.423 + 1;
        D.32030 = imb.b[2];
        *code.423 = D.32030;
        code.424 = code;
        code = code.424 + 1;
        D.32032 = imb.b[3];
        *code.424 = D.32032;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.31983>:
  <D.31939>:
  goto <D.25197>;
  <D.25241>:
  if (0 != 0) goto <D.32033>; else goto <D.32034>;
  <D.32033>:
  code.425 = code;
  code = code.425 + 1;
  *code.425 = 102;
  <D.32034>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.32037>; else goto <D.32038>;
    <D.32037>:
    iftmp.426 = 4;
    goto <D.32039>;
    <D.32038>:
    iftmp.426 = 0;
    <D.32039>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32041 = iftmp.426 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32041;
    if (1 != 0) goto <D.32042>; else goto <D.32043>;
    <D.32042>:
    code.427 = code;
    code = code.427 + 1;
    D.32045 = _amd64_rex_bits | 64;
    *code.427 = D.32045;
    <D.32043>:
  }
  switch (1) <default: <D.25248>, case 1: <D.25243>, case 2: <D.25245>, case 4: <D.25246>, case 8: <D.25247>>
  <D.25243>:
  code.428 = code;
  code = code.428 + 1;
  *code.428 = 136;
  goto <D.25244>;
  <D.25245>:
  <D.25246>:
  <D.25247>:
  code.429 = code;
  code = code.429 + 1;
  *code.429 = 137;
  goto <D.25244>;
  <D.25248>:
  __assert_fail ("0", "mini-amd64.c", 3999, &__PRETTY_FUNCTION__);
  <D.25244>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32048>; else goto <D.32049>;
  <D.32048>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32050>; else goto <D.32051>;
  <D.32050>:
  code.430 = code;
  code = code.430 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.430 = D.32056;
  code.431 = code;
  code = code.431 + 1;
  *code.431 = 36;
  goto <D.32058>;
  <D.32051>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32059>; else goto <D.32060>;
  <D.32059>:
  code.432 = code;
  code = code.432 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.432 = D.32063;
  code.433 = code;
  code = code.433 + 1;
  *code.433 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32065>;
  <D.32060>:
  code.434 = code;
  code = code.434 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.434 = D.32068;
  code.435 = code;
  code = code.435 + 1;
  *code.435 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.436 = code;
        code = code.436 + 1;
        D.32071 = imb.b[0];
        *code.436 = D.32071;
        code.437 = code;
        code = code.437 + 1;
        D.32073 = imb.b[1];
        *code.437 = D.32073;
        code.438 = code;
        code = code.438 + 1;
        D.32075 = imb.b[2];
        *code.438 = D.32075;
        code.439 = code;
        code = code.439 + 1;
        D.32077 = imb.b[3];
        *code.439 = D.32077;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32065>:
  <D.32058>:
  goto <D.25250>;
  <D.32049>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32078>; else goto <D.32079>;
  <D.32078>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32080>; else goto <D.32081>;
  <D.32080>:
  code.440 = code;
  code = code.440 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.440 = D.32084;
  goto <D.25250>;
  <D.32081>:
  <D.32079>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32085>; else goto <D.32086>;
  <D.32085>:
  code.441 = code;
  code = code.441 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.441 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32091>;
  <D.32086>:
  code.442 = code;
  code = code.442 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.442 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.443 = code;
        code = code.443 + 1;
        D.32097 = imb.b[0];
        *code.443 = D.32097;
        code.444 = code;
        code = code.444 + 1;
        D.32099 = imb.b[1];
        *code.444 = D.32099;
        code.445 = code;
        code = code.445 + 1;
        D.32101 = imb.b[2];
        *code.445 = D.32101;
        code.446 = code;
        code = code.446 + 1;
        D.32103 = imb.b[3];
        *code.446 = D.32103;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32091>:
  <D.25250>:
  goto <D.25197>;
  <D.25252>:
  if (1 != 0) goto <D.32104>; else goto <D.32105>;
  <D.32104>:
  code.447 = code;
  code = code.447 + 1;
  *code.447 = 102;
  <D.32105>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.32108>; else goto <D.32109>;
    <D.32108>:
    iftmp.448 = 4;
    goto <D.32110>;
    <D.32109>:
    iftmp.448 = 0;
    <D.32110>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32111 = iftmp.448 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32111;
    if (_amd64_rex_bits != 0) goto <D.32112>; else goto <D.32113>;
    <D.32112>:
    code.449 = code;
    code = code.449 + 1;
    D.32115 = _amd64_rex_bits | 64;
    *code.449 = D.32115;
    <D.32113>:
  }
  switch (2) <default: <D.25259>, case 1: <D.25254>, case 2: <D.25256>, case 4: <D.25257>, case 8: <D.25258>>
  <D.25254>:
  code.450 = code;
  code = code.450 + 1;
  *code.450 = 136;
  goto <D.25255>;
  <D.25256>:
  <D.25257>:
  <D.25258>:
  code.451 = code;
  code = code.451 + 1;
  *code.451 = 137;
  goto <D.25255>;
  <D.25259>:
  __assert_fail ("0", "mini-amd64.c", 4002, &__PRETTY_FUNCTION__);
  <D.25255>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32118>; else goto <D.32119>;
  <D.32118>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32120>; else goto <D.32121>;
  <D.32120>:
  code.452 = code;
  code = code.452 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.452 = D.32056;
  code.453 = code;
  code = code.453 + 1;
  *code.453 = 36;
  goto <D.32124>;
  <D.32121>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32125>; else goto <D.32126>;
  <D.32125>:
  code.454 = code;
  code = code.454 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.454 = D.32063;
  code.455 = code;
  code = code.455 + 1;
  *code.455 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32129>;
  <D.32126>:
  code.456 = code;
  code = code.456 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.456 = D.32068;
  code.457 = code;
  code = code.457 + 1;
  *code.457 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.458 = code;
        code = code.458 + 1;
        D.32133 = imb.b[0];
        *code.458 = D.32133;
        code.459 = code;
        code = code.459 + 1;
        D.32135 = imb.b[1];
        *code.459 = D.32135;
        code.460 = code;
        code = code.460 + 1;
        D.32137 = imb.b[2];
        *code.460 = D.32137;
        code.461 = code;
        code = code.461 + 1;
        D.32139 = imb.b[3];
        *code.461 = D.32139;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32129>:
  <D.32124>:
  goto <D.25261>;
  <D.32119>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32140>; else goto <D.32141>;
  <D.32140>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32142>; else goto <D.32143>;
  <D.32142>:
  code.462 = code;
  code = code.462 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.462 = D.32084;
  goto <D.25261>;
  <D.32143>:
  <D.32141>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32145>; else goto <D.32146>;
  <D.32145>:
  code.463 = code;
  code = code.463 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.463 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32148>;
  <D.32146>:
  code.464 = code;
  code = code.464 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.464 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.465 = code;
        code = code.465 + 1;
        D.32151 = imb.b[0];
        *code.465 = D.32151;
        code.466 = code;
        code = code.466 + 1;
        D.32153 = imb.b[1];
        *code.466 = D.32153;
        code.467 = code;
        code = code.467 + 1;
        D.32155 = imb.b[2];
        *code.467 = D.32155;
        code.468 = code;
        code = code.468 + 1;
        D.32157 = imb.b[3];
        *code.468 = D.32157;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32148>:
  <D.25261>:
  goto <D.25197>;
  <D.25263>:
  if (0 != 0) goto <D.32158>; else goto <D.32159>;
  <D.32158>:
  code.469 = code;
  code = code.469 + 1;
  *code.469 = 102;
  <D.32159>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.32162>; else goto <D.32163>;
    <D.32162>:
    iftmp.470 = 12;
    goto <D.32164>;
    <D.32163>:
    iftmp.470 = 8;
    <D.32164>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32165 = iftmp.470 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32165;
    if (_amd64_rex_bits != 0) goto <D.32166>; else goto <D.32167>;
    <D.32166>:
    code.471 = code;
    code = code.471 + 1;
    D.32169 = _amd64_rex_bits | 64;
    *code.471 = D.32169;
    <D.32167>:
  }
  switch (8) <default: <D.25270>, case 1: <D.25265>, case 2: <D.25267>, case 4: <D.25268>, case 8: <D.25269>>
  <D.25265>:
  code.472 = code;
  code = code.472 + 1;
  *code.472 = 136;
  goto <D.25266>;
  <D.25267>:
  <D.25268>:
  <D.25269>:
  code.473 = code;
  code = code.473 + 1;
  *code.473 = 137;
  goto <D.25266>;
  <D.25270>:
  __assert_fail ("0", "mini-amd64.c", 4007, &__PRETTY_FUNCTION__);
  <D.25266>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32172>; else goto <D.32173>;
  <D.32172>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32174>; else goto <D.32175>;
  <D.32174>:
  code.474 = code;
  code = code.474 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.474 = D.32056;
  code.475 = code;
  code = code.475 + 1;
  *code.475 = 36;
  goto <D.32178>;
  <D.32175>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32179>; else goto <D.32180>;
  <D.32179>:
  code.476 = code;
  code = code.476 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.476 = D.32063;
  code.477 = code;
  code = code.477 + 1;
  *code.477 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32183>;
  <D.32180>:
  code.478 = code;
  code = code.478 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.478 = D.32068;
  code.479 = code;
  code = code.479 + 1;
  *code.479 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.480 = code;
        code = code.480 + 1;
        D.32187 = imb.b[0];
        *code.480 = D.32187;
        code.481 = code;
        code = code.481 + 1;
        D.32189 = imb.b[1];
        *code.481 = D.32189;
        code.482 = code;
        code = code.482 + 1;
        D.32191 = imb.b[2];
        *code.482 = D.32191;
        code.483 = code;
        code = code.483 + 1;
        D.32193 = imb.b[3];
        *code.483 = D.32193;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32183>:
  <D.32178>:
  goto <D.25272>;
  <D.32173>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32194>; else goto <D.32195>;
  <D.32194>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32196>; else goto <D.32197>;
  <D.32196>:
  code.484 = code;
  code = code.484 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.484 = D.32084;
  goto <D.25272>;
  <D.32197>:
  <D.32195>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32199>; else goto <D.32200>;
  <D.32199>:
  code.485 = code;
  code = code.485 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.485 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32202>;
  <D.32200>:
  code.486 = code;
  code = code.486 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.486 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.487 = code;
        code = code.487 + 1;
        D.32205 = imb.b[0];
        *code.487 = D.32205;
        code.488 = code;
        code = code.488 + 1;
        D.32207 = imb.b[1];
        *code.488 = D.32207;
        code.489 = code;
        code = code.489 + 1;
        D.32209 = imb.b[2];
        *code.489 = D.32209;
        code.490 = code;
        code = code.490 + 1;
        D.32211 = imb.b[3];
        *code.490 = D.32211;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32202>:
  <D.25272>:
  goto <D.25197>;
  <D.25274>:
  if (0 != 0) goto <D.32212>; else goto <D.32213>;
  <D.32212>:
  code.491 = code;
  code = code.491 + 1;
  *code.491 = 102;
  <D.32213>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.32216>; else goto <D.32217>;
    <D.32216>:
    iftmp.492 = 12;
    goto <D.32218>;
    <D.32217>:
    iftmp.492 = 8;
    <D.32218>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32219 = iftmp.492 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32219;
    if (_amd64_rex_bits != 0) goto <D.32220>; else goto <D.32221>;
    <D.32220>:
    code.493 = code;
    code = code.493 + 1;
    D.32223 = _amd64_rex_bits | 64;
    *code.493 = D.32223;
    <D.32221>:
  }
  switch (8) <default: <D.25281>, case 1: <D.25276>, case 2: <D.25278>, case 4: <D.25279>, case 8: <D.25280>>
  <D.25276>:
  code.494 = code;
  code = code.494 + 1;
  *code.494 = 136;
  goto <D.25277>;
  <D.25278>:
  <D.25279>:
  <D.25280>:
  code.495 = code;
  code = code.495 + 1;
  *code.495 = 137;
  goto <D.25277>;
  <D.25281>:
  __assert_fail ("0", "mini-amd64.c", 4010, &__PRETTY_FUNCTION__);
  <D.25277>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32226>; else goto <D.32227>;
  <D.32226>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32228>; else goto <D.32229>;
  <D.32228>:
  code.496 = code;
  code = code.496 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.496 = D.32056;
  code.497 = code;
  code = code.497 + 1;
  *code.497 = 36;
  goto <D.32232>;
  <D.32229>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32233>; else goto <D.32234>;
  <D.32233>:
  code.498 = code;
  code = code.498 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.498 = D.32063;
  code.499 = code;
  code = code.499 + 1;
  *code.499 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32237>;
  <D.32234>:
  code.500 = code;
  code = code.500 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.500 = D.32068;
  code.501 = code;
  code = code.501 + 1;
  *code.501 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.502 = code;
        code = code.502 + 1;
        D.32241 = imb.b[0];
        *code.502 = D.32241;
        code.503 = code;
        code = code.503 + 1;
        D.32243 = imb.b[1];
        *code.503 = D.32243;
        code.504 = code;
        code = code.504 + 1;
        D.32245 = imb.b[2];
        *code.504 = D.32245;
        code.505 = code;
        code = code.505 + 1;
        D.32247 = imb.b[3];
        *code.505 = D.32247;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32237>:
  <D.32232>:
  goto <D.25283>;
  <D.32227>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32248>; else goto <D.32249>;
  <D.32248>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32250>; else goto <D.32251>;
  <D.32250>:
  code.506 = code;
  code = code.506 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.506 = D.32084;
  goto <D.25283>;
  <D.32251>:
  <D.32249>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32253>; else goto <D.32254>;
  <D.32253>:
  code.507 = code;
  code = code.507 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.507 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32256>;
  <D.32254>:
  code.508 = code;
  code = code.508 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.508 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.509 = code;
        code = code.509 + 1;
        D.32259 = imb.b[0];
        *code.509 = D.32259;
        code.510 = code;
        code = code.510 + 1;
        D.32261 = imb.b[1];
        *code.510 = D.32261;
        code.511 = code;
        code = code.511 + 1;
        D.32263 = imb.b[2];
        *code.511 = D.32263;
        code.512 = code;
        code = code.512 + 1;
        D.32265 = imb.b[3];
        *code.512 = D.32265;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32256>:
  <D.25283>:
  goto <D.25197>;
  <D.25285>:
  if (0 != 0) goto <D.32266>; else goto <D.32267>;
  <D.32266>:
  code.513 = code;
  code = code.513 + 1;
  *code.513 = 102;
  <D.32267>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.32270>; else goto <D.32271>;
    <D.32270>:
    iftmp.514 = 4;
    goto <D.32272>;
    <D.32271>:
    iftmp.514 = 0;
    <D.32272>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32273 = iftmp.514 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32273;
    if (_amd64_rex_bits != 0) goto <D.32274>; else goto <D.32275>;
    <D.32274>:
    code.515 = code;
    code = code.515 + 1;
    D.32277 = _amd64_rex_bits | 64;
    *code.515 = D.32277;
    <D.32275>:
  }
  switch (4) <default: <D.25292>, case 1: <D.25287>, case 2: <D.25289>, case 4: <D.25290>, case 8: <D.25291>>
  <D.25287>:
  code.516 = code;
  code = code.516 + 1;
  *code.516 = 136;
  goto <D.25288>;
  <D.25289>:
  <D.25290>:
  <D.25291>:
  code.517 = code;
  code = code.517 + 1;
  *code.517 = 137;
  goto <D.25288>;
  <D.25292>:
  __assert_fail ("0", "mini-amd64.c", 4013, &__PRETTY_FUNCTION__);
  <D.25288>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32280>; else goto <D.32281>;
  <D.32280>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32282>; else goto <D.32283>;
  <D.32282>:
  code.518 = code;
  code = code.518 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.518 = D.32056;
  code.519 = code;
  code = code.519 + 1;
  *code.519 = 36;
  goto <D.32286>;
  <D.32283>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32287>; else goto <D.32288>;
  <D.32287>:
  code.520 = code;
  code = code.520 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.520 = D.32063;
  code.521 = code;
  code = code.521 + 1;
  *code.521 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32291>;
  <D.32288>:
  code.522 = code;
  code = code.522 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.522 = D.32068;
  code.523 = code;
  code = code.523 + 1;
  *code.523 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.524 = code;
        code = code.524 + 1;
        D.32295 = imb.b[0];
        *code.524 = D.32295;
        code.525 = code;
        code = code.525 + 1;
        D.32297 = imb.b[1];
        *code.525 = D.32297;
        code.526 = code;
        code = code.526 + 1;
        D.32299 = imb.b[2];
        *code.526 = D.32299;
        code.527 = code;
        code = code.527 + 1;
        D.32301 = imb.b[3];
        *code.527 = D.32301;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32291>:
  <D.32286>:
  goto <D.25294>;
  <D.32281>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32302>; else goto <D.32303>;
  <D.32302>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32304>; else goto <D.32305>;
  <D.32304>:
  code.528 = code;
  code = code.528 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.528 = D.32084;
  goto <D.25294>;
  <D.32305>:
  <D.32303>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32307>; else goto <D.32308>;
  <D.32307>:
  code.529 = code;
  code = code.529 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.529 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32310>;
  <D.32308>:
  code.530 = code;
  code = code.530 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.530 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.531 = code;
        code = code.531 + 1;
        D.32313 = imb.b[0];
        *code.531 = D.32313;
        code.532 = code;
        code = code.532 + 1;
        D.32315 = imb.b[1];
        *code.532 = D.32315;
        code.533 = code;
        code = code.533 + 1;
        D.32317 = imb.b[2];
        *code.533 = D.32317;
        code.534 = code;
        code = code.534 + 1;
        D.32319 = imb.b[3];
        *code.534 = D.32319;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32310>:
  <D.25294>:
  goto <D.25197>;
  <D.25296>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.32325>; else goto <D.32326>;
  <D.32325>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4022, "amd64_is_imm32 (ins->inst_imm)");
  <D.32326>:
  if (0 != 0) goto <D.32327>; else goto <D.32328>;
  <D.32327>:
  code.535 = code;
  code = code.535 + 1;
  *code.535 = 102;
  <D.32328>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32331>; else goto <D.32332>;
    <D.32331>:
    iftmp.536 = 9;
    goto <D.32333>;
    <D.32332>:
    iftmp.536 = 8;
    <D.32333>:
    _amd64_rex_bits = iftmp.536;
    if (_amd64_rex_bits != 0) goto <D.32334>; else goto <D.32335>;
    <D.32334>:
    code.537 = code;
    code = code.537 + 1;
    D.32337 = _amd64_rex_bits | 64;
    *code.537 = D.32337;
    <D.32335>:
  }
  if (0 != 0) goto <D.32338>; else goto <D.32339>;
  <D.32338>:
  code.538 = code;
  code = code.538 + 1;
  *code.538 = 198;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32341>; else goto <D.32342>;
  <D.32341>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32343>; else goto <D.32344>;
  <D.32343>:
  code.539 = code;
  code = code.539 + 1;
  *code.539 = 4;
  code.540 = code;
  code = code.540 + 1;
  *code.540 = 36;
  goto <D.32347>;
  <D.32344>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32348>; else goto <D.32349>;
  <D.32348>:
  code.541 = code;
  code = code.541 + 1;
  *code.541 = 68;
  code.542 = code;
  code = code.542 + 1;
  *code.542 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32352>;
  <D.32349>:
  code.543 = code;
  code = code.543 + 1;
  *code.543 = 132;
  code.544 = code;
  code = code.544 + 1;
  *code.544 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.545 = code;
        code = code.545 + 1;
        D.32356 = imb.b[0];
        *code.545 = D.32356;
        code.546 = code;
        code = code.546 + 1;
        D.32358 = imb.b[1];
        *code.546 = D.32358;
        code.547 = code;
        code = code.547 + 1;
        D.32360 = imb.b[2];
        *code.547 = D.32360;
        code.548 = code;
        code = code.548 + 1;
        D.32362 = imb.b[3];
        *code.548 = D.32362;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32352>:
  <D.32347>:
  goto <D.25299>;
  <D.32342>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32363>; else goto <D.32364>;
  <D.32363>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32365>; else goto <D.32366>;
  <D.32365>:
  code.549 = code;
  code = code.549 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.549 = D.31627;
  goto <D.25299>;
  <D.32366>:
  <D.32364>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32368>; else goto <D.32369>;
  <D.32368>:
  code.550 = code;
  code = code.550 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.550 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32371>;
  <D.32369>:
  code.551 = code;
  code = code.551 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.551 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.552 = code;
        code = code.552 + 1;
        D.32374 = imb.b[0];
        *code.552 = D.32374;
        code.553 = code;
        code = code.553 + 1;
        D.32376 = imb.b[1];
        *code.553 = D.32376;
        code.554 = code;
        code = code.554 + 1;
        D.32378 = imb.b[2];
        *code.554 = D.32378;
        code.555 = code;
        code = code.555 + 1;
        D.32380 = imb.b[3];
        *code.555 = D.32380;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32371>:
  <D.25299>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.32381>;
  <D.32339>:
  if (0 != 0) goto <D.32382>; else goto <D.32383>;
  <D.32382>:
  code.556 = code;
  code = code.556 + 1;
  *code.556 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32385>; else goto <D.32386>;
  <D.32385>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32387>; else goto <D.32388>;
  <D.32387>:
  code.557 = code;
  code = code.557 + 1;
  *code.557 = 4;
  code.558 = code;
  code = code.558 + 1;
  *code.558 = 36;
  goto <D.32391>;
  <D.32388>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32392>; else goto <D.32393>;
  <D.32392>:
  code.559 = code;
  code = code.559 + 1;
  *code.559 = 68;
  code.560 = code;
  code = code.560 + 1;
  *code.560 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32396>;
  <D.32393>:
  code.561 = code;
  code = code.561 + 1;
  *code.561 = 132;
  code.562 = code;
  code = code.562 + 1;
  *code.562 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.563 = code;
        code = code.563 + 1;
        D.32400 = imb.b[0];
        *code.563 = D.32400;
        code.564 = code;
        code = code.564 + 1;
        D.32402 = imb.b[1];
        *code.564 = D.32402;
        code.565 = code;
        code = code.565 + 1;
        D.32404 = imb.b[2];
        *code.565 = D.32404;
        code.566 = code;
        code = code.566 + 1;
        D.32406 = imb.b[3];
        *code.566 = D.32406;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32396>:
  <D.32391>:
  goto <D.25302>;
  <D.32386>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32407>; else goto <D.32408>;
  <D.32407>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32409>; else goto <D.32410>;
  <D.32409>:
  code.567 = code;
  code = code.567 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.567 = D.31627;
  goto <D.25302>;
  <D.32410>:
  <D.32408>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32412>; else goto <D.32413>;
  <D.32412>:
  code.568 = code;
  code = code.568 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.568 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32415>;
  <D.32413>:
  code.569 = code;
  code = code.569 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.569 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.570 = code;
        code = code.570 + 1;
        D.32418 = imb.b[0];
        *code.570 = D.32418;
        code.571 = code;
        code = code.571 + 1;
        D.32420 = imb.b[1];
        *code.571 = D.32420;
        code.572 = code;
        code = code.572 + 1;
        D.32422 = imb.b[2];
        *code.572 = D.32422;
        code.573 = code;
        code = code.573 + 1;
        D.32424 = imb.b[3];
        *code.573 = D.32424;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32415>:
  <D.25302>:
  D.31647 = ins->data.op[1].const_val;
  D.31693 = (short int) D.31647;
  MEM[(short int *)code] = D.31693;
  code = code + 2;
  goto <D.32425>;
  <D.32383>:
  code.574 = code;
  code = code.574 + 1;
  *code.574 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32427>; else goto <D.32428>;
  <D.32427>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32429>; else goto <D.32430>;
  <D.32429>:
  code.575 = code;
  code = code.575 + 1;
  *code.575 = 4;
  code.576 = code;
  code = code.576 + 1;
  *code.576 = 36;
  goto <D.32433>;
  <D.32430>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32434>; else goto <D.32435>;
  <D.32434>:
  code.577 = code;
  code = code.577 + 1;
  *code.577 = 68;
  code.578 = code;
  code = code.578 + 1;
  *code.578 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32438>;
  <D.32435>:
  code.579 = code;
  code = code.579 + 1;
  *code.579 = 132;
  code.580 = code;
  code = code.580 + 1;
  *code.580 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.581 = code;
        code = code.581 + 1;
        D.32442 = imb.b[0];
        *code.581 = D.32442;
        code.582 = code;
        code = code.582 + 1;
        D.32444 = imb.b[1];
        *code.582 = D.32444;
        code.583 = code;
        code = code.583 + 1;
        D.32446 = imb.b[2];
        *code.583 = D.32446;
        code.584 = code;
        code = code.584 + 1;
        D.32448 = imb.b[3];
        *code.584 = D.32448;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32438>:
  <D.32433>:
  goto <D.25305>;
  <D.32428>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32449>; else goto <D.32450>;
  <D.32449>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32451>; else goto <D.32452>;
  <D.32451>:
  code.585 = code;
  code = code.585 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.585 = D.31627;
  goto <D.25305>;
  <D.32452>:
  <D.32450>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32454>; else goto <D.32455>;
  <D.32454>:
  code.586 = code;
  code = code.586 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.586 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32457>;
  <D.32455>:
  code.587 = code;
  code = code.587 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.587 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.588 = code;
        code = code.588 + 1;
        D.32460 = imb.b[0];
        *code.588 = D.32460;
        code.589 = code;
        code = code.589 + 1;
        D.32462 = imb.b[1];
        *code.589 = D.32462;
        code.590 = code;
        code = code.590 + 1;
        D.32464 = imb.b[2];
        *code.590 = D.32464;
        code.591 = code;
        code = code.591 + 1;
        D.32466 = imb.b[3];
        *code.591 = D.32466;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32457>:
  <D.25305>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.592 = code;
        code = code.592 + 1;
        D.32468 = imb.b[0];
        *code.592 = D.32468;
        code.593 = code;
        code = code.593 + 1;
        D.32470 = imb.b[1];
        *code.593 = D.32470;
        code.594 = code;
        code = code.594 + 1;
        D.32472 = imb.b[2];
        *code.594 = D.32472;
        code.595 = code;
        code = code.595 + 1;
        D.32474 = imb.b[3];
        *code.595 = D.32474;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32425>:
  <D.32381>:
  goto <D.25197>;
  <D.25308>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.32475>; else goto <D.32476>;
  <D.32475>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4027, "amd64_is_imm32 (ins->inst_imm)");
  <D.32476>:
  if (0 != 0) goto <D.32477>; else goto <D.32478>;
  <D.32477>:
  code.596 = code;
  code = code.596 + 1;
  *code.596 = 102;
  <D.32478>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32481>; else goto <D.32482>;
    <D.32481>:
    iftmp.597 = 9;
    goto <D.32483>;
    <D.32482>:
    iftmp.597 = 8;
    <D.32483>:
    _amd64_rex_bits = iftmp.597;
    if (_amd64_rex_bits != 0) goto <D.32484>; else goto <D.32485>;
    <D.32484>:
    code.598 = code;
    code = code.598 + 1;
    D.32487 = _amd64_rex_bits | 64;
    *code.598 = D.32487;
    <D.32485>:
  }
  if (0 != 0) goto <D.32488>; else goto <D.32489>;
  <D.32488>:
  code.599 = code;
  code = code.599 + 1;
  *code.599 = 198;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32491>; else goto <D.32492>;
  <D.32491>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32493>; else goto <D.32494>;
  <D.32493>:
  code.600 = code;
  code = code.600 + 1;
  *code.600 = 4;
  code.601 = code;
  code = code.601 + 1;
  *code.601 = 36;
  goto <D.32497>;
  <D.32494>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32498>; else goto <D.32499>;
  <D.32498>:
  code.602 = code;
  code = code.602 + 1;
  *code.602 = 68;
  code.603 = code;
  code = code.603 + 1;
  *code.603 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32502>;
  <D.32499>:
  code.604 = code;
  code = code.604 + 1;
  *code.604 = 132;
  code.605 = code;
  code = code.605 + 1;
  *code.605 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.606 = code;
        code = code.606 + 1;
        D.32506 = imb.b[0];
        *code.606 = D.32506;
        code.607 = code;
        code = code.607 + 1;
        D.32508 = imb.b[1];
        *code.607 = D.32508;
        code.608 = code;
        code = code.608 + 1;
        D.32510 = imb.b[2];
        *code.608 = D.32510;
        code.609 = code;
        code = code.609 + 1;
        D.32512 = imb.b[3];
        *code.609 = D.32512;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32502>:
  <D.32497>:
  goto <D.25311>;
  <D.32492>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32513>; else goto <D.32514>;
  <D.32513>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32515>; else goto <D.32516>;
  <D.32515>:
  code.610 = code;
  code = code.610 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.610 = D.31627;
  goto <D.25311>;
  <D.32516>:
  <D.32514>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32518>; else goto <D.32519>;
  <D.32518>:
  code.611 = code;
  code = code.611 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.611 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32521>;
  <D.32519>:
  code.612 = code;
  code = code.612 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.612 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.613 = code;
        code = code.613 + 1;
        D.32524 = imb.b[0];
        *code.613 = D.32524;
        code.614 = code;
        code = code.614 + 1;
        D.32526 = imb.b[1];
        *code.614 = D.32526;
        code.615 = code;
        code = code.615 + 1;
        D.32528 = imb.b[2];
        *code.615 = D.32528;
        code.616 = code;
        code = code.616 + 1;
        D.32530 = imb.b[3];
        *code.616 = D.32530;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32521>:
  <D.25311>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.32531>;
  <D.32489>:
  if (0 != 0) goto <D.32532>; else goto <D.32533>;
  <D.32532>:
  code.617 = code;
  code = code.617 + 1;
  *code.617 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32535>; else goto <D.32536>;
  <D.32535>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32537>; else goto <D.32538>;
  <D.32537>:
  code.618 = code;
  code = code.618 + 1;
  *code.618 = 4;
  code.619 = code;
  code = code.619 + 1;
  *code.619 = 36;
  goto <D.32541>;
  <D.32538>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32542>; else goto <D.32543>;
  <D.32542>:
  code.620 = code;
  code = code.620 + 1;
  *code.620 = 68;
  code.621 = code;
  code = code.621 + 1;
  *code.621 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32546>;
  <D.32543>:
  code.622 = code;
  code = code.622 + 1;
  *code.622 = 132;
  code.623 = code;
  code = code.623 + 1;
  *code.623 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.624 = code;
        code = code.624 + 1;
        D.32550 = imb.b[0];
        *code.624 = D.32550;
        code.625 = code;
        code = code.625 + 1;
        D.32552 = imb.b[1];
        *code.625 = D.32552;
        code.626 = code;
        code = code.626 + 1;
        D.32554 = imb.b[2];
        *code.626 = D.32554;
        code.627 = code;
        code = code.627 + 1;
        D.32556 = imb.b[3];
        *code.627 = D.32556;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32546>:
  <D.32541>:
  goto <D.25314>;
  <D.32536>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32557>; else goto <D.32558>;
  <D.32557>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32559>; else goto <D.32560>;
  <D.32559>:
  code.628 = code;
  code = code.628 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.628 = D.31627;
  goto <D.25314>;
  <D.32560>:
  <D.32558>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32562>; else goto <D.32563>;
  <D.32562>:
  code.629 = code;
  code = code.629 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.629 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32565>;
  <D.32563>:
  code.630 = code;
  code = code.630 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.630 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.631 = code;
        code = code.631 + 1;
        D.32568 = imb.b[0];
        *code.631 = D.32568;
        code.632 = code;
        code = code.632 + 1;
        D.32570 = imb.b[1];
        *code.632 = D.32570;
        code.633 = code;
        code = code.633 + 1;
        D.32572 = imb.b[2];
        *code.633 = D.32572;
        code.634 = code;
        code = code.634 + 1;
        D.32574 = imb.b[3];
        *code.634 = D.32574;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32565>:
  <D.25314>:
  D.31647 = ins->data.op[1].const_val;
  D.31693 = (short int) D.31647;
  MEM[(short int *)code] = D.31693;
  code = code + 2;
  goto <D.32575>;
  <D.32533>:
  code.635 = code;
  code = code.635 + 1;
  *code.635 = 199;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32577>; else goto <D.32578>;
  <D.32577>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32579>; else goto <D.32580>;
  <D.32579>:
  code.636 = code;
  code = code.636 + 1;
  *code.636 = 4;
  code.637 = code;
  code = code.637 + 1;
  *code.637 = 36;
  goto <D.32583>;
  <D.32580>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32584>; else goto <D.32585>;
  <D.32584>:
  code.638 = code;
  code = code.638 + 1;
  *code.638 = 68;
  code.639 = code;
  code = code.639 + 1;
  *code.639 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32588>;
  <D.32585>:
  code.640 = code;
  code = code.640 + 1;
  *code.640 = 132;
  code.641 = code;
  code = code.641 + 1;
  *code.641 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.642 = code;
        code = code.642 + 1;
        D.32592 = imb.b[0];
        *code.642 = D.32592;
        code.643 = code;
        code = code.643 + 1;
        D.32594 = imb.b[1];
        *code.643 = D.32594;
        code.644 = code;
        code = code.644 + 1;
        D.32596 = imb.b[2];
        *code.644 = D.32596;
        code.645 = code;
        code = code.645 + 1;
        D.32598 = imb.b[3];
        *code.645 = D.32598;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32588>:
  <D.32583>:
  goto <D.25317>;
  <D.32578>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.32599>; else goto <D.32600>;
  <D.32599>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32601>; else goto <D.32602>;
  <D.32601>:
  code.646 = code;
  code = code.646 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  *code.646 = D.31627;
  goto <D.25317>;
  <D.32602>:
  <D.32600>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.32604>; else goto <D.32605>;
  <D.32604>:
  code.647 = code;
  code = code.647 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31633 = D.31632 | 64;
  D.31634 = (unsigned char) D.31633;
  *code.647 = D.31634;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.32607>;
  <D.32605>:
  code.648 = code;
  code = code.648 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.31637 = D.31632 | -128;
  D.31638 = (unsigned char) D.31637;
  *code.648 = D.31638;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.649 = code;
        code = code.649 + 1;
        D.32610 = imb.b[0];
        *code.649 = D.32610;
        code.650 = code;
        code = code.650 + 1;
        D.32612 = imb.b[1];
        *code.650 = D.32612;
        code.651 = code;
        code = code.651 + 1;
        D.32614 = imb.b[2];
        *code.651 = D.32614;
        code.652 = code;
        code = code.652 + 1;
        D.32616 = imb.b[3];
        *code.652 = D.32616;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32607>:
  <D.25317>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.653 = code;
        code = code.653 + 1;
        D.32618 = imb.b[0];
        *code.653 = D.32618;
        code.654 = code;
        code = code.654 + 1;
        D.32620 = imb.b[1];
        *code.654 = D.32620;
        code.655 = code;
        code = code.655 + 1;
        D.32622 = imb.b[2];
        *code.655 = D.32622;
        code.656 = code;
        code = code.656 + 1;
        D.32624 = imb.b[3];
        *code.656 = D.32624;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32575>:
  <D.32531>:
  goto <D.25197>;
  <D.25320>:
  <D.25321>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  if (D.32321 <= 4294967295) goto <D.32625>; else goto <D.32626>;
  <D.32625>:
  if (0 != 0) goto <D.32627>; else goto <D.32628>;
  <D.32627>:
  code.657 = code;
  code = code.657 + 1;
  *code.657 = 102;
  <D.32628>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32631>; else goto <D.32632>;
    <D.32631>:
    iftmp.658 = 12;
    goto <D.32633>;
    <D.32632>:
    iftmp.658 = 8;
    <D.32633>:
    _amd64_rex_bits = iftmp.658;
    if (_amd64_rex_bits != 0) goto <D.32634>; else goto <D.32635>;
    <D.32634>:
    code.659 = code;
    code = code.659 + 1;
    D.32637 = _amd64_rex_bits | 64;
    *code.659 = D.32637;
    <D.32635>:
  }
  switch (8) <default: <D.25328>, case 1: <D.25323>, case 2: <D.25325>, case 4: <D.25326>, case 8: <D.25327>>
  <D.25323>:
  code.660 = code;
  code = code.660 + 1;
  *code.660 = 138;
  goto <D.25324>;
  <D.25325>:
  <D.25326>:
  <D.25327>:
  code.661 = code;
  code = code.661 + 1;
  *code.661 = 139;
  goto <D.25324>;
  <D.25328>:
  __assert_fail ("0", "mini-amd64.c", 4041, &__PRETTY_FUNCTION__);
  <D.25324>:
  code.662 = code;
  code = code.662 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.662 = D.32644;
  code.663 = code;
  code = code.663 + 1;
  *code.663 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.664 = code;
        code = code.664 + 1;
        D.32647 = imb.b[0];
        *code.664 = D.32647;
        code.665 = code;
        code = code.665 + 1;
        D.32649 = imb.b[1];
        *code.665 = D.32649;
        code.666 = code;
        code = code.666 + 1;
        D.32651 = imb.b[2];
        *code.666 = D.32651;
        code.667 = code;
        code = code.667 + 1;
        D.32653 = imb.b[3];
        *code.667 = D.32653;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.32654>;
  <D.32626>:
  {
    int _amd64_width_temp;

    D.31647 = ins->data.op[1].const_val;
    D.32655 = (long unsigned int) D.31647;
    D.31647 = ins->data.op[1].const_val;
    D.31736 = (int) D.31647;
    D.32656 = (long unsigned int) D.31736;
    D.32657 = D.32655 == D.32656;
    _amd64_width_temp = (int) D.32657;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.32659>; else goto <D.32660>;
      <D.32659>:
      iftmp.668 = 8;
      goto <D.32661>;
      <D.32660>:
      iftmp.668 = 0;
      <D.32661>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.32662 = iftmp.668 | D.32040;
      _amd64_rex_bits = (unsigned char) D.32662;
      if (_amd64_rex_bits != 0) goto <D.32663>; else goto <D.32664>;
      <D.32663>:
      code.669 = code;
      code = code.669 + 1;
      D.32666 = _amd64_rex_bits | 64;
      *code.669 = D.32666;
      <D.32664>:
    }
    code.670 = code;
    code = code.670 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.32668 = D.31627 + 184;
    *code.670 = D.32668;
    if (_amd64_width_temp == 0) goto <D.32669>; else goto <D.32670>;
    <D.32669>:
    {
      union amd64_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.32655 = (long unsigned int) D.31647;
          imb.val = D.32655;
          code.671 = code;
          code = code.671 + 1;
          D.32672 = imb.b[0];
          *code.671 = D.32672;
          code.672 = code;
          code = code.672 + 1;
          D.32674 = imb.b[1];
          *code.672 = D.32674;
          code.673 = code;
          code = code.673 + 1;
          D.32676 = imb.b[2];
          *code.673 = D.32676;
          code.674 = code;
          code = code.674 + 1;
          D.32678 = imb.b[3];
          *code.674 = D.32678;
          code.675 = code;
          code = code.675 + 1;
          D.32680 = imb.b[4];
          *code.675 = D.32680;
          code.676 = code;
          code = code.676 + 1;
          D.32682 = imb.b[5];
          *code.676 = D.32682;
          code.677 = code;
          code = code.677 + 1;
          D.32684 = imb.b[6];
          *code.677 = D.32684;
          code.678 = code;
          code = code.678 + 1;
          D.32686 = imb.b[7];
          *code.678 = D.32686;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.32687>;
    <D.32670>:
    {
      union x86_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.31736 = (int) D.31647;
          imb.val = D.31736;
          code.679 = code;
          code = code.679 + 1;
          D.32689 = imb.b[0];
          *code.679 = D.32689;
          code.680 = code;
          code = code.680 + 1;
          D.32691 = imb.b[1];
          *code.680 = D.32691;
          code.681 = code;
          code = code.681 + 1;
          D.32693 = imb.b[2];
          *code.681 = D.32693;
          code.682 = code;
          code = code.682 + 1;
          D.32695 = imb.b[3];
          *code.682 = D.32695;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32687>:
  }
  if (0 != 0) goto <D.32696>; else goto <D.32697>;
  <D.32696>:
  code.683 = code;
  code = code.683 + 1;
  *code.683 = 102;
  <D.32697>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32700>; else goto <D.32701>;
    <D.32700>:
    iftmp.684 = 12;
    goto <D.32702>;
    <D.32701>:
    iftmp.684 = 8;
    <D.32702>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32703 = iftmp.684 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32703;
    if (_amd64_rex_bits != 0) goto <D.32704>; else goto <D.32705>;
    <D.32704>:
    code.685 = code;
    code = code.685 + 1;
    D.32707 = _amd64_rex_bits | 64;
    *code.685 = D.32707;
    <D.32705>:
  }
  switch (8) <default: <D.25340>, case 1: <D.25335>, case 2: <D.25337>, case 4: <D.25338>, case 8: <D.25339>>
  <D.25335>:
  code.686 = code;
  code = code.686 + 1;
  *code.686 = 138;
  goto <D.25336>;
  <D.25337>:
  <D.25338>:
  <D.25339>:
  code.687 = code;
  code = code.687 + 1;
  *code.687 = 139;
  goto <D.25336>;
  <D.25340>:
  __assert_fail ("0", "mini-amd64.c", 4044, &__PRETTY_FUNCTION__);
  <D.25336>:
  D.31589 = ins->dreg;
  if (D.31589 == 16) goto <D.32710>; else goto <D.32711>;
  <D.32710>:
  code.688 = code;
  code = code.688 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.688 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.689 = code;
        code = code.689 + 1;
        D.32716 = imb.b[0];
        *code.689 = D.32716;
        code.690 = code;
        code = code.690 + 1;
        D.32718 = imb.b[1];
        *code.690 = D.32718;
        code.691 = code;
        code = code.691 + 1;
        D.32720 = imb.b[2];
        *code.691 = D.32720;
        code.692 = code;
        code = code.692 + 1;
        D.32722 = imb.b[3];
        *code.692 = D.32722;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.32723>;
  <D.32711>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32724>; else goto <D.32725>;
  <D.32724>:
  if (1 != 0) goto <D.32726>; else goto <D.32727>;
  <D.32726>:
  code.693 = code;
  code = code.693 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.693 = D.32644;
  code.694 = code;
  code = code.694 + 1;
  *code.694 = 36;
  goto <D.32730>;
  <D.32727>:
  if (1 != 0) goto <D.32731>; else goto <D.32732>;
  <D.32731>:
  code.695 = code;
  code = code.695 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.695 = D.32735;
  code.696 = code;
  code = code.696 + 1;
  *code.696 = 36;
  *code = 0;
  code = code + 1;
  goto <D.32737>;
  <D.32732>:
  code.697 = code;
  code = code.697 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.697 = D.32740;
  code.698 = code;
  code = code.698 + 1;
  *code.698 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.699 = code;
        code = code.699 + 1;
        D.32743 = imb.b[0];
        *code.699 = D.32743;
        code.700 = code;
        code = code.700 + 1;
        D.32745 = imb.b[1];
        *code.700 = D.32745;
        code.701 = code;
        code = code.701 + 1;
        D.32747 = imb.b[2];
        *code.701 = D.32747;
        code.702 = code;
        code = code.702 + 1;
        D.32749 = imb.b[3];
        *code.702 = D.32749;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32737>:
  <D.32730>:
  goto <D.25343>;
  <D.32725>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32750>; else goto <D.32751>;
  <D.32750>:
  code.703 = code;
  code = code.703 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32753 = D.32642 | D.31632;
  D.32754 = (unsigned char) D.32753;
  *code.703 = D.32754;
  goto <D.25343>;
  <D.32751>:
  if (1 != 0) goto <D.32755>; else goto <D.32756>;
  <D.32755>:
  code.704 = code;
  code = code.704 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32759 = D.32758 | D.31632;
  D.32760 = (unsigned char) D.32759;
  *code.704 = D.32760;
  *code = 0;
  code = code + 1;
  goto <D.32761>;
  <D.32756>:
  code.705 = code;
  code = code.705 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32764 = D.32763 | D.31632;
  D.32765 = (unsigned char) D.32764;
  *code.705 = D.32765;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.706 = code;
        code = code.706 + 1;
        D.32767 = imb.b[0];
        *code.706 = D.32767;
        code.707 = code;
        code = code.707 + 1;
        D.32769 = imb.b[1];
        *code.707 = D.32769;
        code.708 = code;
        code = code.708 + 1;
        D.32771 = imb.b[2];
        *code.708 = D.32771;
        code.709 = code;
        code = code.709 + 1;
        D.32773 = imb.b[3];
        *code.709 = D.32773;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32761>:
  <D.25343>:
  <D.32723>:
  <D.32654>:
  goto <D.25197>;
  <D.25345>:
  {
    int _amd64_width_temp;

    D.31647 = ins->data.op[1].const_val;
    D.32655 = (long unsigned int) D.31647;
    D.31647 = ins->data.op[1].const_val;
    D.31736 = (int) D.31647;
    D.32656 = (long unsigned int) D.31736;
    D.32657 = D.32655 == D.32656;
    _amd64_width_temp = (int) D.32657;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.32775>; else goto <D.32776>;
      <D.32775>:
      iftmp.710 = 8;
      goto <D.32777>;
      <D.32776>:
      iftmp.710 = 0;
      <D.32777>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.32778 = iftmp.710 | D.32040;
      _amd64_rex_bits = (unsigned char) D.32778;
      if (_amd64_rex_bits != 0) goto <D.32779>; else goto <D.32780>;
      <D.32779>:
      code.711 = code;
      code = code.711 + 1;
      D.32782 = _amd64_rex_bits | 64;
      *code.711 = D.32782;
      <D.32780>:
    }
    code.712 = code;
    code = code.712 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.32668 = D.31627 + 184;
    *code.712 = D.32668;
    if (_amd64_width_temp == 0) goto <D.32784>; else goto <D.32785>;
    <D.32784>:
    {
      union amd64_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.32655 = (long unsigned int) D.31647;
          imb.val = D.32655;
          code.713 = code;
          code = code.713 + 1;
          D.32787 = imb.b[0];
          *code.713 = D.32787;
          code.714 = code;
          code = code.714 + 1;
          D.32789 = imb.b[1];
          *code.714 = D.32789;
          code.715 = code;
          code = code.715 + 1;
          D.32791 = imb.b[2];
          *code.715 = D.32791;
          code.716 = code;
          code = code.716 + 1;
          D.32793 = imb.b[3];
          *code.716 = D.32793;
          code.717 = code;
          code = code.717 + 1;
          D.32795 = imb.b[4];
          *code.717 = D.32795;
          code.718 = code;
          code = code.718 + 1;
          D.32797 = imb.b[5];
          *code.718 = D.32797;
          code.719 = code;
          code = code.719 + 1;
          D.32799 = imb.b[6];
          *code.719 = D.32799;
          code.720 = code;
          code = code.720 + 1;
          D.32801 = imb.b[7];
          *code.720 = D.32801;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.32802>;
    <D.32785>:
    {
      union x86_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.31736 = (int) D.31647;
          imb.val = D.31736;
          code.721 = code;
          code = code.721 + 1;
          D.32804 = imb.b[0];
          *code.721 = D.32804;
          code.722 = code;
          code = code.722 + 1;
          D.32806 = imb.b[1];
          *code.722 = D.32806;
          code.723 = code;
          code = code.723 + 1;
          D.32808 = imb.b[2];
          *code.723 = D.32808;
          code.724 = code;
          code = code.724 + 1;
          D.32810 = imb.b[3];
          *code.724 = D.32810;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32802>:
  }
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32812>; else goto <D.32813>;
    <D.32812>:
    iftmp.725 = 12;
    goto <D.32814>;
    <D.32813>:
    iftmp.725 = 8;
    <D.32814>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32815 = iftmp.725 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32815;
    if (_amd64_rex_bits != 0) goto <D.32816>; else goto <D.32817>;
    <D.32816>:
    code.726 = code;
    code = code.726 + 1;
    D.32819 = _amd64_rex_bits | 64;
    *code.726 = D.32819;
    <D.32817>:
  }
  code.727 = code;
  code = code.727 + 1;
  *code.727 = 99;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32821>; else goto <D.32822>;
  <D.32821>:
  if (1 != 0) goto <D.32823>; else goto <D.32824>;
  <D.32823>:
  code.728 = code;
  code = code.728 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.728 = D.32644;
  code.729 = code;
  code = code.729 + 1;
  *code.729 = 36;
  goto <D.32827>;
  <D.32824>:
  if (1 != 0) goto <D.32828>; else goto <D.32829>;
  <D.32828>:
  code.730 = code;
  code = code.730 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.730 = D.32735;
  code.731 = code;
  code = code.731 + 1;
  *code.731 = 36;
  *code = 0;
  code = code + 1;
  goto <D.32832>;
  <D.32829>:
  code.732 = code;
  code = code.732 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.732 = D.32740;
  code.733 = code;
  code = code.733 + 1;
  *code.733 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.734 = code;
        code = code.734 + 1;
        D.32836 = imb.b[0];
        *code.734 = D.32836;
        code.735 = code;
        code = code.735 + 1;
        D.32838 = imb.b[1];
        *code.735 = D.32838;
        code.736 = code;
        code = code.736 + 1;
        D.32840 = imb.b[2];
        *code.736 = D.32840;
        code.737 = code;
        code = code.737 + 1;
        D.32842 = imb.b[3];
        *code.737 = D.32842;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32832>:
  <D.32827>:
  goto <D.25352>;
  <D.32822>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32843>; else goto <D.32844>;
  <D.32843>:
  code.738 = code;
  code = code.738 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32753 = D.32642 | D.31632;
  D.32754 = (unsigned char) D.32753;
  *code.738 = D.32754;
  goto <D.25352>;
  <D.32844>:
  if (1 != 0) goto <D.32846>; else goto <D.32847>;
  <D.32846>:
  code.739 = code;
  code = code.739 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32759 = D.32758 | D.31632;
  D.32760 = (unsigned char) D.32759;
  *code.739 = D.32760;
  *code = 0;
  code = code + 1;
  goto <D.32849>;
  <D.32847>:
  code.740 = code;
  code = code.740 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32764 = D.32763 | D.31632;
  D.32765 = (unsigned char) D.32764;
  *code.740 = D.32765;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.741 = code;
        code = code.741 + 1;
        D.32852 = imb.b[0];
        *code.741 = D.32852;
        code.742 = code;
        code = code.742 + 1;
        D.32854 = imb.b[1];
        *code.742 = D.32854;
        code.743 = code;
        code = code.743 + 1;
        D.32856 = imb.b[2];
        *code.743 = D.32856;
        code.744 = code;
        code = code.744 + 1;
        D.32858 = imb.b[3];
        *code.744 = D.32858;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32849>:
  <D.25352>:
  goto <D.25197>;
  <D.25354>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  if (D.32321 <= 4294967295) goto <D.32859>; else goto <D.32860>;
  <D.32859>:
  if (0 != 0) goto <D.32861>; else goto <D.32862>;
  <D.32861>:
  code.745 = code;
  code = code.745 + 1;
  *code.745 = 102;
  <D.32862>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32865>; else goto <D.32866>;
    <D.32865>:
    iftmp.746 = 4;
    goto <D.32867>;
    <D.32866>:
    iftmp.746 = 0;
    <D.32867>:
    _amd64_rex_bits = iftmp.746;
    if (_amd64_rex_bits != 0) goto <D.32868>; else goto <D.32869>;
    <D.32868>:
    code.747 = code;
    code = code.747 + 1;
    D.32871 = _amd64_rex_bits | 64;
    *code.747 = D.32871;
    <D.32869>:
  }
  switch (4) <default: <D.25361>, case 1: <D.25356>, case 2: <D.25358>, case 4: <D.25359>, case 8: <D.25360>>
  <D.25356>:
  code.748 = code;
  code = code.748 + 1;
  *code.748 = 138;
  goto <D.25357>;
  <D.25358>:
  <D.25359>:
  <D.25360>:
  code.749 = code;
  code = code.749 + 1;
  *code.749 = 139;
  goto <D.25357>;
  <D.25361>:
  __assert_fail ("0", "mini-amd64.c", 4054, &__PRETTY_FUNCTION__);
  <D.25357>:
  code.750 = code;
  code = code.750 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.750 = D.32644;
  code.751 = code;
  code = code.751 + 1;
  *code.751 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.752 = code;
        code = code.752 + 1;
        D.32877 = imb.b[0];
        *code.752 = D.32877;
        code.753 = code;
        code = code.753 + 1;
        D.32879 = imb.b[1];
        *code.753 = D.32879;
        code.754 = code;
        code = code.754 + 1;
        D.32881 = imb.b[2];
        *code.754 = D.32881;
        code.755 = code;
        code = code.755 + 1;
        D.32883 = imb.b[3];
        *code.755 = D.32883;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.32884>;
  <D.32860>:
  {
    int _amd64_width_temp;

    D.31647 = ins->data.op[1].const_val;
    D.32655 = (long unsigned int) D.31647;
    D.31647 = ins->data.op[1].const_val;
    D.31736 = (int) D.31647;
    D.32656 = (long unsigned int) D.31736;
    D.32657 = D.32655 == D.32656;
    _amd64_width_temp = (int) D.32657;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.32886>; else goto <D.32887>;
      <D.32886>:
      iftmp.756 = 8;
      goto <D.32888>;
      <D.32887>:
      iftmp.756 = 0;
      <D.32888>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.32889 = iftmp.756 | D.32040;
      _amd64_rex_bits = (unsigned char) D.32889;
      if (_amd64_rex_bits != 0) goto <D.32890>; else goto <D.32891>;
      <D.32890>:
      code.757 = code;
      code = code.757 + 1;
      D.32893 = _amd64_rex_bits | 64;
      *code.757 = D.32893;
      <D.32891>:
    }
    code.758 = code;
    code = code.758 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.32668 = D.31627 + 184;
    *code.758 = D.32668;
    if (_amd64_width_temp == 0) goto <D.32895>; else goto <D.32896>;
    <D.32895>:
    {
      union amd64_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.32655 = (long unsigned int) D.31647;
          imb.val = D.32655;
          code.759 = code;
          code = code.759 + 1;
          D.32898 = imb.b[0];
          *code.759 = D.32898;
          code.760 = code;
          code = code.760 + 1;
          D.32900 = imb.b[1];
          *code.760 = D.32900;
          code.761 = code;
          code = code.761 + 1;
          D.32902 = imb.b[2];
          *code.761 = D.32902;
          code.762 = code;
          code = code.762 + 1;
          D.32904 = imb.b[3];
          *code.762 = D.32904;
          code.763 = code;
          code = code.763 + 1;
          D.32906 = imb.b[4];
          *code.763 = D.32906;
          code.764 = code;
          code = code.764 + 1;
          D.32908 = imb.b[5];
          *code.764 = D.32908;
          code.765 = code;
          code = code.765 + 1;
          D.32910 = imb.b[6];
          *code.765 = D.32910;
          code.766 = code;
          code = code.766 + 1;
          D.32912 = imb.b[7];
          *code.766 = D.32912;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.32913>;
    <D.32896>:
    {
      union x86_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.31736 = (int) D.31647;
          imb.val = D.31736;
          code.767 = code;
          code = code.767 + 1;
          D.32915 = imb.b[0];
          *code.767 = D.32915;
          code.768 = code;
          code = code.768 + 1;
          D.32917 = imb.b[1];
          *code.768 = D.32917;
          code.769 = code;
          code = code.769 + 1;
          D.32919 = imb.b[2];
          *code.769 = D.32919;
          code.770 = code;
          code = code.770 + 1;
          D.32921 = imb.b[3];
          *code.770 = D.32921;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.32913>:
  }
  if (0 != 0) goto <D.32922>; else goto <D.32923>;
  <D.32922>:
  code.771 = code;
  code = code.771 + 1;
  *code.771 = 102;
  <D.32923>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.32926>; else goto <D.32927>;
    <D.32926>:
    iftmp.772 = 4;
    goto <D.32928>;
    <D.32927>:
    iftmp.772 = 0;
    <D.32928>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.32929 = iftmp.772 | D.32040;
    _amd64_rex_bits = (unsigned char) D.32929;
    if (_amd64_rex_bits != 0) goto <D.32930>; else goto <D.32931>;
    <D.32930>:
    code.773 = code;
    code = code.773 + 1;
    D.32933 = _amd64_rex_bits | 64;
    *code.773 = D.32933;
    <D.32931>:
  }
  switch (4) <default: <D.25373>, case 1: <D.25368>, case 2: <D.25370>, case 4: <D.25371>, case 8: <D.25372>>
  <D.25368>:
  code.774 = code;
  code = code.774 + 1;
  *code.774 = 138;
  goto <D.25369>;
  <D.25370>:
  <D.25371>:
  <D.25372>:
  code.775 = code;
  code = code.775 + 1;
  *code.775 = 139;
  goto <D.25369>;
  <D.25373>:
  __assert_fail ("0", "mini-amd64.c", 4057, &__PRETTY_FUNCTION__);
  <D.25369>:
  D.31589 = ins->dreg;
  if (D.31589 == 16) goto <D.32936>; else goto <D.32937>;
  <D.32936>:
  code.776 = code;
  code = code.776 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.776 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.777 = code;
        code = code.777 + 1;
        D.32940 = imb.b[0];
        *code.777 = D.32940;
        code.778 = code;
        code = code.778 + 1;
        D.32942 = imb.b[1];
        *code.778 = D.32942;
        code.779 = code;
        code = code.779 + 1;
        D.32944 = imb.b[2];
        *code.779 = D.32944;
        code.780 = code;
        code = code.780 + 1;
        D.32946 = imb.b[3];
        *code.780 = D.32946;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.32947>;
  <D.32937>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.32948>; else goto <D.32949>;
  <D.32948>:
  if (1 != 0) goto <D.32950>; else goto <D.32951>;
  <D.32950>:
  code.781 = code;
  code = code.781 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.781 = D.32644;
  code.782 = code;
  code = code.782 + 1;
  *code.782 = 36;
  goto <D.32954>;
  <D.32951>:
  if (1 != 0) goto <D.32955>; else goto <D.32956>;
  <D.32955>:
  code.783 = code;
  code = code.783 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.783 = D.32735;
  code.784 = code;
  code = code.784 + 1;
  *code.784 = 36;
  *code = 0;
  code = code + 1;
  goto <D.32959>;
  <D.32956>:
  code.785 = code;
  code = code.785 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.785 = D.32740;
  code.786 = code;
  code = code.786 + 1;
  *code.786 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.787 = code;
        code = code.787 + 1;
        D.32963 = imb.b[0];
        *code.787 = D.32963;
        code.788 = code;
        code = code.788 + 1;
        D.32965 = imb.b[1];
        *code.788 = D.32965;
        code.789 = code;
        code = code.789 + 1;
        D.32967 = imb.b[2];
        *code.789 = D.32967;
        code.790 = code;
        code = code.790 + 1;
        D.32969 = imb.b[3];
        *code.790 = D.32969;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32959>:
  <D.32954>:
  goto <D.25376>;
  <D.32949>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.32970>; else goto <D.32971>;
  <D.32970>:
  code.791 = code;
  code = code.791 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32753 = D.32642 | D.31632;
  D.32754 = (unsigned char) D.32753;
  *code.791 = D.32754;
  goto <D.25376>;
  <D.32971>:
  if (1 != 0) goto <D.32973>; else goto <D.32974>;
  <D.32973>:
  code.792 = code;
  code = code.792 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32759 = D.32758 | D.31632;
  D.32760 = (unsigned char) D.32759;
  *code.792 = D.32760;
  *code = 0;
  code = code + 1;
  goto <D.32976>;
  <D.32974>:
  code.793 = code;
  code = code.793 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32764 = D.32763 | D.31632;
  D.32765 = (unsigned char) D.32764;
  *code.793 = D.32765;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.794 = code;
        code = code.794 + 1;
        D.32979 = imb.b[0];
        *code.794 = D.32979;
        code.795 = code;
        code = code.795 + 1;
        D.32981 = imb.b[1];
        *code.795 = D.32981;
        code.796 = code;
        code = code.796 + 1;
        D.32983 = imb.b[2];
        *code.796 = D.32983;
        code.797 = code;
        code = code.797 + 1;
        D.32985 = imb.b[3];
        *code.797 = D.32985;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.32976>:
  <D.25376>:
  <D.32947>:
  <D.32884>:
  goto <D.25197>;
  <D.25378>:
  {
    int _amd64_width_temp;

    D.31647 = ins->data.op[1].const_val;
    D.32655 = (long unsigned int) D.31647;
    D.31647 = ins->data.op[1].const_val;
    D.31736 = (int) D.31647;
    D.32656 = (long unsigned int) D.31736;
    D.32657 = D.32655 == D.32656;
    _amd64_width_temp = (int) D.32657;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.32987>; else goto <D.32988>;
      <D.32987>:
      iftmp.798 = 8;
      goto <D.32989>;
      <D.32988>:
      iftmp.798 = 0;
      <D.32989>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.32990 = iftmp.798 | D.32040;
      _amd64_rex_bits = (unsigned char) D.32990;
      if (_amd64_rex_bits != 0) goto <D.32991>; else goto <D.32992>;
      <D.32991>:
      code.799 = code;
      code = code.799 + 1;
      D.32994 = _amd64_rex_bits | 64;
      *code.799 = D.32994;
      <D.32992>:
    }
    code.800 = code;
    code = code.800 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.32668 = D.31627 + 184;
    *code.800 = D.32668;
    if (_amd64_width_temp == 0) goto <D.32996>; else goto <D.32997>;
    <D.32996>:
    {
      union amd64_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.32655 = (long unsigned int) D.31647;
          imb.val = D.32655;
          code.801 = code;
          code = code.801 + 1;
          D.32999 = imb.b[0];
          *code.801 = D.32999;
          code.802 = code;
          code = code.802 + 1;
          D.33001 = imb.b[1];
          *code.802 = D.33001;
          code.803 = code;
          code = code.803 + 1;
          D.33003 = imb.b[2];
          *code.803 = D.33003;
          code.804 = code;
          code = code.804 + 1;
          D.33005 = imb.b[3];
          *code.804 = D.33005;
          code.805 = code;
          code = code.805 + 1;
          D.33007 = imb.b[4];
          *code.805 = D.33007;
          code.806 = code;
          code = code.806 + 1;
          D.33009 = imb.b[5];
          *code.806 = D.33009;
          code.807 = code;
          code = code.807 + 1;
          D.33011 = imb.b[6];
          *code.807 = D.33011;
          code.808 = code;
          code = code.808 + 1;
          D.33013 = imb.b[7];
          *code.808 = D.33013;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.33014>;
    <D.32997>:
    {
      union x86_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.31736 = (int) D.31647;
          imb.val = D.31736;
          code.809 = code;
          code = code.809 + 1;
          D.33016 = imb.b[0];
          *code.809 = D.33016;
          code.810 = code;
          code = code.810 + 1;
          D.33018 = imb.b[1];
          *code.810 = D.33018;
          code.811 = code;
          code = code.811 + 1;
          D.33020 = imb.b[2];
          *code.811 = D.33020;
          code.812 = code;
          code = code.812 + 1;
          D.33022 = imb.b[3];
          *code.812 = D.33022;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33014>:
  }
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33024>; else goto <D.33025>;
    <D.33024>:
    iftmp.813 = 12;
    goto <D.33026>;
    <D.33025>:
    iftmp.813 = 8;
    <D.33026>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.33027 = iftmp.813 | D.32040;
    _amd64_rex_bits = (unsigned char) D.33027;
    if (_amd64_rex_bits != 0) goto <D.33028>; else goto <D.33029>;
    <D.33028>:
    code.814 = code;
    code = code.814 + 1;
    D.33031 = _amd64_rex_bits | 64;
    *code.814 = D.33031;
    <D.33029>:
  }
  {
    unsigned char op;

    op = 182;
    code.815 = code;
    code = code.815 + 1;
    *code.815 = 15;
    if (0 != 0) goto <D.33033>; else goto <D.33034>;
    <D.33033>:
    op = op + 8;
    <D.33034>:
    if (0 != 0) goto <D.33035>; else goto <D.33036>;
    <D.33035>:
    op = op + 1;
    <D.33036>:
    code.816 = code;
    code = code.816 + 1;
    *code.816 = op;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    if (D.31598 == 4) goto <D.33038>; else goto <D.33039>;
    <D.33038>:
    if (1 != 0) goto <D.33040>; else goto <D.33041>;
    <D.33040>:
    code.817 = code;
    code = code.817 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.817 = D.32644;
    code.818 = code;
    code = code.818 + 1;
    *code.818 = 36;
    goto <D.33044>;
    <D.33041>:
    if (1 != 0) goto <D.33045>; else goto <D.33046>;
    <D.33045>:
    code.819 = code;
    code = code.819 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.819 = D.32735;
    code.820 = code;
    code = code.820 + 1;
    *code.820 = 36;
    *code = 0;
    code = code + 1;
    goto <D.33049>;
    <D.33046>:
    code.821 = code;
    code = code.821 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.821 = D.32740;
    code.822 = code;
    code = code.822 + 1;
    *code.822 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.823 = code;
          code = code.823 + 1;
          D.33053 = imb.b[0];
          *code.823 = D.33053;
          code.824 = code;
          code = code.824 + 1;
          D.33055 = imb.b[1];
          *code.824 = D.33055;
          code.825 = code;
          code = code.825 + 1;
          D.33057 = imb.b[2];
          *code.825 = D.33057;
          code.826 = code;
          code = code.826 + 1;
          D.33059 = imb.b[3];
          *code.826 = D.33059;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33049>:
    <D.33044>:
    goto <D.25386>;
    <D.33039>:
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    if (D.31598 != 5) goto <D.33060>; else goto <D.33061>;
    <D.33060>:
    code.827 = code;
    code = code.827 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32753 = D.32642 | D.31632;
    D.32754 = (unsigned char) D.32753;
    *code.827 = D.32754;
    goto <D.25386>;
    <D.33061>:
    if (1 != 0) goto <D.33063>; else goto <D.33064>;
    <D.33063>:
    code.828 = code;
    code = code.828 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32759 = D.32758 | D.31632;
    D.32760 = (unsigned char) D.32759;
    *code.828 = D.32760;
    *code = 0;
    code = code + 1;
    goto <D.33066>;
    <D.33064>:
    code.829 = code;
    code = code.829 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.829 = D.32765;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.830 = code;
          code = code.830 + 1;
          D.33069 = imb.b[0];
          *code.830 = D.33069;
          code.831 = code;
          code = code.831 + 1;
          D.33071 = imb.b[1];
          *code.831 = D.33071;
          code.832 = code;
          code = code.832 + 1;
          D.33073 = imb.b[2];
          *code.832 = D.33073;
          code.833 = code;
          code = code.833 + 1;
          D.33075 = imb.b[3];
          *code.833 = D.33075;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33066>:
    <D.25386>:
  }
  goto <D.25197>;
  <D.25388>:
  {
    int _amd64_width_temp;

    D.31647 = ins->data.op[1].const_val;
    D.32655 = (long unsigned int) D.31647;
    D.31647 = ins->data.op[1].const_val;
    D.31736 = (int) D.31647;
    D.32656 = (long unsigned int) D.31736;
    D.32657 = D.32655 == D.32656;
    _amd64_width_temp = (int) D.32657;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.33077>; else goto <D.33078>;
      <D.33077>:
      iftmp.834 = 8;
      goto <D.33079>;
      <D.33078>:
      iftmp.834 = 0;
      <D.33079>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.33080 = iftmp.834 | D.32040;
      _amd64_rex_bits = (unsigned char) D.33080;
      if (_amd64_rex_bits != 0) goto <D.33081>; else goto <D.33082>;
      <D.33081>:
      code.835 = code;
      code = code.835 + 1;
      D.33084 = _amd64_rex_bits | 64;
      *code.835 = D.33084;
      <D.33082>:
    }
    code.836 = code;
    code = code.836 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.32668 = D.31627 + 184;
    *code.836 = D.32668;
    if (_amd64_width_temp == 0) goto <D.33086>; else goto <D.33087>;
    <D.33086>:
    {
      union amd64_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.32655 = (long unsigned int) D.31647;
          imb.val = D.32655;
          code.837 = code;
          code = code.837 + 1;
          D.33089 = imb.b[0];
          *code.837 = D.33089;
          code.838 = code;
          code = code.838 + 1;
          D.33091 = imb.b[1];
          *code.838 = D.33091;
          code.839 = code;
          code = code.839 + 1;
          D.33093 = imb.b[2];
          *code.839 = D.33093;
          code.840 = code;
          code = code.840 + 1;
          D.33095 = imb.b[3];
          *code.840 = D.33095;
          code.841 = code;
          code = code.841 + 1;
          D.33097 = imb.b[4];
          *code.841 = D.33097;
          code.842 = code;
          code = code.842 + 1;
          D.33099 = imb.b[5];
          *code.842 = D.33099;
          code.843 = code;
          code = code.843 + 1;
          D.33101 = imb.b[6];
          *code.843 = D.33101;
          code.844 = code;
          code = code.844 + 1;
          D.33103 = imb.b[7];
          *code.844 = D.33103;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.33104>;
    <D.33087>:
    {
      union x86_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.31736 = (int) D.31647;
          imb.val = D.31736;
          code.845 = code;
          code = code.845 + 1;
          D.33106 = imb.b[0];
          *code.845 = D.33106;
          code.846 = code;
          code = code.846 + 1;
          D.33108 = imb.b[1];
          *code.846 = D.33108;
          code.847 = code;
          code = code.847 + 1;
          D.33110 = imb.b[2];
          *code.847 = D.33110;
          code.848 = code;
          code = code.848 + 1;
          D.33112 = imb.b[3];
          *code.848 = D.33112;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33104>:
  }
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33114>; else goto <D.33115>;
    <D.33114>:
    iftmp.849 = 12;
    goto <D.33116>;
    <D.33115>:
    iftmp.849 = 8;
    <D.33116>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.33117 = iftmp.849 | D.32040;
    _amd64_rex_bits = (unsigned char) D.33117;
    if (_amd64_rex_bits != 0) goto <D.33118>; else goto <D.33119>;
    <D.33118>:
    code.850 = code;
    code = code.850 + 1;
    D.33121 = _amd64_rex_bits | 64;
    *code.850 = D.33121;
    <D.33119>:
  }
  {
    unsigned char op;

    op = 182;
    code.851 = code;
    code = code.851 + 1;
    *code.851 = 15;
    if (0 != 0) goto <D.33123>; else goto <D.33124>;
    <D.33123>:
    op = op + 8;
    <D.33124>:
    if (1 != 0) goto <D.33125>; else goto <D.33126>;
    <D.33125>:
    op = op + 1;
    <D.33126>:
    code.852 = code;
    code = code.852 + 1;
    *code.852 = op;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    if (D.31598 == 4) goto <D.33128>; else goto <D.33129>;
    <D.33128>:
    if (1 != 0) goto <D.33130>; else goto <D.33131>;
    <D.33130>:
    code.853 = code;
    code = code.853 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.853 = D.32644;
    code.854 = code;
    code = code.854 + 1;
    *code.854 = 36;
    goto <D.33134>;
    <D.33131>:
    if (1 != 0) goto <D.33135>; else goto <D.33136>;
    <D.33135>:
    code.855 = code;
    code = code.855 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.855 = D.32735;
    code.856 = code;
    code = code.856 + 1;
    *code.856 = 36;
    *code = 0;
    code = code + 1;
    goto <D.33139>;
    <D.33136>:
    code.857 = code;
    code = code.857 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.857 = D.32740;
    code.858 = code;
    code = code.858 + 1;
    *code.858 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.859 = code;
          code = code.859 + 1;
          D.33143 = imb.b[0];
          *code.859 = D.33143;
          code.860 = code;
          code = code.860 + 1;
          D.33145 = imb.b[1];
          *code.860 = D.33145;
          code.861 = code;
          code = code.861 + 1;
          D.33147 = imb.b[2];
          *code.861 = D.33147;
          code.862 = code;
          code = code.862 + 1;
          D.33149 = imb.b[3];
          *code.862 = D.33149;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33139>:
    <D.33134>:
    goto <D.25396>;
    <D.33129>:
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    if (D.31598 != 5) goto <D.33150>; else goto <D.33151>;
    <D.33150>:
    code.863 = code;
    code = code.863 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32753 = D.32642 | D.31632;
    D.32754 = (unsigned char) D.32753;
    *code.863 = D.32754;
    goto <D.25396>;
    <D.33151>:
    if (1 != 0) goto <D.33153>; else goto <D.33154>;
    <D.33153>:
    code.864 = code;
    code = code.864 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32759 = D.32758 | D.31632;
    D.32760 = (unsigned char) D.32759;
    *code.864 = D.32760;
    *code = 0;
    code = code + 1;
    goto <D.33156>;
    <D.33154>:
    code.865 = code;
    code = code.865 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.865 = D.32765;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.866 = code;
          code = code.866 + 1;
          D.33159 = imb.b[0];
          *code.866 = D.33159;
          code.867 = code;
          code = code.867 + 1;
          D.33161 = imb.b[1];
          *code.867 = D.33161;
          code.868 = code;
          code = code.868 + 1;
          D.33163 = imb.b[2];
          *code.868 = D.33163;
          code.869 = code;
          code = code.869 + 1;
          D.33165 = imb.b[3];
          *code.869 = D.33165;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33156>:
    <D.25396>:
  }
  goto <D.25197>;
  <D.25398>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.33167 = D.33166 + 2147483648;
  D.33168 = D.33167 > 4294967295;
  D.33169 = (long int) D.33168;
  D.33170 = __builtin_expect (D.33169, 0);
  if (D.33170 != 0) goto <D.33171>; else goto <D.33172>;
  <D.33171>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4071, "amd64_is_imm32 (ins->inst_offset)");
  <D.33172>:
  if (0 != 0) goto <D.33173>; else goto <D.33174>;
  <D.33173>:
  code.870 = code;
  code = code.870 + 1;
  *code.870 = 102;
  <D.33174>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33177>; else goto <D.33178>;
    <D.33177>:
    iftmp.871 = 12;
    goto <D.33179>;
    <D.33178>:
    iftmp.871 = 8;
    <D.33179>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33181 = iftmp.871 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33181;
    if (_amd64_rex_bits != 0) goto <D.33182>; else goto <D.33183>;
    <D.33182>:
    code.872 = code;
    code = code.872 + 1;
    D.33185 = _amd64_rex_bits | 64;
    *code.872 = D.33185;
    <D.33183>:
  }
  switch (8) <default: <D.25405>, case 1: <D.25400>, case 2: <D.25402>, case 4: <D.25403>, case 8: <D.25404>>
  <D.25400>:
  code.873 = code;
  code = code.873 + 1;
  *code.873 = 138;
  goto <D.25401>;
  <D.25402>:
  <D.25403>:
  <D.25404>:
  code.874 = code;
  code = code.874 + 1;
  *code.874 = 139;
  goto <D.25401>;
  <D.25405>:
  __assert_fail ("0", "mini-amd64.c", 4072, &__PRETTY_FUNCTION__);
  <D.25401>:
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.33188>; else goto <D.33189>;
  <D.33188>:
  code.875 = code;
  code = code.875 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.875 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.876 = code;
        code = code.876 + 1;
        D.33192 = imb.b[0];
        *code.876 = D.33192;
        code.877 = code;
        code = code.877 + 1;
        D.33194 = imb.b[1];
        *code.877 = D.33194;
        code.878 = code;
        code = code.878 + 1;
        D.33196 = imb.b[2];
        *code.878 = D.33196;
        code.879 = code;
        code = code.879 + 1;
        D.33198 = imb.b[3];
        *code.879 = D.33198;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33199>;
  <D.33189>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.33200>; else goto <D.33201>;
  <D.33200>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33202>; else goto <D.33203>;
  <D.33202>:
  code.880 = code;
  code = code.880 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.880 = D.32644;
  code.881 = code;
  code = code.881 + 1;
  *code.881 = 36;
  goto <D.33206>;
  <D.33203>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33207>; else goto <D.33208>;
  <D.33207>:
  code.882 = code;
  code = code.882 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.882 = D.32735;
  code.883 = code;
  code = code.883 + 1;
  *code.883 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33211>;
  <D.33208>:
  code.884 = code;
  code = code.884 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.884 = D.32740;
  code.885 = code;
  code = code.885 + 1;
  *code.885 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.886 = code;
        code = code.886 + 1;
        D.33215 = imb.b[0];
        *code.886 = D.33215;
        code.887 = code;
        code = code.887 + 1;
        D.33217 = imb.b[1];
        *code.887 = D.33217;
        code.888 = code;
        code = code.888 + 1;
        D.33219 = imb.b[2];
        *code.888 = D.33219;
        code.889 = code;
        code = code.889 + 1;
        D.33221 = imb.b[3];
        *code.889 = D.33221;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33211>:
  <D.33206>:
  goto <D.25408>;
  <D.33201>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33222>; else goto <D.33223>;
  <D.33222>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.33224>; else goto <D.33225>;
  <D.33224>:
  code.890 = code;
  code = code.890 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.890 = D.33228;
  goto <D.25408>;
  <D.33225>:
  <D.33223>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33229>; else goto <D.33230>;
  <D.33229>:
  code.891 = code;
  code = code.891 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.891 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33234>;
  <D.33230>:
  code.892 = code;
  code = code.892 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.892 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.893 = code;
        code = code.893 + 1;
        D.33239 = imb.b[0];
        *code.893 = D.33239;
        code.894 = code;
        code = code.894 + 1;
        D.33241 = imb.b[1];
        *code.894 = D.33241;
        code.895 = code;
        code = code.895 + 1;
        D.33243 = imb.b[2];
        *code.895 = D.33243;
        code.896 = code;
        code = code.896 + 1;
        D.33245 = imb.b[3];
        *code.896 = D.33245;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33234>:
  <D.25408>:
  <D.33199>:
  goto <D.25197>;
  <D.25410>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.33167 = D.33166 + 2147483648;
  D.33168 = D.33167 > 4294967295;
  D.33169 = (long int) D.33168;
  D.33170 = __builtin_expect (D.33169, 0);
  if (D.33170 != 0) goto <D.33246>; else goto <D.33247>;
  <D.33246>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4077, "amd64_is_imm32 (ins->inst_offset)");
  <D.33247>:
  if (0 != 0) goto <D.33248>; else goto <D.33249>;
  <D.33248>:
  code.897 = code;
  code = code.897 + 1;
  *code.897 = 102;
  <D.33249>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33252>; else goto <D.33253>;
    <D.33252>:
    iftmp.898 = 12;
    goto <D.33254>;
    <D.33253>:
    iftmp.898 = 8;
    <D.33254>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33255 = iftmp.898 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33255;
    if (_amd64_rex_bits != 0) goto <D.33256>; else goto <D.33257>;
    <D.33256>:
    code.899 = code;
    code = code.899 + 1;
    D.33259 = _amd64_rex_bits | 64;
    *code.899 = D.33259;
    <D.33257>:
  }
  switch (8) <default: <D.25417>, case 1: <D.25412>, case 2: <D.25414>, case 4: <D.25415>, case 8: <D.25416>>
  <D.25412>:
  code.900 = code;
  code = code.900 + 1;
  *code.900 = 138;
  goto <D.25413>;
  <D.25414>:
  <D.25415>:
  <D.25416>:
  code.901 = code;
  code = code.901 + 1;
  *code.901 = 139;
  goto <D.25413>;
  <D.25417>:
  __assert_fail ("0", "mini-amd64.c", 4078, &__PRETTY_FUNCTION__);
  <D.25413>:
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.33262>; else goto <D.33263>;
  <D.33262>:
  code.902 = code;
  code = code.902 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.902 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.903 = code;
        code = code.903 + 1;
        D.33266 = imb.b[0];
        *code.903 = D.33266;
        code.904 = code;
        code = code.904 + 1;
        D.33268 = imb.b[1];
        *code.904 = D.33268;
        code.905 = code;
        code = code.905 + 1;
        D.33270 = imb.b[2];
        *code.905 = D.33270;
        code.906 = code;
        code = code.906 + 1;
        D.33272 = imb.b[3];
        *code.906 = D.33272;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33273>;
  <D.33263>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.33274>; else goto <D.33275>;
  <D.33274>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33276>; else goto <D.33277>;
  <D.33276>:
  code.907 = code;
  code = code.907 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.907 = D.32644;
  code.908 = code;
  code = code.908 + 1;
  *code.908 = 36;
  goto <D.33280>;
  <D.33277>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33281>; else goto <D.33282>;
  <D.33281>:
  code.909 = code;
  code = code.909 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.909 = D.32735;
  code.910 = code;
  code = code.910 + 1;
  *code.910 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33285>;
  <D.33282>:
  code.911 = code;
  code = code.911 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.911 = D.32740;
  code.912 = code;
  code = code.912 + 1;
  *code.912 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.913 = code;
        code = code.913 + 1;
        D.33289 = imb.b[0];
        *code.913 = D.33289;
        code.914 = code;
        code = code.914 + 1;
        D.33291 = imb.b[1];
        *code.914 = D.33291;
        code.915 = code;
        code = code.915 + 1;
        D.33293 = imb.b[2];
        *code.915 = D.33293;
        code.916 = code;
        code = code.916 + 1;
        D.33295 = imb.b[3];
        *code.916 = D.33295;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33285>:
  <D.33280>:
  goto <D.25420>;
  <D.33275>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33296>; else goto <D.33297>;
  <D.33296>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.33298>; else goto <D.33299>;
  <D.33298>:
  code.917 = code;
  code = code.917 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.917 = D.33228;
  goto <D.25420>;
  <D.33299>:
  <D.33297>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33301>; else goto <D.33302>;
  <D.33301>:
  code.918 = code;
  code = code.918 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.918 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33304>;
  <D.33302>:
  code.919 = code;
  code = code.919 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.919 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.920 = code;
        code = code.920 + 1;
        D.33307 = imb.b[0];
        *code.920 = D.33307;
        code.921 = code;
        code = code.921 + 1;
        D.33309 = imb.b[1];
        *code.921 = D.33309;
        code.922 = code;
        code = code.922 + 1;
        D.33311 = imb.b[2];
        *code.922 = D.33311;
        code.923 = code;
        code = code.923 + 1;
        D.33313 = imb.b[3];
        *code.923 = D.33313;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33304>:
  <D.25420>:
  <D.33273>:
  goto <D.25197>;
  <D.25422>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33315>; else goto <D.33316>;
    <D.33315>:
    iftmp.924 = 12;
    goto <D.33317>;
    <D.33316>:
    iftmp.924 = 8;
    <D.33317>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33318 = iftmp.924 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33318;
    if (_amd64_rex_bits != 0) goto <D.33319>; else goto <D.33320>;
    <D.33319>:
    code.925 = code;
    code = code.925 + 1;
    D.33322 = _amd64_rex_bits | 64;
    *code.925 = D.33322;
    <D.33320>:
  }
  code.926 = code;
  code = code.926 + 1;
  *code.926 = 99;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.33324>; else goto <D.33325>;
  <D.33324>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33326>; else goto <D.33327>;
  <D.33326>:
  code.927 = code;
  code = code.927 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.927 = D.32644;
  code.928 = code;
  code = code.928 + 1;
  *code.928 = 36;
  goto <D.33330>;
  <D.33327>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33331>; else goto <D.33332>;
  <D.33331>:
  code.929 = code;
  code = code.929 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.929 = D.32735;
  code.930 = code;
  code = code.930 + 1;
  *code.930 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33335>;
  <D.33332>:
  code.931 = code;
  code = code.931 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.931 = D.32740;
  code.932 = code;
  code = code.932 + 1;
  *code.932 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.933 = code;
        code = code.933 + 1;
        D.33339 = imb.b[0];
        *code.933 = D.33339;
        code.934 = code;
        code = code.934 + 1;
        D.33341 = imb.b[1];
        *code.934 = D.33341;
        code.935 = code;
        code = code.935 + 1;
        D.33343 = imb.b[2];
        *code.935 = D.33343;
        code.936 = code;
        code = code.936 + 1;
        D.33345 = imb.b[3];
        *code.936 = D.33345;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33335>:
  <D.33330>:
  goto <D.25425>;
  <D.33325>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33346>; else goto <D.33347>;
  <D.33346>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.33348>; else goto <D.33349>;
  <D.33348>:
  code.937 = code;
  code = code.937 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.937 = D.33228;
  goto <D.25425>;
  <D.33349>:
  <D.33347>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33351>; else goto <D.33352>;
  <D.33351>:
  code.938 = code;
  code = code.938 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.938 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33354>;
  <D.33352>:
  code.939 = code;
  code = code.939 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.939 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.940 = code;
        code = code.940 + 1;
        D.33357 = imb.b[0];
        *code.940 = D.33357;
        code.941 = code;
        code = code.941 + 1;
        D.33359 = imb.b[1];
        *code.941 = D.33359;
        code.942 = code;
        code = code.942 + 1;
        D.33361 = imb.b[2];
        *code.942 = D.33361;
        code.943 = code;
        code = code.943 + 1;
        D.33363 = imb.b[3];
        *code.943 = D.33363;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33354>:
  <D.25425>:
  goto <D.25197>;
  <D.25427>:
  if (0 != 0) goto <D.33364>; else goto <D.33365>;
  <D.33364>:
  code.944 = code;
  code = code.944 + 1;
  *code.944 = 102;
  <D.33365>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33368>; else goto <D.33369>;
    <D.33368>:
    iftmp.945 = 4;
    goto <D.33370>;
    <D.33369>:
    iftmp.945 = 0;
    <D.33370>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33371 = iftmp.945 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33371;
    if (_amd64_rex_bits != 0) goto <D.33372>; else goto <D.33373>;
    <D.33372>:
    code.946 = code;
    code = code.946 + 1;
    D.33375 = _amd64_rex_bits | 64;
    *code.946 = D.33375;
    <D.33373>:
  }
  switch (4) <default: <D.25434>, case 1: <D.25429>, case 2: <D.25431>, case 4: <D.25432>, case 8: <D.25433>>
  <D.25429>:
  code.947 = code;
  code = code.947 + 1;
  *code.947 = 138;
  goto <D.25430>;
  <D.25431>:
  <D.25432>:
  <D.25433>:
  code.948 = code;
  code = code.948 + 1;
  *code.948 = 139;
  goto <D.25430>;
  <D.25434>:
  __assert_fail ("0", "mini-amd64.c", 4084, &__PRETTY_FUNCTION__);
  <D.25430>:
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.33378>; else goto <D.33379>;
  <D.33378>:
  code.949 = code;
  code = code.949 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.949 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.950 = code;
        code = code.950 + 1;
        D.33382 = imb.b[0];
        *code.950 = D.33382;
        code.951 = code;
        code = code.951 + 1;
        D.33384 = imb.b[1];
        *code.951 = D.33384;
        code.952 = code;
        code = code.952 + 1;
        D.33386 = imb.b[2];
        *code.952 = D.33386;
        code.953 = code;
        code = code.953 + 1;
        D.33388 = imb.b[3];
        *code.953 = D.33388;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33389>;
  <D.33379>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.33390>; else goto <D.33391>;
  <D.33390>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33392>; else goto <D.33393>;
  <D.33392>:
  code.954 = code;
  code = code.954 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.954 = D.32644;
  code.955 = code;
  code = code.955 + 1;
  *code.955 = 36;
  goto <D.33396>;
  <D.33393>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33397>; else goto <D.33398>;
  <D.33397>:
  code.956 = code;
  code = code.956 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.956 = D.32735;
  code.957 = code;
  code = code.957 + 1;
  *code.957 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33401>;
  <D.33398>:
  code.958 = code;
  code = code.958 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.958 = D.32740;
  code.959 = code;
  code = code.959 + 1;
  *code.959 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.960 = code;
        code = code.960 + 1;
        D.33405 = imb.b[0];
        *code.960 = D.33405;
        code.961 = code;
        code = code.961 + 1;
        D.33407 = imb.b[1];
        *code.961 = D.33407;
        code.962 = code;
        code = code.962 + 1;
        D.33409 = imb.b[2];
        *code.962 = D.33409;
        code.963 = code;
        code = code.963 + 1;
        D.33411 = imb.b[3];
        *code.963 = D.33411;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33401>:
  <D.33396>:
  goto <D.25437>;
  <D.33391>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33412>; else goto <D.33413>;
  <D.33412>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.33414>; else goto <D.33415>;
  <D.33414>:
  code.964 = code;
  code = code.964 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.964 = D.33228;
  goto <D.25437>;
  <D.33415>:
  <D.33413>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33417>; else goto <D.33418>;
  <D.33417>:
  code.965 = code;
  code = code.965 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.965 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33420>;
  <D.33418>:
  code.966 = code;
  code = code.966 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.966 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.967 = code;
        code = code.967 + 1;
        D.33423 = imb.b[0];
        *code.967 = D.33423;
        code.968 = code;
        code = code.968 + 1;
        D.33425 = imb.b[1];
        *code.968 = D.33425;
        code.969 = code;
        code = code.969 + 1;
        D.33427 = imb.b[2];
        *code.969 = D.33427;
        code.970 = code;
        code = code.970 + 1;
        D.33429 = imb.b[3];
        *code.970 = D.33429;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33420>:
  <D.25437>:
  <D.33389>:
  goto <D.25197>;
  <D.25439>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33431>; else goto <D.33432>;
    <D.33431>:
    iftmp.971 = 4;
    goto <D.33433>;
    <D.33432>:
    iftmp.971 = 0;
    <D.33433>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33434 = iftmp.971 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33434;
    if (_amd64_rex_bits != 0) goto <D.33435>; else goto <D.33436>;
    <D.33435>:
    code.972 = code;
    code = code.972 + 1;
    D.33438 = _amd64_rex_bits | 64;
    *code.972 = D.33438;
    <D.33436>:
  }
  {
    unsigned char op;

    op = 182;
    code.973 = code;
    code = code.973 + 1;
    *code.973 = 15;
    if (0 != 0) goto <D.33440>; else goto <D.33441>;
    <D.33440>:
    op = op + 8;
    <D.33441>:
    if (0 != 0) goto <D.33442>; else goto <D.33443>;
    <D.33442>:
    op = op + 1;
    <D.33443>:
    code.974 = code;
    code = code.974 + 1;
    *code.974 = op;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.33445>; else goto <D.33446>;
    <D.33445>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33447>; else goto <D.33448>;
    <D.33447>:
    code.975 = code;
    code = code.975 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.975 = D.32644;
    code.976 = code;
    code = code.976 + 1;
    *code.976 = 36;
    goto <D.33451>;
    <D.33448>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33452>; else goto <D.33453>;
    <D.33452>:
    code.977 = code;
    code = code.977 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.977 = D.32735;
    code.978 = code;
    code = code.978 + 1;
    *code.978 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33456>;
    <D.33453>:
    code.979 = code;
    code = code.979 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.979 = D.32740;
    code.980 = code;
    code = code.980 + 1;
    *code.980 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.981 = code;
          code = code.981 + 1;
          D.33460 = imb.b[0];
          *code.981 = D.33460;
          code.982 = code;
          code = code.982 + 1;
          D.33462 = imb.b[1];
          *code.982 = D.33462;
          code.983 = code;
          code = code.983 + 1;
          D.33464 = imb.b[2];
          *code.983 = D.33464;
          code.984 = code;
          code = code.984 + 1;
          D.33466 = imb.b[3];
          *code.984 = D.33466;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33456>:
    <D.33451>:
    goto <D.25443>;
    <D.33446>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33467>; else goto <D.33468>;
    <D.33467>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.33469>; else goto <D.33470>;
    <D.33469>:
    code.985 = code;
    code = code.985 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33227 = D.32642 | D.31571;
    D.33228 = (unsigned char) D.33227;
    *code.985 = D.33228;
    goto <D.25443>;
    <D.33470>:
    <D.33468>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33472>; else goto <D.33473>;
    <D.33472>:
    code.986 = code;
    code = code.986 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33232 = D.32758 | D.31571;
    D.33233 = (unsigned char) D.33232;
    *code.986 = D.33233;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33475>;
    <D.33473>:
    code.987 = code;
    code = code.987 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33236 = D.32763 | D.31571;
    D.33237 = (unsigned char) D.33236;
    *code.987 = D.33237;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.988 = code;
          code = code.988 + 1;
          D.33478 = imb.b[0];
          *code.988 = D.33478;
          code.989 = code;
          code = code.989 + 1;
          D.33480 = imb.b[1];
          *code.989 = D.33480;
          code.990 = code;
          code = code.990 + 1;
          D.33482 = imb.b[2];
          *code.990 = D.33482;
          code.991 = code;
          code = code.991 + 1;
          D.33484 = imb.b[3];
          *code.991 = D.33484;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33475>:
    <D.25443>:
  }
  goto <D.25197>;
  <D.25445>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33486>; else goto <D.33487>;
    <D.33486>:
    iftmp.992 = 12;
    goto <D.33488>;
    <D.33487>:
    iftmp.992 = 8;
    <D.33488>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33489 = iftmp.992 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33489;
    if (_amd64_rex_bits != 0) goto <D.33490>; else goto <D.33491>;
    <D.33490>:
    code.993 = code;
    code = code.993 + 1;
    D.33493 = _amd64_rex_bits | 64;
    *code.993 = D.33493;
    <D.33491>:
  }
  {
    unsigned char op;

    op = 182;
    code.994 = code;
    code = code.994 + 1;
    *code.994 = 15;
    if (1 != 0) goto <D.33495>; else goto <D.33496>;
    <D.33495>:
    op = op + 8;
    <D.33496>:
    if (0 != 0) goto <D.33497>; else goto <D.33498>;
    <D.33497>:
    op = op + 1;
    <D.33498>:
    code.995 = code;
    code = code.995 + 1;
    *code.995 = op;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.33500>; else goto <D.33501>;
    <D.33500>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33502>; else goto <D.33503>;
    <D.33502>:
    code.996 = code;
    code = code.996 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.996 = D.32644;
    code.997 = code;
    code = code.997 + 1;
    *code.997 = 36;
    goto <D.33506>;
    <D.33503>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33507>; else goto <D.33508>;
    <D.33507>:
    code.998 = code;
    code = code.998 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.998 = D.32735;
    code.999 = code;
    code = code.999 + 1;
    *code.999 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33511>;
    <D.33508>:
    code.1000 = code;
    code = code.1000 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.1000 = D.32740;
    code.1001 = code;
    code = code.1001 + 1;
    *code.1001 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.1002 = code;
          code = code.1002 + 1;
          D.33515 = imb.b[0];
          *code.1002 = D.33515;
          code.1003 = code;
          code = code.1003 + 1;
          D.33517 = imb.b[1];
          *code.1003 = D.33517;
          code.1004 = code;
          code = code.1004 + 1;
          D.33519 = imb.b[2];
          *code.1004 = D.33519;
          code.1005 = code;
          code = code.1005 + 1;
          D.33521 = imb.b[3];
          *code.1005 = D.33521;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33511>:
    <D.33506>:
    goto <D.25449>;
    <D.33501>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33522>; else goto <D.33523>;
    <D.33522>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.33524>; else goto <D.33525>;
    <D.33524>:
    code.1006 = code;
    code = code.1006 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33227 = D.32642 | D.31571;
    D.33228 = (unsigned char) D.33227;
    *code.1006 = D.33228;
    goto <D.25449>;
    <D.33525>:
    <D.33523>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33527>; else goto <D.33528>;
    <D.33527>:
    code.1007 = code;
    code = code.1007 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33232 = D.32758 | D.31571;
    D.33233 = (unsigned char) D.33232;
    *code.1007 = D.33233;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33530>;
    <D.33528>:
    code.1008 = code;
    code = code.1008 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33236 = D.32763 | D.31571;
    D.33237 = (unsigned char) D.33236;
    *code.1008 = D.33237;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.1009 = code;
          code = code.1009 + 1;
          D.33533 = imb.b[0];
          *code.1009 = D.33533;
          code.1010 = code;
          code = code.1010 + 1;
          D.33535 = imb.b[1];
          *code.1010 = D.33535;
          code.1011 = code;
          code = code.1011 + 1;
          D.33537 = imb.b[2];
          *code.1011 = D.33537;
          code.1012 = code;
          code = code.1012 + 1;
          D.33539 = imb.b[3];
          *code.1012 = D.33539;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33530>:
    <D.25449>:
  }
  goto <D.25197>;
  <D.25451>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33541>; else goto <D.33542>;
    <D.33541>:
    iftmp.1013 = 4;
    goto <D.33543>;
    <D.33542>:
    iftmp.1013 = 0;
    <D.33543>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33544 = iftmp.1013 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33544;
    if (_amd64_rex_bits != 0) goto <D.33545>; else goto <D.33546>;
    <D.33545>:
    code.1014 = code;
    code = code.1014 + 1;
    D.33548 = _amd64_rex_bits | 64;
    *code.1014 = D.33548;
    <D.33546>:
  }
  {
    unsigned char op;

    op = 182;
    code.1015 = code;
    code = code.1015 + 1;
    *code.1015 = 15;
    if (0 != 0) goto <D.33550>; else goto <D.33551>;
    <D.33550>:
    op = op + 8;
    <D.33551>:
    if (1 != 0) goto <D.33552>; else goto <D.33553>;
    <D.33552>:
    op = op + 1;
    <D.33553>:
    code.1016 = code;
    code = code.1016 + 1;
    *code.1016 = op;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.33555>; else goto <D.33556>;
    <D.33555>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33557>; else goto <D.33558>;
    <D.33557>:
    code.1017 = code;
    code = code.1017 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.1017 = D.32644;
    code.1018 = code;
    code = code.1018 + 1;
    *code.1018 = 36;
    goto <D.33561>;
    <D.33558>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33562>; else goto <D.33563>;
    <D.33562>:
    code.1019 = code;
    code = code.1019 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.1019 = D.32735;
    code.1020 = code;
    code = code.1020 + 1;
    *code.1020 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33566>;
    <D.33563>:
    code.1021 = code;
    code = code.1021 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.1021 = D.32740;
    code.1022 = code;
    code = code.1022 + 1;
    *code.1022 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.1023 = code;
          code = code.1023 + 1;
          D.33570 = imb.b[0];
          *code.1023 = D.33570;
          code.1024 = code;
          code = code.1024 + 1;
          D.33572 = imb.b[1];
          *code.1024 = D.33572;
          code.1025 = code;
          code = code.1025 + 1;
          D.33574 = imb.b[2];
          *code.1025 = D.33574;
          code.1026 = code;
          code = code.1026 + 1;
          D.33576 = imb.b[3];
          *code.1026 = D.33576;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33566>:
    <D.33561>:
    goto <D.25455>;
    <D.33556>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33577>; else goto <D.33578>;
    <D.33577>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.33579>; else goto <D.33580>;
    <D.33579>:
    code.1027 = code;
    code = code.1027 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33227 = D.32642 | D.31571;
    D.33228 = (unsigned char) D.33227;
    *code.1027 = D.33228;
    goto <D.25455>;
    <D.33580>:
    <D.33578>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33582>; else goto <D.33583>;
    <D.33582>:
    code.1028 = code;
    code = code.1028 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33232 = D.32758 | D.31571;
    D.33233 = (unsigned char) D.33232;
    *code.1028 = D.33233;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33585>;
    <D.33583>:
    code.1029 = code;
    code = code.1029 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33236 = D.32763 | D.31571;
    D.33237 = (unsigned char) D.33236;
    *code.1029 = D.33237;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.1030 = code;
          code = code.1030 + 1;
          D.33588 = imb.b[0];
          *code.1030 = D.33588;
          code.1031 = code;
          code = code.1031 + 1;
          D.33590 = imb.b[1];
          *code.1031 = D.33590;
          code.1032 = code;
          code = code.1032 + 1;
          D.33592 = imb.b[2];
          *code.1032 = D.33592;
          code.1033 = code;
          code = code.1033 + 1;
          D.33594 = imb.b[3];
          *code.1033 = D.33594;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33585>:
    <D.25455>:
  }
  goto <D.25197>;
  <D.25457>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33596>; else goto <D.33597>;
    <D.33596>:
    iftmp.1034 = 12;
    goto <D.33598>;
    <D.33597>:
    iftmp.1034 = 8;
    <D.33598>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33599 = iftmp.1034 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33599;
    if (_amd64_rex_bits != 0) goto <D.33600>; else goto <D.33601>;
    <D.33600>:
    code.1035 = code;
    code = code.1035 + 1;
    D.33603 = _amd64_rex_bits | 64;
    *code.1035 = D.33603;
    <D.33601>:
  }
  {
    unsigned char op;

    op = 182;
    code.1036 = code;
    code = code.1036 + 1;
    *code.1036 = 15;
    if (1 != 0) goto <D.33605>; else goto <D.33606>;
    <D.33605>:
    op = op + 8;
    <D.33606>:
    if (1 != 0) goto <D.33607>; else goto <D.33608>;
    <D.33607>:
    op = op + 1;
    <D.33608>:
    code.1037 = code;
    code = code.1037 + 1;
    *code.1037 = op;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.33610>; else goto <D.33611>;
    <D.33610>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33612>; else goto <D.33613>;
    <D.33612>:
    code.1038 = code;
    code = code.1038 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.1038 = D.32644;
    code.1039 = code;
    code = code.1039 + 1;
    *code.1039 = 36;
    goto <D.33616>;
    <D.33613>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33617>; else goto <D.33618>;
    <D.33617>:
    code.1040 = code;
    code = code.1040 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.1040 = D.32735;
    code.1041 = code;
    code = code.1041 + 1;
    *code.1041 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33621>;
    <D.33618>:
    code.1042 = code;
    code = code.1042 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.1042 = D.32740;
    code.1043 = code;
    code = code.1043 + 1;
    *code.1043 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.1044 = code;
          code = code.1044 + 1;
          D.33625 = imb.b[0];
          *code.1044 = D.33625;
          code.1045 = code;
          code = code.1045 + 1;
          D.33627 = imb.b[1];
          *code.1045 = D.33627;
          code.1046 = code;
          code = code.1046 + 1;
          D.33629 = imb.b[2];
          *code.1046 = D.33629;
          code.1047 = code;
          code = code.1047 + 1;
          D.33631 = imb.b[3];
          *code.1047 = D.33631;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33621>:
    <D.33616>:
    goto <D.25461>;
    <D.33611>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.33632>; else goto <D.33633>;
    <D.33632>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.33634>; else goto <D.33635>;
    <D.33634>:
    code.1048 = code;
    code = code.1048 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33227 = D.32642 | D.31571;
    D.33228 = (unsigned char) D.33227;
    *code.1048 = D.33228;
    goto <D.25461>;
    <D.33635>:
    <D.33633>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.33637>; else goto <D.33638>;
    <D.33637>:
    code.1049 = code;
    code = code.1049 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33232 = D.32758 | D.31571;
    D.33233 = (unsigned char) D.33232;
    *code.1049 = D.33233;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.33640>;
    <D.33638>:
    code.1050 = code;
    code = code.1050 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33236 = D.32763 | D.31571;
    D.33237 = (unsigned char) D.33236;
    *code.1050 = D.33237;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.1051 = code;
          code = code.1051 + 1;
          D.33643 = imb.b[0];
          *code.1051 = D.33643;
          code.1052 = code;
          code = code.1052 + 1;
          D.33645 = imb.b[1];
          *code.1052 = D.33645;
          code.1053 = code;
          code = code.1053 + 1;
          D.33647 = imb.b[2];
          *code.1053 = D.33647;
          code.1054 = code;
          code = code.1054 + 1;
          D.33649 = imb.b[3];
          *code.1054 = D.33649;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.33640>:
    <D.25461>:
  }
  goto <D.25197>;
  <D.25463>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33651>; else goto <D.33652>;
    <D.33651>:
    iftmp.1055 = 12;
    goto <D.33653>;
    <D.33652>:
    iftmp.1055 = 8;
    <D.33653>:
    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.33655>; else goto <D.33656>;
    <D.33655>:
    iftmp.1056 = 2;
    goto <D.33657>;
    <D.33656>:
    iftmp.1056 = 0;
    <D.33657>:
    D.33658 = iftmp.1055 | iftmp.1056;
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33659 = D.33658 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33659;
    if (_amd64_rex_bits != 0) goto <D.33660>; else goto <D.33661>;
    <D.33660>:
    code.1057 = code;
    code = code.1057 + 1;
    D.33663 = _amd64_rex_bits | 64;
    *code.1057 = D.33663;
    <D.33661>:
  }
  switch (4) <default: <D.25469>, case 1: <D.25465>, case 2: <D.25467>, case 4: <D.25468>>
  <D.25465>:
  code.1058 = code;
  code = code.1058 + 1;
  *code.1058 = 138;
  goto <D.25466>;
  <D.25467>:
  code.1059 = code;
  code = code.1059 + 1;
  *code.1059 = 102;
  <D.25468>:
  code.1060 = code;
  code = code.1060 + 1;
  *code.1060 = 139;
  goto <D.25466>;
  <D.25469>:
  __assert_fail ("0", "mini-amd64.c", 4101, &__PRETTY_FUNCTION__);
  <D.25466>:
  if (0 != 0) goto <D.33667>; else goto <D.33668>;
  <D.33667>:
  code.1061 = code;
  code = code.1061 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.1061 = D.32644;
  code.1062 = code;
  code = code.1062 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.33674 = D.33673 | 5;
  D.33675 = (unsigned char) D.33674;
  *code.1062 = D.33675;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1063 = code;
        code = code.1063 + 1;
        D.33677 = imb.b[0];
        *code.1063 = D.33677;
        code.1064 = code;
        code = code.1064 + 1;
        D.33679 = imb.b[1];
        *code.1064 = D.33679;
        code.1065 = code;
        code = code.1065 + 1;
        D.33681 = imb.b[2];
        *code.1065 = D.33681;
        code.1066 = code;
        code = code.1066 + 1;
        D.33683 = imb.b[3];
        *code.1066 = D.33683;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33684>;
  <D.33668>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.33685>; else goto <D.33686>;
  <D.33685>:
  code.1067 = code;
  code = code.1067 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.1067 = D.32644;
  code.1068 = code;
  code = code.1068 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1068 = D.33690;
  goto <D.33691>;
  <D.33686>:
  if (1 != 0) goto <D.33692>; else goto <D.33693>;
  <D.33692>:
  code.1069 = code;
  code = code.1069 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.1069 = D.32735;
  code.1070 = code;
  code = code.1070 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1070 = D.33690;
  *code = 0;
  code = code + 1;
  goto <D.33696>;
  <D.33693>:
  code.1071 = code;
  code = code.1071 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.1071 = D.32740;
  code.1072 = code;
  code = code.1072 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1072 = D.33690;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.1073 = code;
        code = code.1073 + 1;
        D.33700 = imb.b[0];
        *code.1073 = D.33700;
        code.1074 = code;
        code = code.1074 + 1;
        D.33702 = imb.b[1];
        *code.1074 = D.33702;
        code.1075 = code;
        code = code.1075 + 1;
        D.33704 = imb.b[2];
        *code.1075 = D.33704;
        code.1076 = code;
        code = code.1076 + 1;
        D.33706 = imb.b[3];
        *code.1076 = D.33706;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33696>:
  <D.33691>:
  <D.33684>:
  goto <D.25197>;
  <D.25472>:
  <D.25473>:
  <D.25474>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33708>; else goto <D.33709>;
    <D.33708>:
    iftmp.1077 = 12;
    goto <D.33710>;
    <D.33709>:
    iftmp.1077 = 8;
    <D.33710>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33711 = iftmp.1077 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33711;
    if (_amd64_rex_bits != 0) goto <D.33712>; else goto <D.33713>;
    <D.33712>:
    code.1078 = code;
    code = code.1078 + 1;
    D.33715 = _amd64_rex_bits | 64;
    *code.1078 = D.33715;
    <D.33713>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.33716>; else goto <D.33717>;
    <D.33716>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4106, "(0) || X86_IS_BYTE_REG (((ins->sreg1)&0x7))");
    <D.33717>:
    code.1079 = code;
    code = code.1079 + 1;
    *code.1079 = 15;
    if (1 != 0) goto <D.33719>; else goto <D.33720>;
    <D.33719>:
    op = op + 8;
    <D.33720>:
    if (0 != 0) goto <D.33721>; else goto <D.33722>;
    <D.33721>:
    op = op + 1;
    <D.33722>:
    code.1080 = code;
    code = code.1080 + 1;
    *code.1080 = op;
    code.1081 = code;
    code = code.1081 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.1081 = D.33727;
  }
  goto <D.25197>;
  <D.25477>:
  <D.25478>:
  <D.25479>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33729>; else goto <D.33730>;
    <D.33729>:
    iftmp.1082 = 12;
    goto <D.33731>;
    <D.33730>:
    iftmp.1082 = 8;
    <D.33731>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33732 = iftmp.1082 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33732;
    if (_amd64_rex_bits != 0) goto <D.33733>; else goto <D.33734>;
    <D.33733>:
    code.1083 = code;
    code = code.1083 + 1;
    D.33736 = _amd64_rex_bits | 64;
    *code.1083 = D.33736;
    <D.33734>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.33737>; else goto <D.33738>;
    <D.33737>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4111, "(1) || X86_IS_BYTE_REG (((ins->sreg1)&0x7))");
    <D.33738>:
    code.1084 = code;
    code = code.1084 + 1;
    *code.1084 = 15;
    if (1 != 0) goto <D.33740>; else goto <D.33741>;
    <D.33740>:
    op = op + 8;
    <D.33741>:
    if (1 != 0) goto <D.33742>; else goto <D.33743>;
    <D.33742>:
    op = op + 1;
    <D.33743>:
    code.1085 = code;
    code = code.1085 + 1;
    *code.1085 = op;
    code.1086 = code;
    code = code.1086 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.1086 = D.33727;
  }
  goto <D.25197>;
  <D.25482>:
  <D.25483>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33747>; else goto <D.33748>;
    <D.33747>:
    iftmp.1087 = 12;
    goto <D.33749>;
    <D.33748>:
    iftmp.1087 = 8;
    <D.33749>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33750 = iftmp.1087 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33750;
    if (_amd64_rex_bits != 0) goto <D.33751>; else goto <D.33752>;
    <D.33751>:
    code.1088 = code;
    code = code.1088 + 1;
    D.33754 = _amd64_rex_bits | 64;
    *code.1088 = D.33754;
    <D.33752>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.33755>; else goto <D.33756>;
    <D.33755>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4115, "(0) || X86_IS_BYTE_REG (((ins->sreg1)&0x7))");
    <D.33756>:
    code.1089 = code;
    code = code.1089 + 1;
    *code.1089 = 15;
    if (0 != 0) goto <D.33758>; else goto <D.33759>;
    <D.33758>:
    op = op + 8;
    <D.33759>:
    if (0 != 0) goto <D.33760>; else goto <D.33761>;
    <D.33760>:
    op = op + 1;
    <D.33761>:
    code.1090 = code;
    code = code.1090 + 1;
    *code.1090 = op;
    code.1091 = code;
    code = code.1091 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.1091 = D.33727;
  }
  goto <D.25197>;
  <D.25486>:
  <D.25487>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33765>; else goto <D.33766>;
    <D.33765>:
    iftmp.1092 = 12;
    goto <D.33767>;
    <D.33766>:
    iftmp.1092 = 8;
    <D.33767>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33768 = iftmp.1092 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33768;
    if (_amd64_rex_bits != 0) goto <D.33769>; else goto <D.33770>;
    <D.33769>:
    code.1093 = code;
    code = code.1093 + 1;
    D.33772 = _amd64_rex_bits | 64;
    *code.1093 = D.33772;
    <D.33770>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.33773>; else goto <D.33774>;
    <D.33773>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4119, "(1) || X86_IS_BYTE_REG (((ins->sreg1)&0x7))");
    <D.33774>:
    code.1094 = code;
    code = code.1094 + 1;
    *code.1094 = 15;
    if (0 != 0) goto <D.33776>; else goto <D.33777>;
    <D.33776>:
    op = op + 8;
    <D.33777>:
    if (1 != 0) goto <D.33778>; else goto <D.33779>;
    <D.33778>:
    op = op + 1;
    <D.33779>:
    code.1095 = code;
    code = code.1095 + 1;
    *code.1095 = op;
    code.1096 = code;
    code = code.1096 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.1096 = D.33727;
  }
  goto <D.25197>;
  <D.25490>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33783>; else goto <D.33784>;
    <D.33783>:
    iftmp.1097 = 4;
    goto <D.33785>;
    <D.33784>:
    iftmp.1097 = 0;
    <D.33785>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33786 = iftmp.1097 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33786;
    if (_amd64_rex_bits != 0) goto <D.33787>; else goto <D.33788>;
    <D.33787>:
    code.1098 = code;
    code = code.1098 + 1;
    D.33790 = _amd64_rex_bits | 64;
    *code.1098 = D.33790;
    <D.33788>:
  }
  switch (4) <default: <D.25496>, case 1: <D.25492>, case 2: <D.25494>, case 4: <D.25495>>
  <D.25492>:
  code.1099 = code;
  code = code.1099 + 1;
  *code.1099 = 138;
  goto <D.25493>;
  <D.25494>:
  code.1100 = code;
  code = code.1100 + 1;
  *code.1100 = 102;
  <D.25495>:
  code.1101 = code;
  code = code.1101 + 1;
  *code.1101 = 139;
  goto <D.25493>;
  <D.25496>:
  __assert_fail ("0", "mini-amd64.c", 4123, &__PRETTY_FUNCTION__);
  <D.25493>:
  code.1102 = code;
  code = code.1102 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.1102 = D.33727;
  goto <D.25197>;
  <D.25497>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.33796>; else goto <D.33797>;
    <D.33796>:
    iftmp.1103 = 12;
    goto <D.33798>;
    <D.33797>:
    iftmp.1103 = 8;
    <D.33798>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33799 = iftmp.1103 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33799;
    if (_amd64_rex_bits != 0) goto <D.33800>; else goto <D.33801>;
    <D.33800>:
    code.1104 = code;
    code = code.1104 + 1;
    D.33803 = _amd64_rex_bits | 64;
    *code.1104 = D.33803;
    <D.33801>:
  }
  code.1105 = code;
  code = code.1105 + 1;
  *code.1105 = 99;
  code.1106 = code;
  code = code.1106 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.1106 = D.33727;
  goto <D.25197>;
  <D.25499>:
  <D.25500>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33807>; else goto <D.33808>;
    <D.33807>:
    iftmp.1107 = 12;
    goto <D.33809>;
    <D.33808>:
    iftmp.1107 = 8;
    <D.33809>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.33812 = iftmp.1107 | D.33811;
    _amd64_rex_bits = (unsigned char) D.33812;
    if (_amd64_rex_bits != 0) goto <D.33813>; else goto <D.33814>;
    <D.33813>:
    code.1108 = code;
    code = code.1108 + 1;
    D.33816 = _amd64_rex_bits | 64;
    *code.1108 = D.33816;
    <D.33814>:
  }
  code.1109 = code;
  code = code.1109 + 1;
  *code.1109 = 59;
  code.1110 = code;
  code = code.1110 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.1110 = D.33821;
  goto <D.25197>;
  <D.25502>:
  <D.25503>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.33822>; else goto <D.33823>;
  <D.33822>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4140, "amd64_is_imm32 (ins->inst_imm)");
  <D.33823>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.33826>; else goto <D.33827>;
  <D.33826>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33829>; else goto <D.33830>;
    <D.33829>:
    iftmp.1111 = 9;
    goto <D.33831>;
    <D.33830>:
    iftmp.1111 = 8;
    <D.33831>:
    _amd64_rex_bits = iftmp.1111;
    if (_amd64_rex_bits != 0) goto <D.33832>; else goto <D.33833>;
    <D.33832>:
    code.1112 = code;
    code = code.1112 + 1;
    D.33835 = _amd64_rex_bits | 64;
    *code.1112 = D.33835;
    <D.33833>:
  }
  code.1113 = code;
  code = code.1113 + 1;
  *code.1113 = 131;
  code.1114 = code;
  code = code.1114 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.1114 = D.33839;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.33840>;
  <D.33827>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.33841>; else goto <D.33842>;
  <D.33841>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.33843>; else goto <D.33844>;
    <D.33843>:
    code.1115 = code;
    code = code.1115 + 1;
    D.33846 = _amd64_rex_bits | 64;
    *code.1115 = D.33846;
    <D.33844>:
  }
  code.1116 = code;
  code = code.1116 + 1;
  *code.1116 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1117 = code;
        code = code.1117 + 1;
        D.33849 = imb.b[0];
        *code.1117 = D.33849;
        code.1118 = code;
        code = code.1118 + 1;
        D.33851 = imb.b[1];
        *code.1118 = D.33851;
        code.1119 = code;
        code = code.1119 + 1;
        D.33853 = imb.b[2];
        *code.1119 = D.33853;
        code.1120 = code;
        code = code.1120 + 1;
        D.33855 = imb.b[3];
        *code.1120 = D.33855;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33856>;
  <D.33842>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33858>; else goto <D.33859>;
    <D.33858>:
    iftmp.1121 = 9;
    goto <D.33860>;
    <D.33859>:
    iftmp.1121 = 8;
    <D.33860>:
    _amd64_rex_bits = iftmp.1121;
    if (_amd64_rex_bits != 0) goto <D.33861>; else goto <D.33862>;
    <D.33861>:
    code.1122 = code;
    code = code.1122 + 1;
    D.33864 = _amd64_rex_bits | 64;
    *code.1122 = D.33864;
    <D.33862>:
  }
  code.1123 = code;
  code = code.1123 + 1;
  *code.1123 = 129;
  code.1124 = code;
  code = code.1124 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.1124 = D.33839;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1125 = code;
        code = code.1125 + 1;
        D.33868 = imb.b[0];
        *code.1125 = D.33868;
        code.1126 = code;
        code = code.1126 + 1;
        D.33870 = imb.b[1];
        *code.1126 = D.33870;
        code.1127 = code;
        code = code.1127 + 1;
        D.33872 = imb.b[2];
        *code.1127 = D.33872;
        code.1128 = code;
        code = code.1128 + 1;
        D.33874 = imb.b[3];
        *code.1128 = D.33874;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33856>:
  <D.33840>:
  goto <D.25197>;
  <D.25509>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33876>; else goto <D.33877>;
    <D.33876>:
    iftmp.1129 = 12;
    goto <D.33878>;
    <D.33877>:
    iftmp.1129 = 8;
    <D.33878>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.33879 = iftmp.1129 | D.33811;
    _amd64_rex_bits = (unsigned char) D.33879;
    if (_amd64_rex_bits != 0) goto <D.33880>; else goto <D.33881>;
    <D.33880>:
    code.1130 = code;
    code = code.1130 + 1;
    D.33883 = _amd64_rex_bits | 64;
    *code.1130 = D.33883;
    <D.33881>:
  }
  code.1131 = code;
  code = code.1131 + 1;
  *code.1131 = 59;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.33885>; else goto <D.33886>;
  <D.33885>:
  code.1132 = code;
  code = code.1132 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1132 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1133 = code;
        code = code.1133 + 1;
        D.33891 = imb.b[0];
        *code.1133 = D.33891;
        code.1134 = code;
        code = code.1134 + 1;
        D.33893 = imb.b[1];
        *code.1134 = D.33893;
        code.1135 = code;
        code = code.1135 + 1;
        D.33895 = imb.b[2];
        *code.1135 = D.33895;
        code.1136 = code;
        code = code.1136 + 1;
        D.33897 = imb.b[3];
        *code.1136 = D.33897;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33898>;
  <D.33886>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.33899>; else goto <D.33900>;
  <D.33899>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33901>; else goto <D.33902>;
  <D.33901>:
  code.1137 = code;
  code = code.1137 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1137 = D.32056;
  code.1138 = code;
  code = code.1138 + 1;
  *code.1138 = 36;
  goto <D.33905>;
  <D.33902>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33906>; else goto <D.33907>;
  <D.33906>:
  code.1139 = code;
  code = code.1139 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1139 = D.32063;
  code.1140 = code;
  code = code.1140 + 1;
  *code.1140 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33910>;
  <D.33907>:
  code.1141 = code;
  code = code.1141 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1141 = D.32068;
  code.1142 = code;
  code = code.1142 + 1;
  *code.1142 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1143 = code;
        code = code.1143 + 1;
        D.33914 = imb.b[0];
        *code.1143 = D.33914;
        code.1144 = code;
        code = code.1144 + 1;
        D.33916 = imb.b[1];
        *code.1144 = D.33916;
        code.1145 = code;
        code = code.1145 + 1;
        D.33918 = imb.b[2];
        *code.1145 = D.33918;
        code.1146 = code;
        code = code.1146 + 1;
        D.33920 = imb.b[3];
        *code.1146 = D.33920;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33910>:
  <D.33905>:
  goto <D.25513>;
  <D.33900>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33921>; else goto <D.33922>;
  <D.33921>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.33923>; else goto <D.33924>;
  <D.33923>:
  code.1147 = code;
  code = code.1147 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1147 = D.33927;
  goto <D.25513>;
  <D.33924>:
  <D.33922>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33928>; else goto <D.33929>;
  <D.33928>:
  code.1148 = code;
  code = code.1148 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1148 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.33933>;
  <D.33929>:
  code.1149 = code;
  code = code.1149 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1149 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1150 = code;
        code = code.1150 + 1;
        D.33938 = imb.b[0];
        *code.1150 = D.33938;
        code.1151 = code;
        code = code.1151 + 1;
        D.33940 = imb.b[1];
        *code.1151 = D.33940;
        code.1152 = code;
        code = code.1152 + 1;
        D.33942 = imb.b[2];
        *code.1152 = D.33942;
        code.1153 = code;
        code = code.1153 + 1;
        D.33944 = imb.b[3];
        *code.1153 = D.33944;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.33933>:
  <D.25513>:
  <D.33898>:
  goto <D.25197>;
  <D.25515>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33946>; else goto <D.33947>;
    <D.33946>:
    iftmp.1154 = 4;
    goto <D.33948>;
    <D.33947>:
    iftmp.1154 = 0;
    <D.33948>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33949 = iftmp.1154 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33949;
    if (_amd64_rex_bits != 0) goto <D.33950>; else goto <D.33951>;
    <D.33950>:
    code.1155 = code;
    code = code.1155 + 1;
    D.33953 = _amd64_rex_bits | 64;
    *code.1155 = D.33953;
    <D.33951>:
  }
  code.1156 = code;
  code = code.1156 + 1;
  *code.1156 = 133;
  code.1157 = code;
  code = code.1157 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33956 = D.33819 | D.31571;
  D.33957 = (unsigned char) D.33956;
  *code.1157 = D.33957;
  goto <D.25197>;
  <D.25517>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33959>; else goto <D.33960>;
    <D.33959>:
    iftmp.1158 = 12;
    goto <D.33961>;
    <D.33960>:
    iftmp.1158 = 8;
    <D.33961>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.33962 = iftmp.1158 | D.33180;
    _amd64_rex_bits = (unsigned char) D.33962;
    if (_amd64_rex_bits != 0) goto <D.33963>; else goto <D.33964>;
    <D.33963>:
    code.1159 = code;
    code = code.1159 + 1;
    D.33966 = _amd64_rex_bits | 64;
    *code.1159 = D.33966;
    <D.33964>:
  }
  code.1160 = code;
  code = code.1160 + 1;
  *code.1160 = 133;
  code.1161 = code;
  code = code.1161 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33956 = D.33819 | D.31571;
  D.33957 = (unsigned char) D.33956;
  *code.1161 = D.33957;
  goto <D.25197>;
  <D.25519>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.33970>; else goto <D.33971>;
    <D.33970>:
    iftmp.1162 = 4;
    goto <D.33972>;
    <D.33971>:
    iftmp.1162 = 0;
    <D.33972>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.33973 = iftmp.1162 | D.33811;
    _amd64_rex_bits = (unsigned char) D.33973;
    if (_amd64_rex_bits != 0) goto <D.33974>; else goto <D.33975>;
    <D.33974>:
    code.1163 = code;
    code = code.1163 + 1;
    D.33977 = _amd64_rex_bits | 64;
    *code.1163 = D.33977;
    <D.33975>:
  }
  code.1164 = code;
  code = code.1164 + 1;
  *code.1164 = 3;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.33979>; else goto <D.33980>;
  <D.33979>:
  code.1165 = code;
  code = code.1165 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1165 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1166 = code;
        code = code.1166 + 1;
        D.33983 = imb.b[0];
        *code.1166 = D.33983;
        code.1167 = code;
        code = code.1167 + 1;
        D.33985 = imb.b[1];
        *code.1167 = D.33985;
        code.1168 = code;
        code = code.1168 + 1;
        D.33987 = imb.b[2];
        *code.1168 = D.33987;
        code.1169 = code;
        code = code.1169 + 1;
        D.33989 = imb.b[3];
        *code.1169 = D.33989;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.33990>;
  <D.33980>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.33991>; else goto <D.33992>;
  <D.33991>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.33993>; else goto <D.33994>;
  <D.33993>:
  code.1170 = code;
  code = code.1170 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1170 = D.32056;
  code.1171 = code;
  code = code.1171 + 1;
  *code.1171 = 36;
  goto <D.33997>;
  <D.33994>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.33998>; else goto <D.33999>;
  <D.33998>:
  code.1172 = code;
  code = code.1172 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1172 = D.32063;
  code.1173 = code;
  code = code.1173 + 1;
  *code.1173 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34002>;
  <D.33999>:
  code.1174 = code;
  code = code.1174 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1174 = D.32068;
  code.1175 = code;
  code = code.1175 + 1;
  *code.1175 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1176 = code;
        code = code.1176 + 1;
        D.34006 = imb.b[0];
        *code.1176 = D.34006;
        code.1177 = code;
        code = code.1177 + 1;
        D.34008 = imb.b[1];
        *code.1177 = D.34008;
        code.1178 = code;
        code = code.1178 + 1;
        D.34010 = imb.b[2];
        *code.1178 = D.34010;
        code.1179 = code;
        code = code.1179 + 1;
        D.34012 = imb.b[3];
        *code.1179 = D.34012;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34002>:
  <D.33997>:
  goto <D.25523>;
  <D.33992>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34013>; else goto <D.34014>;
  <D.34013>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.34015>; else goto <D.34016>;
  <D.34015>:
  code.1180 = code;
  code = code.1180 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1180 = D.33927;
  goto <D.25523>;
  <D.34016>:
  <D.34014>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34018>; else goto <D.34019>;
  <D.34018>:
  code.1181 = code;
  code = code.1181 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1181 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34021>;
  <D.34019>:
  code.1182 = code;
  code = code.1182 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1182 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1183 = code;
        code = code.1183 + 1;
        D.34024 = imb.b[0];
        *code.1183 = D.34024;
        code.1184 = code;
        code = code.1184 + 1;
        D.34026 = imb.b[1];
        *code.1184 = D.34026;
        code.1185 = code;
        code = code.1185 + 1;
        D.34028 = imb.b[2];
        *code.1185 = D.34028;
        code.1186 = code;
        code = code.1186 + 1;
        D.34030 = imb.b[3];
        *code.1186 = D.34030;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34021>:
  <D.25523>:
  <D.33990>:
  goto <D.25197>;
  <D.25525>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.34032>; else goto <D.34033>;
    <D.34032>:
    iftmp.1187 = 4;
    goto <D.34034>;
    <D.34033>:
    iftmp.1187 = 0;
    <D.34034>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.34035 = iftmp.1187 | D.33811;
    _amd64_rex_bits = (unsigned char) D.34035;
    if (_amd64_rex_bits != 0) goto <D.34036>; else goto <D.34037>;
    <D.34036>:
    code.1188 = code;
    code = code.1188 + 1;
    D.34039 = _amd64_rex_bits | 64;
    *code.1188 = D.34039;
    <D.34037>:
  }
  code.1189 = code;
  code = code.1189 + 1;
  *code.1189 = 43;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.34041>; else goto <D.34042>;
  <D.34041>:
  code.1190 = code;
  code = code.1190 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1190 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1191 = code;
        code = code.1191 + 1;
        D.34045 = imb.b[0];
        *code.1191 = D.34045;
        code.1192 = code;
        code = code.1192 + 1;
        D.34047 = imb.b[1];
        *code.1192 = D.34047;
        code.1193 = code;
        code = code.1193 + 1;
        D.34049 = imb.b[2];
        *code.1193 = D.34049;
        code.1194 = code;
        code = code.1194 + 1;
        D.34051 = imb.b[3];
        *code.1194 = D.34051;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34052>;
  <D.34042>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.34053>; else goto <D.34054>;
  <D.34053>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34055>; else goto <D.34056>;
  <D.34055>:
  code.1195 = code;
  code = code.1195 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1195 = D.32056;
  code.1196 = code;
  code = code.1196 + 1;
  *code.1196 = 36;
  goto <D.34059>;
  <D.34056>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34060>; else goto <D.34061>;
  <D.34060>:
  code.1197 = code;
  code = code.1197 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1197 = D.32063;
  code.1198 = code;
  code = code.1198 + 1;
  *code.1198 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34064>;
  <D.34061>:
  code.1199 = code;
  code = code.1199 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1199 = D.32068;
  code.1200 = code;
  code = code.1200 + 1;
  *code.1200 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1201 = code;
        code = code.1201 + 1;
        D.34068 = imb.b[0];
        *code.1201 = D.34068;
        code.1202 = code;
        code = code.1202 + 1;
        D.34070 = imb.b[1];
        *code.1202 = D.34070;
        code.1203 = code;
        code = code.1203 + 1;
        D.34072 = imb.b[2];
        *code.1203 = D.34072;
        code.1204 = code;
        code = code.1204 + 1;
        D.34074 = imb.b[3];
        *code.1204 = D.34074;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34064>:
  <D.34059>:
  goto <D.25529>;
  <D.34054>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34075>; else goto <D.34076>;
  <D.34075>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.34077>; else goto <D.34078>;
  <D.34077>:
  code.1205 = code;
  code = code.1205 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1205 = D.33927;
  goto <D.25529>;
  <D.34078>:
  <D.34076>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34080>; else goto <D.34081>;
  <D.34080>:
  code.1206 = code;
  code = code.1206 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1206 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34083>;
  <D.34081>:
  code.1207 = code;
  code = code.1207 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1207 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1208 = code;
        code = code.1208 + 1;
        D.34086 = imb.b[0];
        *code.1208 = D.34086;
        code.1209 = code;
        code = code.1209 + 1;
        D.34088 = imb.b[1];
        *code.1209 = D.34088;
        code.1210 = code;
        code = code.1210 + 1;
        D.34090 = imb.b[2];
        *code.1210 = D.34090;
        code.1211 = code;
        code = code.1211 + 1;
        D.34092 = imb.b[3];
        *code.1211 = D.34092;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34083>:
  <D.25529>:
  <D.34052>:
  goto <D.25197>;
  <D.25531>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.34094>; else goto <D.34095>;
    <D.34094>:
    iftmp.1212 = 4;
    goto <D.34096>;
    <D.34095>:
    iftmp.1212 = 0;
    <D.34096>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.34097 = iftmp.1212 | D.33811;
    _amd64_rex_bits = (unsigned char) D.34097;
    if (_amd64_rex_bits != 0) goto <D.34098>; else goto <D.34099>;
    <D.34098>:
    code.1213 = code;
    code = code.1213 + 1;
    D.34101 = _amd64_rex_bits | 64;
    *code.1213 = D.34101;
    <D.34099>:
  }
  code.1214 = code;
  code = code.1214 + 1;
  *code.1214 = 35;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.34103>; else goto <D.34104>;
  <D.34103>:
  code.1215 = code;
  code = code.1215 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1215 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1216 = code;
        code = code.1216 + 1;
        D.34107 = imb.b[0];
        *code.1216 = D.34107;
        code.1217 = code;
        code = code.1217 + 1;
        D.34109 = imb.b[1];
        *code.1217 = D.34109;
        code.1218 = code;
        code = code.1218 + 1;
        D.34111 = imb.b[2];
        *code.1218 = D.34111;
        code.1219 = code;
        code = code.1219 + 1;
        D.34113 = imb.b[3];
        *code.1219 = D.34113;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34114>;
  <D.34104>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.34115>; else goto <D.34116>;
  <D.34115>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34117>; else goto <D.34118>;
  <D.34117>:
  code.1220 = code;
  code = code.1220 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1220 = D.32056;
  code.1221 = code;
  code = code.1221 + 1;
  *code.1221 = 36;
  goto <D.34121>;
  <D.34118>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34122>; else goto <D.34123>;
  <D.34122>:
  code.1222 = code;
  code = code.1222 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1222 = D.32063;
  code.1223 = code;
  code = code.1223 + 1;
  *code.1223 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34126>;
  <D.34123>:
  code.1224 = code;
  code = code.1224 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1224 = D.32068;
  code.1225 = code;
  code = code.1225 + 1;
  *code.1225 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1226 = code;
        code = code.1226 + 1;
        D.34130 = imb.b[0];
        *code.1226 = D.34130;
        code.1227 = code;
        code = code.1227 + 1;
        D.34132 = imb.b[1];
        *code.1227 = D.34132;
        code.1228 = code;
        code = code.1228 + 1;
        D.34134 = imb.b[2];
        *code.1228 = D.34134;
        code.1229 = code;
        code = code.1229 + 1;
        D.34136 = imb.b[3];
        *code.1229 = D.34136;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34126>:
  <D.34121>:
  goto <D.25535>;
  <D.34116>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34137>; else goto <D.34138>;
  <D.34137>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.34139>; else goto <D.34140>;
  <D.34139>:
  code.1230 = code;
  code = code.1230 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1230 = D.33927;
  goto <D.25535>;
  <D.34140>:
  <D.34138>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34142>; else goto <D.34143>;
  <D.34142>:
  code.1231 = code;
  code = code.1231 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1231 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34145>;
  <D.34143>:
  code.1232 = code;
  code = code.1232 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1232 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1233 = code;
        code = code.1233 + 1;
        D.34148 = imb.b[0];
        *code.1233 = D.34148;
        code.1234 = code;
        code = code.1234 + 1;
        D.34150 = imb.b[1];
        *code.1234 = D.34150;
        code.1235 = code;
        code = code.1235 + 1;
        D.34152 = imb.b[2];
        *code.1235 = D.34152;
        code.1236 = code;
        code = code.1236 + 1;
        D.34154 = imb.b[3];
        *code.1236 = D.34154;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34145>:
  <D.25535>:
  <D.34114>:
  goto <D.25197>;
  <D.25537>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.34156>; else goto <D.34157>;
    <D.34156>:
    iftmp.1237 = 4;
    goto <D.34158>;
    <D.34157>:
    iftmp.1237 = 0;
    <D.34158>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.34159 = iftmp.1237 | D.33811;
    _amd64_rex_bits = (unsigned char) D.34159;
    if (_amd64_rex_bits != 0) goto <D.34160>; else goto <D.34161>;
    <D.34160>:
    code.1238 = code;
    code = code.1238 + 1;
    D.34163 = _amd64_rex_bits | 64;
    *code.1238 = D.34163;
    <D.34161>:
  }
  code.1239 = code;
  code = code.1239 + 1;
  *code.1239 = 11;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.34165>; else goto <D.34166>;
  <D.34165>:
  code.1240 = code;
  code = code.1240 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1240 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1241 = code;
        code = code.1241 + 1;
        D.34169 = imb.b[0];
        *code.1241 = D.34169;
        code.1242 = code;
        code = code.1242 + 1;
        D.34171 = imb.b[1];
        *code.1242 = D.34171;
        code.1243 = code;
        code = code.1243 + 1;
        D.34173 = imb.b[2];
        *code.1243 = D.34173;
        code.1244 = code;
        code = code.1244 + 1;
        D.34175 = imb.b[3];
        *code.1244 = D.34175;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34176>;
  <D.34166>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.34177>; else goto <D.34178>;
  <D.34177>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34179>; else goto <D.34180>;
  <D.34179>:
  code.1245 = code;
  code = code.1245 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1245 = D.32056;
  code.1246 = code;
  code = code.1246 + 1;
  *code.1246 = 36;
  goto <D.34183>;
  <D.34180>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34184>; else goto <D.34185>;
  <D.34184>:
  code.1247 = code;
  code = code.1247 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1247 = D.32063;
  code.1248 = code;
  code = code.1248 + 1;
  *code.1248 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34188>;
  <D.34185>:
  code.1249 = code;
  code = code.1249 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1249 = D.32068;
  code.1250 = code;
  code = code.1250 + 1;
  *code.1250 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1251 = code;
        code = code.1251 + 1;
        D.34192 = imb.b[0];
        *code.1251 = D.34192;
        code.1252 = code;
        code = code.1252 + 1;
        D.34194 = imb.b[1];
        *code.1252 = D.34194;
        code.1253 = code;
        code = code.1253 + 1;
        D.34196 = imb.b[2];
        *code.1253 = D.34196;
        code.1254 = code;
        code = code.1254 + 1;
        D.34198 = imb.b[3];
        *code.1254 = D.34198;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34188>:
  <D.34183>:
  goto <D.25541>;
  <D.34178>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34199>; else goto <D.34200>;
  <D.34199>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.34201>; else goto <D.34202>;
  <D.34201>:
  code.1255 = code;
  code = code.1255 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1255 = D.33927;
  goto <D.25541>;
  <D.34202>:
  <D.34200>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34204>; else goto <D.34205>;
  <D.34204>:
  code.1256 = code;
  code = code.1256 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1256 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34207>;
  <D.34205>:
  code.1257 = code;
  code = code.1257 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1257 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1258 = code;
        code = code.1258 + 1;
        D.34210 = imb.b[0];
        *code.1258 = D.34210;
        code.1259 = code;
        code = code.1259 + 1;
        D.34212 = imb.b[1];
        *code.1259 = D.34212;
        code.1260 = code;
        code = code.1260 + 1;
        D.34214 = imb.b[2];
        *code.1260 = D.34214;
        code.1261 = code;
        code = code.1261 + 1;
        D.34216 = imb.b[3];
        *code.1261 = D.34216;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34207>:
  <D.25541>:
  <D.34176>:
  goto <D.25197>;
  <D.25543>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.34218>; else goto <D.34219>;
    <D.34218>:
    iftmp.1262 = 4;
    goto <D.34220>;
    <D.34219>:
    iftmp.1262 = 0;
    <D.34220>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.34221 = iftmp.1262 | D.33811;
    _amd64_rex_bits = (unsigned char) D.34221;
    if (_amd64_rex_bits != 0) goto <D.34222>; else goto <D.34223>;
    <D.34222>:
    code.1263 = code;
    code = code.1263 + 1;
    D.34225 = _amd64_rex_bits | 64;
    *code.1263 = D.34225;
    <D.34223>:
  }
  code.1264 = code;
  code = code.1264 + 1;
  *code.1264 = 51;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.34227>; else goto <D.34228>;
  <D.34227>:
  code.1265 = code;
  code = code.1265 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1265 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1266 = code;
        code = code.1266 + 1;
        D.34231 = imb.b[0];
        *code.1266 = D.34231;
        code.1267 = code;
        code = code.1267 + 1;
        D.34233 = imb.b[1];
        *code.1267 = D.34233;
        code.1268 = code;
        code = code.1268 + 1;
        D.34235 = imb.b[2];
        *code.1268 = D.34235;
        code.1269 = code;
        code = code.1269 + 1;
        D.34237 = imb.b[3];
        *code.1269 = D.34237;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.34238>;
  <D.34228>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.34239>; else goto <D.34240>;
  <D.34239>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34241>; else goto <D.34242>;
  <D.34241>:
  code.1270 = code;
  code = code.1270 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1270 = D.32056;
  code.1271 = code;
  code = code.1271 + 1;
  *code.1271 = 36;
  goto <D.34245>;
  <D.34242>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34246>; else goto <D.34247>;
  <D.34246>:
  code.1272 = code;
  code = code.1272 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1272 = D.32063;
  code.1273 = code;
  code = code.1273 + 1;
  *code.1273 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34250>;
  <D.34247>:
  code.1274 = code;
  code = code.1274 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1274 = D.32068;
  code.1275 = code;
  code = code.1275 + 1;
  *code.1275 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1276 = code;
        code = code.1276 + 1;
        D.34254 = imb.b[0];
        *code.1276 = D.34254;
        code.1277 = code;
        code = code.1277 + 1;
        D.34256 = imb.b[1];
        *code.1277 = D.34256;
        code.1278 = code;
        code = code.1278 + 1;
        D.34258 = imb.b[2];
        *code.1278 = D.34258;
        code.1279 = code;
        code = code.1279 + 1;
        D.34260 = imb.b[3];
        *code.1279 = D.34260;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34250>:
  <D.34245>:
  goto <D.25547>;
  <D.34240>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34261>; else goto <D.34262>;
  <D.34261>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.34263>; else goto <D.34264>;
  <D.34263>:
  code.1280 = code;
  code = code.1280 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1280 = D.33927;
  goto <D.25547>;
  <D.34264>:
  <D.34262>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34266>; else goto <D.34267>;
  <D.34266>:
  code.1281 = code;
  code = code.1281 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1281 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34269>;
  <D.34267>:
  code.1282 = code;
  code = code.1282 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1282 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1283 = code;
        code = code.1283 + 1;
        D.34272 = imb.b[0];
        *code.1283 = D.34272;
        code.1284 = code;
        code = code.1284 + 1;
        D.34274 = imb.b[1];
        *code.1284 = D.34274;
        code.1285 = code;
        code = code.1285 + 1;
        D.34276 = imb.b[2];
        *code.1285 = D.34276;
        code.1286 = code;
        code = code.1286 + 1;
        D.34278 = imb.b[3];
        *code.1286 = D.34278;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34269>:
  <D.25547>:
  <D.34238>:
  goto <D.25197>;
  <D.25549>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.34279>; else goto <D.34280>;
    <D.34279>:
    code.1287 = code;
    code = code.1287 + 1;
    D.34282 = _amd64_rex_bits | 64;
    *code.1287 = D.34282;
    <D.34280>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.34283>; else goto <D.34284>;
  <D.34283>:
  code.1288 = code;
  code = code.1288 + 1;
  *code.1288 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34286>; else goto <D.34287>;
  <D.34286>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34288>; else goto <D.34289>;
  <D.34288>:
  code.1289 = code;
  code = code.1289 + 1;
  *code.1289 = 4;
  code.1290 = code;
  code = code.1290 + 1;
  *code.1290 = 36;
  goto <D.34292>;
  <D.34289>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34293>; else goto <D.34294>;
  <D.34293>:
  code.1291 = code;
  code = code.1291 + 1;
  *code.1291 = 68;
  code.1292 = code;
  code = code.1292 + 1;
  *code.1292 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34297>;
  <D.34294>:
  code.1293 = code;
  code = code.1293 + 1;
  *code.1293 = 132;
  code.1294 = code;
  code = code.1294 + 1;
  *code.1294 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1295 = code;
        code = code.1295 + 1;
        D.34301 = imb.b[0];
        *code.1295 = D.34301;
        code.1296 = code;
        code = code.1296 + 1;
        D.34303 = imb.b[1];
        *code.1296 = D.34303;
        code.1297 = code;
        code = code.1297 + 1;
        D.34305 = imb.b[2];
        *code.1297 = D.34305;
        code.1298 = code;
        code = code.1298 + 1;
        D.34307 = imb.b[3];
        *code.1298 = D.34307;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34297>:
  <D.34292>:
  goto <D.25552>;
  <D.34287>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34308>; else goto <D.34309>;
  <D.34308>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34310>; else goto <D.34311>;
  <D.34310>:
  code.1299 = code;
  code = code.1299 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  *code.1299 = D.31566;
  goto <D.25552>;
  <D.34311>:
  <D.34309>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34313>; else goto <D.34314>;
  <D.34313>:
  code.1300 = code;
  code = code.1300 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31572 = D.31571 | 64;
  D.31573 = (unsigned char) D.31572;
  *code.1300 = D.31573;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34316>;
  <D.34314>:
  code.1301 = code;
  code = code.1301 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31576 = D.31571 | -128;
  D.31577 = (unsigned char) D.31576;
  *code.1301 = D.31577;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1302 = code;
        code = code.1302 + 1;
        D.34319 = imb.b[0];
        *code.1302 = D.34319;
        code.1303 = code;
        code = code.1303 + 1;
        D.34321 = imb.b[1];
        *code.1303 = D.34321;
        code.1304 = code;
        code = code.1304 + 1;
        D.34323 = imb.b[2];
        *code.1304 = D.34323;
        code.1305 = code;
        code = code.1305 + 1;
        D.34325 = imb.b[3];
        *code.1305 = D.34325;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34316>:
  <D.25552>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.34326>;
  <D.34284>:
  code.1306 = code;
  code = code.1306 + 1;
  *code.1306 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34328>; else goto <D.34329>;
  <D.34328>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34330>; else goto <D.34331>;
  <D.34330>:
  code.1307 = code;
  code = code.1307 + 1;
  *code.1307 = 4;
  code.1308 = code;
  code = code.1308 + 1;
  *code.1308 = 36;
  goto <D.34334>;
  <D.34331>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34335>; else goto <D.34336>;
  <D.34335>:
  code.1309 = code;
  code = code.1309 + 1;
  *code.1309 = 68;
  code.1310 = code;
  code = code.1310 + 1;
  *code.1310 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34339>;
  <D.34336>:
  code.1311 = code;
  code = code.1311 + 1;
  *code.1311 = 132;
  code.1312 = code;
  code = code.1312 + 1;
  *code.1312 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1313 = code;
        code = code.1313 + 1;
        D.34343 = imb.b[0];
        *code.1313 = D.34343;
        code.1314 = code;
        code = code.1314 + 1;
        D.34345 = imb.b[1];
        *code.1314 = D.34345;
        code.1315 = code;
        code = code.1315 + 1;
        D.34347 = imb.b[2];
        *code.1315 = D.34347;
        code.1316 = code;
        code = code.1316 + 1;
        D.34349 = imb.b[3];
        *code.1316 = D.34349;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34339>:
  <D.34334>:
  goto <D.25555>;
  <D.34329>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34350>; else goto <D.34351>;
  <D.34350>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34352>; else goto <D.34353>;
  <D.34352>:
  code.1317 = code;
  code = code.1317 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  *code.1317 = D.31566;
  goto <D.25555>;
  <D.34353>:
  <D.34351>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34355>; else goto <D.34356>;
  <D.34355>:
  code.1318 = code;
  code = code.1318 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31572 = D.31571 | 64;
  D.31573 = (unsigned char) D.31572;
  *code.1318 = D.31573;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34358>;
  <D.34356>:
  code.1319 = code;
  code = code.1319 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31576 = D.31571 | -128;
  D.31577 = (unsigned char) D.31576;
  *code.1319 = D.31577;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1320 = code;
        code = code.1320 + 1;
        D.34361 = imb.b[0];
        *code.1320 = D.34361;
        code.1321 = code;
        code = code.1321 + 1;
        D.34363 = imb.b[1];
        *code.1321 = D.34363;
        code.1322 = code;
        code = code.1322 + 1;
        D.34365 = imb.b[2];
        *code.1322 = D.34365;
        code.1323 = code;
        code = code.1323 + 1;
        D.34367 = imb.b[3];
        *code.1323 = D.34367;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34358>:
  <D.25555>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1324 = code;
        code = code.1324 + 1;
        D.34369 = imb.b[0];
        *code.1324 = D.34369;
        code.1325 = code;
        code = code.1325 + 1;
        D.34371 = imb.b[1];
        *code.1325 = D.34371;
        code.1326 = code;
        code = code.1326 + 1;
        D.34373 = imb.b[2];
        *code.1326 = D.34373;
        code.1327 = code;
        code = code.1327 + 1;
        D.34375 = imb.b[3];
        *code.1327 = D.34375;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34326>:
  goto <D.25197>;
  <D.25558>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.34376>; else goto <D.34377>;
  <D.34376>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4174, "amd64_is_imm32 (ins->inst_imm)");
  <D.34377>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.34378>; else goto <D.34379>;
    <D.34378>:
    code.1328 = code;
    code = code.1328 + 1;
    D.34381 = _amd64_rex_bits | 64;
    *code.1328 = D.34381;
    <D.34379>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.34382>; else goto <D.34383>;
  <D.34382>:
  code.1329 = code;
  code = code.1329 + 1;
  *code.1329 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34385>; else goto <D.34386>;
  <D.34385>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34387>; else goto <D.34388>;
  <D.34387>:
  code.1330 = code;
  code = code.1330 + 1;
  *code.1330 = 44;
  code.1331 = code;
  code = code.1331 + 1;
  *code.1331 = 36;
  goto <D.34391>;
  <D.34388>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34392>; else goto <D.34393>;
  <D.34392>:
  code.1332 = code;
  code = code.1332 + 1;
  *code.1332 = 108;
  code.1333 = code;
  code = code.1333 + 1;
  *code.1333 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34396>;
  <D.34393>:
  code.1334 = code;
  code = code.1334 + 1;
  *code.1334 = 172;
  code.1335 = code;
  code = code.1335 + 1;
  *code.1335 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1336 = code;
        code = code.1336 + 1;
        D.34400 = imb.b[0];
        *code.1336 = D.34400;
        code.1337 = code;
        code = code.1337 + 1;
        D.34402 = imb.b[1];
        *code.1337 = D.34402;
        code.1338 = code;
        code = code.1338 + 1;
        D.34404 = imb.b[2];
        *code.1338 = D.34404;
        code.1339 = code;
        code = code.1339 + 1;
        D.34406 = imb.b[3];
        *code.1339 = D.34406;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34396>:
  <D.34391>:
  goto <D.25561>;
  <D.34386>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34407>; else goto <D.34408>;
  <D.34407>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34409>; else goto <D.34410>;
  <D.34409>:
  code.1340 = code;
  code = code.1340 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34412 = D.31571 | 40;
  D.34413 = (unsigned char) D.34412;
  *code.1340 = D.34413;
  goto <D.25561>;
  <D.34410>:
  <D.34408>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34414>; else goto <D.34415>;
  <D.34414>:
  code.1341 = code;
  code = code.1341 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34417 = D.31571 | 104;
  D.34418 = (unsigned char) D.34417;
  *code.1341 = D.34418;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34419>;
  <D.34415>:
  code.1342 = code;
  code = code.1342 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34421 = D.31571 | -88;
  D.34422 = (unsigned char) D.34421;
  *code.1342 = D.34422;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1343 = code;
        code = code.1343 + 1;
        D.34424 = imb.b[0];
        *code.1343 = D.34424;
        code.1344 = code;
        code = code.1344 + 1;
        D.34426 = imb.b[1];
        *code.1344 = D.34426;
        code.1345 = code;
        code = code.1345 + 1;
        D.34428 = imb.b[2];
        *code.1345 = D.34428;
        code.1346 = code;
        code = code.1346 + 1;
        D.34430 = imb.b[3];
        *code.1346 = D.34430;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34419>:
  <D.25561>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.34431>;
  <D.34383>:
  code.1347 = code;
  code = code.1347 + 1;
  *code.1347 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34433>; else goto <D.34434>;
  <D.34433>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34435>; else goto <D.34436>;
  <D.34435>:
  code.1348 = code;
  code = code.1348 + 1;
  *code.1348 = 44;
  code.1349 = code;
  code = code.1349 + 1;
  *code.1349 = 36;
  goto <D.34439>;
  <D.34436>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34440>; else goto <D.34441>;
  <D.34440>:
  code.1350 = code;
  code = code.1350 + 1;
  *code.1350 = 108;
  code.1351 = code;
  code = code.1351 + 1;
  *code.1351 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34444>;
  <D.34441>:
  code.1352 = code;
  code = code.1352 + 1;
  *code.1352 = 172;
  code.1353 = code;
  code = code.1353 + 1;
  *code.1353 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1354 = code;
        code = code.1354 + 1;
        D.34448 = imb.b[0];
        *code.1354 = D.34448;
        code.1355 = code;
        code = code.1355 + 1;
        D.34450 = imb.b[1];
        *code.1355 = D.34450;
        code.1356 = code;
        code = code.1356 + 1;
        D.34452 = imb.b[2];
        *code.1356 = D.34452;
        code.1357 = code;
        code = code.1357 + 1;
        D.34454 = imb.b[3];
        *code.1357 = D.34454;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34444>:
  <D.34439>:
  goto <D.25564>;
  <D.34434>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34455>; else goto <D.34456>;
  <D.34455>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34457>; else goto <D.34458>;
  <D.34457>:
  code.1358 = code;
  code = code.1358 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34412 = D.31571 | 40;
  D.34413 = (unsigned char) D.34412;
  *code.1358 = D.34413;
  goto <D.25564>;
  <D.34458>:
  <D.34456>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34460>; else goto <D.34461>;
  <D.34460>:
  code.1359 = code;
  code = code.1359 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34417 = D.31571 | 104;
  D.34418 = (unsigned char) D.34417;
  *code.1359 = D.34418;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34463>;
  <D.34461>:
  code.1360 = code;
  code = code.1360 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34421 = D.31571 | -88;
  D.34422 = (unsigned char) D.34421;
  *code.1360 = D.34422;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1361 = code;
        code = code.1361 + 1;
        D.34466 = imb.b[0];
        *code.1361 = D.34466;
        code.1362 = code;
        code = code.1362 + 1;
        D.34468 = imb.b[1];
        *code.1362 = D.34468;
        code.1363 = code;
        code = code.1363 + 1;
        D.34470 = imb.b[2];
        *code.1363 = D.34470;
        code.1364 = code;
        code = code.1364 + 1;
        D.34472 = imb.b[3];
        *code.1364 = D.34472;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34463>:
  <D.25564>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1365 = code;
        code = code.1365 + 1;
        D.34474 = imb.b[0];
        *code.1365 = D.34474;
        code.1366 = code;
        code = code.1366 + 1;
        D.34476 = imb.b[1];
        *code.1366 = D.34476;
        code.1367 = code;
        code = code.1367 + 1;
        D.34478 = imb.b[2];
        *code.1367 = D.34478;
        code.1368 = code;
        code = code.1368 + 1;
        D.34480 = imb.b[3];
        *code.1368 = D.34480;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34431>:
  goto <D.25197>;
  <D.25567>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.34481>; else goto <D.34482>;
  <D.34481>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4178, "amd64_is_imm32 (ins->inst_imm)");
  <D.34482>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.34483>; else goto <D.34484>;
    <D.34483>:
    code.1369 = code;
    code = code.1369 + 1;
    D.34486 = _amd64_rex_bits | 64;
    *code.1369 = D.34486;
    <D.34484>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.34487>; else goto <D.34488>;
  <D.34487>:
  code.1370 = code;
  code = code.1370 + 1;
  *code.1370 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34490>; else goto <D.34491>;
  <D.34490>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34492>; else goto <D.34493>;
  <D.34492>:
  code.1371 = code;
  code = code.1371 + 1;
  *code.1371 = 36;
  code.1372 = code;
  code = code.1372 + 1;
  *code.1372 = 36;
  goto <D.34496>;
  <D.34493>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34497>; else goto <D.34498>;
  <D.34497>:
  code.1373 = code;
  code = code.1373 + 1;
  *code.1373 = 100;
  code.1374 = code;
  code = code.1374 + 1;
  *code.1374 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34501>;
  <D.34498>:
  code.1375 = code;
  code = code.1375 + 1;
  *code.1375 = 164;
  code.1376 = code;
  code = code.1376 + 1;
  *code.1376 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1377 = code;
        code = code.1377 + 1;
        D.34505 = imb.b[0];
        *code.1377 = D.34505;
        code.1378 = code;
        code = code.1378 + 1;
        D.34507 = imb.b[1];
        *code.1378 = D.34507;
        code.1379 = code;
        code = code.1379 + 1;
        D.34509 = imb.b[2];
        *code.1379 = D.34509;
        code.1380 = code;
        code = code.1380 + 1;
        D.34511 = imb.b[3];
        *code.1380 = D.34511;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34501>:
  <D.34496>:
  goto <D.25570>;
  <D.34491>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34512>; else goto <D.34513>;
  <D.34512>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34514>; else goto <D.34515>;
  <D.34514>:
  code.1381 = code;
  code = code.1381 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34517 = D.31571 | 32;
  D.34518 = (unsigned char) D.34517;
  *code.1381 = D.34518;
  goto <D.25570>;
  <D.34515>:
  <D.34513>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34519>; else goto <D.34520>;
  <D.34519>:
  code.1382 = code;
  code = code.1382 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34522 = D.31571 | 96;
  D.34523 = (unsigned char) D.34522;
  *code.1382 = D.34523;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34524>;
  <D.34520>:
  code.1383 = code;
  code = code.1383 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34526 = D.31571 | -96;
  D.34527 = (unsigned char) D.34526;
  *code.1383 = D.34527;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1384 = code;
        code = code.1384 + 1;
        D.34529 = imb.b[0];
        *code.1384 = D.34529;
        code.1385 = code;
        code = code.1385 + 1;
        D.34531 = imb.b[1];
        *code.1385 = D.34531;
        code.1386 = code;
        code = code.1386 + 1;
        D.34533 = imb.b[2];
        *code.1386 = D.34533;
        code.1387 = code;
        code = code.1387 + 1;
        D.34535 = imb.b[3];
        *code.1387 = D.34535;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34524>:
  <D.25570>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.34536>;
  <D.34488>:
  code.1388 = code;
  code = code.1388 + 1;
  *code.1388 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34538>; else goto <D.34539>;
  <D.34538>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34540>; else goto <D.34541>;
  <D.34540>:
  code.1389 = code;
  code = code.1389 + 1;
  *code.1389 = 36;
  code.1390 = code;
  code = code.1390 + 1;
  *code.1390 = 36;
  goto <D.34544>;
  <D.34541>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34545>; else goto <D.34546>;
  <D.34545>:
  code.1391 = code;
  code = code.1391 + 1;
  *code.1391 = 100;
  code.1392 = code;
  code = code.1392 + 1;
  *code.1392 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34549>;
  <D.34546>:
  code.1393 = code;
  code = code.1393 + 1;
  *code.1393 = 164;
  code.1394 = code;
  code = code.1394 + 1;
  *code.1394 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1395 = code;
        code = code.1395 + 1;
        D.34553 = imb.b[0];
        *code.1395 = D.34553;
        code.1396 = code;
        code = code.1396 + 1;
        D.34555 = imb.b[1];
        *code.1396 = D.34555;
        code.1397 = code;
        code = code.1397 + 1;
        D.34557 = imb.b[2];
        *code.1397 = D.34557;
        code.1398 = code;
        code = code.1398 + 1;
        D.34559 = imb.b[3];
        *code.1398 = D.34559;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34549>:
  <D.34544>:
  goto <D.25573>;
  <D.34539>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34560>; else goto <D.34561>;
  <D.34560>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34562>; else goto <D.34563>;
  <D.34562>:
  code.1399 = code;
  code = code.1399 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34517 = D.31571 | 32;
  D.34518 = (unsigned char) D.34517;
  *code.1399 = D.34518;
  goto <D.25573>;
  <D.34563>:
  <D.34561>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34565>; else goto <D.34566>;
  <D.34565>:
  code.1400 = code;
  code = code.1400 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34522 = D.31571 | 96;
  D.34523 = (unsigned char) D.34522;
  *code.1400 = D.34523;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34568>;
  <D.34566>:
  code.1401 = code;
  code = code.1401 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34526 = D.31571 | -96;
  D.34527 = (unsigned char) D.34526;
  *code.1401 = D.34527;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1402 = code;
        code = code.1402 + 1;
        D.34571 = imb.b[0];
        *code.1402 = D.34571;
        code.1403 = code;
        code = code.1403 + 1;
        D.34573 = imb.b[1];
        *code.1403 = D.34573;
        code.1404 = code;
        code = code.1404 + 1;
        D.34575 = imb.b[2];
        *code.1404 = D.34575;
        code.1405 = code;
        code = code.1405 + 1;
        D.34577 = imb.b[3];
        *code.1405 = D.34577;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34568>:
  <D.25573>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1406 = code;
        code = code.1406 + 1;
        D.34579 = imb.b[0];
        *code.1406 = D.34579;
        code.1407 = code;
        code = code.1407 + 1;
        D.34581 = imb.b[1];
        *code.1407 = D.34581;
        code.1408 = code;
        code = code.1408 + 1;
        D.34583 = imb.b[2];
        *code.1408 = D.34583;
        code.1409 = code;
        code = code.1409 + 1;
        D.34585 = imb.b[3];
        *code.1409 = D.34585;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34536>:
  goto <D.25197>;
  <D.25576>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.34586>; else goto <D.34587>;
  <D.34586>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4182, "amd64_is_imm32 (ins->inst_imm)");
  <D.34587>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.34588>; else goto <D.34589>;
    <D.34588>:
    code.1410 = code;
    code = code.1410 + 1;
    D.34591 = _amd64_rex_bits | 64;
    *code.1410 = D.34591;
    <D.34589>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.34592>; else goto <D.34593>;
  <D.34592>:
  code.1411 = code;
  code = code.1411 + 1;
  *code.1411 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34595>; else goto <D.34596>;
  <D.34595>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34597>; else goto <D.34598>;
  <D.34597>:
  code.1412 = code;
  code = code.1412 + 1;
  *code.1412 = 12;
  code.1413 = code;
  code = code.1413 + 1;
  *code.1413 = 36;
  goto <D.34601>;
  <D.34598>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34602>; else goto <D.34603>;
  <D.34602>:
  code.1414 = code;
  code = code.1414 + 1;
  *code.1414 = 76;
  code.1415 = code;
  code = code.1415 + 1;
  *code.1415 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34606>;
  <D.34603>:
  code.1416 = code;
  code = code.1416 + 1;
  *code.1416 = 140;
  code.1417 = code;
  code = code.1417 + 1;
  *code.1417 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1418 = code;
        code = code.1418 + 1;
        D.34610 = imb.b[0];
        *code.1418 = D.34610;
        code.1419 = code;
        code = code.1419 + 1;
        D.34612 = imb.b[1];
        *code.1419 = D.34612;
        code.1420 = code;
        code = code.1420 + 1;
        D.34614 = imb.b[2];
        *code.1420 = D.34614;
        code.1421 = code;
        code = code.1421 + 1;
        D.34616 = imb.b[3];
        *code.1421 = D.34616;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34606>:
  <D.34601>:
  goto <D.25579>;
  <D.34596>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34617>; else goto <D.34618>;
  <D.34617>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34619>; else goto <D.34620>;
  <D.34619>:
  code.1422 = code;
  code = code.1422 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34622 = D.31571 | 8;
  D.34623 = (unsigned char) D.34622;
  *code.1422 = D.34623;
  goto <D.25579>;
  <D.34620>:
  <D.34618>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34624>; else goto <D.34625>;
  <D.34624>:
  code.1423 = code;
  code = code.1423 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34627 = D.31571 | 72;
  D.34628 = (unsigned char) D.34627;
  *code.1423 = D.34628;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34629>;
  <D.34625>:
  code.1424 = code;
  code = code.1424 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34631 = D.31571 | -120;
  D.34632 = (unsigned char) D.34631;
  *code.1424 = D.34632;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1425 = code;
        code = code.1425 + 1;
        D.34634 = imb.b[0];
        *code.1425 = D.34634;
        code.1426 = code;
        code = code.1426 + 1;
        D.34636 = imb.b[1];
        *code.1426 = D.34636;
        code.1427 = code;
        code = code.1427 + 1;
        D.34638 = imb.b[2];
        *code.1427 = D.34638;
        code.1428 = code;
        code = code.1428 + 1;
        D.34640 = imb.b[3];
        *code.1428 = D.34640;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34629>:
  <D.25579>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.34641>;
  <D.34593>:
  code.1429 = code;
  code = code.1429 + 1;
  *code.1429 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34643>; else goto <D.34644>;
  <D.34643>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34645>; else goto <D.34646>;
  <D.34645>:
  code.1430 = code;
  code = code.1430 + 1;
  *code.1430 = 12;
  code.1431 = code;
  code = code.1431 + 1;
  *code.1431 = 36;
  goto <D.34649>;
  <D.34646>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34650>; else goto <D.34651>;
  <D.34650>:
  code.1432 = code;
  code = code.1432 + 1;
  *code.1432 = 76;
  code.1433 = code;
  code = code.1433 + 1;
  *code.1433 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34654>;
  <D.34651>:
  code.1434 = code;
  code = code.1434 + 1;
  *code.1434 = 140;
  code.1435 = code;
  code = code.1435 + 1;
  *code.1435 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1436 = code;
        code = code.1436 + 1;
        D.34658 = imb.b[0];
        *code.1436 = D.34658;
        code.1437 = code;
        code = code.1437 + 1;
        D.34660 = imb.b[1];
        *code.1437 = D.34660;
        code.1438 = code;
        code = code.1438 + 1;
        D.34662 = imb.b[2];
        *code.1438 = D.34662;
        code.1439 = code;
        code = code.1439 + 1;
        D.34664 = imb.b[3];
        *code.1439 = D.34664;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34654>:
  <D.34649>:
  goto <D.25582>;
  <D.34644>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34665>; else goto <D.34666>;
  <D.34665>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34667>; else goto <D.34668>;
  <D.34667>:
  code.1440 = code;
  code = code.1440 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34622 = D.31571 | 8;
  D.34623 = (unsigned char) D.34622;
  *code.1440 = D.34623;
  goto <D.25582>;
  <D.34668>:
  <D.34666>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34670>; else goto <D.34671>;
  <D.34670>:
  code.1441 = code;
  code = code.1441 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34627 = D.31571 | 72;
  D.34628 = (unsigned char) D.34627;
  *code.1441 = D.34628;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34673>;
  <D.34671>:
  code.1442 = code;
  code = code.1442 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34631 = D.31571 | -120;
  D.34632 = (unsigned char) D.34631;
  *code.1442 = D.34632;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1443 = code;
        code = code.1443 + 1;
        D.34676 = imb.b[0];
        *code.1443 = D.34676;
        code.1444 = code;
        code = code.1444 + 1;
        D.34678 = imb.b[1];
        *code.1444 = D.34678;
        code.1445 = code;
        code = code.1445 + 1;
        D.34680 = imb.b[2];
        *code.1445 = D.34680;
        code.1446 = code;
        code = code.1446 + 1;
        D.34682 = imb.b[3];
        *code.1446 = D.34682;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34673>:
  <D.25582>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1447 = code;
        code = code.1447 + 1;
        D.34684 = imb.b[0];
        *code.1447 = D.34684;
        code.1448 = code;
        code = code.1448 + 1;
        D.34686 = imb.b[1];
        *code.1448 = D.34686;
        code.1449 = code;
        code = code.1449 + 1;
        D.34688 = imb.b[2];
        *code.1449 = D.34688;
        code.1450 = code;
        code = code.1450 + 1;
        D.34690 = imb.b[3];
        *code.1450 = D.34690;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34641>:
  goto <D.25197>;
  <D.25585>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.34691>; else goto <D.34692>;
  <D.34691>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4186, "amd64_is_imm32 (ins->inst_imm)");
  <D.34692>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.34693>; else goto <D.34694>;
    <D.34693>:
    code.1451 = code;
    code = code.1451 + 1;
    D.34696 = _amd64_rex_bits | 64;
    *code.1451 = D.34696;
    <D.34694>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.34697>; else goto <D.34698>;
  <D.34697>:
  code.1452 = code;
  code = code.1452 + 1;
  *code.1452 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34700>; else goto <D.34701>;
  <D.34700>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34702>; else goto <D.34703>;
  <D.34702>:
  code.1453 = code;
  code = code.1453 + 1;
  *code.1453 = 52;
  code.1454 = code;
  code = code.1454 + 1;
  *code.1454 = 36;
  goto <D.34706>;
  <D.34703>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34707>; else goto <D.34708>;
  <D.34707>:
  code.1455 = code;
  code = code.1455 + 1;
  *code.1455 = 116;
  code.1456 = code;
  code = code.1456 + 1;
  *code.1456 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34711>;
  <D.34708>:
  code.1457 = code;
  code = code.1457 + 1;
  *code.1457 = 180;
  code.1458 = code;
  code = code.1458 + 1;
  *code.1458 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1459 = code;
        code = code.1459 + 1;
        D.34715 = imb.b[0];
        *code.1459 = D.34715;
        code.1460 = code;
        code = code.1460 + 1;
        D.34717 = imb.b[1];
        *code.1460 = D.34717;
        code.1461 = code;
        code = code.1461 + 1;
        D.34719 = imb.b[2];
        *code.1461 = D.34719;
        code.1462 = code;
        code = code.1462 + 1;
        D.34721 = imb.b[3];
        *code.1462 = D.34721;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34711>:
  <D.34706>:
  goto <D.25588>;
  <D.34701>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34722>; else goto <D.34723>;
  <D.34722>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34724>; else goto <D.34725>;
  <D.34724>:
  code.1463 = code;
  code = code.1463 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34727 = D.31571 | 48;
  D.34728 = (unsigned char) D.34727;
  *code.1463 = D.34728;
  goto <D.25588>;
  <D.34725>:
  <D.34723>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34729>; else goto <D.34730>;
  <D.34729>:
  code.1464 = code;
  code = code.1464 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34732 = D.31571 | 112;
  D.34733 = (unsigned char) D.34732;
  *code.1464 = D.34733;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34734>;
  <D.34730>:
  code.1465 = code;
  code = code.1465 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34736 = D.31571 | -80;
  D.34737 = (unsigned char) D.34736;
  *code.1465 = D.34737;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1466 = code;
        code = code.1466 + 1;
        D.34739 = imb.b[0];
        *code.1466 = D.34739;
        code.1467 = code;
        code = code.1467 + 1;
        D.34741 = imb.b[1];
        *code.1467 = D.34741;
        code.1468 = code;
        code = code.1468 + 1;
        D.34743 = imb.b[2];
        *code.1468 = D.34743;
        code.1469 = code;
        code = code.1469 + 1;
        D.34745 = imb.b[3];
        *code.1469 = D.34745;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34734>:
  <D.25588>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.34746>;
  <D.34698>:
  code.1470 = code;
  code = code.1470 + 1;
  *code.1470 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34748>; else goto <D.34749>;
  <D.34748>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34750>; else goto <D.34751>;
  <D.34750>:
  code.1471 = code;
  code = code.1471 + 1;
  *code.1471 = 52;
  code.1472 = code;
  code = code.1472 + 1;
  *code.1472 = 36;
  goto <D.34754>;
  <D.34751>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34755>; else goto <D.34756>;
  <D.34755>:
  code.1473 = code;
  code = code.1473 + 1;
  *code.1473 = 116;
  code.1474 = code;
  code = code.1474 + 1;
  *code.1474 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34759>;
  <D.34756>:
  code.1475 = code;
  code = code.1475 + 1;
  *code.1475 = 180;
  code.1476 = code;
  code = code.1476 + 1;
  *code.1476 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1477 = code;
        code = code.1477 + 1;
        D.34763 = imb.b[0];
        *code.1477 = D.34763;
        code.1478 = code;
        code = code.1478 + 1;
        D.34765 = imb.b[1];
        *code.1478 = D.34765;
        code.1479 = code;
        code = code.1479 + 1;
        D.34767 = imb.b[2];
        *code.1479 = D.34767;
        code.1480 = code;
        code = code.1480 + 1;
        D.34769 = imb.b[3];
        *code.1480 = D.34769;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34759>:
  <D.34754>:
  goto <D.25591>;
  <D.34749>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34770>; else goto <D.34771>;
  <D.34770>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34772>; else goto <D.34773>;
  <D.34772>:
  code.1481 = code;
  code = code.1481 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34727 = D.31571 | 48;
  D.34728 = (unsigned char) D.34727;
  *code.1481 = D.34728;
  goto <D.25591>;
  <D.34773>:
  <D.34771>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34775>; else goto <D.34776>;
  <D.34775>:
  code.1482 = code;
  code = code.1482 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34732 = D.31571 | 112;
  D.34733 = (unsigned char) D.34732;
  *code.1482 = D.34733;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34778>;
  <D.34776>:
  code.1483 = code;
  code = code.1483 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34736 = D.31571 | -80;
  D.34737 = (unsigned char) D.34736;
  *code.1483 = D.34737;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1484 = code;
        code = code.1484 + 1;
        D.34781 = imb.b[0];
        *code.1484 = D.34781;
        code.1485 = code;
        code = code.1485 + 1;
        D.34783 = imb.b[1];
        *code.1485 = D.34783;
        code.1486 = code;
        code = code.1486 + 1;
        D.34785 = imb.b[2];
        *code.1486 = D.34785;
        code.1487 = code;
        code = code.1487 + 1;
        D.34787 = imb.b[3];
        *code.1487 = D.34787;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34778>:
  <D.25591>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1488 = code;
        code = code.1488 + 1;
        D.34789 = imb.b[0];
        *code.1488 = D.34789;
        code.1489 = code;
        code = code.1489 + 1;
        D.34791 = imb.b[1];
        *code.1489 = D.34791;
        code.1490 = code;
        code = code.1490 + 1;
        D.34793 = imb.b[2];
        *code.1490 = D.34793;
        code.1491 = code;
        code = code.1491 + 1;
        D.34795 = imb.b[3];
        *code.1491 = D.34795;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34746>:
  goto <D.25197>;
  <D.25594>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.34797>; else goto <D.34798>;
    <D.34797>:
    iftmp.1492 = 4;
    goto <D.34799>;
    <D.34798>:
    iftmp.1492 = 0;
    <D.34799>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.34800 = iftmp.1492 | D.33180;
    _amd64_rex_bits = (unsigned char) D.34800;
    if (_amd64_rex_bits != 0) goto <D.34801>; else goto <D.34802>;
    <D.34801>:
    code.1493 = code;
    code = code.1493 + 1;
    D.34804 = _amd64_rex_bits | 64;
    *code.1493 = D.34804;
    <D.34802>:
  }
  code.1494 = code;
  code = code.1494 + 1;
  *code.1494 = 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34806>; else goto <D.34807>;
  <D.34806>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34808>; else goto <D.34809>;
  <D.34808>:
  code.1495 = code;
  code = code.1495 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1495 = D.34812;
  code.1496 = code;
  code = code.1496 + 1;
  *code.1496 = 36;
  goto <D.34814>;
  <D.34809>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34815>; else goto <D.34816>;
  <D.34815>:
  code.1497 = code;
  code = code.1497 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1497 = D.34819;
  code.1498 = code;
  code = code.1498 + 1;
  *code.1498 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34821>;
  <D.34816>:
  code.1499 = code;
  code = code.1499 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1499 = D.34824;
  code.1500 = code;
  code = code.1500 + 1;
  *code.1500 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1501 = code;
        code = code.1501 + 1;
        D.34827 = imb.b[0];
        *code.1501 = D.34827;
        code.1502 = code;
        code = code.1502 + 1;
        D.34829 = imb.b[1];
        *code.1502 = D.34829;
        code.1503 = code;
        code = code.1503 + 1;
        D.34831 = imb.b[2];
        *code.1503 = D.34831;
        code.1504 = code;
        code = code.1504 + 1;
        D.34833 = imb.b[3];
        *code.1504 = D.34833;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34821>:
  <D.34814>:
  goto <D.25597>;
  <D.34807>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34834>; else goto <D.34835>;
  <D.34834>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34836>; else goto <D.34837>;
  <D.34836>:
  code.1505 = code;
  code = code.1505 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1505 = D.33690;
  goto <D.25597>;
  <D.34837>:
  <D.34835>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34839>; else goto <D.34840>;
  <D.34839>:
  code.1506 = code;
  code = code.1506 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1506 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34845>;
  <D.34840>:
  code.1507 = code;
  code = code.1507 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1507 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1508 = code;
        code = code.1508 + 1;
        D.34851 = imb.b[0];
        *code.1508 = D.34851;
        code.1509 = code;
        code = code.1509 + 1;
        D.34853 = imb.b[1];
        *code.1509 = D.34853;
        code.1510 = code;
        code = code.1510 + 1;
        D.34855 = imb.b[2];
        *code.1510 = D.34855;
        code.1511 = code;
        code = code.1511 + 1;
        D.34857 = imb.b[3];
        *code.1511 = D.34857;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34845>:
  <D.25597>:
  goto <D.25197>;
  <D.25599>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.34859>; else goto <D.34860>;
    <D.34859>:
    iftmp.1512 = 4;
    goto <D.34861>;
    <D.34860>:
    iftmp.1512 = 0;
    <D.34861>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.34862 = iftmp.1512 | D.33180;
    _amd64_rex_bits = (unsigned char) D.34862;
    if (_amd64_rex_bits != 0) goto <D.34863>; else goto <D.34864>;
    <D.34863>:
    code.1513 = code;
    code = code.1513 + 1;
    D.34866 = _amd64_rex_bits | 64;
    *code.1513 = D.34866;
    <D.34864>:
  }
  code.1514 = code;
  code = code.1514 + 1;
  *code.1514 = 41;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34868>; else goto <D.34869>;
  <D.34868>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34870>; else goto <D.34871>;
  <D.34870>:
  code.1515 = code;
  code = code.1515 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1515 = D.34812;
  code.1516 = code;
  code = code.1516 + 1;
  *code.1516 = 36;
  goto <D.34874>;
  <D.34871>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34875>; else goto <D.34876>;
  <D.34875>:
  code.1517 = code;
  code = code.1517 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1517 = D.34819;
  code.1518 = code;
  code = code.1518 + 1;
  *code.1518 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34879>;
  <D.34876>:
  code.1519 = code;
  code = code.1519 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1519 = D.34824;
  code.1520 = code;
  code = code.1520 + 1;
  *code.1520 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1521 = code;
        code = code.1521 + 1;
        D.34883 = imb.b[0];
        *code.1521 = D.34883;
        code.1522 = code;
        code = code.1522 + 1;
        D.34885 = imb.b[1];
        *code.1522 = D.34885;
        code.1523 = code;
        code = code.1523 + 1;
        D.34887 = imb.b[2];
        *code.1523 = D.34887;
        code.1524 = code;
        code = code.1524 + 1;
        D.34889 = imb.b[3];
        *code.1524 = D.34889;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34879>:
  <D.34874>:
  goto <D.25602>;
  <D.34869>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34890>; else goto <D.34891>;
  <D.34890>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34892>; else goto <D.34893>;
  <D.34892>:
  code.1525 = code;
  code = code.1525 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1525 = D.33690;
  goto <D.25602>;
  <D.34893>:
  <D.34891>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34895>; else goto <D.34896>;
  <D.34895>:
  code.1526 = code;
  code = code.1526 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1526 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34898>;
  <D.34896>:
  code.1527 = code;
  code = code.1527 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1527 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1528 = code;
        code = code.1528 + 1;
        D.34901 = imb.b[0];
        *code.1528 = D.34901;
        code.1529 = code;
        code = code.1529 + 1;
        D.34903 = imb.b[1];
        *code.1529 = D.34903;
        code.1530 = code;
        code = code.1530 + 1;
        D.34905 = imb.b[2];
        *code.1530 = D.34905;
        code.1531 = code;
        code = code.1531 + 1;
        D.34907 = imb.b[3];
        *code.1531 = D.34907;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34898>:
  <D.25602>:
  goto <D.25197>;
  <D.25604>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.34909>; else goto <D.34910>;
    <D.34909>:
    iftmp.1532 = 4;
    goto <D.34911>;
    <D.34910>:
    iftmp.1532 = 0;
    <D.34911>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.34912 = iftmp.1532 | D.33180;
    _amd64_rex_bits = (unsigned char) D.34912;
    if (_amd64_rex_bits != 0) goto <D.34913>; else goto <D.34914>;
    <D.34913>:
    code.1533 = code;
    code = code.1533 + 1;
    D.34916 = _amd64_rex_bits | 64;
    *code.1533 = D.34916;
    <D.34914>:
  }
  code.1534 = code;
  code = code.1534 + 1;
  *code.1534 = 33;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34918>; else goto <D.34919>;
  <D.34918>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34920>; else goto <D.34921>;
  <D.34920>:
  code.1535 = code;
  code = code.1535 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1535 = D.34812;
  code.1536 = code;
  code = code.1536 + 1;
  *code.1536 = 36;
  goto <D.34924>;
  <D.34921>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34925>; else goto <D.34926>;
  <D.34925>:
  code.1537 = code;
  code = code.1537 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1537 = D.34819;
  code.1538 = code;
  code = code.1538 + 1;
  *code.1538 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34929>;
  <D.34926>:
  code.1539 = code;
  code = code.1539 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1539 = D.34824;
  code.1540 = code;
  code = code.1540 + 1;
  *code.1540 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1541 = code;
        code = code.1541 + 1;
        D.34933 = imb.b[0];
        *code.1541 = D.34933;
        code.1542 = code;
        code = code.1542 + 1;
        D.34935 = imb.b[1];
        *code.1542 = D.34935;
        code.1543 = code;
        code = code.1543 + 1;
        D.34937 = imb.b[2];
        *code.1543 = D.34937;
        code.1544 = code;
        code = code.1544 + 1;
        D.34939 = imb.b[3];
        *code.1544 = D.34939;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34929>:
  <D.34924>:
  goto <D.25607>;
  <D.34919>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34940>; else goto <D.34941>;
  <D.34940>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34942>; else goto <D.34943>;
  <D.34942>:
  code.1545 = code;
  code = code.1545 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1545 = D.33690;
  goto <D.25607>;
  <D.34943>:
  <D.34941>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34945>; else goto <D.34946>;
  <D.34945>:
  code.1546 = code;
  code = code.1546 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1546 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34948>;
  <D.34946>:
  code.1547 = code;
  code = code.1547 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1547 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1548 = code;
        code = code.1548 + 1;
        D.34951 = imb.b[0];
        *code.1548 = D.34951;
        code.1549 = code;
        code = code.1549 + 1;
        D.34953 = imb.b[1];
        *code.1549 = D.34953;
        code.1550 = code;
        code = code.1550 + 1;
        D.34955 = imb.b[2];
        *code.1550 = D.34955;
        code.1551 = code;
        code = code.1551 + 1;
        D.34957 = imb.b[3];
        *code.1551 = D.34957;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34948>:
  <D.25607>:
  goto <D.25197>;
  <D.25609>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.34959>; else goto <D.34960>;
    <D.34959>:
    iftmp.1552 = 4;
    goto <D.34961>;
    <D.34960>:
    iftmp.1552 = 0;
    <D.34961>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.34962 = iftmp.1552 | D.33180;
    _amd64_rex_bits = (unsigned char) D.34962;
    if (_amd64_rex_bits != 0) goto <D.34963>; else goto <D.34964>;
    <D.34963>:
    code.1553 = code;
    code = code.1553 + 1;
    D.34966 = _amd64_rex_bits | 64;
    *code.1553 = D.34966;
    <D.34964>:
  }
  code.1554 = code;
  code = code.1554 + 1;
  *code.1554 = 9;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.34968>; else goto <D.34969>;
  <D.34968>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34970>; else goto <D.34971>;
  <D.34970>:
  code.1555 = code;
  code = code.1555 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1555 = D.34812;
  code.1556 = code;
  code = code.1556 + 1;
  *code.1556 = 36;
  goto <D.34974>;
  <D.34971>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34975>; else goto <D.34976>;
  <D.34975>:
  code.1557 = code;
  code = code.1557 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1557 = D.34819;
  code.1558 = code;
  code = code.1558 + 1;
  *code.1558 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34979>;
  <D.34976>:
  code.1559 = code;
  code = code.1559 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1559 = D.34824;
  code.1560 = code;
  code = code.1560 + 1;
  *code.1560 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1561 = code;
        code = code.1561 + 1;
        D.34983 = imb.b[0];
        *code.1561 = D.34983;
        code.1562 = code;
        code = code.1562 + 1;
        D.34985 = imb.b[1];
        *code.1562 = D.34985;
        code.1563 = code;
        code = code.1563 + 1;
        D.34987 = imb.b[2];
        *code.1563 = D.34987;
        code.1564 = code;
        code = code.1564 + 1;
        D.34989 = imb.b[3];
        *code.1564 = D.34989;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34979>:
  <D.34974>:
  goto <D.25612>;
  <D.34969>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.34990>; else goto <D.34991>;
  <D.34990>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.34992>; else goto <D.34993>;
  <D.34992>:
  code.1565 = code;
  code = code.1565 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1565 = D.33690;
  goto <D.25612>;
  <D.34993>:
  <D.34991>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.34995>; else goto <D.34996>;
  <D.34995>:
  code.1566 = code;
  code = code.1566 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1566 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.34998>;
  <D.34996>:
  code.1567 = code;
  code = code.1567 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1567 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1568 = code;
        code = code.1568 + 1;
        D.35001 = imb.b[0];
        *code.1568 = D.35001;
        code.1569 = code;
        code = code.1569 + 1;
        D.35003 = imb.b[1];
        *code.1569 = D.35003;
        code.1570 = code;
        code = code.1570 + 1;
        D.35005 = imb.b[2];
        *code.1570 = D.35005;
        code.1571 = code;
        code = code.1571 + 1;
        D.35007 = imb.b[3];
        *code.1571 = D.35007;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.34998>:
  <D.25612>:
  goto <D.25197>;
  <D.25614>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.35009>; else goto <D.35010>;
    <D.35009>:
    iftmp.1572 = 4;
    goto <D.35011>;
    <D.35010>:
    iftmp.1572 = 0;
    <D.35011>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.35012 = iftmp.1572 | D.33180;
    _amd64_rex_bits = (unsigned char) D.35012;
    if (_amd64_rex_bits != 0) goto <D.35013>; else goto <D.35014>;
    <D.35013>:
    code.1573 = code;
    code = code.1573 + 1;
    D.35016 = _amd64_rex_bits | 64;
    *code.1573 = D.35016;
    <D.35014>:
  }
  code.1574 = code;
  code = code.1574 + 1;
  *code.1574 = 49;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35018>; else goto <D.35019>;
  <D.35018>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35020>; else goto <D.35021>;
  <D.35020>:
  code.1575 = code;
  code = code.1575 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1575 = D.34812;
  code.1576 = code;
  code = code.1576 + 1;
  *code.1576 = 36;
  goto <D.35024>;
  <D.35021>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35025>; else goto <D.35026>;
  <D.35025>:
  code.1577 = code;
  code = code.1577 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1577 = D.34819;
  code.1578 = code;
  code = code.1578 + 1;
  *code.1578 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35029>;
  <D.35026>:
  code.1579 = code;
  code = code.1579 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1579 = D.34824;
  code.1580 = code;
  code = code.1580 + 1;
  *code.1580 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1581 = code;
        code = code.1581 + 1;
        D.35033 = imb.b[0];
        *code.1581 = D.35033;
        code.1582 = code;
        code = code.1582 + 1;
        D.35035 = imb.b[1];
        *code.1582 = D.35035;
        code.1583 = code;
        code = code.1583 + 1;
        D.35037 = imb.b[2];
        *code.1583 = D.35037;
        code.1584 = code;
        code = code.1584 + 1;
        D.35039 = imb.b[3];
        *code.1584 = D.35039;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35029>:
  <D.35024>:
  goto <D.25617>;
  <D.35019>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35040>; else goto <D.35041>;
  <D.35040>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35042>; else goto <D.35043>;
  <D.35042>:
  code.1585 = code;
  code = code.1585 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1585 = D.33690;
  goto <D.25617>;
  <D.35043>:
  <D.35041>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35045>; else goto <D.35046>;
  <D.35045>:
  code.1586 = code;
  code = code.1586 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1586 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35048>;
  <D.35046>:
  code.1587 = code;
  code = code.1587 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1587 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1588 = code;
        code = code.1588 + 1;
        D.35051 = imb.b[0];
        *code.1588 = D.35051;
        code.1589 = code;
        code = code.1589 + 1;
        D.35053 = imb.b[1];
        *code.1589 = D.35053;
        code.1590 = code;
        code = code.1590 + 1;
        D.35055 = imb.b[2];
        *code.1590 = D.35055;
        code.1591 = code;
        code = code.1591 + 1;
        D.35057 = imb.b[3];
        *code.1591 = D.35057;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35048>:
  <D.25617>:
  goto <D.25197>;
  <D.25619>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.35058>; else goto <D.35059>;
    <D.35058>:
    code.1592 = code;
    code = code.1592 + 1;
    D.35061 = _amd64_rex_bits | 64;
    *code.1592 = D.35061;
    <D.35059>:
  }
  code.1593 = code;
  code = code.1593 + 1;
  *code.1593 = 255;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35063>; else goto <D.35064>;
  <D.35063>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35065>; else goto <D.35066>;
  <D.35065>:
  code.1594 = code;
  code = code.1594 + 1;
  *code.1594 = 4;
  code.1595 = code;
  code = code.1595 + 1;
  *code.1595 = 36;
  goto <D.35069>;
  <D.35066>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35070>; else goto <D.35071>;
  <D.35070>:
  code.1596 = code;
  code = code.1596 + 1;
  *code.1596 = 68;
  code.1597 = code;
  code = code.1597 + 1;
  *code.1597 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35074>;
  <D.35071>:
  code.1598 = code;
  code = code.1598 + 1;
  *code.1598 = 132;
  code.1599 = code;
  code = code.1599 + 1;
  *code.1599 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1600 = code;
        code = code.1600 + 1;
        D.35078 = imb.b[0];
        *code.1600 = D.35078;
        code.1601 = code;
        code = code.1601 + 1;
        D.35080 = imb.b[1];
        *code.1601 = D.35080;
        code.1602 = code;
        code = code.1602 + 1;
        D.35082 = imb.b[2];
        *code.1602 = D.35082;
        code.1603 = code;
        code = code.1603 + 1;
        D.35084 = imb.b[3];
        *code.1603 = D.35084;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35074>:
  <D.35069>:
  goto <D.25622>;
  <D.35064>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35085>; else goto <D.35086>;
  <D.35085>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35087>; else goto <D.35088>;
  <D.35087>:
  code.1604 = code;
  code = code.1604 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  *code.1604 = D.31566;
  goto <D.25622>;
  <D.35088>:
  <D.35086>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35090>; else goto <D.35091>;
  <D.35090>:
  code.1605 = code;
  code = code.1605 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31572 = D.31571 | 64;
  D.31573 = (unsigned char) D.31572;
  *code.1605 = D.31573;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35093>;
  <D.35091>:
  code.1606 = code;
  code = code.1606 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31576 = D.31571 | -128;
  D.31577 = (unsigned char) D.31576;
  *code.1606 = D.31577;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1607 = code;
        code = code.1607 + 1;
        D.35096 = imb.b[0];
        *code.1607 = D.35096;
        code.1608 = code;
        code = code.1608 + 1;
        D.35098 = imb.b[1];
        *code.1608 = D.35098;
        code.1609 = code;
        code = code.1609 + 1;
        D.35100 = imb.b[2];
        *code.1609 = D.35100;
        code.1610 = code;
        code = code.1610 + 1;
        D.35102 = imb.b[3];
        *code.1610 = D.35102;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35093>:
  <D.25622>:
  goto <D.25197>;
  <D.25624>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.35103>; else goto <D.35104>;
    <D.35103>:
    code.1611 = code;
    code = code.1611 + 1;
    D.35106 = _amd64_rex_bits | 64;
    *code.1611 = D.35106;
    <D.35104>:
  }
  code.1612 = code;
  code = code.1612 + 1;
  *code.1612 = 255;
  code.1613 = code;
  code = code.1613 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.1613 = D.35110;
  goto <D.25197>;
  <D.25626>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.35111>; else goto <D.35112>;
    <D.35111>:
    code.1614 = code;
    code = code.1614 + 1;
    D.35114 = _amd64_rex_bits | 64;
    *code.1614 = D.35114;
    <D.35112>:
  }
  code.1615 = code;
  code = code.1615 + 1;
  *code.1615 = 255;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35116>; else goto <D.35117>;
  <D.35116>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35118>; else goto <D.35119>;
  <D.35118>:
  code.1616 = code;
  code = code.1616 + 1;
  *code.1616 = 12;
  code.1617 = code;
  code = code.1617 + 1;
  *code.1617 = 36;
  goto <D.35122>;
  <D.35119>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35123>; else goto <D.35124>;
  <D.35123>:
  code.1618 = code;
  code = code.1618 + 1;
  *code.1618 = 76;
  code.1619 = code;
  code = code.1619 + 1;
  *code.1619 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35127>;
  <D.35124>:
  code.1620 = code;
  code = code.1620 + 1;
  *code.1620 = 140;
  code.1621 = code;
  code = code.1621 + 1;
  *code.1621 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1622 = code;
        code = code.1622 + 1;
        D.35131 = imb.b[0];
        *code.1622 = D.35131;
        code.1623 = code;
        code = code.1623 + 1;
        D.35133 = imb.b[1];
        *code.1623 = D.35133;
        code.1624 = code;
        code = code.1624 + 1;
        D.35135 = imb.b[2];
        *code.1624 = D.35135;
        code.1625 = code;
        code = code.1625 + 1;
        D.35137 = imb.b[3];
        *code.1625 = D.35137;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35127>:
  <D.35122>:
  goto <D.25629>;
  <D.35117>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35138>; else goto <D.35139>;
  <D.35138>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35140>; else goto <D.35141>;
  <D.35140>:
  code.1626 = code;
  code = code.1626 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34622 = D.31571 | 8;
  D.34623 = (unsigned char) D.34622;
  *code.1626 = D.34623;
  goto <D.25629>;
  <D.35141>:
  <D.35139>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35143>; else goto <D.35144>;
  <D.35143>:
  code.1627 = code;
  code = code.1627 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34627 = D.31571 | 72;
  D.34628 = (unsigned char) D.34627;
  *code.1627 = D.34628;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35146>;
  <D.35144>:
  code.1628 = code;
  code = code.1628 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34631 = D.31571 | -120;
  D.34632 = (unsigned char) D.34631;
  *code.1628 = D.34632;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1629 = code;
        code = code.1629 + 1;
        D.35149 = imb.b[0];
        *code.1629 = D.35149;
        code.1630 = code;
        code = code.1630 + 1;
        D.35151 = imb.b[1];
        *code.1630 = D.35151;
        code.1631 = code;
        code = code.1631 + 1;
        D.35153 = imb.b[2];
        *code.1631 = D.35153;
        code.1632 = code;
        code = code.1632 + 1;
        D.35155 = imb.b[3];
        *code.1632 = D.35155;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35146>:
  <D.25629>:
  goto <D.25197>;
  <D.25631>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.35156>; else goto <D.35157>;
    <D.35156>:
    code.1633 = code;
    code = code.1633 + 1;
    D.35159 = _amd64_rex_bits | 64;
    *code.1633 = D.35159;
    <D.35157>:
  }
  code.1634 = code;
  code = code.1634 + 1;
  *code.1634 = 255;
  code.1635 = code;
  code = code.1635 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35162 = D.31632 | -56;
  D.35163 = (unsigned char) D.35162;
  *code.1635 = D.35163;
  goto <D.25197>;
  <D.25633>:
  <D.25634>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35165>; else goto <D.35166>;
    <D.35165>:
    iftmp.1636 = 4;
    goto <D.35167>;
    <D.35166>:
    iftmp.1636 = 0;
    <D.35167>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35168 = iftmp.1636 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35168;
    if (_amd64_rex_bits != 0) goto <D.35169>; else goto <D.35170>;
    <D.35169>:
    code.1637 = code;
    code = code.1637 + 1;
    D.35172 = _amd64_rex_bits | 64;
    *code.1637 = D.35172;
    <D.35170>:
  }
  code.1638 = code;
  code = code.1638 + 1;
  *code.1638 = 15;
  code.1639 = code;
  code = code.1639 + 1;
  *code.1639 = 175;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35175>; else goto <D.35176>;
  <D.35175>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35177>; else goto <D.35178>;
  <D.35177>:
  code.1640 = code;
  code = code.1640 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1640 = D.32056;
  code.1641 = code;
  code = code.1641 + 1;
  *code.1641 = 36;
  goto <D.35181>;
  <D.35178>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35182>; else goto <D.35183>;
  <D.35182>:
  code.1642 = code;
  code = code.1642 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1642 = D.32063;
  code.1643 = code;
  code = code.1643 + 1;
  *code.1643 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35186>;
  <D.35183>:
  code.1644 = code;
  code = code.1644 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1644 = D.32068;
  code.1645 = code;
  code = code.1645 + 1;
  *code.1645 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1646 = code;
        code = code.1646 + 1;
        D.35190 = imb.b[0];
        *code.1646 = D.35190;
        code.1647 = code;
        code = code.1647 + 1;
        D.35192 = imb.b[1];
        *code.1647 = D.35192;
        code.1648 = code;
        code = code.1648 + 1;
        D.35194 = imb.b[2];
        *code.1648 = D.35194;
        code.1649 = code;
        code = code.1649 + 1;
        D.35196 = imb.b[3];
        *code.1649 = D.35196;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35186>:
  <D.35181>:
  goto <D.25637>;
  <D.35176>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35197>; else goto <D.35198>;
  <D.35197>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35199>; else goto <D.35200>;
  <D.35199>:
  code.1650 = code;
  code = code.1650 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1650 = D.33927;
  goto <D.25637>;
  <D.35200>:
  <D.35198>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35202>; else goto <D.35203>;
  <D.35202>:
  code.1651 = code;
  code = code.1651 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1651 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35205>;
  <D.35203>:
  code.1652 = code;
  code = code.1652 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1652 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1653 = code;
        code = code.1653 + 1;
        D.35208 = imb.b[0];
        *code.1653 = D.35208;
        code.1654 = code;
        code = code.1654 + 1;
        D.35210 = imb.b[1];
        *code.1654 = D.35210;
        code.1655 = code;
        code = code.1655 + 1;
        D.35212 = imb.b[2];
        *code.1655 = D.35212;
        code.1656 = code;
        code = code.1656 + 1;
        D.35214 = imb.b[3];
        *code.1656 = D.35214;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35205>:
  <D.25637>:
  goto <D.25197>;
  <D.25639>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.35216>; else goto <D.35217>;
    <D.35216>:
    iftmp.1657 = 4;
    goto <D.35218>;
    <D.35217>:
    iftmp.1657 = 0;
    <D.35218>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.35219 = iftmp.1657 | D.33180;
    _amd64_rex_bits = (unsigned char) D.35219;
    if (_amd64_rex_bits != 0) goto <D.35220>; else goto <D.35221>;
    <D.35220>:
    code.1658 = code;
    code = code.1658 + 1;
    D.35223 = _amd64_rex_bits | 64;
    *code.1658 = D.35223;
    <D.35221>:
  }
  code.1659 = code;
  code = code.1659 + 1;
  *code.1659 = 57;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35225>; else goto <D.35226>;
  <D.35225>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35227>; else goto <D.35228>;
  <D.35227>:
  code.1660 = code;
  code = code.1660 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1660 = D.34812;
  code.1661 = code;
  code = code.1661 + 1;
  *code.1661 = 36;
  goto <D.35231>;
  <D.35228>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35232>; else goto <D.35233>;
  <D.35232>:
  code.1662 = code;
  code = code.1662 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1662 = D.34819;
  code.1663 = code;
  code = code.1663 + 1;
  *code.1663 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35236>;
  <D.35233>:
  code.1664 = code;
  code = code.1664 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1664 = D.34824;
  code.1665 = code;
  code = code.1665 + 1;
  *code.1665 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1666 = code;
        code = code.1666 + 1;
        D.35240 = imb.b[0];
        *code.1666 = D.35240;
        code.1667 = code;
        code = code.1667 + 1;
        D.35242 = imb.b[1];
        *code.1667 = D.35242;
        code.1668 = code;
        code = code.1668 + 1;
        D.35244 = imb.b[2];
        *code.1668 = D.35244;
        code.1669 = code;
        code = code.1669 + 1;
        D.35246 = imb.b[3];
        *code.1669 = D.35246;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35236>:
  <D.35231>:
  goto <D.25642>;
  <D.35226>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35247>; else goto <D.35248>;
  <D.35247>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35249>; else goto <D.35250>;
  <D.35249>:
  code.1670 = code;
  code = code.1670 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1670 = D.33690;
  goto <D.25642>;
  <D.35250>:
  <D.35248>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35252>; else goto <D.35253>;
  <D.35252>:
  code.1671 = code;
  code = code.1671 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1671 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35255>;
  <D.35253>:
  code.1672 = code;
  code = code.1672 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1672 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1673 = code;
        code = code.1673 + 1;
        D.35258 = imb.b[0];
        *code.1673 = D.35258;
        code.1674 = code;
        code = code.1674 + 1;
        D.35260 = imb.b[1];
        *code.1674 = D.35260;
        code.1675 = code;
        code = code.1675 + 1;
        D.35262 = imb.b[2];
        *code.1675 = D.35262;
        code.1676 = code;
        code = code.1676 + 1;
        D.35264 = imb.b[3];
        *code.1676 = D.35264;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35255>:
  <D.25642>:
  goto <D.25197>;
  <D.25644>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.35265>; else goto <D.35266>;
    <D.35265>:
    code.1677 = code;
    code = code.1677 + 1;
    D.35268 = _amd64_rex_bits | 64;
    *code.1677 = D.35268;
    <D.35266>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.35269>; else goto <D.35270>;
  <D.35269>:
  code.1678 = code;
  code = code.1678 + 1;
  *code.1678 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35272>; else goto <D.35273>;
  <D.35272>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35274>; else goto <D.35275>;
  <D.35274>:
  code.1679 = code;
  code = code.1679 + 1;
  *code.1679 = 60;
  code.1680 = code;
  code = code.1680 + 1;
  *code.1680 = 36;
  goto <D.35278>;
  <D.35275>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35279>; else goto <D.35280>;
  <D.35279>:
  code.1681 = code;
  code = code.1681 + 1;
  *code.1681 = 124;
  code.1682 = code;
  code = code.1682 + 1;
  *code.1682 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35283>;
  <D.35280>:
  code.1683 = code;
  code = code.1683 + 1;
  *code.1683 = 188;
  code.1684 = code;
  code = code.1684 + 1;
  *code.1684 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1685 = code;
        code = code.1685 + 1;
        D.35287 = imb.b[0];
        *code.1685 = D.35287;
        code.1686 = code;
        code = code.1686 + 1;
        D.35289 = imb.b[1];
        *code.1686 = D.35289;
        code.1687 = code;
        code = code.1687 + 1;
        D.35291 = imb.b[2];
        *code.1687 = D.35291;
        code.1688 = code;
        code = code.1688 + 1;
        D.35293 = imb.b[3];
        *code.1688 = D.35293;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35283>:
  <D.35278>:
  goto <D.25647>;
  <D.35273>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35294>; else goto <D.35295>;
  <D.35294>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35296>; else goto <D.35297>;
  <D.35296>:
  code.1689 = code;
  code = code.1689 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.1689 = D.35300;
  goto <D.25647>;
  <D.35297>:
  <D.35295>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35301>; else goto <D.35302>;
  <D.35301>:
  code.1690 = code;
  code = code.1690 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.1690 = D.35305;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35306>;
  <D.35302>:
  code.1691 = code;
  code = code.1691 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.1691 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1692 = code;
        code = code.1692 + 1;
        D.35311 = imb.b[0];
        *code.1692 = D.35311;
        code.1693 = code;
        code = code.1693 + 1;
        D.35313 = imb.b[1];
        *code.1693 = D.35313;
        code.1694 = code;
        code = code.1694 + 1;
        D.35315 = imb.b[2];
        *code.1694 = D.35315;
        code.1695 = code;
        code = code.1695 + 1;
        D.35317 = imb.b[3];
        *code.1695 = D.35317;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35306>:
  <D.25647>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.35318>;
  <D.35270>:
  code.1696 = code;
  code = code.1696 + 1;
  *code.1696 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35320>; else goto <D.35321>;
  <D.35320>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35322>; else goto <D.35323>;
  <D.35322>:
  code.1697 = code;
  code = code.1697 + 1;
  *code.1697 = 60;
  code.1698 = code;
  code = code.1698 + 1;
  *code.1698 = 36;
  goto <D.35326>;
  <D.35323>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35327>; else goto <D.35328>;
  <D.35327>:
  code.1699 = code;
  code = code.1699 + 1;
  *code.1699 = 124;
  code.1700 = code;
  code = code.1700 + 1;
  *code.1700 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35331>;
  <D.35328>:
  code.1701 = code;
  code = code.1701 + 1;
  *code.1701 = 188;
  code.1702 = code;
  code = code.1702 + 1;
  *code.1702 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1703 = code;
        code = code.1703 + 1;
        D.35335 = imb.b[0];
        *code.1703 = D.35335;
        code.1704 = code;
        code = code.1704 + 1;
        D.35337 = imb.b[1];
        *code.1704 = D.35337;
        code.1705 = code;
        code = code.1705 + 1;
        D.35339 = imb.b[2];
        *code.1705 = D.35339;
        code.1706 = code;
        code = code.1706 + 1;
        D.35341 = imb.b[3];
        *code.1706 = D.35341;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35331>:
  <D.35326>:
  goto <D.25650>;
  <D.35321>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35342>; else goto <D.35343>;
  <D.35342>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35344>; else goto <D.35345>;
  <D.35344>:
  code.1707 = code;
  code = code.1707 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.1707 = D.35300;
  goto <D.25650>;
  <D.35345>:
  <D.35343>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35347>; else goto <D.35348>;
  <D.35347>:
  code.1708 = code;
  code = code.1708 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.1708 = D.35305;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35350>;
  <D.35348>:
  code.1709 = code;
  code = code.1709 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.1709 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1710 = code;
        code = code.1710 + 1;
        D.35353 = imb.b[0];
        *code.1710 = D.35353;
        code.1711 = code;
        code = code.1711 + 1;
        D.35355 = imb.b[1];
        *code.1711 = D.35355;
        code.1712 = code;
        code = code.1712 + 1;
        D.35357 = imb.b[2];
        *code.1712 = D.35357;
        code.1713 = code;
        code = code.1713 + 1;
        D.35359 = imb.b[3];
        *code.1713 = D.35359;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35350>:
  <D.25650>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1714 = code;
        code = code.1714 + 1;
        D.35361 = imb.b[0];
        *code.1714 = D.35361;
        code.1715 = code;
        code = code.1715 + 1;
        D.35363 = imb.b[1];
        *code.1715 = D.35363;
        code.1716 = code;
        code = code.1716 + 1;
        D.35365 = imb.b[2];
        *code.1716 = D.35365;
        code.1717 = code;
        code = code.1717 + 1;
        D.35367 = imb.b[3];
        *code.1717 = D.35367;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35318>:
  goto <D.25197>;
  <D.25653>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.35369>; else goto <D.35370>;
    <D.35369>:
    iftmp.1718 = 12;
    goto <D.35371>;
    <D.35370>:
    iftmp.1718 = 8;
    <D.35371>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.35372 = iftmp.1718 | D.33180;
    _amd64_rex_bits = (unsigned char) D.35372;
    if (_amd64_rex_bits != 0) goto <D.35373>; else goto <D.35374>;
    <D.35373>:
    code.1719 = code;
    code = code.1719 + 1;
    D.35376 = _amd64_rex_bits | 64;
    *code.1719 = D.35376;
    <D.35374>:
  }
  code.1720 = code;
  code = code.1720 + 1;
  *code.1720 = 57;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35378>; else goto <D.35379>;
  <D.35378>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35380>; else goto <D.35381>;
  <D.35380>:
  code.1721 = code;
  code = code.1721 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1721 = D.34812;
  code.1722 = code;
  code = code.1722 + 1;
  *code.1722 = 36;
  goto <D.35384>;
  <D.35381>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35385>; else goto <D.35386>;
  <D.35385>:
  code.1723 = code;
  code = code.1723 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1723 = D.34819;
  code.1724 = code;
  code = code.1724 + 1;
  *code.1724 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35389>;
  <D.35386>:
  code.1725 = code;
  code = code.1725 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1725 = D.34824;
  code.1726 = code;
  code = code.1726 + 1;
  *code.1726 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1727 = code;
        code = code.1727 + 1;
        D.35393 = imb.b[0];
        *code.1727 = D.35393;
        code.1728 = code;
        code = code.1728 + 1;
        D.35395 = imb.b[1];
        *code.1728 = D.35395;
        code.1729 = code;
        code = code.1729 + 1;
        D.35397 = imb.b[2];
        *code.1729 = D.35397;
        code.1730 = code;
        code = code.1730 + 1;
        D.35399 = imb.b[3];
        *code.1730 = D.35399;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35389>:
  <D.35384>:
  goto <D.25656>;
  <D.35379>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35400>; else goto <D.35401>;
  <D.35400>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35402>; else goto <D.35403>;
  <D.35402>:
  code.1731 = code;
  code = code.1731 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1731 = D.33690;
  goto <D.25656>;
  <D.35403>:
  <D.35401>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35405>; else goto <D.35406>;
  <D.35405>:
  code.1732 = code;
  code = code.1732 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1732 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35408>;
  <D.35406>:
  code.1733 = code;
  code = code.1733 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1733 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1734 = code;
        code = code.1734 + 1;
        D.35411 = imb.b[0];
        *code.1734 = D.35411;
        code.1735 = code;
        code = code.1735 + 1;
        D.35413 = imb.b[1];
        *code.1735 = D.35413;
        code.1736 = code;
        code = code.1736 + 1;
        D.35415 = imb.b[2];
        *code.1736 = D.35415;
        code.1737 = code;
        code = code.1737 + 1;
        D.35417 = imb.b[3];
        *code.1737 = D.35417;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35408>:
  <D.25656>:
  goto <D.25197>;
  <D.25658>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.35418>; else goto <D.35419>;
  <D.35418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4230, "amd64_is_imm32 (ins->inst_imm)");
  <D.35419>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35421>; else goto <D.35422>;
    <D.35421>:
    iftmp.1738 = 9;
    goto <D.35423>;
    <D.35422>:
    iftmp.1738 = 8;
    <D.35423>:
    _amd64_rex_bits = iftmp.1738;
    if (_amd64_rex_bits != 0) goto <D.35424>; else goto <D.35425>;
    <D.35424>:
    code.1739 = code;
    code = code.1739 + 1;
    D.35427 = _amd64_rex_bits | 64;
    *code.1739 = D.35427;
    <D.35425>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.35428>; else goto <D.35429>;
  <D.35428>:
  code.1740 = code;
  code = code.1740 + 1;
  *code.1740 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35431>; else goto <D.35432>;
  <D.35431>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35433>; else goto <D.35434>;
  <D.35433>:
  code.1741 = code;
  code = code.1741 + 1;
  *code.1741 = 60;
  code.1742 = code;
  code = code.1742 + 1;
  *code.1742 = 36;
  goto <D.35437>;
  <D.35434>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35438>; else goto <D.35439>;
  <D.35438>:
  code.1743 = code;
  code = code.1743 + 1;
  *code.1743 = 124;
  code.1744 = code;
  code = code.1744 + 1;
  *code.1744 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35442>;
  <D.35439>:
  code.1745 = code;
  code = code.1745 + 1;
  *code.1745 = 188;
  code.1746 = code;
  code = code.1746 + 1;
  *code.1746 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1747 = code;
        code = code.1747 + 1;
        D.35446 = imb.b[0];
        *code.1747 = D.35446;
        code.1748 = code;
        code = code.1748 + 1;
        D.35448 = imb.b[1];
        *code.1748 = D.35448;
        code.1749 = code;
        code = code.1749 + 1;
        D.35450 = imb.b[2];
        *code.1749 = D.35450;
        code.1750 = code;
        code = code.1750 + 1;
        D.35452 = imb.b[3];
        *code.1750 = D.35452;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35442>:
  <D.35437>:
  goto <D.25661>;
  <D.35432>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35453>; else goto <D.35454>;
  <D.35453>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35455>; else goto <D.35456>;
  <D.35455>:
  code.1751 = code;
  code = code.1751 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.1751 = D.35300;
  goto <D.25661>;
  <D.35456>:
  <D.35454>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35458>; else goto <D.35459>;
  <D.35458>:
  code.1752 = code;
  code = code.1752 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.1752 = D.35305;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35461>;
  <D.35459>:
  code.1753 = code;
  code = code.1753 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.1753 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1754 = code;
        code = code.1754 + 1;
        D.35464 = imb.b[0];
        *code.1754 = D.35464;
        code.1755 = code;
        code = code.1755 + 1;
        D.35466 = imb.b[1];
        *code.1755 = D.35466;
        code.1756 = code;
        code = code.1756 + 1;
        D.35468 = imb.b[2];
        *code.1756 = D.35468;
        code.1757 = code;
        code = code.1757 + 1;
        D.35470 = imb.b[3];
        *code.1757 = D.35470;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35461>:
  <D.25661>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.35471>;
  <D.35429>:
  code.1758 = code;
  code = code.1758 + 1;
  *code.1758 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35473>; else goto <D.35474>;
  <D.35473>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35475>; else goto <D.35476>;
  <D.35475>:
  code.1759 = code;
  code = code.1759 + 1;
  *code.1759 = 60;
  code.1760 = code;
  code = code.1760 + 1;
  *code.1760 = 36;
  goto <D.35479>;
  <D.35476>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35480>; else goto <D.35481>;
  <D.35480>:
  code.1761 = code;
  code = code.1761 + 1;
  *code.1761 = 124;
  code.1762 = code;
  code = code.1762 + 1;
  *code.1762 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35484>;
  <D.35481>:
  code.1763 = code;
  code = code.1763 + 1;
  *code.1763 = 188;
  code.1764 = code;
  code = code.1764 + 1;
  *code.1764 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1765 = code;
        code = code.1765 + 1;
        D.35488 = imb.b[0];
        *code.1765 = D.35488;
        code.1766 = code;
        code = code.1766 + 1;
        D.35490 = imb.b[1];
        *code.1766 = D.35490;
        code.1767 = code;
        code = code.1767 + 1;
        D.35492 = imb.b[2];
        *code.1767 = D.35492;
        code.1768 = code;
        code = code.1768 + 1;
        D.35494 = imb.b[3];
        *code.1768 = D.35494;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35484>:
  <D.35479>:
  goto <D.25664>;
  <D.35474>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35495>; else goto <D.35496>;
  <D.35495>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35497>; else goto <D.35498>;
  <D.35497>:
  code.1769 = code;
  code = code.1769 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.1769 = D.35300;
  goto <D.25664>;
  <D.35498>:
  <D.35496>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35500>; else goto <D.35501>;
  <D.35500>:
  code.1770 = code;
  code = code.1770 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.1770 = D.35305;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35503>;
  <D.35501>:
  code.1771 = code;
  code = code.1771 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.1771 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1772 = code;
        code = code.1772 + 1;
        D.35506 = imb.b[0];
        *code.1772 = D.35506;
        code.1773 = code;
        code = code.1773 + 1;
        D.35508 = imb.b[1];
        *code.1773 = D.35508;
        code.1774 = code;
        code = code.1774 + 1;
        D.35510 = imb.b[2];
        *code.1774 = D.35510;
        code.1775 = code;
        code = code.1775 + 1;
        D.35512 = imb.b[3];
        *code.1775 = D.35512;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35503>:
  <D.25664>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.1776 = code;
        code = code.1776 + 1;
        D.35514 = imb.b[0];
        *code.1776 = D.35514;
        code.1777 = code;
        code = code.1777 + 1;
        D.35516 = imb.b[1];
        *code.1777 = D.35516;
        code.1778 = code;
        code = code.1778 + 1;
        D.35518 = imb.b[2];
        *code.1778 = D.35518;
        code.1779 = code;
        code = code.1779 + 1;
        D.35520 = imb.b[3];
        *code.1779 = D.35520;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35471>:
  goto <D.25197>;
  <D.25667>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.35521>; else goto <D.35522>;
    <D.35521>:
    code.1780 = code;
    code = code.1780 + 1;
    D.35524 = _amd64_rex_bits | 64;
    *code.1780 = D.35524;
    <D.35522>:
  }
  code.1781 = code;
  code = code.1781 + 1;
  *code.1781 = 128;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.35526>; else goto <D.35527>;
  <D.35526>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35528>; else goto <D.35529>;
  <D.35528>:
  code.1782 = code;
  code = code.1782 + 1;
  *code.1782 = 60;
  code.1783 = code;
  code = code.1783 + 1;
  *code.1783 = 36;
  goto <D.35532>;
  <D.35529>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35533>; else goto <D.35534>;
  <D.35533>:
  code.1784 = code;
  code = code.1784 + 1;
  *code.1784 = 124;
  code.1785 = code;
  code = code.1785 + 1;
  *code.1785 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35537>;
  <D.35534>:
  code.1786 = code;
  code = code.1786 + 1;
  *code.1786 = 188;
  code.1787 = code;
  code = code.1787 + 1;
  *code.1787 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1788 = code;
        code = code.1788 + 1;
        D.35541 = imb.b[0];
        *code.1788 = D.35541;
        code.1789 = code;
        code = code.1789 + 1;
        D.35543 = imb.b[1];
        *code.1789 = D.35543;
        code.1790 = code;
        code = code.1790 + 1;
        D.35545 = imb.b[2];
        *code.1790 = D.35545;
        code.1791 = code;
        code = code.1791 + 1;
        D.35547 = imb.b[3];
        *code.1791 = D.35547;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35537>:
  <D.35532>:
  goto <D.25670>;
  <D.35527>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35548>; else goto <D.35549>;
  <D.35548>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.35550>; else goto <D.35551>;
  <D.35550>:
  code.1792 = code;
  code = code.1792 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.1792 = D.35300;
  goto <D.25670>;
  <D.35551>:
  <D.35549>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35553>; else goto <D.35554>;
  <D.35553>:
  code.1793 = code;
  code = code.1793 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.1793 = D.35305;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35556>;
  <D.35554>:
  code.1794 = code;
  code = code.1794 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.1794 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1795 = code;
        code = code.1795 + 1;
        D.35559 = imb.b[0];
        *code.1795 = D.35559;
        code.1796 = code;
        code = code.1796 + 1;
        D.35561 = imb.b[1];
        *code.1796 = D.35561;
        code.1797 = code;
        code = code.1797 + 1;
        D.35563 = imb.b[2];
        *code.1797 = D.35563;
        code.1798 = code;
        code = code.1798 + 1;
        D.35565 = imb.b[3];
        *code.1798 = D.35565;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35556>:
  <D.25670>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.25672>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35567>; else goto <D.35568>;
    <D.35567>:
    iftmp.1799 = 4;
    goto <D.35569>;
    <D.35568>:
    iftmp.1799 = 0;
    <D.35569>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35570 = iftmp.1799 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35570;
    if (_amd64_rex_bits != 0) goto <D.35571>; else goto <D.35572>;
    <D.35571>:
    code.1800 = code;
    code = code.1800 + 1;
    D.35574 = _amd64_rex_bits | 64;
    *code.1800 = D.35574;
    <D.35572>:
  }
  code.1801 = code;
  code = code.1801 + 1;
  *code.1801 = 59;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35576>; else goto <D.35577>;
  <D.35576>:
  code.1802 = code;
  code = code.1802 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1802 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1803 = code;
        code = code.1803 + 1;
        D.35580 = imb.b[0];
        *code.1803 = D.35580;
        code.1804 = code;
        code = code.1804 + 1;
        D.35582 = imb.b[1];
        *code.1804 = D.35582;
        code.1805 = code;
        code = code.1805 + 1;
        D.35584 = imb.b[2];
        *code.1805 = D.35584;
        code.1806 = code;
        code = code.1806 + 1;
        D.35586 = imb.b[3];
        *code.1806 = D.35586;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35587>;
  <D.35577>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35588>; else goto <D.35589>;
  <D.35588>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35590>; else goto <D.35591>;
  <D.35590>:
  code.1807 = code;
  code = code.1807 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1807 = D.32056;
  code.1808 = code;
  code = code.1808 + 1;
  *code.1808 = 36;
  goto <D.35594>;
  <D.35591>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35595>; else goto <D.35596>;
  <D.35595>:
  code.1809 = code;
  code = code.1809 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1809 = D.32063;
  code.1810 = code;
  code = code.1810 + 1;
  *code.1810 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35599>;
  <D.35596>:
  code.1811 = code;
  code = code.1811 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1811 = D.32068;
  code.1812 = code;
  code = code.1812 + 1;
  *code.1812 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1813 = code;
        code = code.1813 + 1;
        D.35603 = imb.b[0];
        *code.1813 = D.35603;
        code.1814 = code;
        code = code.1814 + 1;
        D.35605 = imb.b[1];
        *code.1814 = D.35605;
        code.1815 = code;
        code = code.1815 + 1;
        D.35607 = imb.b[2];
        *code.1815 = D.35607;
        code.1816 = code;
        code = code.1816 + 1;
        D.35609 = imb.b[3];
        *code.1816 = D.35609;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35599>:
  <D.35594>:
  goto <D.25676>;
  <D.35589>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35610>; else goto <D.35611>;
  <D.35610>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35612>; else goto <D.35613>;
  <D.35612>:
  code.1817 = code;
  code = code.1817 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1817 = D.33927;
  goto <D.25676>;
  <D.35613>:
  <D.35611>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35615>; else goto <D.35616>;
  <D.35615>:
  code.1818 = code;
  code = code.1818 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1818 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35618>;
  <D.35616>:
  code.1819 = code;
  code = code.1819 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1819 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1820 = code;
        code = code.1820 + 1;
        D.35621 = imb.b[0];
        *code.1820 = D.35621;
        code.1821 = code;
        code = code.1821 + 1;
        D.35623 = imb.b[1];
        *code.1821 = D.35623;
        code.1822 = code;
        code = code.1822 + 1;
        D.35625 = imb.b[2];
        *code.1822 = D.35625;
        code.1823 = code;
        code = code.1823 + 1;
        D.35627 = imb.b[3];
        *code.1823 = D.35627;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35618>:
  <D.25676>:
  <D.35587>:
  goto <D.25197>;
  <D.25678>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35629>; else goto <D.35630>;
    <D.35629>:
    iftmp.1824 = 12;
    goto <D.35631>;
    <D.35630>:
    iftmp.1824 = 8;
    <D.35631>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35632 = iftmp.1824 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35632;
    if (_amd64_rex_bits != 0) goto <D.35633>; else goto <D.35634>;
    <D.35633>:
    code.1825 = code;
    code = code.1825 + 1;
    D.35636 = _amd64_rex_bits | 64;
    *code.1825 = D.35636;
    <D.35634>:
  }
  code.1826 = code;
  code = code.1826 + 1;
  *code.1826 = 59;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35638>; else goto <D.35639>;
  <D.35638>:
  code.1827 = code;
  code = code.1827 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1827 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1828 = code;
        code = code.1828 + 1;
        D.35642 = imb.b[0];
        *code.1828 = D.35642;
        code.1829 = code;
        code = code.1829 + 1;
        D.35644 = imb.b[1];
        *code.1829 = D.35644;
        code.1830 = code;
        code = code.1830 + 1;
        D.35646 = imb.b[2];
        *code.1830 = D.35646;
        code.1831 = code;
        code = code.1831 + 1;
        D.35648 = imb.b[3];
        *code.1831 = D.35648;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35649>;
  <D.35639>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35650>; else goto <D.35651>;
  <D.35650>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35652>; else goto <D.35653>;
  <D.35652>:
  code.1832 = code;
  code = code.1832 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1832 = D.32056;
  code.1833 = code;
  code = code.1833 + 1;
  *code.1833 = 36;
  goto <D.35656>;
  <D.35653>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35657>; else goto <D.35658>;
  <D.35657>:
  code.1834 = code;
  code = code.1834 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1834 = D.32063;
  code.1835 = code;
  code = code.1835 + 1;
  *code.1835 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35661>;
  <D.35658>:
  code.1836 = code;
  code = code.1836 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1836 = D.32068;
  code.1837 = code;
  code = code.1837 + 1;
  *code.1837 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1838 = code;
        code = code.1838 + 1;
        D.35665 = imb.b[0];
        *code.1838 = D.35665;
        code.1839 = code;
        code = code.1839 + 1;
        D.35667 = imb.b[1];
        *code.1839 = D.35667;
        code.1840 = code;
        code = code.1840 + 1;
        D.35669 = imb.b[2];
        *code.1840 = D.35669;
        code.1841 = code;
        code = code.1841 + 1;
        D.35671 = imb.b[3];
        *code.1841 = D.35671;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35661>:
  <D.35656>:
  goto <D.25682>;
  <D.35651>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35672>; else goto <D.35673>;
  <D.35672>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35674>; else goto <D.35675>;
  <D.35674>:
  code.1842 = code;
  code = code.1842 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1842 = D.33927;
  goto <D.25682>;
  <D.35675>:
  <D.35673>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35677>; else goto <D.35678>;
  <D.35677>:
  code.1843 = code;
  code = code.1843 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1843 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35680>;
  <D.35678>:
  code.1844 = code;
  code = code.1844 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1844 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1845 = code;
        code = code.1845 + 1;
        D.35683 = imb.b[0];
        *code.1845 = D.35683;
        code.1846 = code;
        code = code.1846 + 1;
        D.35685 = imb.b[1];
        *code.1846 = D.35685;
        code.1847 = code;
        code = code.1847 + 1;
        D.35687 = imb.b[2];
        *code.1847 = D.35687;
        code.1848 = code;
        code = code.1848 + 1;
        D.35689 = imb.b[3];
        *code.1848 = D.35689;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35680>:
  <D.25682>:
  <D.35649>:
  goto <D.25197>;
  <D.25684>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35691>; else goto <D.35692>;
    <D.35691>:
    iftmp.1849 = 12;
    goto <D.35693>;
    <D.35692>:
    iftmp.1849 = 8;
    <D.35693>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35694 = iftmp.1849 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35694;
    if (_amd64_rex_bits != 0) goto <D.35695>; else goto <D.35696>;
    <D.35695>:
    code.1850 = code;
    code = code.1850 + 1;
    D.35698 = _amd64_rex_bits | 64;
    *code.1850 = D.35698;
    <D.35696>:
  }
  code.1851 = code;
  code = code.1851 + 1;
  *code.1851 = 3;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35700>; else goto <D.35701>;
  <D.35700>:
  code.1852 = code;
  code = code.1852 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1852 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1853 = code;
        code = code.1853 + 1;
        D.35704 = imb.b[0];
        *code.1853 = D.35704;
        code.1854 = code;
        code = code.1854 + 1;
        D.35706 = imb.b[1];
        *code.1854 = D.35706;
        code.1855 = code;
        code = code.1855 + 1;
        D.35708 = imb.b[2];
        *code.1855 = D.35708;
        code.1856 = code;
        code = code.1856 + 1;
        D.35710 = imb.b[3];
        *code.1856 = D.35710;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35711>;
  <D.35701>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35712>; else goto <D.35713>;
  <D.35712>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35714>; else goto <D.35715>;
  <D.35714>:
  code.1857 = code;
  code = code.1857 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1857 = D.32056;
  code.1858 = code;
  code = code.1858 + 1;
  *code.1858 = 36;
  goto <D.35718>;
  <D.35715>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35719>; else goto <D.35720>;
  <D.35719>:
  code.1859 = code;
  code = code.1859 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1859 = D.32063;
  code.1860 = code;
  code = code.1860 + 1;
  *code.1860 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35723>;
  <D.35720>:
  code.1861 = code;
  code = code.1861 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1861 = D.32068;
  code.1862 = code;
  code = code.1862 + 1;
  *code.1862 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1863 = code;
        code = code.1863 + 1;
        D.35727 = imb.b[0];
        *code.1863 = D.35727;
        code.1864 = code;
        code = code.1864 + 1;
        D.35729 = imb.b[1];
        *code.1864 = D.35729;
        code.1865 = code;
        code = code.1865 + 1;
        D.35731 = imb.b[2];
        *code.1865 = D.35731;
        code.1866 = code;
        code = code.1866 + 1;
        D.35733 = imb.b[3];
        *code.1866 = D.35733;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35723>:
  <D.35718>:
  goto <D.25688>;
  <D.35713>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35734>; else goto <D.35735>;
  <D.35734>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35736>; else goto <D.35737>;
  <D.35736>:
  code.1867 = code;
  code = code.1867 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1867 = D.33927;
  goto <D.25688>;
  <D.35737>:
  <D.35735>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35739>; else goto <D.35740>;
  <D.35739>:
  code.1868 = code;
  code = code.1868 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1868 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35742>;
  <D.35740>:
  code.1869 = code;
  code = code.1869 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1869 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1870 = code;
        code = code.1870 + 1;
        D.35745 = imb.b[0];
        *code.1870 = D.35745;
        code.1871 = code;
        code = code.1871 + 1;
        D.35747 = imb.b[1];
        *code.1871 = D.35747;
        code.1872 = code;
        code = code.1872 + 1;
        D.35749 = imb.b[2];
        *code.1872 = D.35749;
        code.1873 = code;
        code = code.1873 + 1;
        D.35751 = imb.b[3];
        *code.1873 = D.35751;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35742>:
  <D.25688>:
  <D.35711>:
  goto <D.25197>;
  <D.25690>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35753>; else goto <D.35754>;
    <D.35753>:
    iftmp.1874 = 12;
    goto <D.35755>;
    <D.35754>:
    iftmp.1874 = 8;
    <D.35755>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35756 = iftmp.1874 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35756;
    if (_amd64_rex_bits != 0) goto <D.35757>; else goto <D.35758>;
    <D.35757>:
    code.1875 = code;
    code = code.1875 + 1;
    D.35760 = _amd64_rex_bits | 64;
    *code.1875 = D.35760;
    <D.35758>:
  }
  code.1876 = code;
  code = code.1876 + 1;
  *code.1876 = 43;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35762>; else goto <D.35763>;
  <D.35762>:
  code.1877 = code;
  code = code.1877 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1877 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1878 = code;
        code = code.1878 + 1;
        D.35766 = imb.b[0];
        *code.1878 = D.35766;
        code.1879 = code;
        code = code.1879 + 1;
        D.35768 = imb.b[1];
        *code.1879 = D.35768;
        code.1880 = code;
        code = code.1880 + 1;
        D.35770 = imb.b[2];
        *code.1880 = D.35770;
        code.1881 = code;
        code = code.1881 + 1;
        D.35772 = imb.b[3];
        *code.1881 = D.35772;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35773>;
  <D.35763>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35774>; else goto <D.35775>;
  <D.35774>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35776>; else goto <D.35777>;
  <D.35776>:
  code.1882 = code;
  code = code.1882 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1882 = D.32056;
  code.1883 = code;
  code = code.1883 + 1;
  *code.1883 = 36;
  goto <D.35780>;
  <D.35777>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35781>; else goto <D.35782>;
  <D.35781>:
  code.1884 = code;
  code = code.1884 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1884 = D.32063;
  code.1885 = code;
  code = code.1885 + 1;
  *code.1885 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35785>;
  <D.35782>:
  code.1886 = code;
  code = code.1886 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1886 = D.32068;
  code.1887 = code;
  code = code.1887 + 1;
  *code.1887 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1888 = code;
        code = code.1888 + 1;
        D.35789 = imb.b[0];
        *code.1888 = D.35789;
        code.1889 = code;
        code = code.1889 + 1;
        D.35791 = imb.b[1];
        *code.1889 = D.35791;
        code.1890 = code;
        code = code.1890 + 1;
        D.35793 = imb.b[2];
        *code.1890 = D.35793;
        code.1891 = code;
        code = code.1891 + 1;
        D.35795 = imb.b[3];
        *code.1891 = D.35795;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35785>:
  <D.35780>:
  goto <D.25694>;
  <D.35775>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35796>; else goto <D.35797>;
  <D.35796>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35798>; else goto <D.35799>;
  <D.35798>:
  code.1892 = code;
  code = code.1892 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1892 = D.33927;
  goto <D.25694>;
  <D.35799>:
  <D.35797>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35801>; else goto <D.35802>;
  <D.35801>:
  code.1893 = code;
  code = code.1893 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1893 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35804>;
  <D.35802>:
  code.1894 = code;
  code = code.1894 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1894 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1895 = code;
        code = code.1895 + 1;
        D.35807 = imb.b[0];
        *code.1895 = D.35807;
        code.1896 = code;
        code = code.1896 + 1;
        D.35809 = imb.b[1];
        *code.1896 = D.35809;
        code.1897 = code;
        code = code.1897 + 1;
        D.35811 = imb.b[2];
        *code.1897 = D.35811;
        code.1898 = code;
        code = code.1898 + 1;
        D.35813 = imb.b[3];
        *code.1898 = D.35813;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35804>:
  <D.25694>:
  <D.35773>:
  goto <D.25197>;
  <D.25696>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35815>; else goto <D.35816>;
    <D.35815>:
    iftmp.1899 = 12;
    goto <D.35817>;
    <D.35816>:
    iftmp.1899 = 8;
    <D.35817>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35818 = iftmp.1899 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35818;
    if (_amd64_rex_bits != 0) goto <D.35819>; else goto <D.35820>;
    <D.35819>:
    code.1900 = code;
    code = code.1900 + 1;
    D.35822 = _amd64_rex_bits | 64;
    *code.1900 = D.35822;
    <D.35820>:
  }
  code.1901 = code;
  code = code.1901 + 1;
  *code.1901 = 35;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35824>; else goto <D.35825>;
  <D.35824>:
  code.1902 = code;
  code = code.1902 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1902 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1903 = code;
        code = code.1903 + 1;
        D.35828 = imb.b[0];
        *code.1903 = D.35828;
        code.1904 = code;
        code = code.1904 + 1;
        D.35830 = imb.b[1];
        *code.1904 = D.35830;
        code.1905 = code;
        code = code.1905 + 1;
        D.35832 = imb.b[2];
        *code.1905 = D.35832;
        code.1906 = code;
        code = code.1906 + 1;
        D.35834 = imb.b[3];
        *code.1906 = D.35834;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35835>;
  <D.35825>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35836>; else goto <D.35837>;
  <D.35836>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35838>; else goto <D.35839>;
  <D.35838>:
  code.1907 = code;
  code = code.1907 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1907 = D.32056;
  code.1908 = code;
  code = code.1908 + 1;
  *code.1908 = 36;
  goto <D.35842>;
  <D.35839>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35843>; else goto <D.35844>;
  <D.35843>:
  code.1909 = code;
  code = code.1909 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1909 = D.32063;
  code.1910 = code;
  code = code.1910 + 1;
  *code.1910 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35847>;
  <D.35844>:
  code.1911 = code;
  code = code.1911 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1911 = D.32068;
  code.1912 = code;
  code = code.1912 + 1;
  *code.1912 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1913 = code;
        code = code.1913 + 1;
        D.35851 = imb.b[0];
        *code.1913 = D.35851;
        code.1914 = code;
        code = code.1914 + 1;
        D.35853 = imb.b[1];
        *code.1914 = D.35853;
        code.1915 = code;
        code = code.1915 + 1;
        D.35855 = imb.b[2];
        *code.1915 = D.35855;
        code.1916 = code;
        code = code.1916 + 1;
        D.35857 = imb.b[3];
        *code.1916 = D.35857;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35847>:
  <D.35842>:
  goto <D.25700>;
  <D.35837>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35858>; else goto <D.35859>;
  <D.35858>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35860>; else goto <D.35861>;
  <D.35860>:
  code.1917 = code;
  code = code.1917 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1917 = D.33927;
  goto <D.25700>;
  <D.35861>:
  <D.35859>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35863>; else goto <D.35864>;
  <D.35863>:
  code.1918 = code;
  code = code.1918 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1918 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35866>;
  <D.35864>:
  code.1919 = code;
  code = code.1919 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1919 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1920 = code;
        code = code.1920 + 1;
        D.35869 = imb.b[0];
        *code.1920 = D.35869;
        code.1921 = code;
        code = code.1921 + 1;
        D.35871 = imb.b[1];
        *code.1921 = D.35871;
        code.1922 = code;
        code = code.1922 + 1;
        D.35873 = imb.b[2];
        *code.1922 = D.35873;
        code.1923 = code;
        code = code.1923 + 1;
        D.35875 = imb.b[3];
        *code.1923 = D.35875;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35866>:
  <D.25700>:
  <D.35835>:
  goto <D.25197>;
  <D.25702>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35877>; else goto <D.35878>;
    <D.35877>:
    iftmp.1924 = 12;
    goto <D.35879>;
    <D.35878>:
    iftmp.1924 = 8;
    <D.35879>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35880 = iftmp.1924 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35880;
    if (_amd64_rex_bits != 0) goto <D.35881>; else goto <D.35882>;
    <D.35881>:
    code.1925 = code;
    code = code.1925 + 1;
    D.35884 = _amd64_rex_bits | 64;
    *code.1925 = D.35884;
    <D.35882>:
  }
  code.1926 = code;
  code = code.1926 + 1;
  *code.1926 = 11;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35886>; else goto <D.35887>;
  <D.35886>:
  code.1927 = code;
  code = code.1927 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1927 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1928 = code;
        code = code.1928 + 1;
        D.35890 = imb.b[0];
        *code.1928 = D.35890;
        code.1929 = code;
        code = code.1929 + 1;
        D.35892 = imb.b[1];
        *code.1929 = D.35892;
        code.1930 = code;
        code = code.1930 + 1;
        D.35894 = imb.b[2];
        *code.1930 = D.35894;
        code.1931 = code;
        code = code.1931 + 1;
        D.35896 = imb.b[3];
        *code.1931 = D.35896;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35897>;
  <D.35887>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35898>; else goto <D.35899>;
  <D.35898>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35900>; else goto <D.35901>;
  <D.35900>:
  code.1932 = code;
  code = code.1932 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1932 = D.32056;
  code.1933 = code;
  code = code.1933 + 1;
  *code.1933 = 36;
  goto <D.35904>;
  <D.35901>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35905>; else goto <D.35906>;
  <D.35905>:
  code.1934 = code;
  code = code.1934 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1934 = D.32063;
  code.1935 = code;
  code = code.1935 + 1;
  *code.1935 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35909>;
  <D.35906>:
  code.1936 = code;
  code = code.1936 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1936 = D.32068;
  code.1937 = code;
  code = code.1937 + 1;
  *code.1937 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1938 = code;
        code = code.1938 + 1;
        D.35913 = imb.b[0];
        *code.1938 = D.35913;
        code.1939 = code;
        code = code.1939 + 1;
        D.35915 = imb.b[1];
        *code.1939 = D.35915;
        code.1940 = code;
        code = code.1940 + 1;
        D.35917 = imb.b[2];
        *code.1940 = D.35917;
        code.1941 = code;
        code = code.1941 + 1;
        D.35919 = imb.b[3];
        *code.1941 = D.35919;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35909>:
  <D.35904>:
  goto <D.25706>;
  <D.35899>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35920>; else goto <D.35921>;
  <D.35920>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35922>; else goto <D.35923>;
  <D.35922>:
  code.1942 = code;
  code = code.1942 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1942 = D.33927;
  goto <D.25706>;
  <D.35923>:
  <D.35921>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35925>; else goto <D.35926>;
  <D.35925>:
  code.1943 = code;
  code = code.1943 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1943 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35928>;
  <D.35926>:
  code.1944 = code;
  code = code.1944 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1944 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1945 = code;
        code = code.1945 + 1;
        D.35931 = imb.b[0];
        *code.1945 = D.35931;
        code.1946 = code;
        code = code.1946 + 1;
        D.35933 = imb.b[1];
        *code.1946 = D.35933;
        code.1947 = code;
        code = code.1947 + 1;
        D.35935 = imb.b[2];
        *code.1947 = D.35935;
        code.1948 = code;
        code = code.1948 + 1;
        D.35937 = imb.b[3];
        *code.1948 = D.35937;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35928>:
  <D.25706>:
  <D.35897>:
  goto <D.25197>;
  <D.25708>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.35939>; else goto <D.35940>;
    <D.35939>:
    iftmp.1949 = 12;
    goto <D.35941>;
    <D.35940>:
    iftmp.1949 = 8;
    <D.35941>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.35942 = iftmp.1949 | D.33811;
    _amd64_rex_bits = (unsigned char) D.35942;
    if (_amd64_rex_bits != 0) goto <D.35943>; else goto <D.35944>;
    <D.35943>:
    code.1950 = code;
    code = code.1950 + 1;
    D.35946 = _amd64_rex_bits | 64;
    *code.1950 = D.35946;
    <D.35944>:
  }
  code.1951 = code;
  code = code.1951 + 1;
  *code.1951 = 51;
  D.31490 = ins->sreg2;
  if (D.31490 == 16) goto <D.35948>; else goto <D.35949>;
  <D.35948>:
  code.1952 = code;
  code = code.1952 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.1952 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1953 = code;
        code = code.1953 + 1;
        D.35952 = imb.b[0];
        *code.1953 = D.35952;
        code.1954 = code;
        code = code.1954 + 1;
        D.35954 = imb.b[1];
        *code.1954 = D.35954;
        code.1955 = code;
        code = code.1955 + 1;
        D.35956 = imb.b[2];
        *code.1955 = D.35956;
        code.1956 = code;
        code = code.1956 + 1;
        D.35958 = imb.b[3];
        *code.1956 = D.35958;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.35959>;
  <D.35949>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 == 4) goto <D.35960>; else goto <D.35961>;
  <D.35960>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35962>; else goto <D.35963>;
  <D.35962>:
  code.1957 = code;
  code = code.1957 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.1957 = D.32056;
  code.1958 = code;
  code = code.1958 + 1;
  *code.1958 = 36;
  goto <D.35966>;
  <D.35963>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35967>; else goto <D.35968>;
  <D.35967>:
  code.1959 = code;
  code = code.1959 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.1959 = D.32063;
  code.1960 = code;
  code = code.1960 + 1;
  *code.1960 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35971>;
  <D.35968>:
  code.1961 = code;
  code = code.1961 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.1961 = D.32068;
  code.1962 = code;
  code = code.1962 + 1;
  *code.1962 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1963 = code;
        code = code.1963 + 1;
        D.35975 = imb.b[0];
        *code.1963 = D.35975;
        code.1964 = code;
        code = code.1964 + 1;
        D.35977 = imb.b[1];
        *code.1964 = D.35977;
        code.1965 = code;
        code = code.1965 + 1;
        D.35979 = imb.b[2];
        *code.1965 = D.35979;
        code.1966 = code;
        code = code.1966 + 1;
        D.35981 = imb.b[3];
        *code.1966 = D.35981;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35971>:
  <D.35966>:
  goto <D.25712>;
  <D.35961>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.35982>; else goto <D.35983>;
  <D.35982>:
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  if (D.33671 != 5) goto <D.35984>; else goto <D.35985>;
  <D.35984>:
  code.1967 = code;
  code = code.1967 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33926 = D.32054 | D.31501;
  D.33927 = (unsigned char) D.33926;
  *code.1967 = D.33927;
  goto <D.25712>;
  <D.35985>:
  <D.35983>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.35987>; else goto <D.35988>;
  <D.35987>:
  code.1968 = code;
  code = code.1968 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33931 = D.32088 | D.31501;
  D.33932 = (unsigned char) D.33931;
  *code.1968 = D.33932;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.35990>;
  <D.35988>:
  code.1969 = code;
  code = code.1969 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33935 = D.32093 | D.31501;
  D.33936 = (unsigned char) D.33935;
  *code.1969 = D.33936;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1970 = code;
        code = code.1970 + 1;
        D.35993 = imb.b[0];
        *code.1970 = D.35993;
        code.1971 = code;
        code = code.1971 + 1;
        D.35995 = imb.b[1];
        *code.1971 = D.35995;
        code.1972 = code;
        code = code.1972 + 1;
        D.35997 = imb.b[2];
        *code.1972 = D.35997;
        code.1973 = code;
        code = code.1973 + 1;
        D.35999 = imb.b[3];
        *code.1973 = D.35999;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.35990>:
  <D.25712>:
  <D.35959>:
  goto <D.25197>;
  <D.25714>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.36001>; else goto <D.36002>;
    <D.36001>:
    iftmp.1974 = 12;
    goto <D.36003>;
    <D.36002>:
    iftmp.1974 = 8;
    <D.36003>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.36004 = iftmp.1974 | D.33180;
    _amd64_rex_bits = (unsigned char) D.36004;
    if (_amd64_rex_bits != 0) goto <D.36005>; else goto <D.36006>;
    <D.36005>:
    code.1975 = code;
    code = code.1975 + 1;
    D.36008 = _amd64_rex_bits | 64;
    *code.1975 = D.36008;
    <D.36006>:
  }
  code.1976 = code;
  code = code.1976 + 1;
  *code.1976 = 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36010>; else goto <D.36011>;
  <D.36010>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36012>; else goto <D.36013>;
  <D.36012>:
  code.1977 = code;
  code = code.1977 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1977 = D.34812;
  code.1978 = code;
  code = code.1978 + 1;
  *code.1978 = 36;
  goto <D.36016>;
  <D.36013>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36017>; else goto <D.36018>;
  <D.36017>:
  code.1979 = code;
  code = code.1979 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1979 = D.34819;
  code.1980 = code;
  code = code.1980 + 1;
  *code.1980 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36021>;
  <D.36018>:
  code.1981 = code;
  code = code.1981 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.1981 = D.34824;
  code.1982 = code;
  code = code.1982 + 1;
  *code.1982 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1983 = code;
        code = code.1983 + 1;
        D.36025 = imb.b[0];
        *code.1983 = D.36025;
        code.1984 = code;
        code = code.1984 + 1;
        D.36027 = imb.b[1];
        *code.1984 = D.36027;
        code.1985 = code;
        code = code.1985 + 1;
        D.36029 = imb.b[2];
        *code.1985 = D.36029;
        code.1986 = code;
        code = code.1986 + 1;
        D.36031 = imb.b[3];
        *code.1986 = D.36031;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36021>:
  <D.36016>:
  goto <D.25717>;
  <D.36011>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36032>; else goto <D.36033>;
  <D.36032>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36034>; else goto <D.36035>;
  <D.36034>:
  code.1987 = code;
  code = code.1987 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.1987 = D.33690;
  goto <D.25717>;
  <D.36035>:
  <D.36033>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36037>; else goto <D.36038>;
  <D.36037>:
  code.1988 = code;
  code = code.1988 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.1988 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36040>;
  <D.36038>:
  code.1989 = code;
  code = code.1989 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.1989 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.1990 = code;
        code = code.1990 + 1;
        D.36043 = imb.b[0];
        *code.1990 = D.36043;
        code.1991 = code;
        code = code.1991 + 1;
        D.36045 = imb.b[1];
        *code.1991 = D.36045;
        code.1992 = code;
        code = code.1992 + 1;
        D.36047 = imb.b[2];
        *code.1992 = D.36047;
        code.1993 = code;
        code = code.1993 + 1;
        D.36049 = imb.b[3];
        *code.1993 = D.36049;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36040>:
  <D.25717>:
  goto <D.25197>;
  <D.25719>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.36051>; else goto <D.36052>;
    <D.36051>:
    iftmp.1994 = 12;
    goto <D.36053>;
    <D.36052>:
    iftmp.1994 = 8;
    <D.36053>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.36054 = iftmp.1994 | D.33180;
    _amd64_rex_bits = (unsigned char) D.36054;
    if (_amd64_rex_bits != 0) goto <D.36055>; else goto <D.36056>;
    <D.36055>:
    code.1995 = code;
    code = code.1995 + 1;
    D.36058 = _amd64_rex_bits | 64;
    *code.1995 = D.36058;
    <D.36056>:
  }
  code.1996 = code;
  code = code.1996 + 1;
  *code.1996 = 41;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36060>; else goto <D.36061>;
  <D.36060>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36062>; else goto <D.36063>;
  <D.36062>:
  code.1997 = code;
  code = code.1997 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.1997 = D.34812;
  code.1998 = code;
  code = code.1998 + 1;
  *code.1998 = 36;
  goto <D.36066>;
  <D.36063>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36067>; else goto <D.36068>;
  <D.36067>:
  code.1999 = code;
  code = code.1999 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.1999 = D.34819;
  code.2000 = code;
  code = code.2000 + 1;
  *code.2000 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36071>;
  <D.36068>:
  code.2001 = code;
  code = code.2001 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.2001 = D.34824;
  code.2002 = code;
  code = code.2002 + 1;
  *code.2002 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2003 = code;
        code = code.2003 + 1;
        D.36075 = imb.b[0];
        *code.2003 = D.36075;
        code.2004 = code;
        code = code.2004 + 1;
        D.36077 = imb.b[1];
        *code.2004 = D.36077;
        code.2005 = code;
        code = code.2005 + 1;
        D.36079 = imb.b[2];
        *code.2005 = D.36079;
        code.2006 = code;
        code = code.2006 + 1;
        D.36081 = imb.b[3];
        *code.2006 = D.36081;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36071>:
  <D.36066>:
  goto <D.25722>;
  <D.36061>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36082>; else goto <D.36083>;
  <D.36082>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36084>; else goto <D.36085>;
  <D.36084>:
  code.2007 = code;
  code = code.2007 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.2007 = D.33690;
  goto <D.25722>;
  <D.36085>:
  <D.36083>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36087>; else goto <D.36088>;
  <D.36087>:
  code.2008 = code;
  code = code.2008 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.2008 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36090>;
  <D.36088>:
  code.2009 = code;
  code = code.2009 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.2009 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2010 = code;
        code = code.2010 + 1;
        D.36093 = imb.b[0];
        *code.2010 = D.36093;
        code.2011 = code;
        code = code.2011 + 1;
        D.36095 = imb.b[1];
        *code.2011 = D.36095;
        code.2012 = code;
        code = code.2012 + 1;
        D.36097 = imb.b[2];
        *code.2012 = D.36097;
        code.2013 = code;
        code = code.2013 + 1;
        D.36099 = imb.b[3];
        *code.2013 = D.36099;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36090>:
  <D.25722>:
  goto <D.25197>;
  <D.25724>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.36101>; else goto <D.36102>;
    <D.36101>:
    iftmp.2014 = 12;
    goto <D.36103>;
    <D.36102>:
    iftmp.2014 = 8;
    <D.36103>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.36104 = iftmp.2014 | D.33180;
    _amd64_rex_bits = (unsigned char) D.36104;
    if (_amd64_rex_bits != 0) goto <D.36105>; else goto <D.36106>;
    <D.36105>:
    code.2015 = code;
    code = code.2015 + 1;
    D.36108 = _amd64_rex_bits | 64;
    *code.2015 = D.36108;
    <D.36106>:
  }
  code.2016 = code;
  code = code.2016 + 1;
  *code.2016 = 33;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36110>; else goto <D.36111>;
  <D.36110>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36112>; else goto <D.36113>;
  <D.36112>:
  code.2017 = code;
  code = code.2017 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.2017 = D.34812;
  code.2018 = code;
  code = code.2018 + 1;
  *code.2018 = 36;
  goto <D.36116>;
  <D.36113>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36117>; else goto <D.36118>;
  <D.36117>:
  code.2019 = code;
  code = code.2019 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.2019 = D.34819;
  code.2020 = code;
  code = code.2020 + 1;
  *code.2020 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36121>;
  <D.36118>:
  code.2021 = code;
  code = code.2021 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.2021 = D.34824;
  code.2022 = code;
  code = code.2022 + 1;
  *code.2022 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2023 = code;
        code = code.2023 + 1;
        D.36125 = imb.b[0];
        *code.2023 = D.36125;
        code.2024 = code;
        code = code.2024 + 1;
        D.36127 = imb.b[1];
        *code.2024 = D.36127;
        code.2025 = code;
        code = code.2025 + 1;
        D.36129 = imb.b[2];
        *code.2025 = D.36129;
        code.2026 = code;
        code = code.2026 + 1;
        D.36131 = imb.b[3];
        *code.2026 = D.36131;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36121>:
  <D.36116>:
  goto <D.25727>;
  <D.36111>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36132>; else goto <D.36133>;
  <D.36132>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36134>; else goto <D.36135>;
  <D.36134>:
  code.2027 = code;
  code = code.2027 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.2027 = D.33690;
  goto <D.25727>;
  <D.36135>:
  <D.36133>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36137>; else goto <D.36138>;
  <D.36137>:
  code.2028 = code;
  code = code.2028 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.2028 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36140>;
  <D.36138>:
  code.2029 = code;
  code = code.2029 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.2029 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2030 = code;
        code = code.2030 + 1;
        D.36143 = imb.b[0];
        *code.2030 = D.36143;
        code.2031 = code;
        code = code.2031 + 1;
        D.36145 = imb.b[1];
        *code.2031 = D.36145;
        code.2032 = code;
        code = code.2032 + 1;
        D.36147 = imb.b[2];
        *code.2032 = D.36147;
        code.2033 = code;
        code = code.2033 + 1;
        D.36149 = imb.b[3];
        *code.2033 = D.36149;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36140>:
  <D.25727>:
  goto <D.25197>;
  <D.25729>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.36151>; else goto <D.36152>;
    <D.36151>:
    iftmp.2034 = 12;
    goto <D.36153>;
    <D.36152>:
    iftmp.2034 = 8;
    <D.36153>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.36154 = iftmp.2034 | D.33180;
    _amd64_rex_bits = (unsigned char) D.36154;
    if (_amd64_rex_bits != 0) goto <D.36155>; else goto <D.36156>;
    <D.36155>:
    code.2035 = code;
    code = code.2035 + 1;
    D.36158 = _amd64_rex_bits | 64;
    *code.2035 = D.36158;
    <D.36156>:
  }
  code.2036 = code;
  code = code.2036 + 1;
  *code.2036 = 9;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36160>; else goto <D.36161>;
  <D.36160>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36162>; else goto <D.36163>;
  <D.36162>:
  code.2037 = code;
  code = code.2037 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.2037 = D.34812;
  code.2038 = code;
  code = code.2038 + 1;
  *code.2038 = 36;
  goto <D.36166>;
  <D.36163>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36167>; else goto <D.36168>;
  <D.36167>:
  code.2039 = code;
  code = code.2039 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.2039 = D.34819;
  code.2040 = code;
  code = code.2040 + 1;
  *code.2040 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36171>;
  <D.36168>:
  code.2041 = code;
  code = code.2041 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.2041 = D.34824;
  code.2042 = code;
  code = code.2042 + 1;
  *code.2042 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2043 = code;
        code = code.2043 + 1;
        D.36175 = imb.b[0];
        *code.2043 = D.36175;
        code.2044 = code;
        code = code.2044 + 1;
        D.36177 = imb.b[1];
        *code.2044 = D.36177;
        code.2045 = code;
        code = code.2045 + 1;
        D.36179 = imb.b[2];
        *code.2045 = D.36179;
        code.2046 = code;
        code = code.2046 + 1;
        D.36181 = imb.b[3];
        *code.2046 = D.36181;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36171>:
  <D.36166>:
  goto <D.25732>;
  <D.36161>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36182>; else goto <D.36183>;
  <D.36182>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36184>; else goto <D.36185>;
  <D.36184>:
  code.2047 = code;
  code = code.2047 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.2047 = D.33690;
  goto <D.25732>;
  <D.36185>:
  <D.36183>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36187>; else goto <D.36188>;
  <D.36187>:
  code.2048 = code;
  code = code.2048 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.2048 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36190>;
  <D.36188>:
  code.2049 = code;
  code = code.2049 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.2049 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2050 = code;
        code = code.2050 + 1;
        D.36193 = imb.b[0];
        *code.2050 = D.36193;
        code.2051 = code;
        code = code.2051 + 1;
        D.36195 = imb.b[1];
        *code.2051 = D.36195;
        code.2052 = code;
        code = code.2052 + 1;
        D.36197 = imb.b[2];
        *code.2052 = D.36197;
        code.2053 = code;
        code = code.2053 + 1;
        D.36199 = imb.b[3];
        *code.2053 = D.36199;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36190>:
  <D.25732>:
  goto <D.25197>;
  <D.25734>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.36201>; else goto <D.36202>;
    <D.36201>:
    iftmp.2054 = 12;
    goto <D.36203>;
    <D.36202>:
    iftmp.2054 = 8;
    <D.36203>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.36204 = iftmp.2054 | D.33180;
    _amd64_rex_bits = (unsigned char) D.36204;
    if (_amd64_rex_bits != 0) goto <D.36205>; else goto <D.36206>;
    <D.36205>:
    code.2055 = code;
    code = code.2055 + 1;
    D.36208 = _amd64_rex_bits | 64;
    *code.2055 = D.36208;
    <D.36206>:
  }
  code.2056 = code;
  code = code.2056 + 1;
  *code.2056 = 49;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36210>; else goto <D.36211>;
  <D.36210>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36212>; else goto <D.36213>;
  <D.36212>:
  code.2057 = code;
  code = code.2057 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34811 = D.33673 | 4;
  D.34812 = (unsigned char) D.34811;
  *code.2057 = D.34812;
  code.2058 = code;
  code = code.2058 + 1;
  *code.2058 = 36;
  goto <D.36216>;
  <D.36213>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36217>; else goto <D.36218>;
  <D.36217>:
  code.2059 = code;
  code = code.2059 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34818 = D.33673 | 68;
  D.34819 = (unsigned char) D.34818;
  *code.2059 = D.34819;
  code.2060 = code;
  code = code.2060 + 1;
  *code.2060 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36221>;
  <D.36218>:
  code.2061 = code;
  code = code.2061 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34823 = D.33673 | -124;
  D.34824 = (unsigned char) D.34823;
  *code.2061 = D.34824;
  code.2062 = code;
  code = code.2062 + 1;
  *code.2062 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2063 = code;
        code = code.2063 + 1;
        D.36225 = imb.b[0];
        *code.2063 = D.36225;
        code.2064 = code;
        code = code.2064 + 1;
        D.36227 = imb.b[1];
        *code.2064 = D.36227;
        code.2065 = code;
        code = code.2065 + 1;
        D.36229 = imb.b[2];
        *code.2065 = D.36229;
        code.2066 = code;
        code = code.2066 + 1;
        D.36231 = imb.b[3];
        *code.2066 = D.36231;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36221>:
  <D.36216>:
  goto <D.25737>;
  <D.36211>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36232>; else goto <D.36233>;
  <D.36232>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36234>; else goto <D.36235>;
  <D.36234>:
  code.2067 = code;
  code = code.2067 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33689 = D.33673 | D.31571;
  D.33690 = (unsigned char) D.33689;
  *code.2067 = D.33690;
  goto <D.25737>;
  <D.36235>:
  <D.36233>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36237>; else goto <D.36238>;
  <D.36237>:
  code.2068 = code;
  code = code.2068 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34842 = D.33673 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34843 = D.34842 | D.31571;
  D.34844 = (unsigned char) D.34843;
  *code.2068 = D.34844;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36240>;
  <D.36238>:
  code.2069 = code;
  code = code.2069 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.34847 = D.33673 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34848 = D.34847 | D.31571;
  D.34849 = (unsigned char) D.34848;
  *code.2069 = D.34849;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2070 = code;
        code = code.2070 + 1;
        D.36243 = imb.b[0];
        *code.2070 = D.36243;
        code.2071 = code;
        code = code.2071 + 1;
        D.36245 = imb.b[1];
        *code.2071 = D.36245;
        code.2072 = code;
        code = code.2072 + 1;
        D.36247 = imb.b[2];
        *code.2072 = D.36247;
        code.2073 = code;
        code = code.2073 + 1;
        D.36249 = imb.b[3];
        *code.2073 = D.36249;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36240>:
  <D.25737>:
  goto <D.25197>;
  <D.25739>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.36250>; else goto <D.36251>;
  <D.36250>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4276, "amd64_is_imm32 (ins->inst_imm)");
  <D.36251>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.36253>; else goto <D.36254>;
    <D.36253>:
    iftmp.2074 = 9;
    goto <D.36255>;
    <D.36254>:
    iftmp.2074 = 8;
    <D.36255>:
    _amd64_rex_bits = iftmp.2074;
    if (_amd64_rex_bits != 0) goto <D.36256>; else goto <D.36257>;
    <D.36256>:
    code.2075 = code;
    code = code.2075 + 1;
    D.36259 = _amd64_rex_bits | 64;
    *code.2075 = D.36259;
    <D.36257>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.36260>; else goto <D.36261>;
  <D.36260>:
  code.2076 = code;
  code = code.2076 + 1;
  *code.2076 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36263>; else goto <D.36264>;
  <D.36263>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36265>; else goto <D.36266>;
  <D.36265>:
  code.2077 = code;
  code = code.2077 + 1;
  *code.2077 = 4;
  code.2078 = code;
  code = code.2078 + 1;
  *code.2078 = 36;
  goto <D.36269>;
  <D.36266>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36270>; else goto <D.36271>;
  <D.36270>:
  code.2079 = code;
  code = code.2079 + 1;
  *code.2079 = 68;
  code.2080 = code;
  code = code.2080 + 1;
  *code.2080 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36274>;
  <D.36271>:
  code.2081 = code;
  code = code.2081 + 1;
  *code.2081 = 132;
  code.2082 = code;
  code = code.2082 + 1;
  *code.2082 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2083 = code;
        code = code.2083 + 1;
        D.36278 = imb.b[0];
        *code.2083 = D.36278;
        code.2084 = code;
        code = code.2084 + 1;
        D.36280 = imb.b[1];
        *code.2084 = D.36280;
        code.2085 = code;
        code = code.2085 + 1;
        D.36282 = imb.b[2];
        *code.2085 = D.36282;
        code.2086 = code;
        code = code.2086 + 1;
        D.36284 = imb.b[3];
        *code.2086 = D.36284;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36274>:
  <D.36269>:
  goto <D.25742>;
  <D.36264>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36285>; else goto <D.36286>;
  <D.36285>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36287>; else goto <D.36288>;
  <D.36287>:
  code.2087 = code;
  code = code.2087 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  *code.2087 = D.31566;
  goto <D.25742>;
  <D.36288>:
  <D.36286>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36290>; else goto <D.36291>;
  <D.36290>:
  code.2088 = code;
  code = code.2088 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31572 = D.31571 | 64;
  D.31573 = (unsigned char) D.31572;
  *code.2088 = D.31573;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36293>;
  <D.36291>:
  code.2089 = code;
  code = code.2089 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31576 = D.31571 | -128;
  D.31577 = (unsigned char) D.31576;
  *code.2089 = D.31577;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2090 = code;
        code = code.2090 + 1;
        D.36296 = imb.b[0];
        *code.2090 = D.36296;
        code.2091 = code;
        code = code.2091 + 1;
        D.36298 = imb.b[1];
        *code.2091 = D.36298;
        code.2092 = code;
        code = code.2092 + 1;
        D.36300 = imb.b[2];
        *code.2092 = D.36300;
        code.2093 = code;
        code = code.2093 + 1;
        D.36302 = imb.b[3];
        *code.2093 = D.36302;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36293>:
  <D.25742>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.36303>;
  <D.36261>:
  code.2094 = code;
  code = code.2094 + 1;
  *code.2094 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36305>; else goto <D.36306>;
  <D.36305>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36307>; else goto <D.36308>;
  <D.36307>:
  code.2095 = code;
  code = code.2095 + 1;
  *code.2095 = 4;
  code.2096 = code;
  code = code.2096 + 1;
  *code.2096 = 36;
  goto <D.36311>;
  <D.36308>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36312>; else goto <D.36313>;
  <D.36312>:
  code.2097 = code;
  code = code.2097 + 1;
  *code.2097 = 68;
  code.2098 = code;
  code = code.2098 + 1;
  *code.2098 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36316>;
  <D.36313>:
  code.2099 = code;
  code = code.2099 + 1;
  *code.2099 = 132;
  code.2100 = code;
  code = code.2100 + 1;
  *code.2100 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2101 = code;
        code = code.2101 + 1;
        D.36320 = imb.b[0];
        *code.2101 = D.36320;
        code.2102 = code;
        code = code.2102 + 1;
        D.36322 = imb.b[1];
        *code.2102 = D.36322;
        code.2103 = code;
        code = code.2103 + 1;
        D.36324 = imb.b[2];
        *code.2103 = D.36324;
        code.2104 = code;
        code = code.2104 + 1;
        D.36326 = imb.b[3];
        *code.2104 = D.36326;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36316>:
  <D.36311>:
  goto <D.25745>;
  <D.36306>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36327>; else goto <D.36328>;
  <D.36327>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36329>; else goto <D.36330>;
  <D.36329>:
  code.2105 = code;
  code = code.2105 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  *code.2105 = D.31566;
  goto <D.25745>;
  <D.36330>:
  <D.36328>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36332>; else goto <D.36333>;
  <D.36332>:
  code.2106 = code;
  code = code.2106 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31572 = D.31571 | 64;
  D.31573 = (unsigned char) D.31572;
  *code.2106 = D.31573;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36335>;
  <D.36333>:
  code.2107 = code;
  code = code.2107 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.31576 = D.31571 | -128;
  D.31577 = (unsigned char) D.31576;
  *code.2107 = D.31577;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2108 = code;
        code = code.2108 + 1;
        D.36338 = imb.b[0];
        *code.2108 = D.36338;
        code.2109 = code;
        code = code.2109 + 1;
        D.36340 = imb.b[1];
        *code.2109 = D.36340;
        code.2110 = code;
        code = code.2110 + 1;
        D.36342 = imb.b[2];
        *code.2110 = D.36342;
        code.2111 = code;
        code = code.2111 + 1;
        D.36344 = imb.b[3];
        *code.2111 = D.36344;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36335>:
  <D.25745>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2112 = code;
        code = code.2112 + 1;
        D.36346 = imb.b[0];
        *code.2112 = D.36346;
        code.2113 = code;
        code = code.2113 + 1;
        D.36348 = imb.b[1];
        *code.2113 = D.36348;
        code.2114 = code;
        code = code.2114 + 1;
        D.36350 = imb.b[2];
        *code.2114 = D.36350;
        code.2115 = code;
        code = code.2115 + 1;
        D.36352 = imb.b[3];
        *code.2115 = D.36352;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36303>:
  goto <D.25197>;
  <D.25748>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.36353>; else goto <D.36354>;
  <D.36353>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4280, "amd64_is_imm32 (ins->inst_imm)");
  <D.36354>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.36356>; else goto <D.36357>;
    <D.36356>:
    iftmp.2116 = 9;
    goto <D.36358>;
    <D.36357>:
    iftmp.2116 = 8;
    <D.36358>:
    _amd64_rex_bits = iftmp.2116;
    if (_amd64_rex_bits != 0) goto <D.36359>; else goto <D.36360>;
    <D.36359>:
    code.2117 = code;
    code = code.2117 + 1;
    D.36362 = _amd64_rex_bits | 64;
    *code.2117 = D.36362;
    <D.36360>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.36363>; else goto <D.36364>;
  <D.36363>:
  code.2118 = code;
  code = code.2118 + 1;
  *code.2118 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36366>; else goto <D.36367>;
  <D.36366>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36368>; else goto <D.36369>;
  <D.36368>:
  code.2119 = code;
  code = code.2119 + 1;
  *code.2119 = 44;
  code.2120 = code;
  code = code.2120 + 1;
  *code.2120 = 36;
  goto <D.36372>;
  <D.36369>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36373>; else goto <D.36374>;
  <D.36373>:
  code.2121 = code;
  code = code.2121 + 1;
  *code.2121 = 108;
  code.2122 = code;
  code = code.2122 + 1;
  *code.2122 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36377>;
  <D.36374>:
  code.2123 = code;
  code = code.2123 + 1;
  *code.2123 = 172;
  code.2124 = code;
  code = code.2124 + 1;
  *code.2124 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2125 = code;
        code = code.2125 + 1;
        D.36381 = imb.b[0];
        *code.2125 = D.36381;
        code.2126 = code;
        code = code.2126 + 1;
        D.36383 = imb.b[1];
        *code.2126 = D.36383;
        code.2127 = code;
        code = code.2127 + 1;
        D.36385 = imb.b[2];
        *code.2127 = D.36385;
        code.2128 = code;
        code = code.2128 + 1;
        D.36387 = imb.b[3];
        *code.2128 = D.36387;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36377>:
  <D.36372>:
  goto <D.25751>;
  <D.36367>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36388>; else goto <D.36389>;
  <D.36388>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36390>; else goto <D.36391>;
  <D.36390>:
  code.2129 = code;
  code = code.2129 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34412 = D.31571 | 40;
  D.34413 = (unsigned char) D.34412;
  *code.2129 = D.34413;
  goto <D.25751>;
  <D.36391>:
  <D.36389>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36393>; else goto <D.36394>;
  <D.36393>:
  code.2130 = code;
  code = code.2130 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34417 = D.31571 | 104;
  D.34418 = (unsigned char) D.34417;
  *code.2130 = D.34418;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36396>;
  <D.36394>:
  code.2131 = code;
  code = code.2131 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34421 = D.31571 | -88;
  D.34422 = (unsigned char) D.34421;
  *code.2131 = D.34422;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2132 = code;
        code = code.2132 + 1;
        D.36399 = imb.b[0];
        *code.2132 = D.36399;
        code.2133 = code;
        code = code.2133 + 1;
        D.36401 = imb.b[1];
        *code.2133 = D.36401;
        code.2134 = code;
        code = code.2134 + 1;
        D.36403 = imb.b[2];
        *code.2134 = D.36403;
        code.2135 = code;
        code = code.2135 + 1;
        D.36405 = imb.b[3];
        *code.2135 = D.36405;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36396>:
  <D.25751>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.36406>;
  <D.36364>:
  code.2136 = code;
  code = code.2136 + 1;
  *code.2136 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36408>; else goto <D.36409>;
  <D.36408>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36410>; else goto <D.36411>;
  <D.36410>:
  code.2137 = code;
  code = code.2137 + 1;
  *code.2137 = 44;
  code.2138 = code;
  code = code.2138 + 1;
  *code.2138 = 36;
  goto <D.36414>;
  <D.36411>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36415>; else goto <D.36416>;
  <D.36415>:
  code.2139 = code;
  code = code.2139 + 1;
  *code.2139 = 108;
  code.2140 = code;
  code = code.2140 + 1;
  *code.2140 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36419>;
  <D.36416>:
  code.2141 = code;
  code = code.2141 + 1;
  *code.2141 = 172;
  code.2142 = code;
  code = code.2142 + 1;
  *code.2142 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2143 = code;
        code = code.2143 + 1;
        D.36423 = imb.b[0];
        *code.2143 = D.36423;
        code.2144 = code;
        code = code.2144 + 1;
        D.36425 = imb.b[1];
        *code.2144 = D.36425;
        code.2145 = code;
        code = code.2145 + 1;
        D.36427 = imb.b[2];
        *code.2145 = D.36427;
        code.2146 = code;
        code = code.2146 + 1;
        D.36429 = imb.b[3];
        *code.2146 = D.36429;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36419>:
  <D.36414>:
  goto <D.25754>;
  <D.36409>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36430>; else goto <D.36431>;
  <D.36430>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36432>; else goto <D.36433>;
  <D.36432>:
  code.2147 = code;
  code = code.2147 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34412 = D.31571 | 40;
  D.34413 = (unsigned char) D.34412;
  *code.2147 = D.34413;
  goto <D.25754>;
  <D.36433>:
  <D.36431>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36435>; else goto <D.36436>;
  <D.36435>:
  code.2148 = code;
  code = code.2148 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34417 = D.31571 | 104;
  D.34418 = (unsigned char) D.34417;
  *code.2148 = D.34418;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36438>;
  <D.36436>:
  code.2149 = code;
  code = code.2149 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34421 = D.31571 | -88;
  D.34422 = (unsigned char) D.34421;
  *code.2149 = D.34422;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2150 = code;
        code = code.2150 + 1;
        D.36441 = imb.b[0];
        *code.2150 = D.36441;
        code.2151 = code;
        code = code.2151 + 1;
        D.36443 = imb.b[1];
        *code.2151 = D.36443;
        code.2152 = code;
        code = code.2152 + 1;
        D.36445 = imb.b[2];
        *code.2152 = D.36445;
        code.2153 = code;
        code = code.2153 + 1;
        D.36447 = imb.b[3];
        *code.2153 = D.36447;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36438>:
  <D.25754>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2154 = code;
        code = code.2154 + 1;
        D.36449 = imb.b[0];
        *code.2154 = D.36449;
        code.2155 = code;
        code = code.2155 + 1;
        D.36451 = imb.b[1];
        *code.2155 = D.36451;
        code.2156 = code;
        code = code.2156 + 1;
        D.36453 = imb.b[2];
        *code.2156 = D.36453;
        code.2157 = code;
        code = code.2157 + 1;
        D.36455 = imb.b[3];
        *code.2157 = D.36455;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36406>:
  goto <D.25197>;
  <D.25757>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.36456>; else goto <D.36457>;
  <D.36456>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4284, "amd64_is_imm32 (ins->inst_imm)");
  <D.36457>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.36459>; else goto <D.36460>;
    <D.36459>:
    iftmp.2158 = 9;
    goto <D.36461>;
    <D.36460>:
    iftmp.2158 = 8;
    <D.36461>:
    _amd64_rex_bits = iftmp.2158;
    if (_amd64_rex_bits != 0) goto <D.36462>; else goto <D.36463>;
    <D.36462>:
    code.2159 = code;
    code = code.2159 + 1;
    D.36465 = _amd64_rex_bits | 64;
    *code.2159 = D.36465;
    <D.36463>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.36466>; else goto <D.36467>;
  <D.36466>:
  code.2160 = code;
  code = code.2160 + 1;
  *code.2160 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36469>; else goto <D.36470>;
  <D.36469>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36471>; else goto <D.36472>;
  <D.36471>:
  code.2161 = code;
  code = code.2161 + 1;
  *code.2161 = 36;
  code.2162 = code;
  code = code.2162 + 1;
  *code.2162 = 36;
  goto <D.36475>;
  <D.36472>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36476>; else goto <D.36477>;
  <D.36476>:
  code.2163 = code;
  code = code.2163 + 1;
  *code.2163 = 100;
  code.2164 = code;
  code = code.2164 + 1;
  *code.2164 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36480>;
  <D.36477>:
  code.2165 = code;
  code = code.2165 + 1;
  *code.2165 = 164;
  code.2166 = code;
  code = code.2166 + 1;
  *code.2166 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2167 = code;
        code = code.2167 + 1;
        D.36484 = imb.b[0];
        *code.2167 = D.36484;
        code.2168 = code;
        code = code.2168 + 1;
        D.36486 = imb.b[1];
        *code.2168 = D.36486;
        code.2169 = code;
        code = code.2169 + 1;
        D.36488 = imb.b[2];
        *code.2169 = D.36488;
        code.2170 = code;
        code = code.2170 + 1;
        D.36490 = imb.b[3];
        *code.2170 = D.36490;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36480>:
  <D.36475>:
  goto <D.25760>;
  <D.36470>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36491>; else goto <D.36492>;
  <D.36491>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36493>; else goto <D.36494>;
  <D.36493>:
  code.2171 = code;
  code = code.2171 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34517 = D.31571 | 32;
  D.34518 = (unsigned char) D.34517;
  *code.2171 = D.34518;
  goto <D.25760>;
  <D.36494>:
  <D.36492>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36496>; else goto <D.36497>;
  <D.36496>:
  code.2172 = code;
  code = code.2172 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34522 = D.31571 | 96;
  D.34523 = (unsigned char) D.34522;
  *code.2172 = D.34523;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36499>;
  <D.36497>:
  code.2173 = code;
  code = code.2173 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34526 = D.31571 | -96;
  D.34527 = (unsigned char) D.34526;
  *code.2173 = D.34527;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2174 = code;
        code = code.2174 + 1;
        D.36502 = imb.b[0];
        *code.2174 = D.36502;
        code.2175 = code;
        code = code.2175 + 1;
        D.36504 = imb.b[1];
        *code.2175 = D.36504;
        code.2176 = code;
        code = code.2176 + 1;
        D.36506 = imb.b[2];
        *code.2176 = D.36506;
        code.2177 = code;
        code = code.2177 + 1;
        D.36508 = imb.b[3];
        *code.2177 = D.36508;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36499>:
  <D.25760>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.36509>;
  <D.36467>:
  code.2178 = code;
  code = code.2178 + 1;
  *code.2178 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36511>; else goto <D.36512>;
  <D.36511>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36513>; else goto <D.36514>;
  <D.36513>:
  code.2179 = code;
  code = code.2179 + 1;
  *code.2179 = 36;
  code.2180 = code;
  code = code.2180 + 1;
  *code.2180 = 36;
  goto <D.36517>;
  <D.36514>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36518>; else goto <D.36519>;
  <D.36518>:
  code.2181 = code;
  code = code.2181 + 1;
  *code.2181 = 100;
  code.2182 = code;
  code = code.2182 + 1;
  *code.2182 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36522>;
  <D.36519>:
  code.2183 = code;
  code = code.2183 + 1;
  *code.2183 = 164;
  code.2184 = code;
  code = code.2184 + 1;
  *code.2184 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2185 = code;
        code = code.2185 + 1;
        D.36526 = imb.b[0];
        *code.2185 = D.36526;
        code.2186 = code;
        code = code.2186 + 1;
        D.36528 = imb.b[1];
        *code.2186 = D.36528;
        code.2187 = code;
        code = code.2187 + 1;
        D.36530 = imb.b[2];
        *code.2187 = D.36530;
        code.2188 = code;
        code = code.2188 + 1;
        D.36532 = imb.b[3];
        *code.2188 = D.36532;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36522>:
  <D.36517>:
  goto <D.25763>;
  <D.36512>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36533>; else goto <D.36534>;
  <D.36533>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36535>; else goto <D.36536>;
  <D.36535>:
  code.2189 = code;
  code = code.2189 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34517 = D.31571 | 32;
  D.34518 = (unsigned char) D.34517;
  *code.2189 = D.34518;
  goto <D.25763>;
  <D.36536>:
  <D.36534>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36538>; else goto <D.36539>;
  <D.36538>:
  code.2190 = code;
  code = code.2190 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34522 = D.31571 | 96;
  D.34523 = (unsigned char) D.34522;
  *code.2190 = D.34523;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36541>;
  <D.36539>:
  code.2191 = code;
  code = code.2191 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34526 = D.31571 | -96;
  D.34527 = (unsigned char) D.34526;
  *code.2191 = D.34527;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2192 = code;
        code = code.2192 + 1;
        D.36544 = imb.b[0];
        *code.2192 = D.36544;
        code.2193 = code;
        code = code.2193 + 1;
        D.36546 = imb.b[1];
        *code.2193 = D.36546;
        code.2194 = code;
        code = code.2194 + 1;
        D.36548 = imb.b[2];
        *code.2194 = D.36548;
        code.2195 = code;
        code = code.2195 + 1;
        D.36550 = imb.b[3];
        *code.2195 = D.36550;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36541>:
  <D.25763>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2196 = code;
        code = code.2196 + 1;
        D.36552 = imb.b[0];
        *code.2196 = D.36552;
        code.2197 = code;
        code = code.2197 + 1;
        D.36554 = imb.b[1];
        *code.2197 = D.36554;
        code.2198 = code;
        code = code.2198 + 1;
        D.36556 = imb.b[2];
        *code.2198 = D.36556;
        code.2199 = code;
        code = code.2199 + 1;
        D.36558 = imb.b[3];
        *code.2199 = D.36558;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36509>:
  goto <D.25197>;
  <D.25766>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.36559>; else goto <D.36560>;
  <D.36559>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4288, "amd64_is_imm32 (ins->inst_imm)");
  <D.36560>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.36562>; else goto <D.36563>;
    <D.36562>:
    iftmp.2200 = 9;
    goto <D.36564>;
    <D.36563>:
    iftmp.2200 = 8;
    <D.36564>:
    _amd64_rex_bits = iftmp.2200;
    if (_amd64_rex_bits != 0) goto <D.36565>; else goto <D.36566>;
    <D.36565>:
    code.2201 = code;
    code = code.2201 + 1;
    D.36568 = _amd64_rex_bits | 64;
    *code.2201 = D.36568;
    <D.36566>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.36569>; else goto <D.36570>;
  <D.36569>:
  code.2202 = code;
  code = code.2202 + 1;
  *code.2202 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36572>; else goto <D.36573>;
  <D.36572>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36574>; else goto <D.36575>;
  <D.36574>:
  code.2203 = code;
  code = code.2203 + 1;
  *code.2203 = 12;
  code.2204 = code;
  code = code.2204 + 1;
  *code.2204 = 36;
  goto <D.36578>;
  <D.36575>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36579>; else goto <D.36580>;
  <D.36579>:
  code.2205 = code;
  code = code.2205 + 1;
  *code.2205 = 76;
  code.2206 = code;
  code = code.2206 + 1;
  *code.2206 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36583>;
  <D.36580>:
  code.2207 = code;
  code = code.2207 + 1;
  *code.2207 = 140;
  code.2208 = code;
  code = code.2208 + 1;
  *code.2208 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2209 = code;
        code = code.2209 + 1;
        D.36587 = imb.b[0];
        *code.2209 = D.36587;
        code.2210 = code;
        code = code.2210 + 1;
        D.36589 = imb.b[1];
        *code.2210 = D.36589;
        code.2211 = code;
        code = code.2211 + 1;
        D.36591 = imb.b[2];
        *code.2211 = D.36591;
        code.2212 = code;
        code = code.2212 + 1;
        D.36593 = imb.b[3];
        *code.2212 = D.36593;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36583>:
  <D.36578>:
  goto <D.25769>;
  <D.36573>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36594>; else goto <D.36595>;
  <D.36594>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36596>; else goto <D.36597>;
  <D.36596>:
  code.2213 = code;
  code = code.2213 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34622 = D.31571 | 8;
  D.34623 = (unsigned char) D.34622;
  *code.2213 = D.34623;
  goto <D.25769>;
  <D.36597>:
  <D.36595>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36599>; else goto <D.36600>;
  <D.36599>:
  code.2214 = code;
  code = code.2214 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34627 = D.31571 | 72;
  D.34628 = (unsigned char) D.34627;
  *code.2214 = D.34628;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36602>;
  <D.36600>:
  code.2215 = code;
  code = code.2215 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34631 = D.31571 | -120;
  D.34632 = (unsigned char) D.34631;
  *code.2215 = D.34632;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2216 = code;
        code = code.2216 + 1;
        D.36605 = imb.b[0];
        *code.2216 = D.36605;
        code.2217 = code;
        code = code.2217 + 1;
        D.36607 = imb.b[1];
        *code.2217 = D.36607;
        code.2218 = code;
        code = code.2218 + 1;
        D.36609 = imb.b[2];
        *code.2218 = D.36609;
        code.2219 = code;
        code = code.2219 + 1;
        D.36611 = imb.b[3];
        *code.2219 = D.36611;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36602>:
  <D.25769>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.36612>;
  <D.36570>:
  code.2220 = code;
  code = code.2220 + 1;
  *code.2220 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36614>; else goto <D.36615>;
  <D.36614>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36616>; else goto <D.36617>;
  <D.36616>:
  code.2221 = code;
  code = code.2221 + 1;
  *code.2221 = 12;
  code.2222 = code;
  code = code.2222 + 1;
  *code.2222 = 36;
  goto <D.36620>;
  <D.36617>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36621>; else goto <D.36622>;
  <D.36621>:
  code.2223 = code;
  code = code.2223 + 1;
  *code.2223 = 76;
  code.2224 = code;
  code = code.2224 + 1;
  *code.2224 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36625>;
  <D.36622>:
  code.2225 = code;
  code = code.2225 + 1;
  *code.2225 = 140;
  code.2226 = code;
  code = code.2226 + 1;
  *code.2226 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2227 = code;
        code = code.2227 + 1;
        D.36629 = imb.b[0];
        *code.2227 = D.36629;
        code.2228 = code;
        code = code.2228 + 1;
        D.36631 = imb.b[1];
        *code.2228 = D.36631;
        code.2229 = code;
        code = code.2229 + 1;
        D.36633 = imb.b[2];
        *code.2229 = D.36633;
        code.2230 = code;
        code = code.2230 + 1;
        D.36635 = imb.b[3];
        *code.2230 = D.36635;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36625>:
  <D.36620>:
  goto <D.25772>;
  <D.36615>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36636>; else goto <D.36637>;
  <D.36636>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36638>; else goto <D.36639>;
  <D.36638>:
  code.2231 = code;
  code = code.2231 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34622 = D.31571 | 8;
  D.34623 = (unsigned char) D.34622;
  *code.2231 = D.34623;
  goto <D.25772>;
  <D.36639>:
  <D.36637>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36641>; else goto <D.36642>;
  <D.36641>:
  code.2232 = code;
  code = code.2232 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34627 = D.31571 | 72;
  D.34628 = (unsigned char) D.34627;
  *code.2232 = D.34628;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36644>;
  <D.36642>:
  code.2233 = code;
  code = code.2233 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34631 = D.31571 | -120;
  D.34632 = (unsigned char) D.34631;
  *code.2233 = D.34632;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2234 = code;
        code = code.2234 + 1;
        D.36647 = imb.b[0];
        *code.2234 = D.36647;
        code.2235 = code;
        code = code.2235 + 1;
        D.36649 = imb.b[1];
        *code.2235 = D.36649;
        code.2236 = code;
        code = code.2236 + 1;
        D.36651 = imb.b[2];
        *code.2236 = D.36651;
        code.2237 = code;
        code = code.2237 + 1;
        D.36653 = imb.b[3];
        *code.2237 = D.36653;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36644>:
  <D.25772>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2238 = code;
        code = code.2238 + 1;
        D.36655 = imb.b[0];
        *code.2238 = D.36655;
        code.2239 = code;
        code = code.2239 + 1;
        D.36657 = imb.b[1];
        *code.2239 = D.36657;
        code.2240 = code;
        code = code.2240 + 1;
        D.36659 = imb.b[2];
        *code.2240 = D.36659;
        code.2241 = code;
        code = code.2241 + 1;
        D.36661 = imb.b[3];
        *code.2241 = D.36661;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36612>:
  goto <D.25197>;
  <D.25775>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.36662>; else goto <D.36663>;
  <D.36662>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4292, "amd64_is_imm32 (ins->inst_imm)");
  <D.36663>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.36665>; else goto <D.36666>;
    <D.36665>:
    iftmp.2242 = 9;
    goto <D.36667>;
    <D.36666>:
    iftmp.2242 = 8;
    <D.36667>:
    _amd64_rex_bits = iftmp.2242;
    if (_amd64_rex_bits != 0) goto <D.36668>; else goto <D.36669>;
    <D.36668>:
    code.2243 = code;
    code = code.2243 + 1;
    D.36671 = _amd64_rex_bits | 64;
    *code.2243 = D.36671;
    <D.36669>:
  }
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.36672>; else goto <D.36673>;
  <D.36672>:
  code.2244 = code;
  code = code.2244 + 1;
  *code.2244 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36675>; else goto <D.36676>;
  <D.36675>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36677>; else goto <D.36678>;
  <D.36677>:
  code.2245 = code;
  code = code.2245 + 1;
  *code.2245 = 52;
  code.2246 = code;
  code = code.2246 + 1;
  *code.2246 = 36;
  goto <D.36681>;
  <D.36678>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36682>; else goto <D.36683>;
  <D.36682>:
  code.2247 = code;
  code = code.2247 + 1;
  *code.2247 = 116;
  code.2248 = code;
  code = code.2248 + 1;
  *code.2248 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36686>;
  <D.36683>:
  code.2249 = code;
  code = code.2249 + 1;
  *code.2249 = 180;
  code.2250 = code;
  code = code.2250 + 1;
  *code.2250 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2251 = code;
        code = code.2251 + 1;
        D.36690 = imb.b[0];
        *code.2251 = D.36690;
        code.2252 = code;
        code = code.2252 + 1;
        D.36692 = imb.b[1];
        *code.2252 = D.36692;
        code.2253 = code;
        code = code.2253 + 1;
        D.36694 = imb.b[2];
        *code.2253 = D.36694;
        code.2254 = code;
        code = code.2254 + 1;
        D.36696 = imb.b[3];
        *code.2254 = D.36696;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36686>:
  <D.36681>:
  goto <D.25778>;
  <D.36676>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36697>; else goto <D.36698>;
  <D.36697>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36699>; else goto <D.36700>;
  <D.36699>:
  code.2255 = code;
  code = code.2255 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34727 = D.31571 | 48;
  D.34728 = (unsigned char) D.34727;
  *code.2255 = D.34728;
  goto <D.25778>;
  <D.36700>:
  <D.36698>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36702>; else goto <D.36703>;
  <D.36702>:
  code.2256 = code;
  code = code.2256 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34732 = D.31571 | 112;
  D.34733 = (unsigned char) D.34732;
  *code.2256 = D.34733;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36705>;
  <D.36703>:
  code.2257 = code;
  code = code.2257 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34736 = D.31571 | -80;
  D.34737 = (unsigned char) D.34736;
  *code.2257 = D.34737;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2258 = code;
        code = code.2258 + 1;
        D.36708 = imb.b[0];
        *code.2258 = D.36708;
        code.2259 = code;
        code = code.2259 + 1;
        D.36710 = imb.b[1];
        *code.2259 = D.36710;
        code.2260 = code;
        code = code.2260 + 1;
        D.36712 = imb.b[2];
        *code.2260 = D.36712;
        code.2261 = code;
        code = code.2261 + 1;
        D.36714 = imb.b[3];
        *code.2261 = D.36714;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36705>:
  <D.25778>:
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.36715>;
  <D.36673>:
  code.2262 = code;
  code = code.2262 + 1;
  *code.2262 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.36717>; else goto <D.36718>;
  <D.36717>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36719>; else goto <D.36720>;
  <D.36719>:
  code.2263 = code;
  code = code.2263 + 1;
  *code.2263 = 52;
  code.2264 = code;
  code = code.2264 + 1;
  *code.2264 = 36;
  goto <D.36723>;
  <D.36720>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36724>; else goto <D.36725>;
  <D.36724>:
  code.2265 = code;
  code = code.2265 + 1;
  *code.2265 = 116;
  code.2266 = code;
  code = code.2266 + 1;
  *code.2266 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36728>;
  <D.36725>:
  code.2267 = code;
  code = code.2267 + 1;
  *code.2267 = 180;
  code.2268 = code;
  code = code.2268 + 1;
  *code.2268 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2269 = code;
        code = code.2269 + 1;
        D.36732 = imb.b[0];
        *code.2269 = D.36732;
        code.2270 = code;
        code = code.2270 + 1;
        D.36734 = imb.b[1];
        *code.2270 = D.36734;
        code.2271 = code;
        code = code.2271 + 1;
        D.36736 = imb.b[2];
        *code.2271 = D.36736;
        code.2272 = code;
        code = code.2272 + 1;
        D.36738 = imb.b[3];
        *code.2272 = D.36738;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36728>:
  <D.36723>:
  goto <D.25781>;
  <D.36718>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.36739>; else goto <D.36740>;
  <D.36739>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.36741>; else goto <D.36742>;
  <D.36741>:
  code.2273 = code;
  code = code.2273 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34727 = D.31571 | 48;
  D.34728 = (unsigned char) D.34727;
  *code.2273 = D.34728;
  goto <D.25781>;
  <D.36742>:
  <D.36740>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.36744>; else goto <D.36745>;
  <D.36744>:
  code.2274 = code;
  code = code.2274 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34732 = D.31571 | 112;
  D.34733 = (unsigned char) D.34732;
  *code.2274 = D.34733;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.36747>;
  <D.36745>:
  code.2275 = code;
  code = code.2275 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34736 = D.31571 | -80;
  D.34737 = (unsigned char) D.34736;
  *code.2275 = D.34737;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.2276 = code;
        code = code.2276 + 1;
        D.36750 = imb.b[0];
        *code.2276 = D.36750;
        code.2277 = code;
        code = code.2277 + 1;
        D.36752 = imb.b[1];
        *code.2277 = D.36752;
        code.2278 = code;
        code = code.2278 + 1;
        D.36754 = imb.b[2];
        *code.2278 = D.36754;
        code.2279 = code;
        code = code.2279 + 1;
        D.36756 = imb.b[3];
        *code.2279 = D.36756;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36747>:
  <D.25781>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2280 = code;
        code = code.2280 + 1;
        D.36758 = imb.b[0];
        *code.2280 = D.36758;
        code.2281 = code;
        code = code.2281 + 1;
        D.36760 = imb.b[1];
        *code.2281 = D.36760;
        code.2282 = code;
        code = code.2282 + 1;
        D.36762 = imb.b[2];
        *code.2282 = D.36762;
        code.2283 = code;
        code = code.2283 + 1;
        D.36764 = imb.b[3];
        *code.2283 = D.36764;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.36715>:
  goto <D.25197>;
  <D.25784>:
  code.2284 = code;
  code = code.2284 + 1;
  *code.2284 = 204;
  goto <D.25197>;
  <D.25785>:
  code.2285 = code;
  code = code.2285 + 1;
  *code.2285 = 243;
  code.2286 = code;
  code = code.2286 + 1;
  *code.2286 = 144;
  goto <D.25197>;
  <D.25786>:
  code.2287 = code;
  code = code.2287 + 1;
  *code.2287 = 144;
  goto <D.25197>;
  <D.25787>:
  <D.25788>:
  <D.25789>:
  <D.25790>:
  <D.25791>:
  goto <D.25197>;
  <D.25792>:
  {
    int i;

    D.36769 = ins->flags;
    D.36770 = (int) D.36769;
    D.36771 = D.36770 & 1;
    if (D.36771 != 0) goto <D.36772>; else goto <D.36773>;
    <D.36772>:
    {
      struct MonoInst * var;

      var = cfg->arch.ss_trigger_page_var;
      if (0 != 0) goto <D.36774>; else goto <D.36775>;
      <D.36774>:
      code.2288 = code;
      code = code.2288 + 1;
      *code.2288 = 102;
      <D.36775>:
      {
        unsigned char _amd64_rex_bits;

        D.36778 = var->sreg1;
        if (D.36778 > 7) goto <D.36779>; else goto <D.36780>;
        <D.36779>:
        iftmp.2289 = 13;
        goto <D.36781>;
        <D.36780>:
        iftmp.2289 = 12;
        <D.36781>:
        _amd64_rex_bits = iftmp.2289;
        if (_amd64_rex_bits != 0) goto <D.36782>; else goto <D.36783>;
        <D.36782>:
        code.2290 = code;
        code = code.2290 + 1;
        D.36785 = _amd64_rex_bits | 64;
        *code.2290 = D.36785;
        <D.36783>:
      }
      switch (8) <default: <D.25801>, case 1: <D.25796>, case 2: <D.25798>, case 4: <D.25799>, case 8: <D.25800>>
      <D.25796>:
      code.2291 = code;
      code = code.2291 + 1;
      *code.2291 = 138;
      goto <D.25797>;
      <D.25798>:
      <D.25799>:
      <D.25800>:
      code.2292 = code;
      code = code.2292 + 1;
      *code.2292 = 139;
      goto <D.25797>;
      <D.25801>:
      __assert_fail ("0", "mini-amd64.c", 4324, &__PRETTY_FUNCTION__);
      <D.25797>:
      D.36778 = var->sreg1;
      if (D.36778 == 16) goto <D.36788>; else goto <D.36789>;
      <D.36788>:
      code.2293 = code;
      code = code.2293 + 1;
      *code.2293 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            D.36791 = var->data.op[0].const_val;
            D.36792 = (int) D.36791;
            imb.val = D.36792;
            code.2294 = code;
            code = code.2294 + 1;
            D.36794 = imb.b[0];
            *code.2294 = D.36794;
            code.2295 = code;
            code = code.2295 + 1;
            D.36796 = imb.b[1];
            *code.2295 = D.36796;
            code.2296 = code;
            code = code.2296 + 1;
            D.36798 = imb.b[2];
            *code.2296 = D.36798;
            code.2297 = code;
            code = code.2297 + 1;
            D.36800 = imb.b[3];
            *code.2297 = D.36800;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.36801>;
      <D.36789>:
      D.36778 = var->sreg1;
      D.36802 = D.36778 & 7;
      if (D.36802 == 4) goto <D.36803>; else goto <D.36804>;
      <D.36803>:
      D.36791 = var->data.op[0].const_val;
      if (D.36791 == 0) goto <D.36805>; else goto <D.36806>;
      <D.36805>:
      code.2298 = code;
      code = code.2298 + 1;
      *code.2298 = 28;
      code.2299 = code;
      code = code.2299 + 1;
      *code.2299 = 36;
      goto <D.36809>;
      <D.36806>:
      D.36791 = var->data.op[0].const_val;
      D.36810 = (unsigned int) D.36791;
      D.36811 = D.36810 + 128;
      if (D.36811 <= 255) goto <D.36812>; else goto <D.36813>;
      <D.36812>:
      code.2300 = code;
      code = code.2300 + 1;
      *code.2300 = 92;
      code.2301 = code;
      code = code.2301 + 1;
      *code.2301 = 36;
      D.36791 = var->data.op[0].const_val;
      D.36816 = (unsigned char) D.36791;
      *code = D.36816;
      code = code + 1;
      goto <D.36817>;
      <D.36813>:
      code.2302 = code;
      code = code.2302 + 1;
      *code.2302 = 156;
      code.2303 = code;
      code = code.2303 + 1;
      *code.2303 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.36791 = var->data.op[0].const_val;
            D.36792 = (int) D.36791;
            imb.val = D.36792;
            code.2304 = code;
            code = code.2304 + 1;
            D.36821 = imb.b[0];
            *code.2304 = D.36821;
            code.2305 = code;
            code = code.2305 + 1;
            D.36823 = imb.b[1];
            *code.2305 = D.36823;
            code.2306 = code;
            code = code.2306 + 1;
            D.36825 = imb.b[2];
            *code.2306 = D.36825;
            code.2307 = code;
            code = code.2307 + 1;
            D.36827 = imb.b[3];
            *code.2307 = D.36827;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36817>:
      <D.36809>:
      goto <D.25804>;
      <D.36804>:
      D.36791 = var->data.op[0].const_val;
      if (D.36791 == 0) goto <D.36828>; else goto <D.36829>;
      <D.36828>:
      D.36778 = var->sreg1;
      D.36802 = D.36778 & 7;
      if (D.36802 != 5) goto <D.36830>; else goto <D.36831>;
      <D.36830>:
      code.2308 = code;
      code = code.2308 + 1;
      D.36778 = var->sreg1;
      D.36833 = (signed char) D.36778;
      D.36834 = D.36833 & 7;
      D.36835 = D.36834 | 24;
      D.36836 = (unsigned char) D.36835;
      *code.2308 = D.36836;
      goto <D.25804>;
      <D.36831>:
      <D.36829>:
      D.36791 = var->data.op[0].const_val;
      D.36810 = (unsigned int) D.36791;
      D.36811 = D.36810 + 128;
      if (D.36811 <= 255) goto <D.36837>; else goto <D.36838>;
      <D.36837>:
      code.2309 = code;
      code = code.2309 + 1;
      D.36778 = var->sreg1;
      D.36833 = (signed char) D.36778;
      D.36834 = D.36833 & 7;
      D.36840 = D.36834 | 88;
      D.36841 = (unsigned char) D.36840;
      *code.2309 = D.36841;
      D.36791 = var->data.op[0].const_val;
      D.36816 = (unsigned char) D.36791;
      *code = D.36816;
      code = code + 1;
      goto <D.36842>;
      <D.36838>:
      code.2310 = code;
      code = code.2310 + 1;
      D.36778 = var->sreg1;
      D.36833 = (signed char) D.36778;
      D.36834 = D.36833 & 7;
      D.36844 = D.36834 | -104;
      D.36845 = (unsigned char) D.36844;
      *code.2310 = D.36845;
      {
        union x86_imm_buf imb;

        try
          {
            D.36791 = var->data.op[0].const_val;
            D.36792 = (int) D.36791;
            imb.val = D.36792;
            code.2311 = code;
            code = code.2311 + 1;
            D.36847 = imb.b[0];
            *code.2311 = D.36847;
            code.2312 = code;
            code = code.2312 + 1;
            D.36849 = imb.b[1];
            *code.2312 = D.36849;
            code.2313 = code;
            code = code.2313 + 1;
            D.36851 = imb.b[2];
            *code.2313 = D.36851;
            code.2314 = code;
            code = code.2314 + 1;
            D.36853 = imb.b[3];
            *code.2314 = D.36853;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36842>:
      <D.25804>:
      <D.36801>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.36854>; else goto <D.36855>;
        <D.36854>:
        code.2315 = code;
        code = code.2315 + 1;
        D.36857 = _amd64_rex_bits | 64;
        *code.2315 = D.36857;
        <D.36855>:
      }
      if (1 != 0) goto <D.36858>; else goto <D.36859>;
      <D.36858>:
      code.2316 = code;
      code = code.2316 + 1;
      *code.2316 = 131;
      if (0 != 0) goto <D.36861>; else goto <D.36862>;
      <D.36861>:
      if (1 != 0) goto <D.36863>; else goto <D.36864>;
      <D.36863>:
      code.2317 = code;
      code = code.2317 + 1;
      *code.2317 = 60;
      code.2318 = code;
      code = code.2318 + 1;
      *code.2318 = 36;
      goto <D.36867>;
      <D.36864>:
      if (1 != 0) goto <D.36868>; else goto <D.36869>;
      <D.36868>:
      code.2319 = code;
      code = code.2319 + 1;
      *code.2319 = 124;
      code.2320 = code;
      code = code.2320 + 1;
      *code.2320 = 36;
      *code = 0;
      code = code + 1;
      goto <D.36872>;
      <D.36869>:
      code.2321 = code;
      code = code.2321 + 1;
      *code.2321 = 188;
      code.2322 = code;
      code = code.2322 + 1;
      *code.2322 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2323 = code;
            code = code.2323 + 1;
            D.36876 = imb.b[0];
            *code.2323 = D.36876;
            code.2324 = code;
            code = code.2324 + 1;
            D.36878 = imb.b[1];
            *code.2324 = D.36878;
            code.2325 = code;
            code = code.2325 + 1;
            D.36880 = imb.b[2];
            *code.2325 = D.36880;
            code.2326 = code;
            code = code.2326 + 1;
            D.36882 = imb.b[3];
            *code.2326 = D.36882;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36872>:
      <D.36867>:
      goto <D.25808>;
      <D.36862>:
      if (1 != 0) goto <D.36883>; else goto <D.36884>;
      <D.36883>:
      code.2327 = code;
      code = code.2327 + 1;
      *code.2327 = 59;
      goto <D.25808>;
      <D.36884>:
      if (1 != 0) goto <D.36886>; else goto <D.36887>;
      <D.36886>:
      code.2328 = code;
      code = code.2328 + 1;
      *code.2328 = 123;
      *code = 0;
      code = code + 1;
      goto <D.36889>;
      <D.36887>:
      code.2329 = code;
      code = code.2329 + 1;
      *code.2329 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2330 = code;
            code = code.2330 + 1;
            D.36892 = imb.b[0];
            *code.2330 = D.36892;
            code.2331 = code;
            code = code.2331 + 1;
            D.36894 = imb.b[1];
            *code.2331 = D.36894;
            code.2332 = code;
            code = code.2332 + 1;
            D.36896 = imb.b[2];
            *code.2332 = D.36896;
            code.2333 = code;
            code = code.2333 + 1;
            D.36898 = imb.b[3];
            *code.2333 = D.36898;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36889>:
      <D.25808>:
      *code = 0;
      code = code + 1;
      goto <D.36899>;
      <D.36859>:
      code.2334 = code;
      code = code.2334 + 1;
      *code.2334 = 129;
      if (0 != 0) goto <D.36901>; else goto <D.36902>;
      <D.36901>:
      if (1 != 0) goto <D.36903>; else goto <D.36904>;
      <D.36903>:
      code.2335 = code;
      code = code.2335 + 1;
      *code.2335 = 60;
      code.2336 = code;
      code = code.2336 + 1;
      *code.2336 = 36;
      goto <D.36907>;
      <D.36904>:
      if (1 != 0) goto <D.36908>; else goto <D.36909>;
      <D.36908>:
      code.2337 = code;
      code = code.2337 + 1;
      *code.2337 = 124;
      code.2338 = code;
      code = code.2338 + 1;
      *code.2338 = 36;
      *code = 0;
      code = code + 1;
      goto <D.36912>;
      <D.36909>:
      code.2339 = code;
      code = code.2339 + 1;
      *code.2339 = 188;
      code.2340 = code;
      code = code.2340 + 1;
      *code.2340 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2341 = code;
            code = code.2341 + 1;
            D.36916 = imb.b[0];
            *code.2341 = D.36916;
            code.2342 = code;
            code = code.2342 + 1;
            D.36918 = imb.b[1];
            *code.2342 = D.36918;
            code.2343 = code;
            code = code.2343 + 1;
            D.36920 = imb.b[2];
            *code.2343 = D.36920;
            code.2344 = code;
            code = code.2344 + 1;
            D.36922 = imb.b[3];
            *code.2344 = D.36922;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36912>:
      <D.36907>:
      goto <D.25811>;
      <D.36902>:
      if (1 != 0) goto <D.36923>; else goto <D.36924>;
      <D.36923>:
      code.2345 = code;
      code = code.2345 + 1;
      *code.2345 = 59;
      goto <D.25811>;
      <D.36924>:
      if (1 != 0) goto <D.36926>; else goto <D.36927>;
      <D.36926>:
      code.2346 = code;
      code = code.2346 + 1;
      *code.2346 = 123;
      *code = 0;
      code = code + 1;
      goto <D.36929>;
      <D.36927>:
      code.2347 = code;
      code = code.2347 + 1;
      *code.2347 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2348 = code;
            code = code.2348 + 1;
            D.36932 = imb.b[0];
            *code.2348 = D.36932;
            code.2349 = code;
            code = code.2349 + 1;
            D.36934 = imb.b[1];
            *code.2349 = D.36934;
            code.2350 = code;
            code = code.2350 + 1;
            D.36936 = imb.b[2];
            *code.2350 = D.36936;
            code.2351 = code;
            code = code.2351 + 1;
            D.36938 = imb.b[3];
            *code.2351 = D.36938;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36929>:
      <D.25811>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2352 = code;
            code = code.2352 + 1;
            D.36940 = imb.b[0];
            *code.2352 = D.36940;
            code.2353 = code;
            code = code.2353 + 1;
            D.36942 = imb.b[1];
            *code.2353 = D.36942;
            code.2354 = code;
            code = code.2354 + 1;
            D.36944 = imb.b[2];
            *code.2354 = D.36944;
            code.2355 = code;
            code = code.2355 + 1;
            D.36946 = imb.b[3];
            *code.2355 = D.36946;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36899>:
    }
    <D.36773>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_seq_point (cfg, bb, ins, D.36947);
    D.31356 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.31357 = D.31356 & 64;
    if (D.31357 != 0) goto <D.36948>; else goto <D.36949>;
    <D.36948>:
    {
      guint32 offset;
      guint32 val;
      struct MonoInst * info_var;

      code.211 = (long int) code;
      D.31283 = cfg->native_code;
      D.31451 = (long int) D.31283;
      D.31452 = code.211 - D.31451;
      offset = (guint32) D.31452;
      info_var = cfg->arch.seq_point_info_var;
      if (0 != 0) goto <D.36950>; else goto <D.36951>;
      <D.36950>:
      code.2356 = code;
      code = code.2356 + 1;
      *code.2356 = 102;
      <D.36951>:
      {
        unsigned char _amd64_rex_bits;

        D.36954 = info_var->sreg1;
        if (D.36954 > 7) goto <D.36955>; else goto <D.36956>;
        <D.36955>:
        iftmp.2357 = 13;
        goto <D.36957>;
        <D.36956>:
        iftmp.2357 = 12;
        <D.36957>:
        _amd64_rex_bits = iftmp.2357;
        if (_amd64_rex_bits != 0) goto <D.36958>; else goto <D.36959>;
        <D.36958>:
        code.2358 = code;
        code = code.2358 + 1;
        D.36961 = _amd64_rex_bits | 64;
        *code.2358 = D.36961;
        <D.36959>:
      }
      switch (8) <default: <D.25823>, case 1: <D.25818>, case 2: <D.25820>, case 4: <D.25821>, case 8: <D.25822>>
      <D.25818>:
      code.2359 = code;
      code = code.2359 + 1;
      *code.2359 = 138;
      goto <D.25819>;
      <D.25820>:
      <D.25821>:
      <D.25822>:
      code.2360 = code;
      code = code.2360 + 1;
      *code.2360 = 139;
      goto <D.25819>;
      <D.25823>:
      __assert_fail ("0", "mini-amd64.c", 4339, &__PRETTY_FUNCTION__);
      <D.25819>:
      D.36954 = info_var->sreg1;
      if (D.36954 == 16) goto <D.36964>; else goto <D.36965>;
      <D.36964>:
      code.2361 = code;
      code = code.2361 + 1;
      *code.2361 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            D.36967 = info_var->data.op[0].const_val;
            D.36968 = (int) D.36967;
            imb.val = D.36968;
            code.2362 = code;
            code = code.2362 + 1;
            D.36970 = imb.b[0];
            *code.2362 = D.36970;
            code.2363 = code;
            code = code.2363 + 1;
            D.36972 = imb.b[1];
            *code.2363 = D.36972;
            code.2364 = code;
            code = code.2364 + 1;
            D.36974 = imb.b[2];
            *code.2364 = D.36974;
            code.2365 = code;
            code = code.2365 + 1;
            D.36976 = imb.b[3];
            *code.2365 = D.36976;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.36977>;
      <D.36965>:
      D.36954 = info_var->sreg1;
      D.36978 = D.36954 & 7;
      if (D.36978 == 4) goto <D.36979>; else goto <D.36980>;
      <D.36979>:
      D.36967 = info_var->data.op[0].const_val;
      if (D.36967 == 0) goto <D.36981>; else goto <D.36982>;
      <D.36981>:
      code.2366 = code;
      code = code.2366 + 1;
      *code.2366 = 28;
      code.2367 = code;
      code = code.2367 + 1;
      *code.2367 = 36;
      goto <D.36985>;
      <D.36982>:
      D.36967 = info_var->data.op[0].const_val;
      D.36986 = (unsigned int) D.36967;
      D.36987 = D.36986 + 128;
      if (D.36987 <= 255) goto <D.36988>; else goto <D.36989>;
      <D.36988>:
      code.2368 = code;
      code = code.2368 + 1;
      *code.2368 = 92;
      code.2369 = code;
      code = code.2369 + 1;
      *code.2369 = 36;
      D.36967 = info_var->data.op[0].const_val;
      D.36992 = (unsigned char) D.36967;
      *code = D.36992;
      code = code + 1;
      goto <D.36993>;
      <D.36989>:
      code.2370 = code;
      code = code.2370 + 1;
      *code.2370 = 156;
      code.2371 = code;
      code = code.2371 + 1;
      *code.2371 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.36967 = info_var->data.op[0].const_val;
            D.36968 = (int) D.36967;
            imb.val = D.36968;
            code.2372 = code;
            code = code.2372 + 1;
            D.36997 = imb.b[0];
            *code.2372 = D.36997;
            code.2373 = code;
            code = code.2373 + 1;
            D.36999 = imb.b[1];
            *code.2373 = D.36999;
            code.2374 = code;
            code = code.2374 + 1;
            D.37001 = imb.b[2];
            *code.2374 = D.37001;
            code.2375 = code;
            code = code.2375 + 1;
            D.37003 = imb.b[3];
            *code.2375 = D.37003;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.36993>:
      <D.36985>:
      goto <D.25826>;
      <D.36980>:
      D.36967 = info_var->data.op[0].const_val;
      if (D.36967 == 0) goto <D.37004>; else goto <D.37005>;
      <D.37004>:
      D.36954 = info_var->sreg1;
      D.36978 = D.36954 & 7;
      if (D.36978 != 5) goto <D.37006>; else goto <D.37007>;
      <D.37006>:
      code.2376 = code;
      code = code.2376 + 1;
      D.36954 = info_var->sreg1;
      D.37009 = (signed char) D.36954;
      D.37010 = D.37009 & 7;
      D.37011 = D.37010 | 24;
      D.37012 = (unsigned char) D.37011;
      *code.2376 = D.37012;
      goto <D.25826>;
      <D.37007>:
      <D.37005>:
      D.36967 = info_var->data.op[0].const_val;
      D.36986 = (unsigned int) D.36967;
      D.36987 = D.36986 + 128;
      if (D.36987 <= 255) goto <D.37013>; else goto <D.37014>;
      <D.37013>:
      code.2377 = code;
      code = code.2377 + 1;
      D.36954 = info_var->sreg1;
      D.37009 = (signed char) D.36954;
      D.37010 = D.37009 & 7;
      D.37016 = D.37010 | 88;
      D.37017 = (unsigned char) D.37016;
      *code.2377 = D.37017;
      D.36967 = info_var->data.op[0].const_val;
      D.36992 = (unsigned char) D.36967;
      *code = D.36992;
      code = code + 1;
      goto <D.37018>;
      <D.37014>:
      code.2378 = code;
      code = code.2378 + 1;
      D.36954 = info_var->sreg1;
      D.37009 = (signed char) D.36954;
      D.37010 = D.37009 & 7;
      D.37020 = D.37010 | -104;
      D.37021 = (unsigned char) D.37020;
      *code.2378 = D.37021;
      {
        union x86_imm_buf imb;

        try
          {
            D.36967 = info_var->data.op[0].const_val;
            D.36968 = (int) D.36967;
            imb.val = D.36968;
            code.2379 = code;
            code = code.2379 + 1;
            D.37023 = imb.b[0];
            *code.2379 = D.37023;
            code.2380 = code;
            code = code.2380 + 1;
            D.37025 = imb.b[1];
            *code.2380 = D.37025;
            code.2381 = code;
            code = code.2381 + 1;
            D.37027 = imb.b[2];
            *code.2381 = D.37027;
            code.2382 = code;
            code = code.2382 + 1;
            D.37029 = imb.b[3];
            *code.2382 = D.37029;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37018>:
      <D.25826>:
      <D.36977>:
      D.37030 = (long unsigned int) offset;
      D.37031 = D.37030 + 2;
      D.37032 = (unsigned int) D.37031;
      val = D.37032 * 8;
      if (0 != 0) goto <D.37033>; else goto <D.37034>;
      <D.37033>:
      code.2383 = code;
      code = code.2383 + 1;
      *code.2383 = 102;
      <D.37034>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.37036>; else goto <D.37037>;
        <D.37036>:
        code.2384 = code;
        code = code.2384 + 1;
        D.37039 = _amd64_rex_bits | 64;
        *code.2384 = D.37039;
        <D.37037>:
      }
      switch (8) <default: <D.25834>, case 1: <D.25829>, case 2: <D.25831>, case 4: <D.25832>, case 8: <D.25833>>
      <D.25829>:
      code.2385 = code;
      code = code.2385 + 1;
      *code.2385 = 138;
      goto <D.25830>;
      <D.25831>:
      <D.25832>:
      <D.25833>:
      code.2386 = code;
      code = code.2386 + 1;
      *code.2386 = 139;
      goto <D.25830>;
      <D.25834>:
      __assert_fail ("0", "mini-amd64.c", 4342, &__PRETTY_FUNCTION__);
      <D.25830>:
      if (0 != 0) goto <D.37042>; else goto <D.37043>;
      <D.37042>:
      code.2387 = code;
      code = code.2387 + 1;
      *code.2387 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            val.2388 = (int) val;
            imb.val = val.2388;
            code.2389 = code;
            code = code.2389 + 1;
            D.37047 = imb.b[0];
            *code.2389 = D.37047;
            code.2390 = code;
            code = code.2390 + 1;
            D.37049 = imb.b[1];
            *code.2390 = D.37049;
            code.2391 = code;
            code = code.2391 + 1;
            D.37051 = imb.b[2];
            *code.2391 = D.37051;
            code.2392 = code;
            code = code.2392 + 1;
            D.37053 = imb.b[3];
            *code.2392 = D.37053;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.37054>;
      <D.37043>:
      if (0 != 0) goto <D.37055>; else goto <D.37056>;
      <D.37055>:
      if (val == 0) goto <D.37057>; else goto <D.37058>;
      <D.37057>:
      code.2393 = code;
      code = code.2393 + 1;
      *code.2393 = 28;
      code.2394 = code;
      code = code.2394 + 1;
      *code.2394 = 36;
      goto <D.37061>;
      <D.37058>:
      val.2388 = (int) val;
      D.37062 = val.2388 >= -128;
      val.2388 = (int) val;
      D.37063 = val.2388 <= 127;
      D.37064 = D.37062 & D.37063;
      if (D.37064 != 0) goto <D.37065>; else goto <D.37066>;
      <D.37065>:
      code.2395 = code;
      code = code.2395 + 1;
      *code.2395 = 92;
      code.2396 = code;
      code = code.2396 + 1;
      *code.2396 = 36;
      D.37069 = (unsigned char) val;
      *code = D.37069;
      code = code + 1;
      goto <D.37070>;
      <D.37066>:
      code.2397 = code;
      code = code.2397 + 1;
      *code.2397 = 156;
      code.2398 = code;
      code = code.2398 + 1;
      *code.2398 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            val.2388 = (int) val;
            imb.val = val.2388;
            code.2399 = code;
            code = code.2399 + 1;
            D.37074 = imb.b[0];
            *code.2399 = D.37074;
            code.2400 = code;
            code = code.2400 + 1;
            D.37076 = imb.b[1];
            *code.2400 = D.37076;
            code.2401 = code;
            code = code.2401 + 1;
            D.37078 = imb.b[2];
            *code.2401 = D.37078;
            code.2402 = code;
            code = code.2402 + 1;
            D.37080 = imb.b[3];
            *code.2402 = D.37080;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37070>:
      <D.37061>:
      goto <D.25837>;
      <D.37056>:
      if (val == 0) goto <D.37081>; else goto <D.37082>;
      <D.37081>:
      code.2403 = code;
      code = code.2403 + 1;
      *code.2403 = 27;
      goto <D.25837>;
      <D.37082>:
      val.2388 = (int) val;
      D.37062 = val.2388 >= -128;
      val.2388 = (int) val;
      D.37063 = val.2388 <= 127;
      D.37064 = D.37062 & D.37063;
      if (D.37064 != 0) goto <D.37084>; else goto <D.37085>;
      <D.37084>:
      code.2404 = code;
      code = code.2404 + 1;
      *code.2404 = 91;
      D.37069 = (unsigned char) val;
      *code = D.37069;
      code = code + 1;
      goto <D.37087>;
      <D.37085>:
      code.2405 = code;
      code = code.2405 + 1;
      *code.2405 = 155;
      {
        union x86_imm_buf imb;

        try
          {
            val.2388 = (int) val;
            imb.val = val.2388;
            code.2406 = code;
            code = code.2406 + 1;
            D.37090 = imb.b[0];
            *code.2406 = D.37090;
            code.2407 = code;
            code = code.2407 + 1;
            D.37092 = imb.b[1];
            *code.2407 = D.37092;
            code.2408 = code;
            code = code.2408 + 1;
            D.37094 = imb.b[2];
            *code.2408 = D.37094;
            code.2409 = code;
            code = code.2409 + 1;
            D.37096 = imb.b[3];
            *code.2409 = D.37096;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37087>:
      <D.25837>:
      <D.37054>:
      if (0 != 0) goto <D.37097>; else goto <D.37098>;
      <D.37097>:
      code.2410 = code;
      code = code.2410 + 1;
      *code.2410 = 102;
      <D.37098>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.37100>; else goto <D.37101>;
        <D.37100>:
        code.2411 = code;
        code = code.2411 + 1;
        D.37103 = _amd64_rex_bits | 64;
        *code.2411 = D.37103;
        <D.37101>:
      }
      switch (8) <default: <D.25845>, case 1: <D.25840>, case 2: <D.25842>, case 4: <D.25843>, case 8: <D.25844>>
      <D.25840>:
      code.2412 = code;
      code = code.2412 + 1;
      *code.2412 = 138;
      goto <D.25841>;
      <D.25842>:
      <D.25843>:
      <D.25844>:
      code.2413 = code;
      code = code.2413 + 1;
      *code.2413 = 139;
      goto <D.25841>;
      <D.25845>:
      __assert_fail ("0", "mini-amd64.c", 4343, &__PRETTY_FUNCTION__);
      <D.25841>:
      if (0 != 0) goto <D.37106>; else goto <D.37107>;
      <D.37106>:
      code.2414 = code;
      code = code.2414 + 1;
      *code.2414 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2415 = code;
            code = code.2415 + 1;
            D.37110 = imb.b[0];
            *code.2415 = D.37110;
            code.2416 = code;
            code = code.2416 + 1;
            D.37112 = imb.b[1];
            *code.2416 = D.37112;
            code.2417 = code;
            code = code.2417 + 1;
            D.37114 = imb.b[2];
            *code.2417 = D.37114;
            code.2418 = code;
            code = code.2418 + 1;
            D.37116 = imb.b[3];
            *code.2418 = D.37116;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.37117>;
      <D.37107>:
      if (0 != 0) goto <D.37118>; else goto <D.37119>;
      <D.37118>:
      if (1 != 0) goto <D.37120>; else goto <D.37121>;
      <D.37120>:
      code.2419 = code;
      code = code.2419 + 1;
      *code.2419 = 28;
      code.2420 = code;
      code = code.2420 + 1;
      *code.2420 = 36;
      goto <D.37124>;
      <D.37121>:
      if (1 != 0) goto <D.37125>; else goto <D.37126>;
      <D.37125>:
      code.2421 = code;
      code = code.2421 + 1;
      *code.2421 = 92;
      code.2422 = code;
      code = code.2422 + 1;
      *code.2422 = 36;
      *code = 0;
      code = code + 1;
      goto <D.37129>;
      <D.37126>:
      code.2423 = code;
      code = code.2423 + 1;
      *code.2423 = 156;
      code.2424 = code;
      code = code.2424 + 1;
      *code.2424 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2425 = code;
            code = code.2425 + 1;
            D.37133 = imb.b[0];
            *code.2425 = D.37133;
            code.2426 = code;
            code = code.2426 + 1;
            D.37135 = imb.b[1];
            *code.2426 = D.37135;
            code.2427 = code;
            code = code.2427 + 1;
            D.37137 = imb.b[2];
            *code.2427 = D.37137;
            code.2428 = code;
            code = code.2428 + 1;
            D.37139 = imb.b[3];
            *code.2428 = D.37139;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37129>:
      <D.37124>:
      goto <D.25848>;
      <D.37119>:
      if (1 != 0) goto <D.37140>; else goto <D.37141>;
      <D.37140>:
      code.2429 = code;
      code = code.2429 + 1;
      *code.2429 = 27;
      goto <D.25848>;
      <D.37141>:
      if (1 != 0) goto <D.37143>; else goto <D.37144>;
      <D.37143>:
      code.2430 = code;
      code = code.2430 + 1;
      *code.2430 = 91;
      *code = 0;
      code = code + 1;
      goto <D.37146>;
      <D.37144>:
      code.2431 = code;
      code = code.2431 + 1;
      *code.2431 = 155;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2432 = code;
            code = code.2432 + 1;
            D.37149 = imb.b[0];
            *code.2432 = D.37149;
            code.2433 = code;
            code = code.2433 + 1;
            D.37151 = imb.b[1];
            *code.2433 = D.37151;
            code.2434 = code;
            code = code.2434 + 1;
            D.37153 = imb.b[2];
            *code.2434 = D.37153;
            code.2435 = code;
            code = code.2435 + 1;
            D.37155 = imb.b[3];
            *code.2435 = D.37155;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.37146>:
      <D.25848>:
      <D.37117>:
    }
    goto <D.37156>;
    <D.36949>:
    i = 0;
    goto <D.25851>;
    <D.25850>:
    code.2436 = code;
    code = code.2436 + 1;
    *code.2436 = 144;
    i = i + 1;
    <D.25851>:
    breakpoint_size.2437 = breakpoint_size;
    if (i < breakpoint_size.2437) goto <D.25850>; else goto <D.25852>;
    <D.25852>:
    <D.37156>:
    code.2438 = code;
    code = code.2438 + 1;
    *code.2438 = 144;
    goto <D.25197>;
  }
  <D.25853>:
  <D.25854>:
  <D.25855>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37161>; else goto <D.37162>;
    <D.37161>:
    iftmp.2439 = 12;
    goto <D.37163>;
    <D.37162>:
    iftmp.2439 = 8;
    <D.37163>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.37164 = iftmp.2439 | D.33811;
    _amd64_rex_bits = (unsigned char) D.37164;
    if (_amd64_rex_bits != 0) goto <D.37165>; else goto <D.37166>;
    <D.37165>:
    code.2440 = code;
    code = code.2440 + 1;
    D.37168 = _amd64_rex_bits | 64;
    *code.2440 = D.37168;
    <D.37166>:
  }
  code.2441 = code;
  code = code.2441 + 1;
  *code.2441 = 3;
  code.2442 = code;
  code = code.2442 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.2442 = D.33821;
  goto <D.25197>;
  <D.25857>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37172>; else goto <D.37173>;
    <D.37172>:
    iftmp.2443 = 12;
    goto <D.37174>;
    <D.37173>:
    iftmp.2443 = 8;
    <D.37174>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.37175 = iftmp.2443 | D.33811;
    _amd64_rex_bits = (unsigned char) D.37175;
    if (_amd64_rex_bits != 0) goto <D.37176>; else goto <D.37177>;
    <D.37176>:
    code.2444 = code;
    code = code.2444 + 1;
    D.37179 = _amd64_rex_bits | 64;
    *code.2444 = D.37179;
    <D.37177>:
  }
  code.2445 = code;
  code = code.2445 + 1;
  *code.2445 = 19;
  code.2446 = code;
  code = code.2446 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.2446 = D.33821;
  goto <D.25197>;
  <D.25859>:
  <D.25860>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.37182>; else goto <D.37183>;
  <D.37182>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4369, "amd64_is_imm32 (ins->inst_imm)");
  <D.37183>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.37184>; else goto <D.37185>;
  <D.37184>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37187>; else goto <D.37188>;
    <D.37187>:
    iftmp.2447 = 9;
    goto <D.37189>;
    <D.37188>:
    iftmp.2447 = 8;
    <D.37189>:
    _amd64_rex_bits = iftmp.2447;
    if (_amd64_rex_bits != 0) goto <D.37190>; else goto <D.37191>;
    <D.37190>:
    code.2448 = code;
    code = code.2448 + 1;
    D.37193 = _amd64_rex_bits | 64;
    *code.2448 = D.37193;
    <D.37191>:
  }
  code.2449 = code;
  code = code.2449 + 1;
  *code.2449 = 131;
  code.2450 = code;
  code = code.2450 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.2450 = D.35110;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.37196>;
  <D.37185>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.37197>; else goto <D.37198>;
  <D.37197>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.37199>; else goto <D.37200>;
    <D.37199>:
    code.2451 = code;
    code = code.2451 + 1;
    D.37202 = _amd64_rex_bits | 64;
    *code.2451 = D.37202;
    <D.37200>:
  }
  code.2452 = code;
  code = code.2452 + 1;
  *code.2452 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2453 = code;
        code = code.2453 + 1;
        D.37205 = imb.b[0];
        *code.2453 = D.37205;
        code.2454 = code;
        code = code.2454 + 1;
        D.37207 = imb.b[1];
        *code.2454 = D.37207;
        code.2455 = code;
        code = code.2455 + 1;
        D.37209 = imb.b[2];
        *code.2455 = D.37209;
        code.2456 = code;
        code = code.2456 + 1;
        D.37211 = imb.b[3];
        *code.2456 = D.37211;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.37212>;
  <D.37198>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37214>; else goto <D.37215>;
    <D.37214>:
    iftmp.2457 = 9;
    goto <D.37216>;
    <D.37215>:
    iftmp.2457 = 8;
    <D.37216>:
    _amd64_rex_bits = iftmp.2457;
    if (_amd64_rex_bits != 0) goto <D.37217>; else goto <D.37218>;
    <D.37217>:
    code.2458 = code;
    code = code.2458 + 1;
    D.37220 = _amd64_rex_bits | 64;
    *code.2458 = D.37220;
    <D.37218>:
  }
  code.2459 = code;
  code = code.2459 + 1;
  *code.2459 = 129;
  code.2460 = code;
  code = code.2460 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.2460 = D.35110;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2461 = code;
        code = code.2461 + 1;
        D.37224 = imb.b[0];
        *code.2461 = D.37224;
        code.2462 = code;
        code = code.2462 + 1;
        D.37226 = imb.b[1];
        *code.2462 = D.37226;
        code.2463 = code;
        code = code.2463 + 1;
        D.37228 = imb.b[2];
        *code.2463 = D.37228;
        code.2464 = code;
        code = code.2464 + 1;
        D.37230 = imb.b[3];
        *code.2464 = D.37230;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37212>:
  <D.37196>:
  goto <D.25197>;
  <D.25866>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.37231>; else goto <D.37232>;
  <D.37231>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4373, "amd64_is_imm32 (ins->inst_imm)");
  <D.37232>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.37233>; else goto <D.37234>;
  <D.37233>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37236>; else goto <D.37237>;
    <D.37236>:
    iftmp.2465 = 9;
    goto <D.37238>;
    <D.37237>:
    iftmp.2465 = 8;
    <D.37238>:
    _amd64_rex_bits = iftmp.2465;
    if (_amd64_rex_bits != 0) goto <D.37239>; else goto <D.37240>;
    <D.37239>:
    code.2466 = code;
    code = code.2466 + 1;
    D.37242 = _amd64_rex_bits | 64;
    *code.2466 = D.37242;
    <D.37240>:
  }
  code.2467 = code;
  code = code.2467 + 1;
  *code.2467 = 131;
  code.2468 = code;
  code = code.2468 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.2468 = D.37246;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.37247>;
  <D.37234>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.37248>; else goto <D.37249>;
  <D.37248>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.37250>; else goto <D.37251>;
    <D.37250>:
    code.2469 = code;
    code = code.2469 + 1;
    D.37253 = _amd64_rex_bits | 64;
    *code.2469 = D.37253;
    <D.37251>:
  }
  code.2470 = code;
  code = code.2470 + 1;
  *code.2470 = 21;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2471 = code;
        code = code.2471 + 1;
        D.37256 = imb.b[0];
        *code.2471 = D.37256;
        code.2472 = code;
        code = code.2472 + 1;
        D.37258 = imb.b[1];
        *code.2472 = D.37258;
        code.2473 = code;
        code = code.2473 + 1;
        D.37260 = imb.b[2];
        *code.2473 = D.37260;
        code.2474 = code;
        code = code.2474 + 1;
        D.37262 = imb.b[3];
        *code.2474 = D.37262;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.37263>;
  <D.37249>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37265>; else goto <D.37266>;
    <D.37265>:
    iftmp.2475 = 9;
    goto <D.37267>;
    <D.37266>:
    iftmp.2475 = 8;
    <D.37267>:
    _amd64_rex_bits = iftmp.2475;
    if (_amd64_rex_bits != 0) goto <D.37268>; else goto <D.37269>;
    <D.37268>:
    code.2476 = code;
    code = code.2476 + 1;
    D.37271 = _amd64_rex_bits | 64;
    *code.2476 = D.37271;
    <D.37269>:
  }
  code.2477 = code;
  code = code.2477 + 1;
  *code.2477 = 129;
  code.2478 = code;
  code = code.2478 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.2478 = D.37246;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2479 = code;
        code = code.2479 + 1;
        D.37275 = imb.b[0];
        *code.2479 = D.37275;
        code.2480 = code;
        code = code.2480 + 1;
        D.37277 = imb.b[1];
        *code.2480 = D.37277;
        code.2481 = code;
        code = code.2481 + 1;
        D.37279 = imb.b[2];
        *code.2481 = D.37279;
        code.2482 = code;
        code = code.2482 + 1;
        D.37281 = imb.b[3];
        *code.2482 = D.37281;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37263>:
  <D.37247>:
  goto <D.25197>;
  <D.25872>:
  <D.25873>:
  <D.25874>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37283>; else goto <D.37284>;
    <D.37283>:
    iftmp.2483 = 12;
    goto <D.37285>;
    <D.37284>:
    iftmp.2483 = 8;
    <D.37285>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.37286 = iftmp.2483 | D.33811;
    _amd64_rex_bits = (unsigned char) D.37286;
    if (_amd64_rex_bits != 0) goto <D.37287>; else goto <D.37288>;
    <D.37287>:
    code.2484 = code;
    code = code.2484 + 1;
    D.37290 = _amd64_rex_bits | 64;
    *code.2484 = D.37290;
    <D.37288>:
  }
  code.2485 = code;
  code = code.2485 + 1;
  *code.2485 = 43;
  code.2486 = code;
  code = code.2486 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.2486 = D.33821;
  goto <D.25197>;
  <D.25876>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37294>; else goto <D.37295>;
    <D.37294>:
    iftmp.2487 = 12;
    goto <D.37296>;
    <D.37295>:
    iftmp.2487 = 8;
    <D.37296>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.37297 = iftmp.2487 | D.33811;
    _amd64_rex_bits = (unsigned char) D.37297;
    if (_amd64_rex_bits != 0) goto <D.37298>; else goto <D.37299>;
    <D.37298>:
    code.2488 = code;
    code = code.2488 + 1;
    D.37301 = _amd64_rex_bits | 64;
    *code.2488 = D.37301;
    <D.37299>:
  }
  code.2489 = code;
  code = code.2489 + 1;
  *code.2489 = 27;
  code.2490 = code;
  code = code.2490 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.2490 = D.33821;
  goto <D.25197>;
  <D.25878>:
  <D.25879>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.37304>; else goto <D.37305>;
  <D.37304>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4386, "amd64_is_imm32 (ins->inst_imm)");
  <D.37305>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.37306>; else goto <D.37307>;
  <D.37306>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37309>; else goto <D.37310>;
    <D.37309>:
    iftmp.2491 = 9;
    goto <D.37311>;
    <D.37310>:
    iftmp.2491 = 8;
    <D.37311>:
    _amd64_rex_bits = iftmp.2491;
    if (_amd64_rex_bits != 0) goto <D.37312>; else goto <D.37313>;
    <D.37312>:
    code.2492 = code;
    code = code.2492 + 1;
    D.37315 = _amd64_rex_bits | 64;
    *code.2492 = D.37315;
    <D.37313>:
  }
  code.2493 = code;
  code = code.2493 + 1;
  *code.2493 = 131;
  code.2494 = code;
  code = code.2494 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.2494 = D.37319;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.37320>;
  <D.37307>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.37321>; else goto <D.37322>;
  <D.37321>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.37323>; else goto <D.37324>;
    <D.37323>:
    code.2495 = code;
    code = code.2495 + 1;
    D.37326 = _amd64_rex_bits | 64;
    *code.2495 = D.37326;
    <D.37324>:
  }
  code.2496 = code;
  code = code.2496 + 1;
  *code.2496 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2497 = code;
        code = code.2497 + 1;
        D.37329 = imb.b[0];
        *code.2497 = D.37329;
        code.2498 = code;
        code = code.2498 + 1;
        D.37331 = imb.b[1];
        *code.2498 = D.37331;
        code.2499 = code;
        code = code.2499 + 1;
        D.37333 = imb.b[2];
        *code.2499 = D.37333;
        code.2500 = code;
        code = code.2500 + 1;
        D.37335 = imb.b[3];
        *code.2500 = D.37335;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.37336>;
  <D.37322>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37338>; else goto <D.37339>;
    <D.37338>:
    iftmp.2501 = 9;
    goto <D.37340>;
    <D.37339>:
    iftmp.2501 = 8;
    <D.37340>:
    _amd64_rex_bits = iftmp.2501;
    if (_amd64_rex_bits != 0) goto <D.37341>; else goto <D.37342>;
    <D.37341>:
    code.2502 = code;
    code = code.2502 + 1;
    D.37344 = _amd64_rex_bits | 64;
    *code.2502 = D.37344;
    <D.37342>:
  }
  code.2503 = code;
  code = code.2503 + 1;
  *code.2503 = 129;
  code.2504 = code;
  code = code.2504 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.2504 = D.37319;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2505 = code;
        code = code.2505 + 1;
        D.37348 = imb.b[0];
        *code.2505 = D.37348;
        code.2506 = code;
        code = code.2506 + 1;
        D.37350 = imb.b[1];
        *code.2506 = D.37350;
        code.2507 = code;
        code = code.2507 + 1;
        D.37352 = imb.b[2];
        *code.2507 = D.37352;
        code.2508 = code;
        code = code.2508 + 1;
        D.37354 = imb.b[3];
        *code.2508 = D.37354;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37336>:
  <D.37320>:
  goto <D.25197>;
  <D.25885>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.37355>; else goto <D.37356>;
  <D.37355>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4390, "amd64_is_imm32 (ins->inst_imm)");
  <D.37356>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.37357>; else goto <D.37358>;
  <D.37357>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37360>; else goto <D.37361>;
    <D.37360>:
    iftmp.2509 = 9;
    goto <D.37362>;
    <D.37361>:
    iftmp.2509 = 8;
    <D.37362>:
    _amd64_rex_bits = iftmp.2509;
    if (_amd64_rex_bits != 0) goto <D.37363>; else goto <D.37364>;
    <D.37363>:
    code.2510 = code;
    code = code.2510 + 1;
    D.37366 = _amd64_rex_bits | 64;
    *code.2510 = D.37366;
    <D.37364>:
  }
  code.2511 = code;
  code = code.2511 + 1;
  *code.2511 = 131;
  code.2512 = code;
  code = code.2512 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37369 = D.31632 | -40;
  D.37370 = (unsigned char) D.37369;
  *code.2512 = D.37370;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.37371>;
  <D.37358>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.37372>; else goto <D.37373>;
  <D.37372>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.37374>; else goto <D.37375>;
    <D.37374>:
    code.2513 = code;
    code = code.2513 + 1;
    D.37377 = _amd64_rex_bits | 64;
    *code.2513 = D.37377;
    <D.37375>:
  }
  code.2514 = code;
  code = code.2514 + 1;
  *code.2514 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2515 = code;
        code = code.2515 + 1;
        D.37380 = imb.b[0];
        *code.2515 = D.37380;
        code.2516 = code;
        code = code.2516 + 1;
        D.37382 = imb.b[1];
        *code.2516 = D.37382;
        code.2517 = code;
        code = code.2517 + 1;
        D.37384 = imb.b[2];
        *code.2517 = D.37384;
        code.2518 = code;
        code = code.2518 + 1;
        D.37386 = imb.b[3];
        *code.2518 = D.37386;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.37387>;
  <D.37373>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.37389>; else goto <D.37390>;
    <D.37389>:
    iftmp.2519 = 9;
    goto <D.37391>;
    <D.37390>:
    iftmp.2519 = 8;
    <D.37391>:
    _amd64_rex_bits = iftmp.2519;
    if (_amd64_rex_bits != 0) goto <D.37392>; else goto <D.37393>;
    <D.37392>:
    code.2520 = code;
    code = code.2520 + 1;
    D.37395 = _amd64_rex_bits | 64;
    *code.2520 = D.37395;
    <D.37393>:
  }
  code.2521 = code;
  code = code.2521 + 1;
  *code.2521 = 129;
  code.2522 = code;
  code = code.2522 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37369 = D.31632 | -40;
  D.37370 = (unsigned char) D.37369;
  *code.2522 = D.37370;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2523 = code;
        code = code.2523 + 1;
        D.37399 = imb.b[0];
        *code.2523 = D.37399;
        code.2524 = code;
        code = code.2524 + 1;
        D.37401 = imb.b[1];
        *code.2524 = D.37401;
        code.2525 = code;
        code = code.2525 + 1;
        D.37403 = imb.b[2];
        *code.2525 = D.37403;
        code.2526 = code;
        code = code.2526 + 1;
        D.37405 = imb.b[3];
        *code.2526 = D.37405;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37387>:
  <D.37371>:
  goto <D.25197>;
  <D.25891>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37407>; else goto <D.37408>;
    <D.37407>:
    iftmp.2527 = 12;
    goto <D.37409>;
    <D.37408>:
    iftmp.2527 = 8;
    <D.37409>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.37410 = iftmp.2527 | D.33811;
    _amd64_rex_bits = (unsigned char) D.37410;
    if (_amd64_rex_bits != 0) goto <D.37411>; else goto <D.37412>;
    <D.37411>:
    code.2528 = code;
    code = code.2528 + 1;
    D.37414 = _amd64_rex_bits | 64;
    *code.2528 = D.37414;
    <D.37412>:
  }
  code.2529 = code;
  code = code.2529 + 1;
  *code.2529 = 35;
  code.2530 = code;
  code = code.2530 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.2530 = D.33821;
  goto <D.25197>;
  <D.25893>:
  <D.25894>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.37417>; else goto <D.37418>;
  <D.37417>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4398, "amd64_is_imm32 (ins->inst_imm)");
  <D.37418>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.37419>; else goto <D.37420>;
  <D.37419>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37422>; else goto <D.37423>;
    <D.37422>:
    iftmp.2531 = 9;
    goto <D.37424>;
    <D.37423>:
    iftmp.2531 = 8;
    <D.37424>:
    _amd64_rex_bits = iftmp.2531;
    if (_amd64_rex_bits != 0) goto <D.37425>; else goto <D.37426>;
    <D.37425>:
    code.2532 = code;
    code = code.2532 + 1;
    D.37428 = _amd64_rex_bits | 64;
    *code.2532 = D.37428;
    <D.37426>:
  }
  code.2533 = code;
  code = code.2533 + 1;
  *code.2533 = 131;
  code.2534 = code;
  code = code.2534 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.2534 = D.37432;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.37433>;
  <D.37420>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.37434>; else goto <D.37435>;
  <D.37434>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.37436>; else goto <D.37437>;
    <D.37436>:
    code.2535 = code;
    code = code.2535 + 1;
    D.37439 = _amd64_rex_bits | 64;
    *code.2535 = D.37439;
    <D.37437>:
  }
  code.2536 = code;
  code = code.2536 + 1;
  *code.2536 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2537 = code;
        code = code.2537 + 1;
        D.37442 = imb.b[0];
        *code.2537 = D.37442;
        code.2538 = code;
        code = code.2538 + 1;
        D.37444 = imb.b[1];
        *code.2538 = D.37444;
        code.2539 = code;
        code = code.2539 + 1;
        D.37446 = imb.b[2];
        *code.2539 = D.37446;
        code.2540 = code;
        code = code.2540 + 1;
        D.37448 = imb.b[3];
        *code.2540 = D.37448;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.37449>;
  <D.37435>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37451>; else goto <D.37452>;
    <D.37451>:
    iftmp.2541 = 9;
    goto <D.37453>;
    <D.37452>:
    iftmp.2541 = 8;
    <D.37453>:
    _amd64_rex_bits = iftmp.2541;
    if (_amd64_rex_bits != 0) goto <D.37454>; else goto <D.37455>;
    <D.37454>:
    code.2542 = code;
    code = code.2542 + 1;
    D.37457 = _amd64_rex_bits | 64;
    *code.2542 = D.37457;
    <D.37455>:
  }
  code.2543 = code;
  code = code.2543 + 1;
  *code.2543 = 129;
  code.2544 = code;
  code = code.2544 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.2544 = D.37432;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.2545 = code;
        code = code.2545 + 1;
        D.37461 = imb.b[0];
        *code.2545 = D.37461;
        code.2546 = code;
        code = code.2546 + 1;
        D.37463 = imb.b[1];
        *code.2546 = D.37463;
        code.2547 = code;
        code = code.2547 + 1;
        D.37465 = imb.b[2];
        *code.2547 = D.37465;
        code.2548 = code;
        code = code.2548 + 1;
        D.37467 = imb.b[3];
        *code.2548 = D.37467;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.37449>:
  <D.37433>:
  goto <D.25197>;
  <D.25900>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.37469>; else goto <D.37470>;
    <D.37469>:
    iftmp.2549 = 12;
    goto <D.37471>;
    <D.37470>:
    iftmp.2549 = 8;
    <D.37471>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.37472 = iftmp.2549 | D.33811;
    _amd64_rex_bits = (unsigned char) D.37472;
    if (_amd64_rex_bits != 0) goto <D.37473>; else goto <D.37474>;
    <D.37473>:
    code.2550 = code;
    code = code.2550 + 1;
    D.37476 = _amd64_rex_bits | 64;
    *code.2550 = D.37476;
    <D.37474>:
  }
  code.2551 = code;
  code = code.2551 + 1;
  *code.2551 = 15;
  code.2552 = code;
  code = code.2552 + 1;
  *code.2552 = 175;
  code.2553 = code;
  code = code.2553 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.2553 = D.33821;
  goto <D.25197>;
  <D.25902>:
  <D.25903>:
  <D.25904>:
  {
    guint32 size;

    D.31464 = ins->opcode;
    if (D.31464 == 631) goto <D.37481>; else goto <D.37482>;
    <D.37481>:
    iftmp.2554 = 4;
    goto <D.37483>;
    <D.37482>:
    iftmp.2554 = 8;
    <D.37483>:
    size = iftmp.2554;
    D.31647 = ins->data.op[1].const_val;
    switch (D.31647) <default: <D.25958>, case 2: <D.25906>, case 3: <D.25916>, case 5: <D.25920>, case 6: <D.25924>, case 9: <D.25929>, case 10: <D.25933>, case 12: <D.25938>, case 25: <D.25943>, case 100: <D.25950>>
    <D.25906>:
    D.31589 = ins->dreg;
    D.31516 = ins->sreg1;
    if (D.31589 != D.31516) goto <D.37484>; else goto <D.37485>;
    <D.37484>:
    if (size == 2) goto <D.37486>; else goto <D.37487>;
    <D.37486>:
    code.2555 = code;
    code = code.2555 + 1;
    *code.2555 = 102;
    <D.37487>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.37490>; else goto <D.37491>;
      <D.37490>:
      iftmp.2556 = 8;
      goto <D.37492>;
      <D.37491>:
      iftmp.2556 = 0;
      <D.37492>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37494>; else goto <D.37495>;
      <D.37494>:
      iftmp.2557 = 4;
      goto <D.37496>;
      <D.37495>:
      iftmp.2557 = 0;
      <D.37496>:
      D.37497 = iftmp.2556 | iftmp.2557;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37498 = D.37497 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37498;
      D.37499 = _amd64_rex_bits != 0;
      D.37500 = size == 1;
      D.37501 = D.37499 | D.37500;
      if (D.37501 != 0) goto <D.37502>; else goto <D.37503>;
      <D.37502>:
      code.2558 = code;
      code = code.2558 + 1;
      D.37505 = _amd64_rex_bits | 64;
      *code.2558 = D.37505;
      <D.37503>:
    }
    switch (size) <default: <D.25913>, case 1: <D.25908>, case 2: <D.25910>, case 4: <D.25911>, case 8: <D.25912>>
    <D.25908>:
    code.2559 = code;
    code = code.2559 + 1;
    *code.2559 = 138;
    goto <D.25909>;
    <D.25910>:
    <D.25911>:
    <D.25912>:
    code.2560 = code;
    code = code.2560 + 1;
    *code.2560 = 139;
    goto <D.25909>;
    <D.25913>:
    __assert_fail ("0", "mini-amd64.c", 4414, &__PRETTY_FUNCTION__);
    <D.25909>:
    code.2561 = code;
    code = code.2561 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.2561 = D.33727;
    <D.37485>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37510>; else goto <D.37511>;
      <D.37510>:
      iftmp.2562 = 12;
      goto <D.37512>;
      <D.37511>:
      iftmp.2562 = 8;
      <D.37512>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.37513 = iftmp.2562 | D.32040;
      _amd64_rex_bits = (unsigned char) D.37513;
      if (_amd64_rex_bits != 0) goto <D.37514>; else goto <D.37515>;
      <D.37514>:
      code.2563 = code;
      code = code.2563 + 1;
      D.37517 = _amd64_rex_bits | 64;
      *code.2563 = D.37517;
      <D.37515>:
    }
    code.2564 = code;
    code = code.2564 + 1;
    *code.2564 = 3;
    code.2565 = code;
    code = code.2565 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.2565 = D.37521;
    goto <D.25915>;
    <D.25916>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37523>; else goto <D.37524>;
      <D.37523>:
      iftmp.2566 = 12;
      goto <D.37525>;
      <D.37524>:
      iftmp.2566 = 8;
      <D.37525>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37527>; else goto <D.37528>;
      <D.37527>:
      iftmp.2567 = 2;
      goto <D.37529>;
      <D.37528>:
      iftmp.2567 = 0;
      <D.37529>:
      D.37530 = iftmp.2566 | iftmp.2567;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37531 = D.37530 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37531;
      if (_amd64_rex_bits != 0) goto <D.37532>; else goto <D.37533>;
      <D.37532>:
      code.2568 = code;
      code = code.2568 + 1;
      D.37535 = _amd64_rex_bits | 64;
      *code.2568 = D.37535;
      <D.37533>:
    }
    code.2569 = code;
    code = code.2569 + 1;
    *code.2569 = 141;
    if (0 != 0) goto <D.37537>; else goto <D.37538>;
    <D.37537>:
    code.2570 = code;
    code = code.2570 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2570 = D.32644;
    code.2571 = code;
    code = code.2571 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37541 = D.32054 | 69;
    D.37542 = (unsigned char) D.37541;
    *code.2571 = D.37542;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2572 = code;
          code = code.2572 + 1;
          D.37544 = imb.b[0];
          *code.2572 = D.37544;
          code.2573 = code;
          code = code.2573 + 1;
          D.37546 = imb.b[1];
          *code.2573 = D.37546;
          code.2574 = code;
          code = code.2574 + 1;
          D.37548 = imb.b[2];
          *code.2574 = D.37548;
          code.2575 = code;
          code = code.2575 + 1;
          D.37550 = imb.b[3];
          *code.2575 = D.37550;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37551>;
    <D.37538>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37552>; else goto <D.37553>;
    <D.37552>:
    code.2576 = code;
    code = code.2576 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2576 = D.32644;
    code.2577 = code;
    code = code.2577 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2577 = D.37557;
    goto <D.37558>;
    <D.37553>:
    if (1 != 0) goto <D.37559>; else goto <D.37560>;
    <D.37559>:
    code.2578 = code;
    code = code.2578 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2578 = D.32735;
    code.2579 = code;
    code = code.2579 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2579 = D.37557;
    *code = 0;
    code = code + 1;
    goto <D.37563>;
    <D.37560>:
    code.2580 = code;
    code = code.2580 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2580 = D.32740;
    code.2581 = code;
    code = code.2581 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2581 = D.37557;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2582 = code;
          code = code.2582 + 1;
          D.37567 = imb.b[0];
          *code.2582 = D.37567;
          code.2583 = code;
          code = code.2583 + 1;
          D.37569 = imb.b[1];
          *code.2583 = D.37569;
          code.2584 = code;
          code = code.2584 + 1;
          D.37571 = imb.b[2];
          *code.2584 = D.37571;
          code.2585 = code;
          code = code.2585 + 1;
          D.37573 = imb.b[3];
          *code.2585 = D.37573;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37563>:
    <D.37558>:
    <D.37551>:
    goto <D.25915>;
    <D.25920>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37575>; else goto <D.37576>;
      <D.37575>:
      iftmp.2586 = 12;
      goto <D.37577>;
      <D.37576>:
      iftmp.2586 = 8;
      <D.37577>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37579>; else goto <D.37580>;
      <D.37579>:
      iftmp.2587 = 2;
      goto <D.37581>;
      <D.37580>:
      iftmp.2587 = 0;
      <D.37581>:
      D.37582 = iftmp.2586 | iftmp.2587;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37583 = D.37582 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37583;
      if (_amd64_rex_bits != 0) goto <D.37584>; else goto <D.37585>;
      <D.37584>:
      code.2588 = code;
      code = code.2588 + 1;
      D.37587 = _amd64_rex_bits | 64;
      *code.2588 = D.37587;
      <D.37585>:
    }
    code.2589 = code;
    code = code.2589 + 1;
    *code.2589 = 141;
    if (0 != 0) goto <D.37589>; else goto <D.37590>;
    <D.37589>:
    code.2590 = code;
    code = code.2590 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2590 = D.32644;
    code.2591 = code;
    code = code.2591 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37593 = D.32054 | -123;
    D.37594 = (unsigned char) D.37593;
    *code.2591 = D.37594;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2592 = code;
          code = code.2592 + 1;
          D.37596 = imb.b[0];
          *code.2592 = D.37596;
          code.2593 = code;
          code = code.2593 + 1;
          D.37598 = imb.b[1];
          *code.2593 = D.37598;
          code.2594 = code;
          code = code.2594 + 1;
          D.37600 = imb.b[2];
          *code.2594 = D.37600;
          code.2595 = code;
          code = code.2595 + 1;
          D.37602 = imb.b[3];
          *code.2595 = D.37602;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37603>;
    <D.37590>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37604>; else goto <D.37605>;
    <D.37604>:
    code.2596 = code;
    code = code.2596 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2596 = D.32644;
    code.2597 = code;
    code = code.2597 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2597 = D.37609;
    goto <D.37610>;
    <D.37605>:
    if (1 != 0) goto <D.37611>; else goto <D.37612>;
    <D.37611>:
    code.2598 = code;
    code = code.2598 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2598 = D.32735;
    code.2599 = code;
    code = code.2599 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2599 = D.37609;
    *code = 0;
    code = code + 1;
    goto <D.37615>;
    <D.37612>:
    code.2600 = code;
    code = code.2600 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2600 = D.32740;
    code.2601 = code;
    code = code.2601 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2601 = D.37609;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2602 = code;
          code = code.2602 + 1;
          D.37619 = imb.b[0];
          *code.2602 = D.37619;
          code.2603 = code;
          code = code.2603 + 1;
          D.37621 = imb.b[1];
          *code.2603 = D.37621;
          code.2604 = code;
          code = code.2604 + 1;
          D.37623 = imb.b[2];
          *code.2604 = D.37623;
          code.2605 = code;
          code = code.2605 + 1;
          D.37625 = imb.b[3];
          *code.2605 = D.37625;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37615>:
    <D.37610>:
    <D.37603>:
    goto <D.25915>;
    <D.25924>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37627>; else goto <D.37628>;
      <D.37627>:
      iftmp.2606 = 12;
      goto <D.37629>;
      <D.37628>:
      iftmp.2606 = 8;
      <D.37629>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37631>; else goto <D.37632>;
      <D.37631>:
      iftmp.2607 = 2;
      goto <D.37633>;
      <D.37632>:
      iftmp.2607 = 0;
      <D.37633>:
      D.37634 = iftmp.2606 | iftmp.2607;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37635 = D.37634 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37635;
      if (_amd64_rex_bits != 0) goto <D.37636>; else goto <D.37637>;
      <D.37636>:
      code.2608 = code;
      code = code.2608 + 1;
      D.37639 = _amd64_rex_bits | 64;
      *code.2608 = D.37639;
      <D.37637>:
    }
    code.2609 = code;
    code = code.2609 + 1;
    *code.2609 = 141;
    if (0 != 0) goto <D.37641>; else goto <D.37642>;
    <D.37641>:
    code.2610 = code;
    code = code.2610 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2610 = D.32644;
    code.2611 = code;
    code = code.2611 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37541 = D.32054 | 69;
    D.37542 = (unsigned char) D.37541;
    *code.2611 = D.37542;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2612 = code;
          code = code.2612 + 1;
          D.37646 = imb.b[0];
          *code.2612 = D.37646;
          code.2613 = code;
          code = code.2613 + 1;
          D.37648 = imb.b[1];
          *code.2613 = D.37648;
          code.2614 = code;
          code = code.2614 + 1;
          D.37650 = imb.b[2];
          *code.2614 = D.37650;
          code.2615 = code;
          code = code.2615 + 1;
          D.37652 = imb.b[3];
          *code.2615 = D.37652;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37653>;
    <D.37642>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37654>; else goto <D.37655>;
    <D.37654>:
    code.2616 = code;
    code = code.2616 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2616 = D.32644;
    code.2617 = code;
    code = code.2617 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2617 = D.37557;
    goto <D.37658>;
    <D.37655>:
    if (1 != 0) goto <D.37659>; else goto <D.37660>;
    <D.37659>:
    code.2618 = code;
    code = code.2618 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2618 = D.32735;
    code.2619 = code;
    code = code.2619 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2619 = D.37557;
    *code = 0;
    code = code + 1;
    goto <D.37663>;
    <D.37660>:
    code.2620 = code;
    code = code.2620 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2620 = D.32740;
    code.2621 = code;
    code = code.2621 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2621 = D.37557;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2622 = code;
          code = code.2622 + 1;
          D.37667 = imb.b[0];
          *code.2622 = D.37667;
          code.2623 = code;
          code = code.2623 + 1;
          D.37669 = imb.b[1];
          *code.2623 = D.37669;
          code.2624 = code;
          code = code.2624 + 1;
          D.37671 = imb.b[2];
          *code.2624 = D.37671;
          code.2625 = code;
          code = code.2625 + 1;
          D.37673 = imb.b[3];
          *code.2625 = D.37673;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37663>:
    <D.37658>:
    <D.37653>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37675>; else goto <D.37676>;
      <D.37675>:
      iftmp.2626 = 12;
      goto <D.37677>;
      <D.37676>:
      iftmp.2626 = 8;
      <D.37677>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.37678 = iftmp.2626 | D.32040;
      _amd64_rex_bits = (unsigned char) D.37678;
      if (_amd64_rex_bits != 0) goto <D.37679>; else goto <D.37680>;
      <D.37679>:
      code.2627 = code;
      code = code.2627 + 1;
      D.37682 = _amd64_rex_bits | 64;
      *code.2627 = D.37682;
      <D.37680>:
    }
    code.2628 = code;
    code = code.2628 + 1;
    *code.2628 = 3;
    code.2629 = code;
    code = code.2629 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.2629 = D.37521;
    goto <D.25915>;
    <D.25929>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37686>; else goto <D.37687>;
      <D.37686>:
      iftmp.2630 = 12;
      goto <D.37688>;
      <D.37687>:
      iftmp.2630 = 8;
      <D.37688>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37690>; else goto <D.37691>;
      <D.37690>:
      iftmp.2631 = 2;
      goto <D.37692>;
      <D.37691>:
      iftmp.2631 = 0;
      <D.37692>:
      D.37693 = iftmp.2630 | iftmp.2631;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37694 = D.37693 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37694;
      if (_amd64_rex_bits != 0) goto <D.37695>; else goto <D.37696>;
      <D.37695>:
      code.2632 = code;
      code = code.2632 + 1;
      D.37698 = _amd64_rex_bits | 64;
      *code.2632 = D.37698;
      <D.37696>:
    }
    code.2633 = code;
    code = code.2633 + 1;
    *code.2633 = 141;
    if (0 != 0) goto <D.37700>; else goto <D.37701>;
    <D.37700>:
    code.2634 = code;
    code = code.2634 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2634 = D.32644;
    code.2635 = code;
    code = code.2635 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37704 = D.32054 | -59;
    D.37705 = (unsigned char) D.37704;
    *code.2635 = D.37705;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2636 = code;
          code = code.2636 + 1;
          D.37707 = imb.b[0];
          *code.2636 = D.37707;
          code.2637 = code;
          code = code.2637 + 1;
          D.37709 = imb.b[1];
          *code.2637 = D.37709;
          code.2638 = code;
          code = code.2638 + 1;
          D.37711 = imb.b[2];
          *code.2638 = D.37711;
          code.2639 = code;
          code = code.2639 + 1;
          D.37713 = imb.b[3];
          *code.2639 = D.37713;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37714>;
    <D.37701>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37715>; else goto <D.37716>;
    <D.37715>:
    code.2640 = code;
    code = code.2640 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2640 = D.32644;
    code.2641 = code;
    code = code.2641 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.33819 = D.32054 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33956 = D.33819 | D.31571;
    D.33957 = (unsigned char) D.33956;
    *code.2641 = D.33957;
    goto <D.37719>;
    <D.37716>:
    if (1 != 0) goto <D.37720>; else goto <D.37721>;
    <D.37720>:
    code.2642 = code;
    code = code.2642 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2642 = D.32735;
    code.2643 = code;
    code = code.2643 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.33819 = D.32054 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33956 = D.33819 | D.31571;
    D.33957 = (unsigned char) D.33956;
    *code.2643 = D.33957;
    *code = 0;
    code = code + 1;
    goto <D.37724>;
    <D.37721>:
    code.2644 = code;
    code = code.2644 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2644 = D.32740;
    code.2645 = code;
    code = code.2645 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.33819 = D.32054 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33956 = D.33819 | D.31571;
    D.33957 = (unsigned char) D.33956;
    *code.2645 = D.33957;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2646 = code;
          code = code.2646 + 1;
          D.37728 = imb.b[0];
          *code.2646 = D.37728;
          code.2647 = code;
          code = code.2647 + 1;
          D.37730 = imb.b[1];
          *code.2647 = D.37730;
          code.2648 = code;
          code = code.2648 + 1;
          D.37732 = imb.b[2];
          *code.2648 = D.37732;
          code.2649 = code;
          code = code.2649 + 1;
          D.37734 = imb.b[3];
          *code.2649 = D.37734;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37724>:
    <D.37719>:
    <D.37714>:
    goto <D.25915>;
    <D.25933>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37736>; else goto <D.37737>;
      <D.37736>:
      iftmp.2650 = 12;
      goto <D.37738>;
      <D.37737>:
      iftmp.2650 = 8;
      <D.37738>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37740>; else goto <D.37741>;
      <D.37740>:
      iftmp.2651 = 2;
      goto <D.37742>;
      <D.37741>:
      iftmp.2651 = 0;
      <D.37742>:
      D.37743 = iftmp.2650 | iftmp.2651;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37744 = D.37743 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37744;
      if (_amd64_rex_bits != 0) goto <D.37745>; else goto <D.37746>;
      <D.37745>:
      code.2652 = code;
      code = code.2652 + 1;
      D.37748 = _amd64_rex_bits | 64;
      *code.2652 = D.37748;
      <D.37746>:
    }
    code.2653 = code;
    code = code.2653 + 1;
    *code.2653 = 141;
    if (0 != 0) goto <D.37750>; else goto <D.37751>;
    <D.37750>:
    code.2654 = code;
    code = code.2654 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2654 = D.32644;
    code.2655 = code;
    code = code.2655 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37593 = D.32054 | -123;
    D.37594 = (unsigned char) D.37593;
    *code.2655 = D.37594;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2656 = code;
          code = code.2656 + 1;
          D.37755 = imb.b[0];
          *code.2656 = D.37755;
          code.2657 = code;
          code = code.2657 + 1;
          D.37757 = imb.b[1];
          *code.2657 = D.37757;
          code.2658 = code;
          code = code.2658 + 1;
          D.37759 = imb.b[2];
          *code.2658 = D.37759;
          code.2659 = code;
          code = code.2659 + 1;
          D.37761 = imb.b[3];
          *code.2659 = D.37761;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37762>;
    <D.37751>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37763>; else goto <D.37764>;
    <D.37763>:
    code.2660 = code;
    code = code.2660 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2660 = D.32644;
    code.2661 = code;
    code = code.2661 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2661 = D.37609;
    goto <D.37767>;
    <D.37764>:
    if (1 != 0) goto <D.37768>; else goto <D.37769>;
    <D.37768>:
    code.2662 = code;
    code = code.2662 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2662 = D.32735;
    code.2663 = code;
    code = code.2663 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2663 = D.37609;
    *code = 0;
    code = code + 1;
    goto <D.37772>;
    <D.37769>:
    code.2664 = code;
    code = code.2664 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2664 = D.32740;
    code.2665 = code;
    code = code.2665 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2665 = D.37609;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2666 = code;
          code = code.2666 + 1;
          D.37776 = imb.b[0];
          *code.2666 = D.37776;
          code.2667 = code;
          code = code.2667 + 1;
          D.37778 = imb.b[1];
          *code.2667 = D.37778;
          code.2668 = code;
          code = code.2668 + 1;
          D.37780 = imb.b[2];
          *code.2668 = D.37780;
          code.2669 = code;
          code = code.2669 + 1;
          D.37782 = imb.b[3];
          *code.2669 = D.37782;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37772>:
    <D.37767>:
    <D.37762>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37784>; else goto <D.37785>;
      <D.37784>:
      iftmp.2670 = 12;
      goto <D.37786>;
      <D.37785>:
      iftmp.2670 = 8;
      <D.37786>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.37787 = iftmp.2670 | D.32040;
      _amd64_rex_bits = (unsigned char) D.37787;
      if (_amd64_rex_bits != 0) goto <D.37788>; else goto <D.37789>;
      <D.37788>:
      code.2671 = code;
      code = code.2671 + 1;
      D.37791 = _amd64_rex_bits | 64;
      *code.2671 = D.37791;
      <D.37789>:
    }
    code.2672 = code;
    code = code.2672 + 1;
    *code.2672 = 3;
    code.2673 = code;
    code = code.2673 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.2673 = D.37521;
    goto <D.25915>;
    <D.25938>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37795>; else goto <D.37796>;
      <D.37795>:
      iftmp.2674 = 12;
      goto <D.37797>;
      <D.37796>:
      iftmp.2674 = 8;
      <D.37797>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37799>; else goto <D.37800>;
      <D.37799>:
      iftmp.2675 = 2;
      goto <D.37801>;
      <D.37800>:
      iftmp.2675 = 0;
      <D.37801>:
      D.37802 = iftmp.2674 | iftmp.2675;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37803 = D.37802 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37803;
      if (_amd64_rex_bits != 0) goto <D.37804>; else goto <D.37805>;
      <D.37804>:
      code.2676 = code;
      code = code.2676 + 1;
      D.37807 = _amd64_rex_bits | 64;
      *code.2676 = D.37807;
      <D.37805>:
    }
    code.2677 = code;
    code = code.2677 + 1;
    *code.2677 = 141;
    if (0 != 0) goto <D.37809>; else goto <D.37810>;
    <D.37809>:
    code.2678 = code;
    code = code.2678 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2678 = D.32644;
    code.2679 = code;
    code = code.2679 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37541 = D.32054 | 69;
    D.37542 = (unsigned char) D.37541;
    *code.2679 = D.37542;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2680 = code;
          code = code.2680 + 1;
          D.37814 = imb.b[0];
          *code.2680 = D.37814;
          code.2681 = code;
          code = code.2681 + 1;
          D.37816 = imb.b[1];
          *code.2681 = D.37816;
          code.2682 = code;
          code = code.2682 + 1;
          D.37818 = imb.b[2];
          *code.2682 = D.37818;
          code.2683 = code;
          code = code.2683 + 1;
          D.37820 = imb.b[3];
          *code.2683 = D.37820;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37821>;
    <D.37810>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37822>; else goto <D.37823>;
    <D.37822>:
    code.2684 = code;
    code = code.2684 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2684 = D.32644;
    code.2685 = code;
    code = code.2685 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2685 = D.37557;
    goto <D.37826>;
    <D.37823>:
    if (1 != 0) goto <D.37827>; else goto <D.37828>;
    <D.37827>:
    code.2686 = code;
    code = code.2686 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2686 = D.32735;
    code.2687 = code;
    code = code.2687 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2687 = D.37557;
    *code = 0;
    code = code + 1;
    goto <D.37831>;
    <D.37828>:
    code.2688 = code;
    code = code.2688 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2688 = D.32740;
    code.2689 = code;
    code = code.2689 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37556 = D.32088 | D.31571;
    D.37557 = (unsigned char) D.37556;
    *code.2689 = D.37557;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2690 = code;
          code = code.2690 + 1;
          D.37835 = imb.b[0];
          *code.2690 = D.37835;
          code.2691 = code;
          code = code.2691 + 1;
          D.37837 = imb.b[1];
          *code.2691 = D.37837;
          code.2692 = code;
          code = code.2692 + 1;
          D.37839 = imb.b[2];
          *code.2692 = D.37839;
          code.2693 = code;
          code = code.2693 + 1;
          D.37841 = imb.b[3];
          *code.2693 = D.37841;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37831>:
    <D.37826>:
    <D.37821>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37843>; else goto <D.37844>;
      <D.37843>:
      iftmp.2694 = 9;
      goto <D.37845>;
      <D.37844>:
      iftmp.2694 = 8;
      <D.37845>:
      _amd64_rex_bits = iftmp.2694;
      if (_amd64_rex_bits != 0) goto <D.37846>; else goto <D.37847>;
      <D.37846>:
      code.2695 = code;
      code = code.2695 + 1;
      D.37849 = _amd64_rex_bits | 64;
      *code.2695 = D.37849;
      <D.37847>:
    }
    if (0 != 0) goto <D.37850>; else goto <D.37851>;
    <D.37850>:
    code.2696 = code;
    code = code.2696 + 1;
    *code.2696 = 209;
    code.2697 = code;
    code = code.2697 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37854 = D.31632 | -32;
    D.37855 = (unsigned char) D.37854;
    *code.2697 = D.37855;
    goto <D.37856>;
    <D.37851>:
    code.2698 = code;
    code = code.2698 + 1;
    *code.2698 = 193;
    code.2699 = code;
    code = code.2699 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37854 = D.31632 | -32;
    D.37855 = (unsigned char) D.37854;
    *code.2699 = D.37855;
    *code = 2;
    code = code + 1;
    <D.37856>:
    goto <D.25915>;
    <D.25943>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37860>; else goto <D.37861>;
      <D.37860>:
      iftmp.2700 = 12;
      goto <D.37862>;
      <D.37861>:
      iftmp.2700 = 8;
      <D.37862>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37864>; else goto <D.37865>;
      <D.37864>:
      iftmp.2701 = 2;
      goto <D.37866>;
      <D.37865>:
      iftmp.2701 = 0;
      <D.37866>:
      D.37867 = iftmp.2700 | iftmp.2701;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37868 = D.37867 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37868;
      if (_amd64_rex_bits != 0) goto <D.37869>; else goto <D.37870>;
      <D.37869>:
      code.2702 = code;
      code = code.2702 + 1;
      D.37872 = _amd64_rex_bits | 64;
      *code.2702 = D.37872;
      <D.37870>:
    }
    code.2703 = code;
    code = code.2703 + 1;
    *code.2703 = 141;
    if (0 != 0) goto <D.37874>; else goto <D.37875>;
    <D.37874>:
    code.2704 = code;
    code = code.2704 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2704 = D.32644;
    code.2705 = code;
    code = code.2705 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37593 = D.32054 | -123;
    D.37594 = (unsigned char) D.37593;
    *code.2705 = D.37594;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2706 = code;
          code = code.2706 + 1;
          D.37879 = imb.b[0];
          *code.2706 = D.37879;
          code.2707 = code;
          code = code.2707 + 1;
          D.37881 = imb.b[1];
          *code.2707 = D.37881;
          code.2708 = code;
          code = code.2708 + 1;
          D.37883 = imb.b[2];
          *code.2708 = D.37883;
          code.2709 = code;
          code = code.2709 + 1;
          D.37885 = imb.b[3];
          *code.2709 = D.37885;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37886>;
    <D.37875>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37887>; else goto <D.37888>;
    <D.37887>:
    code.2710 = code;
    code = code.2710 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2710 = D.32644;
    code.2711 = code;
    code = code.2711 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2711 = D.37609;
    goto <D.37891>;
    <D.37888>:
    if (1 != 0) goto <D.37892>; else goto <D.37893>;
    <D.37892>:
    code.2712 = code;
    code = code.2712 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2712 = D.32735;
    code.2713 = code;
    code = code.2713 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2713 = D.37609;
    *code = 0;
    code = code + 1;
    goto <D.37896>;
    <D.37893>:
    code.2714 = code;
    code = code.2714 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2714 = D.32740;
    code.2715 = code;
    code = code.2715 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2715 = D.37609;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2716 = code;
          code = code.2716 + 1;
          D.37900 = imb.b[0];
          *code.2716 = D.37900;
          code.2717 = code;
          code = code.2717 + 1;
          D.37902 = imb.b[1];
          *code.2717 = D.37902;
          code.2718 = code;
          code = code.2718 + 1;
          D.37904 = imb.b[2];
          *code.2718 = D.37904;
          code.2719 = code;
          code = code.2719 + 1;
          D.37906 = imb.b[3];
          *code.2719 = D.37906;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37896>:
    <D.37891>:
    <D.37886>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37908>; else goto <D.37909>;
      <D.37908>:
      iftmp.2720 = 12;
      goto <D.37910>;
      <D.37909>:
      iftmp.2720 = 8;
      <D.37910>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37912>; else goto <D.37913>;
      <D.37912>:
      iftmp.2721 = 2;
      goto <D.37914>;
      <D.37913>:
      iftmp.2721 = 0;
      <D.37914>:
      D.37915 = iftmp.2720 | iftmp.2721;
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.37916 = D.37915 | D.32040;
      _amd64_rex_bits = (unsigned char) D.37916;
      if (_amd64_rex_bits != 0) goto <D.37917>; else goto <D.37918>;
      <D.37917>:
      code.2722 = code;
      code = code.2722 + 1;
      D.37920 = _amd64_rex_bits | 64;
      *code.2722 = D.37920;
      <D.37918>:
    }
    code.2723 = code;
    code = code.2723 + 1;
    *code.2723 = 141;
    if (0 != 0) goto <D.37922>; else goto <D.37923>;
    <D.37922>:
    code.2724 = code;
    code = code.2724 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2724 = D.32644;
    code.2725 = code;
    code = code.2725 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.37926 = D.32642 | -123;
    D.37927 = (unsigned char) D.37926;
    *code.2725 = D.37927;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2726 = code;
          code = code.2726 + 1;
          D.37929 = imb.b[0];
          *code.2726 = D.37929;
          code.2727 = code;
          code = code.2727 + 1;
          D.37931 = imb.b[1];
          *code.2727 = D.37931;
          code.2728 = code;
          code = code.2728 + 1;
          D.37933 = imb.b[2];
          *code.2728 = D.37933;
          code.2729 = code;
          code = code.2729 + 1;
          D.37935 = imb.b[3];
          *code.2729 = D.37935;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37936>;
    <D.37923>:
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    if (D.31598 != 5) goto <D.37937>; else goto <D.37938>;
    <D.37937>:
    code.2730 = code;
    code = code.2730 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2730 = D.32644;
    code.2731 = code;
    code = code.2731 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.2731 = D.32765;
    goto <D.37941>;
    <D.37938>:
    if (1 != 0) goto <D.37942>; else goto <D.37943>;
    <D.37942>:
    code.2732 = code;
    code = code.2732 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2732 = D.32735;
    code.2733 = code;
    code = code.2733 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.2733 = D.32765;
    *code = 0;
    code = code + 1;
    goto <D.37946>;
    <D.37943>:
    code.2734 = code;
    code = code.2734 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2734 = D.32740;
    code.2735 = code;
    code = code.2735 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.2735 = D.32765;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2736 = code;
          code = code.2736 + 1;
          D.37950 = imb.b[0];
          *code.2736 = D.37950;
          code.2737 = code;
          code = code.2737 + 1;
          D.37952 = imb.b[1];
          *code.2737 = D.37952;
          code.2738 = code;
          code = code.2738 + 1;
          D.37954 = imb.b[2];
          *code.2738 = D.37954;
          code.2739 = code;
          code = code.2739 + 1;
          D.37956 = imb.b[3];
          *code.2739 = D.37956;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37946>:
    <D.37941>:
    <D.37936>:
    goto <D.25915>;
    <D.25950>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.37958>; else goto <D.37959>;
      <D.37958>:
      iftmp.2740 = 12;
      goto <D.37960>;
      <D.37959>:
      iftmp.2740 = 8;
      <D.37960>:
      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.37962>; else goto <D.37963>;
      <D.37962>:
      iftmp.2741 = 2;
      goto <D.37964>;
      <D.37963>:
      iftmp.2741 = 0;
      <D.37964>:
      D.37965 = iftmp.2740 | iftmp.2741;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.37966 = D.37965 | D.33180;
      _amd64_rex_bits = (unsigned char) D.37966;
      if (_amd64_rex_bits != 0) goto <D.37967>; else goto <D.37968>;
      <D.37967>:
      code.2742 = code;
      code = code.2742 + 1;
      D.37970 = _amd64_rex_bits | 64;
      *code.2742 = D.37970;
      <D.37968>:
    }
    code.2743 = code;
    code = code.2743 + 1;
    *code.2743 = 141;
    if (0 != 0) goto <D.37972>; else goto <D.37973>;
    <D.37972>:
    code.2744 = code;
    code = code.2744 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2744 = D.32644;
    code.2745 = code;
    code = code.2745 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.37593 = D.32054 | -123;
    D.37594 = (unsigned char) D.37593;
    *code.2745 = D.37594;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2746 = code;
          code = code.2746 + 1;
          D.37977 = imb.b[0];
          *code.2746 = D.37977;
          code.2747 = code;
          code = code.2747 + 1;
          D.37979 = imb.b[1];
          *code.2747 = D.37979;
          code.2748 = code;
          code = code.2748 + 1;
          D.37981 = imb.b[2];
          *code.2748 = D.37981;
          code.2749 = code;
          code = code.2749 + 1;
          D.37983 = imb.b[3];
          *code.2749 = D.37983;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.37984>;
    <D.37973>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.37985>; else goto <D.37986>;
    <D.37985>:
    code.2750 = code;
    code = code.2750 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2750 = D.32644;
    code.2751 = code;
    code = code.2751 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2751 = D.37609;
    goto <D.37989>;
    <D.37986>:
    if (1 != 0) goto <D.37990>; else goto <D.37991>;
    <D.37990>:
    code.2752 = code;
    code = code.2752 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2752 = D.32735;
    code.2753 = code;
    code = code.2753 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2753 = D.37609;
    *code = 0;
    code = code + 1;
    goto <D.37994>;
    <D.37991>:
    code.2754 = code;
    code = code.2754 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2754 = D.32740;
    code.2755 = code;
    code = code.2755 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.37608 = D.32093 | D.31571;
    D.37609 = (unsigned char) D.37608;
    *code.2755 = D.37609;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2756 = code;
          code = code.2756 + 1;
          D.37998 = imb.b[0];
          *code.2756 = D.37998;
          code.2757 = code;
          code = code.2757 + 1;
          D.38000 = imb.b[1];
          *code.2757 = D.38000;
          code.2758 = code;
          code = code.2758 + 1;
          D.38002 = imb.b[2];
          *code.2758 = D.38002;
          code.2759 = code;
          code = code.2759 + 1;
          D.38004 = imb.b[3];
          *code.2759 = D.38004;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.37994>:
    <D.37989>:
    <D.37984>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.38006>; else goto <D.38007>;
      <D.38006>:
      iftmp.2760 = 9;
      goto <D.38008>;
      <D.38007>:
      iftmp.2760 = 8;
      <D.38008>:
      _amd64_rex_bits = iftmp.2760;
      if (_amd64_rex_bits != 0) goto <D.38009>; else goto <D.38010>;
      <D.38009>:
      code.2761 = code;
      code = code.2761 + 1;
      D.38012 = _amd64_rex_bits | 64;
      *code.2761 = D.38012;
      <D.38010>:
    }
    if (0 != 0) goto <D.38013>; else goto <D.38014>;
    <D.38013>:
    code.2762 = code;
    code = code.2762 + 1;
    *code.2762 = 209;
    code.2763 = code;
    code = code.2763 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37854 = D.31632 | -32;
    D.37855 = (unsigned char) D.37854;
    *code.2763 = D.37855;
    goto <D.38017>;
    <D.38014>:
    code.2764 = code;
    code = code.2764 + 1;
    *code.2764 = 193;
    code.2765 = code;
    code = code.2765 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37854 = D.31632 | -32;
    D.37855 = (unsigned char) D.37854;
    *code.2765 = D.37855;
    *code = 2;
    code = code + 1;
    <D.38017>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.38021>; else goto <D.38022>;
      <D.38021>:
      iftmp.2766 = 12;
      goto <D.38023>;
      <D.38022>:
      iftmp.2766 = 8;
      <D.38023>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.38025>; else goto <D.38026>;
      <D.38025>:
      iftmp.2767 = 2;
      goto <D.38027>;
      <D.38026>:
      iftmp.2767 = 0;
      <D.38027>:
      D.38028 = iftmp.2766 | iftmp.2767;
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.38029 = D.38028 | D.32040;
      _amd64_rex_bits = (unsigned char) D.38029;
      if (_amd64_rex_bits != 0) goto <D.38030>; else goto <D.38031>;
      <D.38030>:
      code.2768 = code;
      code = code.2768 + 1;
      D.38033 = _amd64_rex_bits | 64;
      *code.2768 = D.38033;
      <D.38031>:
    }
    code.2769 = code;
    code = code.2769 + 1;
    *code.2769 = 141;
    if (0 != 0) goto <D.38035>; else goto <D.38036>;
    <D.38035>:
    code.2770 = code;
    code = code.2770 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2770 = D.32644;
    code.2771 = code;
    code = code.2771 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.37926 = D.32642 | -123;
    D.37927 = (unsigned char) D.37926;
    *code.2771 = D.37927;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2772 = code;
          code = code.2772 + 1;
          D.38040 = imb.b[0];
          *code.2772 = D.38040;
          code.2773 = code;
          code = code.2773 + 1;
          D.38042 = imb.b[1];
          *code.2773 = D.38042;
          code.2774 = code;
          code = code.2774 + 1;
          D.38044 = imb.b[2];
          *code.2774 = D.38044;
          code.2775 = code;
          code = code.2775 + 1;
          D.38046 = imb.b[3];
          *code.2775 = D.38046;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.38047>;
    <D.38036>:
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    if (D.31598 != 5) goto <D.38048>; else goto <D.38049>;
    <D.38048>:
    code.2776 = code;
    code = code.2776 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.2776 = D.32644;
    code.2777 = code;
    code = code.2777 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.2777 = D.32765;
    goto <D.38052>;
    <D.38049>:
    if (1 != 0) goto <D.38053>; else goto <D.38054>;
    <D.38053>:
    code.2778 = code;
    code = code.2778 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.2778 = D.32735;
    code.2779 = code;
    code = code.2779 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.2779 = D.32765;
    *code = 0;
    code = code + 1;
    goto <D.38057>;
    <D.38054>:
    code.2780 = code;
    code = code.2780 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.2780 = D.32740;
    code.2781 = code;
    code = code.2781 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.32764 = D.32763 | D.31632;
    D.32765 = (unsigned char) D.32764;
    *code.2781 = D.32765;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.2782 = code;
          code = code.2782 + 1;
          D.38061 = imb.b[0];
          *code.2782 = D.38061;
          code.2783 = code;
          code = code.2783 + 1;
          D.38063 = imb.b[1];
          *code.2783 = D.38063;
          code.2784 = code;
          code = code.2784 + 1;
          D.38065 = imb.b[2];
          *code.2784 = D.38065;
          code.2785 = code;
          code = code.2785 + 1;
          D.38067 = imb.b[3];
          *code.2785 = D.38067;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.38057>:
    <D.38052>:
    <D.38047>:
    goto <D.25915>;
    <D.25958>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.38069>; else goto <D.38070>;
      <D.38069>:
      iftmp.2786 = 8;
      goto <D.38071>;
      <D.38070>:
      iftmp.2786 = 0;
      <D.38071>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.38073>; else goto <D.38074>;
      <D.38073>:
      iftmp.2787 = 4;
      goto <D.38075>;
      <D.38074>:
      iftmp.2787 = 0;
      <D.38075>:
      D.38076 = iftmp.2786 | iftmp.2787;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.38077 = D.38076 | D.33180;
      _amd64_rex_bits = (unsigned char) D.38077;
      D.38078 = _amd64_rex_bits != 0;
      D.37500 = size == 1;
      D.38079 = D.38078 | D.37500;
      if (D.38079 != 0) goto <D.38080>; else goto <D.38081>;
      <D.38080>:
      code.2788 = code;
      code = code.2788 + 1;
      D.38083 = _amd64_rex_bits | 64;
      *code.2788 = D.38083;
      <D.38081>:
    }
    D.31647 = ins->data.op[1].const_val;
    D.33824 = (unsigned int) D.31647;
    D.33825 = D.33824 + 128;
    if (D.33825 <= 255) goto <D.38084>; else goto <D.38085>;
    <D.38084>:
    code.2789 = code;
    code = code.2789 + 1;
    *code.2789 = 107;
    code.2790 = code;
    code = code.2790 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.2790 = D.33727;
    D.31647 = ins->data.op[1].const_val;
    D.31648 = (unsigned char) D.31647;
    *code = D.31648;
    code = code + 1;
    goto <D.38088>;
    <D.38085>:
    code.2791 = code;
    code = code.2791 + 1;
    *code.2791 = 105;
    code.2792 = code;
    code = code.2792 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33726 = D.33725 | D.31571;
    D.33727 = (unsigned char) D.33726;
    *code.2792 = D.33727;
    {
      union x86_imm_buf imb;

      try
        {
          D.31647 = ins->data.op[1].const_val;
          D.31736 = (int) D.31647;
          imb.val = D.31736;
          code.2793 = code;
          code = code.2793 + 1;
          D.38092 = imb.b[0];
          *code.2793 = D.38092;
          code.2794 = code;
          code = code.2794 + 1;
          D.38094 = imb.b[1];
          *code.2794 = D.38094;
          code.2795 = code;
          code = code.2795 + 1;
          D.38096 = imb.b[2];
          *code.2795 = D.38096;
          code.2796 = code;
          code = code.2796 + 1;
          D.38098 = imb.b[3];
          *code.2796 = D.38098;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.38088>:
    goto <D.25915>;
    <D.25915>:
    goto <D.25197>;
  }
  <D.25961>:
  <D.25962>:
  D.31490 = ins->sreg2;
  if (D.31490 == 2) goto <D.38099>; else goto <D.38100>;
  <D.38099>:
  if (0 != 0) goto <D.38101>; else goto <D.38102>;
  <D.38101>:
  code.2797 = code;
  code = code.2797 + 1;
  *code.2797 = 102;
  <D.38102>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38104>; else goto <D.38105>;
    <D.38104>:
    code.2798 = code;
    code = code.2798 + 1;
    D.38107 = _amd64_rex_bits | 64;
    *code.2798 = D.38107;
    <D.38105>:
  }
  switch (8) <default: <D.25969>, case 1: <D.25964>, case 2: <D.25966>, case 4: <D.25967>, case 8: <D.25968>>
  <D.25964>:
  code.2799 = code;
  code = code.2799 + 1;
  *code.2799 = 136;
  goto <D.25965>;
  <D.25966>:
  <D.25967>:
  <D.25968>:
  code.2800 = code;
  code = code.2800 + 1;
  *code.2800 = 137;
  goto <D.25965>;
  <D.25969>:
  __assert_fail ("0", "mini-amd64.c", 4475, &__PRETTY_FUNCTION__);
  <D.25965>:
  if (1 != 0) goto <D.38110>; else goto <D.38111>;
  <D.38110>:
  if (0 != 0) goto <D.38112>; else goto <D.38113>;
  <D.38112>:
  code.2801 = code;
  code = code.2801 + 1;
  *code.2801 = 20;
  code.2802 = code;
  code = code.2802 + 1;
  *code.2802 = 36;
  goto <D.38116>;
  <D.38113>:
  if (1 != 0) goto <D.38117>; else goto <D.38118>;
  <D.38117>:
  code.2803 = code;
  code = code.2803 + 1;
  *code.2803 = 84;
  code.2804 = code;
  code = code.2804 + 1;
  *code.2804 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38121>;
  <D.38118>:
  code.2805 = code;
  code = code.2805 + 1;
  *code.2805 = 148;
  code.2806 = code;
  code = code.2806 + 1;
  *code.2806 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2807 = code;
        code = code.2807 + 1;
        D.38125 = imb.b[0];
        *code.2807 = D.38125;
        code.2808 = code;
        code = code.2808 + 1;
        D.38127 = imb.b[1];
        *code.2808 = D.38127;
        code.2809 = code;
        code = code.2809 + 1;
        D.38129 = imb.b[2];
        *code.2809 = D.38129;
        code.2810 = code;
        code = code.2810 + 1;
        D.38131 = imb.b[3];
        *code.2810 = D.38131;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38121>:
  <D.38116>:
  goto <D.25971>;
  <D.38111>:
  if (0 != 0) goto <D.38132>; else goto <D.38133>;
  <D.38132>:
  code.2811 = code;
  code = code.2811 + 1;
  *code.2811 = 20;
  goto <D.25971>;
  <D.38133>:
  if (1 != 0) goto <D.38135>; else goto <D.38136>;
  <D.38135>:
  code.2812 = code;
  code = code.2812 + 1;
  *code.2812 = 84;
  *code = 248;
  code = code + 1;
  goto <D.38138>;
  <D.38136>:
  code.2813 = code;
  code = code.2813 + 1;
  *code.2813 = 148;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2814 = code;
        code = code.2814 + 1;
        D.38141 = imb.b[0];
        *code.2814 = D.38141;
        code.2815 = code;
        code = code.2815 + 1;
        D.38143 = imb.b[1];
        *code.2815 = D.38143;
        code.2816 = code;
        code = code.2816 + 1;
        D.38145 = imb.b[2];
        *code.2816 = D.38145;
        code.2817 = code;
        code = code.2817 + 1;
        D.38147 = imb.b[3];
        *code.2817 = D.38147;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38138>:
  <D.25971>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38148>; else goto <D.38149>;
    <D.38148>:
    code.2818 = code;
    code = code.2818 + 1;
    D.38151 = _amd64_rex_bits | 64;
    *code.2818 = D.38151;
    <D.38149>:
  }
  code.2819 = code;
  code = code.2819 + 1;
  *code.2819 = 153;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38153>; else goto <D.38154>;
    <D.38153>:
    code.2820 = code;
    code = code.2820 + 1;
    D.38156 = _amd64_rex_bits | 64;
    *code.2820 = D.38156;
    <D.38154>:
  }
  code.2821 = code;
  code = code.2821 + 1;
  *code.2821 = 247;
  if (1 != 0) goto <D.38158>; else goto <D.38159>;
  <D.38158>:
  if (0 != 0) goto <D.38160>; else goto <D.38161>;
  <D.38160>:
  code.2822 = code;
  code = code.2822 + 1;
  *code.2822 = 60;
  code.2823 = code;
  code = code.2823 + 1;
  *code.2823 = 36;
  goto <D.38164>;
  <D.38161>:
  if (1 != 0) goto <D.38165>; else goto <D.38166>;
  <D.38165>:
  code.2824 = code;
  code = code.2824 + 1;
  *code.2824 = 124;
  code.2825 = code;
  code = code.2825 + 1;
  *code.2825 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38169>;
  <D.38166>:
  code.2826 = code;
  code = code.2826 + 1;
  *code.2826 = 188;
  code.2827 = code;
  code = code.2827 + 1;
  *code.2827 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2828 = code;
        code = code.2828 + 1;
        D.38173 = imb.b[0];
        *code.2828 = D.38173;
        code.2829 = code;
        code = code.2829 + 1;
        D.38175 = imb.b[1];
        *code.2829 = D.38175;
        code.2830 = code;
        code = code.2830 + 1;
        D.38177 = imb.b[2];
        *code.2830 = D.38177;
        code.2831 = code;
        code = code.2831 + 1;
        D.38179 = imb.b[3];
        *code.2831 = D.38179;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38169>:
  <D.38164>:
  goto <D.25976>;
  <D.38159>:
  if (0 != 0) goto <D.38180>; else goto <D.38181>;
  <D.38180>:
  code.2832 = code;
  code = code.2832 + 1;
  *code.2832 = 60;
  goto <D.25976>;
  <D.38181>:
  if (1 != 0) goto <D.38183>; else goto <D.38184>;
  <D.38183>:
  code.2833 = code;
  code = code.2833 + 1;
  *code.2833 = 124;
  *code = 248;
  code = code + 1;
  goto <D.38186>;
  <D.38184>:
  code.2834 = code;
  code = code.2834 + 1;
  *code.2834 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2835 = code;
        code = code.2835 + 1;
        D.38189 = imb.b[0];
        *code.2835 = D.38189;
        code.2836 = code;
        code = code.2836 + 1;
        D.38191 = imb.b[1];
        *code.2836 = D.38191;
        code.2837 = code;
        code = code.2837 + 1;
        D.38193 = imb.b[2];
        *code.2837 = D.38193;
        code.2838 = code;
        code = code.2838 + 1;
        D.38195 = imb.b[3];
        *code.2838 = D.38195;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38186>:
  <D.25976>:
  goto <D.38196>;
  <D.38100>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38197>; else goto <D.38198>;
    <D.38197>:
    code.2839 = code;
    code = code.2839 + 1;
    D.38200 = _amd64_rex_bits | 64;
    *code.2839 = D.38200;
    <D.38198>:
  }
  code.2840 = code;
  code = code.2840 + 1;
  *code.2840 = 153;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.38203>; else goto <D.38204>;
    <D.38203>:
    iftmp.2841 = 9;
    goto <D.38205>;
    <D.38204>:
    iftmp.2841 = 8;
    <D.38205>:
    _amd64_rex_bits = iftmp.2841;
    if (_amd64_rex_bits != 0) goto <D.38206>; else goto <D.38207>;
    <D.38206>:
    code.2842 = code;
    code = code.2842 + 1;
    D.38209 = _amd64_rex_bits | 64;
    *code.2842 = D.38209;
    <D.38207>:
  }
  code.2843 = code;
  code = code.2843 + 1;
  *code.2843 = 247;
  code.2844 = code;
  code = code.2844 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.38212 = D.31500 | -8;
  D.38213 = (unsigned char) D.38212;
  *code.2844 = D.38213;
  <D.38196>:
  goto <D.25197>;
  <D.25980>:
  <D.25981>:
  D.31490 = ins->sreg2;
  if (D.31490 == 2) goto <D.38214>; else goto <D.38215>;
  <D.38214>:
  if (0 != 0) goto <D.38216>; else goto <D.38217>;
  <D.38216>:
  code.2845 = code;
  code = code.2845 + 1;
  *code.2845 = 102;
  <D.38217>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38219>; else goto <D.38220>;
    <D.38219>:
    code.2846 = code;
    code = code.2846 + 1;
    D.38222 = _amd64_rex_bits | 64;
    *code.2846 = D.38222;
    <D.38220>:
  }
  switch (8) <default: <D.25988>, case 1: <D.25983>, case 2: <D.25985>, case 4: <D.25986>, case 8: <D.25987>>
  <D.25983>:
  code.2847 = code;
  code = code.2847 + 1;
  *code.2847 = 136;
  goto <D.25984>;
  <D.25985>:
  <D.25986>:
  <D.25987>:
  code.2848 = code;
  code = code.2848 + 1;
  *code.2848 = 137;
  goto <D.25984>;
  <D.25988>:
  __assert_fail ("0", "mini-amd64.c", 4490, &__PRETTY_FUNCTION__);
  <D.25984>:
  if (1 != 0) goto <D.38225>; else goto <D.38226>;
  <D.38225>:
  if (0 != 0) goto <D.38227>; else goto <D.38228>;
  <D.38227>:
  code.2849 = code;
  code = code.2849 + 1;
  *code.2849 = 20;
  code.2850 = code;
  code = code.2850 + 1;
  *code.2850 = 36;
  goto <D.38231>;
  <D.38228>:
  if (1 != 0) goto <D.38232>; else goto <D.38233>;
  <D.38232>:
  code.2851 = code;
  code = code.2851 + 1;
  *code.2851 = 84;
  code.2852 = code;
  code = code.2852 + 1;
  *code.2852 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38236>;
  <D.38233>:
  code.2853 = code;
  code = code.2853 + 1;
  *code.2853 = 148;
  code.2854 = code;
  code = code.2854 + 1;
  *code.2854 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2855 = code;
        code = code.2855 + 1;
        D.38240 = imb.b[0];
        *code.2855 = D.38240;
        code.2856 = code;
        code = code.2856 + 1;
        D.38242 = imb.b[1];
        *code.2856 = D.38242;
        code.2857 = code;
        code = code.2857 + 1;
        D.38244 = imb.b[2];
        *code.2857 = D.38244;
        code.2858 = code;
        code = code.2858 + 1;
        D.38246 = imb.b[3];
        *code.2858 = D.38246;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38236>:
  <D.38231>:
  goto <D.25990>;
  <D.38226>:
  if (0 != 0) goto <D.38247>; else goto <D.38248>;
  <D.38247>:
  code.2859 = code;
  code = code.2859 + 1;
  *code.2859 = 20;
  goto <D.25990>;
  <D.38248>:
  if (1 != 0) goto <D.38250>; else goto <D.38251>;
  <D.38250>:
  code.2860 = code;
  code = code.2860 + 1;
  *code.2860 = 84;
  *code = 248;
  code = code + 1;
  goto <D.38253>;
  <D.38251>:
  code.2861 = code;
  code = code.2861 + 1;
  *code.2861 = 148;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2862 = code;
        code = code.2862 + 1;
        D.38256 = imb.b[0];
        *code.2862 = D.38256;
        code.2863 = code;
        code = code.2863 + 1;
        D.38258 = imb.b[1];
        *code.2863 = D.38258;
        code.2864 = code;
        code = code.2864 + 1;
        D.38260 = imb.b[2];
        *code.2864 = D.38260;
        code.2865 = code;
        code = code.2865 + 1;
        D.38262 = imb.b[3];
        *code.2865 = D.38262;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38253>:
  <D.25990>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38263>; else goto <D.38264>;
    <D.38263>:
    code.2866 = code;
    code = code.2866 + 1;
    D.38266 = _amd64_rex_bits | 64;
    *code.2866 = D.38266;
    <D.38264>:
  }
  code.2867 = code;
  code = code.2867 + 1;
  *code.2867 = 51;
  code.2868 = code;
  code = code.2868 + 1;
  *code.2868 = 210;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38269>; else goto <D.38270>;
    <D.38269>:
    code.2869 = code;
    code = code.2869 + 1;
    D.38272 = _amd64_rex_bits | 64;
    *code.2869 = D.38272;
    <D.38270>:
  }
  code.2870 = code;
  code = code.2870 + 1;
  *code.2870 = 247;
  if (1 != 0) goto <D.38274>; else goto <D.38275>;
  <D.38274>:
  if (0 != 0) goto <D.38276>; else goto <D.38277>;
  <D.38276>:
  code.2871 = code;
  code = code.2871 + 1;
  *code.2871 = 52;
  code.2872 = code;
  code = code.2872 + 1;
  *code.2872 = 36;
  goto <D.38280>;
  <D.38277>:
  if (1 != 0) goto <D.38281>; else goto <D.38282>;
  <D.38281>:
  code.2873 = code;
  code = code.2873 + 1;
  *code.2873 = 116;
  code.2874 = code;
  code = code.2874 + 1;
  *code.2874 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38285>;
  <D.38282>:
  code.2875 = code;
  code = code.2875 + 1;
  *code.2875 = 180;
  code.2876 = code;
  code = code.2876 + 1;
  *code.2876 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2877 = code;
        code = code.2877 + 1;
        D.38289 = imb.b[0];
        *code.2877 = D.38289;
        code.2878 = code;
        code = code.2878 + 1;
        D.38291 = imb.b[1];
        *code.2878 = D.38291;
        code.2879 = code;
        code = code.2879 + 1;
        D.38293 = imb.b[2];
        *code.2879 = D.38293;
        code.2880 = code;
        code = code.2880 + 1;
        D.38295 = imb.b[3];
        *code.2880 = D.38295;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38285>:
  <D.38280>:
  goto <D.25995>;
  <D.38275>:
  if (0 != 0) goto <D.38296>; else goto <D.38297>;
  <D.38296>:
  code.2881 = code;
  code = code.2881 + 1;
  *code.2881 = 52;
  goto <D.25995>;
  <D.38297>:
  if (1 != 0) goto <D.38299>; else goto <D.38300>;
  <D.38299>:
  code.2882 = code;
  code = code.2882 + 1;
  *code.2882 = 116;
  *code = 248;
  code = code + 1;
  goto <D.38302>;
  <D.38300>:
  code.2883 = code;
  code = code.2883 + 1;
  *code.2883 = 180;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2884 = code;
        code = code.2884 + 1;
        D.38305 = imb.b[0];
        *code.2884 = D.38305;
        code.2885 = code;
        code = code.2885 + 1;
        D.38307 = imb.b[1];
        *code.2885 = D.38307;
        code.2886 = code;
        code = code.2886 + 1;
        D.38309 = imb.b[2];
        *code.2886 = D.38309;
        code.2887 = code;
        code = code.2887 + 1;
        D.38311 = imb.b[3];
        *code.2887 = D.38311;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38302>:
  <D.25995>:
  goto <D.38312>;
  <D.38215>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38313>; else goto <D.38314>;
    <D.38313>:
    code.2888 = code;
    code = code.2888 + 1;
    D.38316 = _amd64_rex_bits | 64;
    *code.2888 = D.38316;
    <D.38314>:
  }
  code.2889 = code;
  code = code.2889 + 1;
  *code.2889 = 51;
  code.2890 = code;
  code = code.2890 + 1;
  *code.2890 = 210;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.38320>; else goto <D.38321>;
    <D.38320>:
    iftmp.2891 = 9;
    goto <D.38322>;
    <D.38321>:
    iftmp.2891 = 8;
    <D.38322>:
    _amd64_rex_bits = iftmp.2891;
    if (_amd64_rex_bits != 0) goto <D.38323>; else goto <D.38324>;
    <D.38323>:
    code.2892 = code;
    code = code.2892 + 1;
    D.38326 = _amd64_rex_bits | 64;
    *code.2892 = D.38326;
    <D.38324>:
  }
  code.2893 = code;
  code = code.2893 + 1;
  *code.2893 = 247;
  code.2894 = code;
  code = code.2894 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.38329 = D.31501 | -16;
  D.38330 = (unsigned char) D.38329;
  *code.2894 = D.38330;
  <D.38312>:
  goto <D.25197>;
  <D.25999>:
  <D.26000>:
  D.31490 = ins->sreg2;
  if (D.31490 == 2) goto <D.38331>; else goto <D.38332>;
  <D.38331>:
  if (0 != 0) goto <D.38333>; else goto <D.38334>;
  <D.38333>:
  code.2895 = code;
  code = code.2895 + 1;
  *code.2895 = 102;
  <D.38334>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38336>; else goto <D.38337>;
    <D.38336>:
    code.2896 = code;
    code = code.2896 + 1;
    D.38339 = _amd64_rex_bits | 64;
    *code.2896 = D.38339;
    <D.38337>:
  }
  switch (8) <default: <D.26007>, case 1: <D.26002>, case 2: <D.26004>, case 4: <D.26005>, case 8: <D.26006>>
  <D.26002>:
  code.2897 = code;
  code = code.2897 + 1;
  *code.2897 = 136;
  goto <D.26003>;
  <D.26004>:
  <D.26005>:
  <D.26006>:
  code.2898 = code;
  code = code.2898 + 1;
  *code.2898 = 137;
  goto <D.26003>;
  <D.26007>:
  __assert_fail ("0", "mini-amd64.c", 4505, &__PRETTY_FUNCTION__);
  <D.26003>:
  if (1 != 0) goto <D.38342>; else goto <D.38343>;
  <D.38342>:
  if (0 != 0) goto <D.38344>; else goto <D.38345>;
  <D.38344>:
  code.2899 = code;
  code = code.2899 + 1;
  *code.2899 = 20;
  code.2900 = code;
  code = code.2900 + 1;
  *code.2900 = 36;
  goto <D.38348>;
  <D.38345>:
  if (1 != 0) goto <D.38349>; else goto <D.38350>;
  <D.38349>:
  code.2901 = code;
  code = code.2901 + 1;
  *code.2901 = 84;
  code.2902 = code;
  code = code.2902 + 1;
  *code.2902 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38353>;
  <D.38350>:
  code.2903 = code;
  code = code.2903 + 1;
  *code.2903 = 148;
  code.2904 = code;
  code = code.2904 + 1;
  *code.2904 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2905 = code;
        code = code.2905 + 1;
        D.38357 = imb.b[0];
        *code.2905 = D.38357;
        code.2906 = code;
        code = code.2906 + 1;
        D.38359 = imb.b[1];
        *code.2906 = D.38359;
        code.2907 = code;
        code = code.2907 + 1;
        D.38361 = imb.b[2];
        *code.2907 = D.38361;
        code.2908 = code;
        code = code.2908 + 1;
        D.38363 = imb.b[3];
        *code.2908 = D.38363;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38353>:
  <D.38348>:
  goto <D.26009>;
  <D.38343>:
  if (0 != 0) goto <D.38364>; else goto <D.38365>;
  <D.38364>:
  code.2909 = code;
  code = code.2909 + 1;
  *code.2909 = 20;
  goto <D.26009>;
  <D.38365>:
  if (1 != 0) goto <D.38367>; else goto <D.38368>;
  <D.38367>:
  code.2910 = code;
  code = code.2910 + 1;
  *code.2910 = 84;
  *code = 248;
  code = code + 1;
  goto <D.38370>;
  <D.38368>:
  code.2911 = code;
  code = code.2911 + 1;
  *code.2911 = 148;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2912 = code;
        code = code.2912 + 1;
        D.38373 = imb.b[0];
        *code.2912 = D.38373;
        code.2913 = code;
        code = code.2913 + 1;
        D.38375 = imb.b[1];
        *code.2913 = D.38375;
        code.2914 = code;
        code = code.2914 + 1;
        D.38377 = imb.b[2];
        *code.2914 = D.38377;
        code.2915 = code;
        code = code.2915 + 1;
        D.38379 = imb.b[3];
        *code.2915 = D.38379;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38370>:
  <D.26009>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.38380>; else goto <D.38381>;
    <D.38380>:
    code.2916 = code;
    code = code.2916 + 1;
    D.38383 = _amd64_rex_bits | 64;
    *code.2916 = D.38383;
    <D.38381>:
  }
  code.2917 = code;
  code = code.2917 + 1;
  *code.2917 = 153;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.38385>; else goto <D.38386>;
    <D.38385>:
    code.2918 = code;
    code = code.2918 + 1;
    D.38388 = _amd64_rex_bits | 64;
    *code.2918 = D.38388;
    <D.38386>:
  }
  code.2919 = code;
  code = code.2919 + 1;
  *code.2919 = 247;
  if (1 != 0) goto <D.38390>; else goto <D.38391>;
  <D.38390>:
  if (0 != 0) goto <D.38392>; else goto <D.38393>;
  <D.38392>:
  code.2920 = code;
  code = code.2920 + 1;
  *code.2920 = 60;
  code.2921 = code;
  code = code.2921 + 1;
  *code.2921 = 36;
  goto <D.38396>;
  <D.38393>:
  if (1 != 0) goto <D.38397>; else goto <D.38398>;
  <D.38397>:
  code.2922 = code;
  code = code.2922 + 1;
  *code.2922 = 124;
  code.2923 = code;
  code = code.2923 + 1;
  *code.2923 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38401>;
  <D.38398>:
  code.2924 = code;
  code = code.2924 + 1;
  *code.2924 = 188;
  code.2925 = code;
  code = code.2925 + 1;
  *code.2925 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2926 = code;
        code = code.2926 + 1;
        D.38405 = imb.b[0];
        *code.2926 = D.38405;
        code.2927 = code;
        code = code.2927 + 1;
        D.38407 = imb.b[1];
        *code.2927 = D.38407;
        code.2928 = code;
        code = code.2928 + 1;
        D.38409 = imb.b[2];
        *code.2928 = D.38409;
        code.2929 = code;
        code = code.2929 + 1;
        D.38411 = imb.b[3];
        *code.2929 = D.38411;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38401>:
  <D.38396>:
  goto <D.26014>;
  <D.38391>:
  if (0 != 0) goto <D.38412>; else goto <D.38413>;
  <D.38412>:
  code.2930 = code;
  code = code.2930 + 1;
  *code.2930 = 60;
  goto <D.26014>;
  <D.38413>:
  if (1 != 0) goto <D.38415>; else goto <D.38416>;
  <D.38415>:
  code.2931 = code;
  code = code.2931 + 1;
  *code.2931 = 124;
  *code = 248;
  code = code + 1;
  goto <D.38418>;
  <D.38416>:
  code.2932 = code;
  code = code.2932 + 1;
  *code.2932 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2933 = code;
        code = code.2933 + 1;
        D.38421 = imb.b[0];
        *code.2933 = D.38421;
        code.2934 = code;
        code = code.2934 + 1;
        D.38423 = imb.b[1];
        *code.2934 = D.38423;
        code.2935 = code;
        code = code.2935 + 1;
        D.38425 = imb.b[2];
        *code.2935 = D.38425;
        code.2936 = code;
        code = code.2936 + 1;
        D.38427 = imb.b[3];
        *code.2936 = D.38427;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38418>:
  <D.26014>:
  goto <D.38428>;
  <D.38332>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.38429>; else goto <D.38430>;
    <D.38429>:
    code.2937 = code;
    code = code.2937 + 1;
    D.38432 = _amd64_rex_bits | 64;
    *code.2937 = D.38432;
    <D.38430>:
  }
  code.2938 = code;
  code = code.2938 + 1;
  *code.2938 = 153;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    _amd64_rex_bits = (unsigned char) D.33810;
    if (_amd64_rex_bits != 0) goto <D.38434>; else goto <D.38435>;
    <D.38434>:
    code.2939 = code;
    code = code.2939 + 1;
    D.38437 = _amd64_rex_bits | 64;
    *code.2939 = D.38437;
    <D.38435>:
  }
  code.2940 = code;
  code = code.2940 + 1;
  *code.2940 = 247;
  code.2941 = code;
  code = code.2941 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.38212 = D.31500 | -8;
  D.38213 = (unsigned char) D.38212;
  *code.2941 = D.38213;
  <D.38428>:
  goto <D.25197>;
  <D.26018>:
  <D.26019>:
  D.31490 = ins->sreg2;
  if (D.31490 == 2) goto <D.38440>; else goto <D.38441>;
  <D.38440>:
  if (0 != 0) goto <D.38442>; else goto <D.38443>;
  <D.38442>:
  code.2942 = code;
  code = code.2942 + 1;
  *code.2942 = 102;
  <D.38443>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38445>; else goto <D.38446>;
    <D.38445>:
    code.2943 = code;
    code = code.2943 + 1;
    D.38448 = _amd64_rex_bits | 64;
    *code.2943 = D.38448;
    <D.38446>:
  }
  switch (8) <default: <D.26026>, case 1: <D.26021>, case 2: <D.26023>, case 4: <D.26024>, case 8: <D.26025>>
  <D.26021>:
  code.2944 = code;
  code = code.2944 + 1;
  *code.2944 = 136;
  goto <D.26022>;
  <D.26023>:
  <D.26024>:
  <D.26025>:
  code.2945 = code;
  code = code.2945 + 1;
  *code.2945 = 137;
  goto <D.26022>;
  <D.26026>:
  __assert_fail ("0", "mini-amd64.c", 4520, &__PRETTY_FUNCTION__);
  <D.26022>:
  if (1 != 0) goto <D.38451>; else goto <D.38452>;
  <D.38451>:
  if (0 != 0) goto <D.38453>; else goto <D.38454>;
  <D.38453>:
  code.2946 = code;
  code = code.2946 + 1;
  *code.2946 = 20;
  code.2947 = code;
  code = code.2947 + 1;
  *code.2947 = 36;
  goto <D.38457>;
  <D.38454>:
  if (1 != 0) goto <D.38458>; else goto <D.38459>;
  <D.38458>:
  code.2948 = code;
  code = code.2948 + 1;
  *code.2948 = 84;
  code.2949 = code;
  code = code.2949 + 1;
  *code.2949 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38462>;
  <D.38459>:
  code.2950 = code;
  code = code.2950 + 1;
  *code.2950 = 148;
  code.2951 = code;
  code = code.2951 + 1;
  *code.2951 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2952 = code;
        code = code.2952 + 1;
        D.38466 = imb.b[0];
        *code.2952 = D.38466;
        code.2953 = code;
        code = code.2953 + 1;
        D.38468 = imb.b[1];
        *code.2953 = D.38468;
        code.2954 = code;
        code = code.2954 + 1;
        D.38470 = imb.b[2];
        *code.2954 = D.38470;
        code.2955 = code;
        code = code.2955 + 1;
        D.38472 = imb.b[3];
        *code.2955 = D.38472;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38462>:
  <D.38457>:
  goto <D.26028>;
  <D.38452>:
  if (0 != 0) goto <D.38473>; else goto <D.38474>;
  <D.38473>:
  code.2956 = code;
  code = code.2956 + 1;
  *code.2956 = 20;
  goto <D.26028>;
  <D.38474>:
  if (1 != 0) goto <D.38476>; else goto <D.38477>;
  <D.38476>:
  code.2957 = code;
  code = code.2957 + 1;
  *code.2957 = 84;
  *code = 248;
  code = code + 1;
  goto <D.38479>;
  <D.38477>:
  code.2958 = code;
  code = code.2958 + 1;
  *code.2958 = 148;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2959 = code;
        code = code.2959 + 1;
        D.38482 = imb.b[0];
        *code.2959 = D.38482;
        code.2960 = code;
        code = code.2960 + 1;
        D.38484 = imb.b[1];
        *code.2960 = D.38484;
        code.2961 = code;
        code = code.2961 + 1;
        D.38486 = imb.b[2];
        *code.2961 = D.38486;
        code.2962 = code;
        code = code.2962 + 1;
        D.38488 = imb.b[3];
        *code.2962 = D.38488;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38479>:
  <D.26028>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38489>; else goto <D.38490>;
    <D.38489>:
    code.2963 = code;
    code = code.2963 + 1;
    D.38492 = _amd64_rex_bits | 64;
    *code.2963 = D.38492;
    <D.38490>:
  }
  code.2964 = code;
  code = code.2964 + 1;
  *code.2964 = 51;
  code.2965 = code;
  code = code.2965 + 1;
  *code.2965 = 210;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.38495>; else goto <D.38496>;
    <D.38495>:
    code.2966 = code;
    code = code.2966 + 1;
    D.38498 = _amd64_rex_bits | 64;
    *code.2966 = D.38498;
    <D.38496>:
  }
  code.2967 = code;
  code = code.2967 + 1;
  *code.2967 = 247;
  if (1 != 0) goto <D.38500>; else goto <D.38501>;
  <D.38500>:
  if (0 != 0) goto <D.38502>; else goto <D.38503>;
  <D.38502>:
  code.2968 = code;
  code = code.2968 + 1;
  *code.2968 = 52;
  code.2969 = code;
  code = code.2969 + 1;
  *code.2969 = 36;
  goto <D.38506>;
  <D.38503>:
  if (1 != 0) goto <D.38507>; else goto <D.38508>;
  <D.38507>:
  code.2970 = code;
  code = code.2970 + 1;
  *code.2970 = 116;
  code.2971 = code;
  code = code.2971 + 1;
  *code.2971 = 36;
  *code = 248;
  code = code + 1;
  goto <D.38511>;
  <D.38508>:
  code.2972 = code;
  code = code.2972 + 1;
  *code.2972 = 180;
  code.2973 = code;
  code = code.2973 + 1;
  *code.2973 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2974 = code;
        code = code.2974 + 1;
        D.38515 = imb.b[0];
        *code.2974 = D.38515;
        code.2975 = code;
        code = code.2975 + 1;
        D.38517 = imb.b[1];
        *code.2975 = D.38517;
        code.2976 = code;
        code = code.2976 + 1;
        D.38519 = imb.b[2];
        *code.2976 = D.38519;
        code.2977 = code;
        code = code.2977 + 1;
        D.38521 = imb.b[3];
        *code.2977 = D.38521;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38511>:
  <D.38506>:
  goto <D.26033>;
  <D.38501>:
  if (0 != 0) goto <D.38522>; else goto <D.38523>;
  <D.38522>:
  code.2978 = code;
  code = code.2978 + 1;
  *code.2978 = 52;
  goto <D.26033>;
  <D.38523>:
  if (1 != 0) goto <D.38525>; else goto <D.38526>;
  <D.38525>:
  code.2979 = code;
  code = code.2979 + 1;
  *code.2979 = 116;
  *code = 248;
  code = code + 1;
  goto <D.38528>;
  <D.38526>:
  code.2980 = code;
  code = code.2980 + 1;
  *code.2980 = 180;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.2981 = code;
        code = code.2981 + 1;
        D.38531 = imb.b[0];
        *code.2981 = D.38531;
        code.2982 = code;
        code = code.2982 + 1;
        D.38533 = imb.b[1];
        *code.2982 = D.38533;
        code.2983 = code;
        code = code.2983 + 1;
        D.38535 = imb.b[2];
        *code.2983 = D.38535;
        code.2984 = code;
        code = code.2984 + 1;
        D.38537 = imb.b[3];
        *code.2984 = D.38537;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38528>:
  <D.26033>:
  goto <D.38538>;
  <D.38441>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38539>; else goto <D.38540>;
    <D.38539>:
    code.2985 = code;
    code = code.2985 + 1;
    D.38542 = _amd64_rex_bits | 64;
    *code.2985 = D.38542;
    <D.38540>:
  }
  code.2986 = code;
  code = code.2986 + 1;
  *code.2986 = 51;
  code.2987 = code;
  code = code.2987 + 1;
  *code.2987 = 210;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    _amd64_rex_bits = (unsigned char) D.33810;
    if (_amd64_rex_bits != 0) goto <D.38545>; else goto <D.38546>;
    <D.38545>:
    code.2988 = code;
    code = code.2988 + 1;
    D.38548 = _amd64_rex_bits | 64;
    *code.2988 = D.38548;
    <D.38546>:
  }
  code.2989 = code;
  code = code.2989 + 1;
  *code.2989 = 247;
  code.2990 = code;
  code = code.2990 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.38329 = D.31501 | -16;
  D.38330 = (unsigned char) D.38329;
  *code.2990 = D.38330;
  <D.38538>:
  goto <D.25197>;
  <D.26037>:
  {
    int power;

    D.31647 = ins->data.op[1].const_val;
    D.38551 = (unsigned int) D.31647;
    power = mono_is_power_of_two (D.38551);
    D.31516 = ins->sreg1;
    D.38552 = D.31516 != 0;
    D.38553 = (long int) D.38552;
    D.38554 = __builtin_expect (D.38553, 0);
    if (D.38554 != 0) goto <D.38555>; else goto <D.38556>;
    <D.38555>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4531, "ins->sreg1 == X86_EAX");
    <D.38556>:
    D.31589 = ins->dreg;
    D.38557 = D.31589 != 0;
    D.38558 = (long int) D.38557;
    D.38559 = __builtin_expect (D.38558, 0);
    if (D.38559 != 0) goto <D.38560>; else goto <D.38561>;
    <D.38560>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4532, "ins->dreg == X86_EAX");
    <D.38561>:
    D.38562 = power < 0;
    D.38563 = (long int) D.38562;
    D.38564 = __builtin_expect (D.38563, 0);
    if (D.38564 != 0) goto <D.38565>; else goto <D.38566>;
    <D.38565>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4533, "power >= 0");
    <D.38566>:
    if (power == 0) goto <D.38567>; else goto <D.38568>;
    <D.38567>:
    {
      int _amd64_width_temp;

      _amd64_width_temp = 1;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.38570>; else goto <D.38571>;
        <D.38570>:
        iftmp.2991 = 8;
        goto <D.38572>;
        <D.38571>:
        iftmp.2991 = 0;
        <D.38572>:
        D.31589 = ins->dreg;
        D.31590 = D.31589 > 7;
        D.32040 = (signed char) D.31590;
        D.38573 = iftmp.2991 | D.32040;
        _amd64_rex_bits = (unsigned char) D.38573;
        if (_amd64_rex_bits != 0) goto <D.38574>; else goto <D.38575>;
        <D.38574>:
        code.2992 = code;
        code = code.2992 + 1;
        D.38577 = _amd64_rex_bits | 64;
        *code.2992 = D.38577;
        <D.38575>:
      }
      code.2993 = code;
      code = code.2993 + 1;
      D.31589 = ins->dreg;
      D.31626 = (unsigned char) D.31589;
      D.31627 = D.31626 & 7;
      D.32668 = D.31627 + 184;
      *code.2993 = D.32668;
      if (_amd64_width_temp == 0) goto <D.38579>; else goto <D.38580>;
      <D.38579>:
      {
        union amd64_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2994 = code;
            code = code.2994 + 1;
            D.38582 = imb.b[0];
            *code.2994 = D.38582;
            code.2995 = code;
            code = code.2995 + 1;
            D.38584 = imb.b[1];
            *code.2995 = D.38584;
            code.2996 = code;
            code = code.2996 + 1;
            D.38586 = imb.b[2];
            *code.2996 = D.38586;
            code.2997 = code;
            code = code.2997 + 1;
            D.38588 = imb.b[3];
            *code.2997 = D.38588;
            code.2998 = code;
            code = code.2998 + 1;
            D.38590 = imb.b[4];
            *code.2998 = D.38590;
            code.2999 = code;
            code = code.2999 + 1;
            D.38592 = imb.b[5];
            *code.2999 = D.38592;
            code.3000 = code;
            code = code.3000 + 1;
            D.38594 = imb.b[6];
            *code.3000 = D.38594;
            code.3001 = code;
            code = code.3001 + 1;
            D.38596 = imb.b[7];
            *code.3001 = D.38596;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.38597>;
      <D.38580>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.3002 = code;
            code = code.3002 + 1;
            D.38599 = imb.b[0];
            *code.3002 = D.38599;
            code.3003 = code;
            code = code.3003 + 1;
            D.38601 = imb.b[1];
            *code.3003 = D.38601;
            code.3004 = code;
            code = code.3004 + 1;
            D.38603 = imb.b[2];
            *code.3004 = D.38603;
            code.3005 = code;
            code = code.3005 + 1;
            D.38605 = imb.b[3];
            *code.3005 = D.38605;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.38597>:
    }
    goto <D.25197>;
    <D.38568>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38606>; else goto <D.38607>;
      <D.38606>:
      code.3006 = code;
      code = code.3006 + 1;
      D.38609 = _amd64_rex_bits | 64;
      *code.3006 = D.38609;
      <D.38607>:
    }
    switch (4) <default: <D.26048>, case 1: <D.26044>, case 2: <D.26046>, case 4: <D.26047>>
    <D.26044>:
    code.3007 = code;
    code = code.3007 + 1;
    *code.3007 = 138;
    goto <D.26045>;
    <D.26046>:
    code.3008 = code;
    code = code.3008 + 1;
    *code.3008 = 102;
    <D.26047>:
    code.3009 = code;
    code = code.3009 + 1;
    *code.3009 = 139;
    goto <D.26045>;
    <D.26048>:
    __assert_fail ("0", "mini-amd64.c", 4543, &__PRETTY_FUNCTION__);
    <D.26045>:
    code.3010 = code;
    code = code.3010 + 1;
    *code.3010 = 208;
    if (power > 1) goto <D.38614>; else goto <D.38615>;
    <D.38614>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38616>; else goto <D.38617>;
      <D.38616>:
      code.3011 = code;
      code = code.3011 + 1;
      D.38619 = _amd64_rex_bits | 64;
      *code.3011 = D.38619;
      <D.38617>:
    }
    if (0 != 0) goto <D.38620>; else goto <D.38621>;
    <D.38620>:
    code.3012 = code;
    code = code.3012 + 1;
    *code.3012 = 209;
    code.3013 = code;
    code = code.3013 + 1;
    *code.3013 = 250;
    goto <D.38624>;
    <D.38621>:
    code.3014 = code;
    code = code.3014 + 1;
    *code.3014 = 193;
    code.3015 = code;
    code = code.3015 + 1;
    *code.3015 = 250;
    *code = 31;
    code = code + 1;
    <D.38624>:
    <D.38615>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38627>; else goto <D.38628>;
      <D.38627>:
      code.3016 = code;
      code = code.3016 + 1;
      D.38630 = _amd64_rex_bits | 64;
      *code.3016 = D.38630;
      <D.38628>:
    }
    D.38631 = 32 - power;
    if (D.38631 == 1) goto <D.38632>; else goto <D.38633>;
    <D.38632>:
    code.3017 = code;
    code = code.3017 + 1;
    *code.3017 = 209;
    code.3018 = code;
    code = code.3018 + 1;
    *code.3018 = 234;
    goto <D.38636>;
    <D.38633>:
    code.3019 = code;
    code = code.3019 + 1;
    *code.3019 = 193;
    code.3020 = code;
    code = code.3020 + 1;
    *code.3020 = 234;
    D.38639 = (unsigned char) power;
    D.38640 = 32 - D.38639;
    *code = D.38640;
    code = code + 1;
    <D.38636>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38641>; else goto <D.38642>;
      <D.38641>:
      code.3021 = code;
      code = code.3021 + 1;
      D.38644 = _amd64_rex_bits | 64;
      *code.3021 = D.38644;
      <D.38642>:
    }
    code.3022 = code;
    code = code.3022 + 1;
    *code.3022 = 3;
    code.3023 = code;
    code = code.3023 + 1;
    *code.3023 = 194;
    D.38647 = 1 << power;
    D.38648 = (unsigned int) D.38647;
    D.38649 = D.38648 + 127;
    if (D.38649 <= 255) goto <D.38650>; else goto <D.38651>;
    <D.38650>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38652>; else goto <D.38653>;
      <D.38652>:
      code.3024 = code;
      code = code.3024 + 1;
      D.38655 = _amd64_rex_bits | 64;
      *code.3024 = D.38655;
      <D.38653>:
    }
    code.3025 = code;
    code = code.3025 + 1;
    *code.3025 = 131;
    code.3026 = code;
    code = code.3026 + 1;
    *code.3026 = 224;
    D.38647 = 1 << power;
    D.38658 = (unsigned char) D.38647;
    D.38659 = D.38658 + 255;
    *code = D.38659;
    code = code + 1;
    goto <D.38660>;
    <D.38651>:
    if (1 != 0) goto <D.38661>; else goto <D.38662>;
    <D.38661>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38663>; else goto <D.38664>;
      <D.38663>:
      code.3027 = code;
      code = code.3027 + 1;
      D.38666 = _amd64_rex_bits | 64;
      *code.3027 = D.38666;
      <D.38664>:
    }
    code.3028 = code;
    code = code.3028 + 1;
    *code.3028 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          D.38647 = 1 << power;
          D.38668 = D.38647 + -1;
          imb.val = D.38668;
          code.3029 = code;
          code = code.3029 + 1;
          D.38670 = imb.b[0];
          *code.3029 = D.38670;
          code.3030 = code;
          code = code.3030 + 1;
          D.38672 = imb.b[1];
          *code.3030 = D.38672;
          code.3031 = code;
          code = code.3031 + 1;
          D.38674 = imb.b[2];
          *code.3031 = D.38674;
          code.3032 = code;
          code = code.3032 + 1;
          D.38676 = imb.b[3];
          *code.3032 = D.38676;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.38677>;
    <D.38662>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38678>; else goto <D.38679>;
      <D.38678>:
      code.3033 = code;
      code = code.3033 + 1;
      D.38681 = _amd64_rex_bits | 64;
      *code.3033 = D.38681;
      <D.38679>:
    }
    code.3034 = code;
    code = code.3034 + 1;
    *code.3034 = 129;
    code.3035 = code;
    code = code.3035 + 1;
    *code.3035 = 224;
    {
      union x86_imm_buf imb;

      try
        {
          D.38647 = 1 << power;
          D.38668 = D.38647 + -1;
          imb.val = D.38668;
          code.3036 = code;
          code = code.3036 + 1;
          D.38685 = imb.b[0];
          *code.3036 = D.38685;
          code.3037 = code;
          code = code.3037 + 1;
          D.38687 = imb.b[1];
          *code.3037 = D.38687;
          code.3038 = code;
          code = code.3038 + 1;
          D.38689 = imb.b[2];
          *code.3038 = D.38689;
          code.3039 = code;
          code = code.3039 + 1;
          D.38691 = imb.b[3];
          *code.3039 = D.38691;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.38677>:
    <D.38660>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.38692>; else goto <D.38693>;
      <D.38692>:
      code.3040 = code;
      code = code.3040 + 1;
      D.38695 = _amd64_rex_bits | 64;
      *code.3040 = D.38695;
      <D.38693>:
    }
    code.3041 = code;
    code = code.3041 + 1;
    *code.3041 = 43;
    code.3042 = code;
    code = code.3042 + 1;
    *code.3042 = 194;
    goto <D.25197>;
  }
  <D.26058>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38699>; else goto <D.38700>;
    <D.38699>:
    iftmp.3043 = 12;
    goto <D.38701>;
    <D.38700>:
    iftmp.3043 = 8;
    <D.38701>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.38702 = iftmp.3043 | D.33811;
    _amd64_rex_bits = (unsigned char) D.38702;
    if (_amd64_rex_bits != 0) goto <D.38703>; else goto <D.38704>;
    <D.38703>:
    code.3044 = code;
    code = code.3044 + 1;
    D.38706 = _amd64_rex_bits | 64;
    *code.3044 = D.38706;
    <D.38704>:
  }
  code.3045 = code;
  code = code.3045 + 1;
  *code.3045 = 15;
  code.3046 = code;
  code = code.3046 + 1;
  *code.3046 = 175;
  code.3047 = code;
  code = code.3047 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3047 = D.33821;
  {
    struct MonoInst * tins;

    tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
    if (tins == 0B) goto <D.38710>; else goto <D.38711>;
    <D.38710>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, "OverflowException");
    code.3048 = code;
    code = code.3048 + 1;
    *code.3048 = 15;
    if (0 != 0) goto <D.38713>; else goto <D.38714>;
    <D.38713>:
    code.3049 = code;
    code = code.3049 + 1;
    D.38716 = 112;
    D.38717 = D.38716 + 16;
    *code.3049 = D.38717;
    goto <D.38718>;
    <D.38714>:
    code.3050 = code;
    code = code.3050 + 1;
    D.38720 = 112;
    D.38721 = D.38720 + 16;
    *code.3050 = D.38721;
    <D.38718>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3051 = code;
          code = code.3051 + 1;
          D.38723 = imb.b[0];
          *code.3051 = D.38723;
          code.3052 = code;
          code = code.3052 + 1;
          D.38725 = imb.b[1];
          *code.3052 = D.38725;
          code.3053 = code;
          code = code.3053 + 1;
          D.38727 = imb.b[2];
          *code.3053 = D.38727;
          code.3054 = code;
          code = code.3054 + 1;
          D.38729 = imb.b[3];
          *code.3054 = D.38729;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.38730>;
    <D.38711>:
    D.38731 = tins->data.op[1].many_blocks;
    D.38732 = *D.38731;
    D.38733 = D.38732->native_offset;
    if (D.38733 != 0) goto <D.38734>; else goto <D.38735>;
    <D.38734>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.38731 = tins->data.op[1].many_blocks;
      D.38732 = *D.38731;
      D.38733 = D.38732->native_offset;
      D.38736 = (sizetype) D.38733;
      D.38737 = D.31283 + D.38736;
      D.38738 = (long int) D.38737;
      code.211 = (long int) code;
      D.38739 = D.38738 - code.211;
      D.38740 = (unsigned int) D.38739;
      D.38741 = D.38740 + 4294967294;
      offset = (int) D.38741;
      offset.3055 = (unsigned int) offset;
      D.38743 = offset.3055 + 128;
      if (D.38743 <= 255) goto <D.38744>; else goto <D.38745>;
      <D.38744>:
      if (0 != 0) goto <D.38746>; else goto <D.38747>;
      <D.38746>:
      code.3056 = code;
      code = code.3056 + 1;
      D.38716 = 112;
      *code.3056 = D.38716;
      goto <D.38749>;
      <D.38747>:
      code.3057 = code;
      code = code.3057 + 1;
      D.38720 = 112;
      *code.3057 = D.38720;
      <D.38749>:
      D.38751 = (unsigned char) offset;
      *code = D.38751;
      code = code + 1;
      goto <D.38752>;
      <D.38745>:
      D.31283 = cfg->native_code;
      D.38731 = tins->data.op[1].many_blocks;
      D.38732 = *D.38731;
      D.38733 = D.38732->native_offset;
      D.38736 = (sizetype) D.38733;
      D.38737 = D.31283 + D.38736;
      D.38738 = (long int) D.38737;
      code.211 = (long int) code;
      D.38739 = D.38738 - code.211;
      D.38740 = (unsigned int) D.38739;
      D.38753 = D.38740 + 4294967290;
      offset = (int) D.38753;
      code.3058 = code;
      code = code.3058 + 1;
      *code.3058 = 15;
      if (0 != 0) goto <D.38755>; else goto <D.38756>;
      <D.38755>:
      code.3059 = code;
      code = code.3059 + 1;
      D.38716 = 112;
      D.38717 = D.38716 + 16;
      *code.3059 = D.38717;
      goto <D.38758>;
      <D.38756>:
      code.3060 = code;
      code = code.3060 + 1;
      D.38720 = 112;
      D.38721 = D.38720 + 16;
      *code.3060 = D.38721;
      <D.38758>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.3061 = code;
            code = code.3061 + 1;
            D.38761 = imb.b[0];
            *code.3061 = D.38761;
            code.3062 = code;
            code = code.3062 + 1;
            D.38763 = imb.b[1];
            *code.3062 = D.38763;
            code.3063 = code;
            code = code.3063 + 1;
            D.38765 = imb.b[2];
            *code.3063 = D.38765;
            code.3064 = code;
            code = code.3064 + 1;
            D.38767 = imb.b[3];
            *code.3064 = D.38767;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.38752>:
    }
    goto <D.38768>;
    <D.38735>:
    D.38731 = tins->data.op[1].many_blocks;
    D.38732 = *D.38731;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.38732);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.38771>; else goto <D.38769>;
    <D.38771>:
    D.38731 = tins->data.op[1].many_blocks;
    D.38732 = *D.38731;
    D.38772 = D.38732->max_offset;
    D.38773 = (unsigned int) D.38772;
    D.38774 = D.38773 - offset;
    D.38775 = (int) D.38774;
    if (D.38775 >= -128) goto <D.38776>; else goto <D.38769>;
    <D.38776>:
    D.38731 = tins->data.op[1].many_blocks;
    D.38732 = *D.38731;
    D.38772 = D.38732->max_offset;
    D.38773 = (unsigned int) D.38772;
    D.38774 = D.38773 - offset;
    D.38775 = (int) D.38774;
    if (D.38775 <= 127) goto <D.38777>; else goto <D.38769>;
    <D.38777>:
    if (0 != 0) goto <D.38778>; else goto <D.38779>;
    <D.38778>:
    code.3065 = code;
    code = code.3065 + 1;
    D.38716 = 112;
    *code.3065 = D.38716;
    goto <D.38781>;
    <D.38779>:
    code.3066 = code;
    code = code.3066 + 1;
    D.38720 = 112;
    *code.3066 = D.38720;
    <D.38781>:
    *code = 0;
    code = code + 1;
    goto <D.38770>;
    <D.38769>:
    code.3067 = code;
    code = code.3067 + 1;
    *code.3067 = 15;
    if (0 != 0) goto <D.38784>; else goto <D.38785>;
    <D.38784>:
    code.3068 = code;
    code = code.3068 + 1;
    D.38716 = 112;
    D.38717 = D.38716 + 16;
    *code.3068 = D.38717;
    goto <D.38787>;
    <D.38785>:
    code.3069 = code;
    code = code.3069 + 1;
    D.38720 = 112;
    D.38721 = D.38720 + 16;
    *code.3069 = D.38721;
    <D.38787>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3070 = code;
          code = code.3070 + 1;
          D.38790 = imb.b[0];
          *code.3070 = D.38790;
          code.3071 = code;
          code = code.3071 + 1;
          D.38792 = imb.b[1];
          *code.3071 = D.38792;
          code.3072 = code;
          code = code.3072 + 1;
          D.38794 = imb.b[2];
          *code.3072 = D.38794;
          code.3073 = code;
          code = code.3073 + 1;
          D.38796 = imb.b[3];
          *code.3073 = D.38796;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.38770>:
    <D.38768>:
    <D.38730>:
  }
  goto <D.25197>;
  <D.26065>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38798>; else goto <D.38799>;
    <D.38798>:
    iftmp.3074 = 12;
    goto <D.38800>;
    <D.38799>:
    iftmp.3074 = 8;
    <D.38800>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.38801 = iftmp.3074 | D.33811;
    _amd64_rex_bits = (unsigned char) D.38801;
    if (_amd64_rex_bits != 0) goto <D.38802>; else goto <D.38803>;
    <D.38802>:
    code.3075 = code;
    code = code.3075 + 1;
    D.38805 = _amd64_rex_bits | 64;
    *code.3075 = D.38805;
    <D.38803>:
  }
  code.3076 = code;
  code = code.3076 + 1;
  *code.3076 = 11;
  code.3077 = code;
  code = code.3077 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3077 = D.33821;
  goto <D.25197>;
  <D.26067>:
  <D.26068>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.38808>; else goto <D.38809>;
  <D.38808>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4563, "amd64_is_imm32 (ins->inst_imm)");
  <D.38809>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.38810>; else goto <D.38811>;
  <D.38810>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38813>; else goto <D.38814>;
    <D.38813>:
    iftmp.3078 = 9;
    goto <D.38815>;
    <D.38814>:
    iftmp.3078 = 8;
    <D.38815>:
    _amd64_rex_bits = iftmp.3078;
    if (_amd64_rex_bits != 0) goto <D.38816>; else goto <D.38817>;
    <D.38816>:
    code.3079 = code;
    code = code.3079 + 1;
    D.38819 = _amd64_rex_bits | 64;
    *code.3079 = D.38819;
    <D.38817>:
  }
  code.3080 = code;
  code = code.3080 + 1;
  *code.3080 = 131;
  code.3081 = code;
  code = code.3081 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38822 = D.31571 | -56;
  D.38823 = (unsigned char) D.38822;
  *code.3081 = D.38823;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.38824>;
  <D.38811>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.38825>; else goto <D.38826>;
  <D.38825>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38827>; else goto <D.38828>;
    <D.38827>:
    code.3082 = code;
    code = code.3082 + 1;
    D.38830 = _amd64_rex_bits | 64;
    *code.3082 = D.38830;
    <D.38828>:
  }
  code.3083 = code;
  code = code.3083 + 1;
  *code.3083 = 13;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3084 = code;
        code = code.3084 + 1;
        D.38833 = imb.b[0];
        *code.3084 = D.38833;
        code.3085 = code;
        code = code.3085 + 1;
        D.38835 = imb.b[1];
        *code.3085 = D.38835;
        code.3086 = code;
        code = code.3086 + 1;
        D.38837 = imb.b[2];
        *code.3086 = D.38837;
        code.3087 = code;
        code = code.3087 + 1;
        D.38839 = imb.b[3];
        *code.3087 = D.38839;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.38840>;
  <D.38826>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38842>; else goto <D.38843>;
    <D.38842>:
    iftmp.3088 = 9;
    goto <D.38844>;
    <D.38843>:
    iftmp.3088 = 8;
    <D.38844>:
    _amd64_rex_bits = iftmp.3088;
    if (_amd64_rex_bits != 0) goto <D.38845>; else goto <D.38846>;
    <D.38845>:
    code.3089 = code;
    code = code.3089 + 1;
    D.38848 = _amd64_rex_bits | 64;
    *code.3089 = D.38848;
    <D.38846>:
  }
  code.3090 = code;
  code = code.3090 + 1;
  *code.3090 = 129;
  code.3091 = code;
  code = code.3091 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38822 = D.31571 | -56;
  D.38823 = (unsigned char) D.38822;
  *code.3091 = D.38823;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3092 = code;
        code = code.3092 + 1;
        D.38852 = imb.b[0];
        *code.3092 = D.38852;
        code.3093 = code;
        code = code.3093 + 1;
        D.38854 = imb.b[1];
        *code.3093 = D.38854;
        code.3094 = code;
        code = code.3094 + 1;
        D.38856 = imb.b[2];
        *code.3094 = D.38856;
        code.3095 = code;
        code = code.3095 + 1;
        D.38858 = imb.b[3];
        *code.3095 = D.38858;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38840>:
  <D.38824>:
  goto <D.25197>;
  <D.26074>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38860>; else goto <D.38861>;
    <D.38860>:
    iftmp.3096 = 12;
    goto <D.38862>;
    <D.38861>:
    iftmp.3096 = 8;
    <D.38862>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.38863 = iftmp.3096 | D.33811;
    _amd64_rex_bits = (unsigned char) D.38863;
    if (_amd64_rex_bits != 0) goto <D.38864>; else goto <D.38865>;
    <D.38864>:
    code.3097 = code;
    code = code.3097 + 1;
    D.38867 = _amd64_rex_bits | 64;
    *code.3097 = D.38867;
    <D.38865>:
  }
  code.3098 = code;
  code = code.3098 + 1;
  *code.3098 = 51;
  code.3099 = code;
  code = code.3099 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3099 = D.33821;
  goto <D.25197>;
  <D.26076>:
  <D.26077>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.38870>; else goto <D.38871>;
  <D.38870>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4571, "amd64_is_imm32 (ins->inst_imm)");
  <D.38871>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.38872>; else goto <D.38873>;
  <D.38872>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38875>; else goto <D.38876>;
    <D.38875>:
    iftmp.3100 = 9;
    goto <D.38877>;
    <D.38876>:
    iftmp.3100 = 8;
    <D.38877>:
    _amd64_rex_bits = iftmp.3100;
    if (_amd64_rex_bits != 0) goto <D.38878>; else goto <D.38879>;
    <D.38878>:
    code.3101 = code;
    code = code.3101 + 1;
    D.38881 = _amd64_rex_bits | 64;
    *code.3101 = D.38881;
    <D.38879>:
  }
  code.3102 = code;
  code = code.3102 + 1;
  *code.3102 = 131;
  code.3103 = code;
  code = code.3103 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38884 = D.31571 | -16;
  D.38885 = (unsigned char) D.38884;
  *code.3103 = D.38885;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.38886>;
  <D.38873>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.38887>; else goto <D.38888>;
  <D.38887>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.38889>; else goto <D.38890>;
    <D.38889>:
    code.3104 = code;
    code = code.3104 + 1;
    D.38892 = _amd64_rex_bits | 64;
    *code.3104 = D.38892;
    <D.38890>:
  }
  code.3105 = code;
  code = code.3105 + 1;
  *code.3105 = 53;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3106 = code;
        code = code.3106 + 1;
        D.38895 = imb.b[0];
        *code.3106 = D.38895;
        code.3107 = code;
        code = code.3107 + 1;
        D.38897 = imb.b[1];
        *code.3107 = D.38897;
        code.3108 = code;
        code = code.3108 + 1;
        D.38899 = imb.b[2];
        *code.3108 = D.38899;
        code.3109 = code;
        code = code.3109 + 1;
        D.38901 = imb.b[3];
        *code.3109 = D.38901;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.38902>;
  <D.38888>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.38904>; else goto <D.38905>;
    <D.38904>:
    iftmp.3110 = 9;
    goto <D.38906>;
    <D.38905>:
    iftmp.3110 = 8;
    <D.38906>:
    _amd64_rex_bits = iftmp.3110;
    if (_amd64_rex_bits != 0) goto <D.38907>; else goto <D.38908>;
    <D.38907>:
    code.3111 = code;
    code = code.3111 + 1;
    D.38910 = _amd64_rex_bits | 64;
    *code.3111 = D.38910;
    <D.38908>:
  }
  code.3112 = code;
  code = code.3112 + 1;
  *code.3112 = 129;
  code.3113 = code;
  code = code.3113 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38884 = D.31571 | -16;
  D.38885 = (unsigned char) D.38884;
  *code.3113 = D.38885;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3114 = code;
        code = code.3114 + 1;
        D.38914 = imb.b[0];
        *code.3114 = D.38914;
        code.3115 = code;
        code = code.3115 + 1;
        D.38916 = imb.b[1];
        *code.3115 = D.38916;
        code.3116 = code;
        code = code.3116 + 1;
        D.38918 = imb.b[2];
        *code.3116 = D.38918;
        code.3117 = code;
        code = code.3117 + 1;
        D.38920 = imb.b[3];
        *code.3117 = D.38920;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.38902>:
  <D.38886>:
  goto <D.25197>;
  <D.26083>:
  D.31490 = ins->sreg2;
  D.38921 = D.31490 != 1;
  D.38922 = (long int) D.38921;
  D.38923 = __builtin_expect (D.38922, 0);
  if (D.38923 != 0) goto <D.38924>; else goto <D.38925>;
  <D.38924>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4575, "ins->sreg2 == AMD64_RCX");
  <D.38925>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.38927>; else goto <D.38928>;
    <D.38927>:
    iftmp.3118 = 9;
    goto <D.38929>;
    <D.38928>:
    iftmp.3118 = 8;
    <D.38929>:
    _amd64_rex_bits = iftmp.3118;
    if (_amd64_rex_bits != 0) goto <D.38930>; else goto <D.38931>;
    <D.38930>:
    code.3119 = code;
    code = code.3119 + 1;
    D.38933 = _amd64_rex_bits | 64;
    *code.3119 = D.38933;
    <D.38931>:
  }
  code.3120 = code;
  code = code.3120 + 1;
  *code.3120 = 211;
  code.3121 = code;
  code = code.3121 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3121 = D.37855;
  goto <D.25197>;
  <D.26085>:
  D.31490 = ins->sreg2;
  D.38921 = D.31490 != 1;
  D.38922 = (long int) D.38921;
  D.38923 = __builtin_expect (D.38922, 0);
  if (D.38923 != 0) goto <D.38936>; else goto <D.38937>;
  <D.38936>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4579, "ins->sreg2 == AMD64_RCX");
  <D.38937>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.38939>; else goto <D.38940>;
    <D.38939>:
    iftmp.3122 = 9;
    goto <D.38941>;
    <D.38940>:
    iftmp.3122 = 8;
    <D.38941>:
    _amd64_rex_bits = iftmp.3122;
    if (_amd64_rex_bits != 0) goto <D.38942>; else goto <D.38943>;
    <D.38942>:
    code.3123 = code;
    code = code.3123 + 1;
    D.38945 = _amd64_rex_bits | 64;
    *code.3123 = D.38945;
    <D.38943>:
  }
  code.3124 = code;
  code = code.3124 + 1;
  *code.3124 = 211;
  code.3125 = code;
  code = code.3125 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3125 = D.38949;
  goto <D.25197>;
  <D.26087>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.38950>; else goto <D.38951>;
  <D.38950>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4583, "amd64_is_imm32 (ins->inst_imm)");
  <D.38951>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.38952>; else goto <D.38953>;
    <D.38952>:
    code.3126 = code;
    code = code.3126 + 1;
    D.38955 = _amd64_rex_bits | 64;
    *code.3126 = D.38955;
    <D.38953>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.38956>; else goto <D.38957>;
  <D.38956>:
  code.3127 = code;
  code = code.3127 + 1;
  *code.3127 = 209;
  code.3128 = code;
  code = code.3128 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3128 = D.38949;
  goto <D.38960>;
  <D.38957>:
  code.3129 = code;
  code = code.3129 + 1;
  *code.3129 = 193;
  code.3130 = code;
  code = code.3130 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3130 = D.38949;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.38960>:
  goto <D.25197>;
  <D.26089>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.38963>; else goto <D.38964>;
  <D.38963>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4587, "amd64_is_imm32 (ins->inst_imm)");
  <D.38964>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.38966>; else goto <D.38967>;
    <D.38966>:
    iftmp.3131 = 9;
    goto <D.38968>;
    <D.38967>:
    iftmp.3131 = 8;
    <D.38968>:
    _amd64_rex_bits = iftmp.3131;
    if (_amd64_rex_bits != 0) goto <D.38969>; else goto <D.38970>;
    <D.38969>:
    code.3132 = code;
    code = code.3132 + 1;
    D.38972 = _amd64_rex_bits | 64;
    *code.3132 = D.38972;
    <D.38970>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.38973>; else goto <D.38974>;
  <D.38973>:
  code.3133 = code;
  code = code.3133 + 1;
  *code.3133 = 209;
  code.3134 = code;
  code = code.3134 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3134 = D.38949;
  goto <D.38977>;
  <D.38974>:
  code.3135 = code;
  code = code.3135 + 1;
  *code.3135 = 193;
  code.3136 = code;
  code = code.3136 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3136 = D.38949;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.38977>:
  goto <D.25197>;
  <D.26091>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.38980>; else goto <D.38981>;
  <D.38980>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4591, "amd64_is_imm32 (ins->inst_imm)");
  <D.38981>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.38982>; else goto <D.38983>;
    <D.38982>:
    code.3137 = code;
    code = code.3137 + 1;
    D.38985 = _amd64_rex_bits | 64;
    *code.3137 = D.38985;
    <D.38983>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.38986>; else goto <D.38987>;
  <D.38986>:
  code.3138 = code;
  code = code.3138 + 1;
  *code.3138 = 209;
  code.3139 = code;
  code = code.3139 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3139 = D.37319;
  goto <D.38990>;
  <D.38987>:
  code.3140 = code;
  code = code.3140 + 1;
  *code.3140 = 193;
  code.3141 = code;
  code = code.3141 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3141 = D.37319;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.38990>:
  goto <D.25197>;
  <D.26093>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.38993>; else goto <D.38994>;
  <D.38993>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4595, "amd64_is_imm32 (ins->inst_imm)");
  <D.38994>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.38996>; else goto <D.38997>;
    <D.38996>:
    iftmp.3142 = 9;
    goto <D.38998>;
    <D.38997>:
    iftmp.3142 = 8;
    <D.38998>:
    _amd64_rex_bits = iftmp.3142;
    if (_amd64_rex_bits != 0) goto <D.38999>; else goto <D.39000>;
    <D.38999>:
    code.3143 = code;
    code = code.3143 + 1;
    D.39002 = _amd64_rex_bits | 64;
    *code.3143 = D.39002;
    <D.39000>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.39003>; else goto <D.39004>;
  <D.39003>:
  code.3144 = code;
  code = code.3144 + 1;
  *code.3144 = 209;
  code.3145 = code;
  code = code.3145 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3145 = D.37319;
  goto <D.39007>;
  <D.39004>:
  code.3146 = code;
  code = code.3146 + 1;
  *code.3146 = 193;
  code.3147 = code;
  code = code.3147 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3147 = D.37319;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.39007>:
  goto <D.25197>;
  <D.26095>:
  D.31490 = ins->sreg2;
  D.38921 = D.31490 != 1;
  D.38922 = (long int) D.38921;
  D.38923 = __builtin_expect (D.38922, 0);
  if (D.38923 != 0) goto <D.39010>; else goto <D.39011>;
  <D.39010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4599, "ins->sreg2 == AMD64_RCX");
  <D.39011>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.39013>; else goto <D.39014>;
    <D.39013>:
    iftmp.3148 = 9;
    goto <D.39015>;
    <D.39014>:
    iftmp.3148 = 8;
    <D.39015>:
    _amd64_rex_bits = iftmp.3148;
    if (_amd64_rex_bits != 0) goto <D.39016>; else goto <D.39017>;
    <D.39016>:
    code.3149 = code;
    code = code.3149 + 1;
    D.39019 = _amd64_rex_bits | 64;
    *code.3149 = D.39019;
    <D.39017>:
  }
  code.3150 = code;
  code = code.3150 + 1;
  *code.3150 = 211;
  code.3151 = code;
  code = code.3151 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3151 = D.37319;
  goto <D.25197>;
  <D.26097>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.39022>; else goto <D.39023>;
  <D.39022>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4603, "amd64_is_imm32 (ins->inst_imm)");
  <D.39023>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39024>; else goto <D.39025>;
    <D.39024>:
    code.3152 = code;
    code = code.3152 + 1;
    D.39027 = _amd64_rex_bits | 64;
    *code.3152 = D.39027;
    <D.39025>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.39028>; else goto <D.39029>;
  <D.39028>:
  code.3153 = code;
  code = code.3153 + 1;
  *code.3153 = 209;
  code.3154 = code;
  code = code.3154 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3154 = D.37855;
  goto <D.39032>;
  <D.39029>:
  code.3155 = code;
  code = code.3155 + 1;
  *code.3155 = 193;
  code.3156 = code;
  code = code.3156 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3156 = D.37855;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.39032>:
  goto <D.25197>;
  <D.26099>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.39035>; else goto <D.39036>;
  <D.39035>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4607, "amd64_is_imm32 (ins->inst_imm)");
  <D.39036>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.39038>; else goto <D.39039>;
    <D.39038>:
    iftmp.3157 = 9;
    goto <D.39040>;
    <D.39039>:
    iftmp.3157 = 8;
    <D.39040>:
    _amd64_rex_bits = iftmp.3157;
    if (_amd64_rex_bits != 0) goto <D.39041>; else goto <D.39042>;
    <D.39041>:
    code.3158 = code;
    code = code.3158 + 1;
    D.39044 = _amd64_rex_bits | 64;
    *code.3158 = D.39044;
    <D.39042>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.39045>; else goto <D.39046>;
  <D.39045>:
  code.3159 = code;
  code = code.3159 + 1;
  *code.3159 = 209;
  code.3160 = code;
  code = code.3160 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3160 = D.37855;
  goto <D.39049>;
  <D.39046>:
  code.3161 = code;
  code = code.3161 + 1;
  *code.3161 = 193;
  code.3162 = code;
  code = code.3162 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3162 = D.37855;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.39049>:
  goto <D.25197>;
  <D.26101>:
  <D.26102>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39053>; else goto <D.39054>;
    <D.39053>:
    iftmp.3163 = 4;
    goto <D.39055>;
    <D.39054>:
    iftmp.3163 = 0;
    <D.39055>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39056 = iftmp.3163 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39056;
    if (_amd64_rex_bits != 0) goto <D.39057>; else goto <D.39058>;
    <D.39057>:
    code.3164 = code;
    code = code.3164 + 1;
    D.39060 = _amd64_rex_bits | 64;
    *code.3164 = D.39060;
    <D.39058>:
  }
  code.3165 = code;
  code = code.3165 + 1;
  *code.3165 = 3;
  code.3166 = code;
  code = code.3166 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3166 = D.33821;
  goto <D.25197>;
  <D.26104>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39064>; else goto <D.39065>;
    <D.39064>:
    iftmp.3167 = 4;
    goto <D.39066>;
    <D.39065>:
    iftmp.3167 = 0;
    <D.39066>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39067 = iftmp.3167 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39067;
    if (_amd64_rex_bits != 0) goto <D.39068>; else goto <D.39069>;
    <D.39068>:
    code.3168 = code;
    code = code.3168 + 1;
    D.39071 = _amd64_rex_bits | 64;
    *code.3168 = D.39071;
    <D.39069>:
  }
  code.3169 = code;
  code = code.3169 + 1;
  *code.3169 = 19;
  code.3170 = code;
  code = code.3170 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3170 = D.33821;
  goto <D.25197>;
  <D.26106>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39074>; else goto <D.39075>;
  <D.39074>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39076>; else goto <D.39077>;
    <D.39076>:
    code.3171 = code;
    code = code.3171 + 1;
    D.39079 = _amd64_rex_bits | 64;
    *code.3171 = D.39079;
    <D.39077>:
  }
  code.3172 = code;
  code = code.3172 + 1;
  *code.3172 = 131;
  code.3173 = code;
  code = code.3173 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.3173 = D.35110;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39082>;
  <D.39075>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.39083>; else goto <D.39084>;
  <D.39083>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39085>; else goto <D.39086>;
    <D.39085>:
    code.3174 = code;
    code = code.3174 + 1;
    D.39088 = _amd64_rex_bits | 64;
    *code.3174 = D.39088;
    <D.39086>:
  }
  code.3175 = code;
  code = code.3175 + 1;
  *code.3175 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3176 = code;
        code = code.3176 + 1;
        D.39091 = imb.b[0];
        *code.3176 = D.39091;
        code.3177 = code;
        code = code.3177 + 1;
        D.39093 = imb.b[1];
        *code.3177 = D.39093;
        code.3178 = code;
        code = code.3178 + 1;
        D.39095 = imb.b[2];
        *code.3178 = D.39095;
        code.3179 = code;
        code = code.3179 + 1;
        D.39097 = imb.b[3];
        *code.3179 = D.39097;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39098>;
  <D.39084>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39099>; else goto <D.39100>;
    <D.39099>:
    code.3180 = code;
    code = code.3180 + 1;
    D.39102 = _amd64_rex_bits | 64;
    *code.3180 = D.39102;
    <D.39100>:
  }
  code.3181 = code;
  code = code.3181 + 1;
  *code.3181 = 129;
  code.3182 = code;
  code = code.3182 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.3182 = D.35110;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3183 = code;
        code = code.3183 + 1;
        D.39106 = imb.b[0];
        *code.3183 = D.39106;
        code.3184 = code;
        code = code.3184 + 1;
        D.39108 = imb.b[1];
        *code.3184 = D.39108;
        code.3185 = code;
        code = code.3185 + 1;
        D.39110 = imb.b[2];
        *code.3185 = D.39110;
        code.3186 = code;
        code = code.3186 + 1;
        D.39112 = imb.b[3];
        *code.3186 = D.39112;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39098>:
  <D.39082>:
  goto <D.25197>;
  <D.26112>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39113>; else goto <D.39114>;
  <D.39113>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39115>; else goto <D.39116>;
    <D.39115>:
    code.3187 = code;
    code = code.3187 + 1;
    D.39118 = _amd64_rex_bits | 64;
    *code.3187 = D.39118;
    <D.39116>:
  }
  code.3188 = code;
  code = code.3188 + 1;
  *code.3188 = 131;
  code.3189 = code;
  code = code.3189 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.3189 = D.37246;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39121>;
  <D.39114>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.39122>; else goto <D.39123>;
  <D.39122>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39124>; else goto <D.39125>;
    <D.39124>:
    code.3190 = code;
    code = code.3190 + 1;
    D.39127 = _amd64_rex_bits | 64;
    *code.3190 = D.39127;
    <D.39125>:
  }
  code.3191 = code;
  code = code.3191 + 1;
  *code.3191 = 21;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3192 = code;
        code = code.3192 + 1;
        D.39130 = imb.b[0];
        *code.3192 = D.39130;
        code.3193 = code;
        code = code.3193 + 1;
        D.39132 = imb.b[1];
        *code.3193 = D.39132;
        code.3194 = code;
        code = code.3194 + 1;
        D.39134 = imb.b[2];
        *code.3194 = D.39134;
        code.3195 = code;
        code = code.3195 + 1;
        D.39136 = imb.b[3];
        *code.3195 = D.39136;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39137>;
  <D.39123>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39138>; else goto <D.39139>;
    <D.39138>:
    code.3196 = code;
    code = code.3196 + 1;
    D.39141 = _amd64_rex_bits | 64;
    *code.3196 = D.39141;
    <D.39139>:
  }
  code.3197 = code;
  code = code.3197 + 1;
  *code.3197 = 129;
  code.3198 = code;
  code = code.3198 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.3198 = D.37246;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3199 = code;
        code = code.3199 + 1;
        D.39145 = imb.b[0];
        *code.3199 = D.39145;
        code.3200 = code;
        code = code.3200 + 1;
        D.39147 = imb.b[1];
        *code.3200 = D.39147;
        code.3201 = code;
        code = code.3201 + 1;
        D.39149 = imb.b[2];
        *code.3201 = D.39149;
        code.3202 = code;
        code = code.3202 + 1;
        D.39151 = imb.b[3];
        *code.3202 = D.39151;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39137>:
  <D.39121>:
  goto <D.25197>;
  <D.26118>:
  <D.26119>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39153>; else goto <D.39154>;
    <D.39153>:
    iftmp.3203 = 4;
    goto <D.39155>;
    <D.39154>:
    iftmp.3203 = 0;
    <D.39155>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39156 = iftmp.3203 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39156;
    if (_amd64_rex_bits != 0) goto <D.39157>; else goto <D.39158>;
    <D.39157>:
    code.3204 = code;
    code = code.3204 + 1;
    D.39160 = _amd64_rex_bits | 64;
    *code.3204 = D.39160;
    <D.39158>:
  }
  code.3205 = code;
  code = code.3205 + 1;
  *code.3205 = 43;
  code.3206 = code;
  code = code.3206 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3206 = D.33821;
  goto <D.25197>;
  <D.26121>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39164>; else goto <D.39165>;
    <D.39164>:
    iftmp.3207 = 4;
    goto <D.39166>;
    <D.39165>:
    iftmp.3207 = 0;
    <D.39166>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39167 = iftmp.3207 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39167;
    if (_amd64_rex_bits != 0) goto <D.39168>; else goto <D.39169>;
    <D.39168>:
    code.3208 = code;
    code = code.3208 + 1;
    D.39171 = _amd64_rex_bits | 64;
    *code.3208 = D.39171;
    <D.39169>:
  }
  code.3209 = code;
  code = code.3209 + 1;
  *code.3209 = 27;
  code.3210 = code;
  code = code.3210 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3210 = D.33821;
  goto <D.25197>;
  <D.26123>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39174>; else goto <D.39175>;
  <D.39174>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39176>; else goto <D.39177>;
    <D.39176>:
    code.3211 = code;
    code = code.3211 + 1;
    D.39179 = _amd64_rex_bits | 64;
    *code.3211 = D.39179;
    <D.39177>:
  }
  code.3212 = code;
  code = code.3212 + 1;
  *code.3212 = 131;
  code.3213 = code;
  code = code.3213 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3213 = D.37319;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39182>;
  <D.39175>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.39183>; else goto <D.39184>;
  <D.39183>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39185>; else goto <D.39186>;
    <D.39185>:
    code.3214 = code;
    code = code.3214 + 1;
    D.39188 = _amd64_rex_bits | 64;
    *code.3214 = D.39188;
    <D.39186>:
  }
  code.3215 = code;
  code = code.3215 + 1;
  *code.3215 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3216 = code;
        code = code.3216 + 1;
        D.39191 = imb.b[0];
        *code.3216 = D.39191;
        code.3217 = code;
        code = code.3217 + 1;
        D.39193 = imb.b[1];
        *code.3217 = D.39193;
        code.3218 = code;
        code = code.3218 + 1;
        D.39195 = imb.b[2];
        *code.3218 = D.39195;
        code.3219 = code;
        code = code.3219 + 1;
        D.39197 = imb.b[3];
        *code.3219 = D.39197;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39198>;
  <D.39184>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39199>; else goto <D.39200>;
    <D.39199>:
    code.3220 = code;
    code = code.3220 + 1;
    D.39202 = _amd64_rex_bits | 64;
    *code.3220 = D.39202;
    <D.39200>:
  }
  code.3221 = code;
  code = code.3221 + 1;
  *code.3221 = 129;
  code.3222 = code;
  code = code.3222 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3222 = D.37319;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3223 = code;
        code = code.3223 + 1;
        D.39206 = imb.b[0];
        *code.3223 = D.39206;
        code.3224 = code;
        code = code.3224 + 1;
        D.39208 = imb.b[1];
        *code.3224 = D.39208;
        code.3225 = code;
        code = code.3225 + 1;
        D.39210 = imb.b[2];
        *code.3225 = D.39210;
        code.3226 = code;
        code = code.3226 + 1;
        D.39212 = imb.b[3];
        *code.3226 = D.39212;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39198>:
  <D.39182>:
  goto <D.25197>;
  <D.26129>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39213>; else goto <D.39214>;
  <D.39213>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39215>; else goto <D.39216>;
    <D.39215>:
    code.3227 = code;
    code = code.3227 + 1;
    D.39218 = _amd64_rex_bits | 64;
    *code.3227 = D.39218;
    <D.39216>:
  }
  code.3228 = code;
  code = code.3228 + 1;
  *code.3228 = 131;
  code.3229 = code;
  code = code.3229 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37369 = D.31632 | -40;
  D.37370 = (unsigned char) D.37369;
  *code.3229 = D.37370;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39221>;
  <D.39214>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.39222>; else goto <D.39223>;
  <D.39222>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39224>; else goto <D.39225>;
    <D.39224>:
    code.3230 = code;
    code = code.3230 + 1;
    D.39227 = _amd64_rex_bits | 64;
    *code.3230 = D.39227;
    <D.39225>:
  }
  code.3231 = code;
  code = code.3231 + 1;
  *code.3231 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3232 = code;
        code = code.3232 + 1;
        D.39230 = imb.b[0];
        *code.3232 = D.39230;
        code.3233 = code;
        code = code.3233 + 1;
        D.39232 = imb.b[1];
        *code.3233 = D.39232;
        code.3234 = code;
        code = code.3234 + 1;
        D.39234 = imb.b[2];
        *code.3234 = D.39234;
        code.3235 = code;
        code = code.3235 + 1;
        D.39236 = imb.b[3];
        *code.3235 = D.39236;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39237>;
  <D.39223>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39238>; else goto <D.39239>;
    <D.39238>:
    code.3236 = code;
    code = code.3236 + 1;
    D.39241 = _amd64_rex_bits | 64;
    *code.3236 = D.39241;
    <D.39239>:
  }
  code.3237 = code;
  code = code.3237 + 1;
  *code.3237 = 129;
  code.3238 = code;
  code = code.3238 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37369 = D.31632 | -40;
  D.37370 = (unsigned char) D.37369;
  *code.3238 = D.37370;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3239 = code;
        code = code.3239 + 1;
        D.39245 = imb.b[0];
        *code.3239 = D.39245;
        code.3240 = code;
        code = code.3240 + 1;
        D.39247 = imb.b[1];
        *code.3240 = D.39247;
        code.3241 = code;
        code = code.3241 + 1;
        D.39249 = imb.b[2];
        *code.3241 = D.39249;
        code.3242 = code;
        code = code.3242 + 1;
        D.39251 = imb.b[3];
        *code.3242 = D.39251;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39237>:
  <D.39221>:
  goto <D.25197>;
  <D.26135>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39253>; else goto <D.39254>;
    <D.39253>:
    iftmp.3243 = 4;
    goto <D.39255>;
    <D.39254>:
    iftmp.3243 = 0;
    <D.39255>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39256 = iftmp.3243 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39256;
    if (_amd64_rex_bits != 0) goto <D.39257>; else goto <D.39258>;
    <D.39257>:
    code.3244 = code;
    code = code.3244 + 1;
    D.39260 = _amd64_rex_bits | 64;
    *code.3244 = D.39260;
    <D.39258>:
  }
  code.3245 = code;
  code = code.3245 + 1;
  *code.3245 = 35;
  code.3246 = code;
  code = code.3246 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3246 = D.33821;
  goto <D.25197>;
  <D.26137>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39263>; else goto <D.39264>;
  <D.39263>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39265>; else goto <D.39266>;
    <D.39265>:
    code.3247 = code;
    code = code.3247 + 1;
    D.39268 = _amd64_rex_bits | 64;
    *code.3247 = D.39268;
    <D.39266>:
  }
  code.3248 = code;
  code = code.3248 + 1;
  *code.3248 = 131;
  code.3249 = code;
  code = code.3249 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.3249 = D.37432;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39271>;
  <D.39264>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.39272>; else goto <D.39273>;
  <D.39272>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39274>; else goto <D.39275>;
    <D.39274>:
    code.3250 = code;
    code = code.3250 + 1;
    D.39277 = _amd64_rex_bits | 64;
    *code.3250 = D.39277;
    <D.39275>:
  }
  code.3251 = code;
  code = code.3251 + 1;
  *code.3251 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3252 = code;
        code = code.3252 + 1;
        D.39280 = imb.b[0];
        *code.3252 = D.39280;
        code.3253 = code;
        code = code.3253 + 1;
        D.39282 = imb.b[1];
        *code.3253 = D.39282;
        code.3254 = code;
        code = code.3254 + 1;
        D.39284 = imb.b[2];
        *code.3254 = D.39284;
        code.3255 = code;
        code = code.3255 + 1;
        D.39286 = imb.b[3];
        *code.3255 = D.39286;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39287>;
  <D.39273>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39288>; else goto <D.39289>;
    <D.39288>:
    code.3256 = code;
    code = code.3256 + 1;
    D.39291 = _amd64_rex_bits | 64;
    *code.3256 = D.39291;
    <D.39289>:
  }
  code.3257 = code;
  code = code.3257 + 1;
  *code.3257 = 129;
  code.3258 = code;
  code = code.3258 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.3258 = D.37432;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3259 = code;
        code = code.3259 + 1;
        D.39295 = imb.b[0];
        *code.3259 = D.39295;
        code.3260 = code;
        code = code.3260 + 1;
        D.39297 = imb.b[1];
        *code.3260 = D.39297;
        code.3261 = code;
        code = code.3261 + 1;
        D.39299 = imb.b[2];
        *code.3261 = D.39299;
        code.3262 = code;
        code = code.3262 + 1;
        D.39301 = imb.b[3];
        *code.3262 = D.39301;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39287>:
  <D.39271>:
  goto <D.25197>;
  <D.26143>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39303>; else goto <D.39304>;
    <D.39303>:
    iftmp.3263 = 4;
    goto <D.39305>;
    <D.39304>:
    iftmp.3263 = 0;
    <D.39305>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39306 = iftmp.3263 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39306;
    if (_amd64_rex_bits != 0) goto <D.39307>; else goto <D.39308>;
    <D.39307>:
    code.3264 = code;
    code = code.3264 + 1;
    D.39310 = _amd64_rex_bits | 64;
    *code.3264 = D.39310;
    <D.39308>:
  }
  code.3265 = code;
  code = code.3265 + 1;
  *code.3265 = 11;
  code.3266 = code;
  code = code.3266 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3266 = D.33821;
  goto <D.25197>;
  <D.26145>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39313>; else goto <D.39314>;
  <D.39313>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39315>; else goto <D.39316>;
    <D.39315>:
    code.3267 = code;
    code = code.3267 + 1;
    D.39318 = _amd64_rex_bits | 64;
    *code.3267 = D.39318;
    <D.39316>:
  }
  code.3268 = code;
  code = code.3268 + 1;
  *code.3268 = 131;
  code.3269 = code;
  code = code.3269 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38822 = D.31571 | -56;
  D.38823 = (unsigned char) D.38822;
  *code.3269 = D.38823;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39321>;
  <D.39314>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.39322>; else goto <D.39323>;
  <D.39322>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39324>; else goto <D.39325>;
    <D.39324>:
    code.3270 = code;
    code = code.3270 + 1;
    D.39327 = _amd64_rex_bits | 64;
    *code.3270 = D.39327;
    <D.39325>:
  }
  code.3271 = code;
  code = code.3271 + 1;
  *code.3271 = 13;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3272 = code;
        code = code.3272 + 1;
        D.39330 = imb.b[0];
        *code.3272 = D.39330;
        code.3273 = code;
        code = code.3273 + 1;
        D.39332 = imb.b[1];
        *code.3273 = D.39332;
        code.3274 = code;
        code = code.3274 + 1;
        D.39334 = imb.b[2];
        *code.3274 = D.39334;
        code.3275 = code;
        code = code.3275 + 1;
        D.39336 = imb.b[3];
        *code.3275 = D.39336;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39337>;
  <D.39323>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39338>; else goto <D.39339>;
    <D.39338>:
    code.3276 = code;
    code = code.3276 + 1;
    D.39341 = _amd64_rex_bits | 64;
    *code.3276 = D.39341;
    <D.39339>:
  }
  code.3277 = code;
  code = code.3277 + 1;
  *code.3277 = 129;
  code.3278 = code;
  code = code.3278 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38822 = D.31571 | -56;
  D.38823 = (unsigned char) D.38822;
  *code.3278 = D.38823;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3279 = code;
        code = code.3279 + 1;
        D.39345 = imb.b[0];
        *code.3279 = D.39345;
        code.3280 = code;
        code = code.3280 + 1;
        D.39347 = imb.b[1];
        *code.3280 = D.39347;
        code.3281 = code;
        code = code.3281 + 1;
        D.39349 = imb.b[2];
        *code.3281 = D.39349;
        code.3282 = code;
        code = code.3282 + 1;
        D.39351 = imb.b[3];
        *code.3282 = D.39351;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39337>:
  <D.39321>:
  goto <D.25197>;
  <D.26151>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39353>; else goto <D.39354>;
    <D.39353>:
    iftmp.3283 = 4;
    goto <D.39355>;
    <D.39354>:
    iftmp.3283 = 0;
    <D.39355>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39356 = iftmp.3283 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39356;
    if (_amd64_rex_bits != 0) goto <D.39357>; else goto <D.39358>;
    <D.39357>:
    code.3284 = code;
    code = code.3284 + 1;
    D.39360 = _amd64_rex_bits | 64;
    *code.3284 = D.39360;
    <D.39358>:
  }
  code.3285 = code;
  code = code.3285 + 1;
  *code.3285 = 51;
  code.3286 = code;
  code = code.3286 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3286 = D.33821;
  goto <D.25197>;
  <D.26153>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39363>; else goto <D.39364>;
  <D.39363>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39365>; else goto <D.39366>;
    <D.39365>:
    code.3287 = code;
    code = code.3287 + 1;
    D.39368 = _amd64_rex_bits | 64;
    *code.3287 = D.39368;
    <D.39366>:
  }
  code.3288 = code;
  code = code.3288 + 1;
  *code.3288 = 131;
  code.3289 = code;
  code = code.3289 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38884 = D.31571 | -16;
  D.38885 = (unsigned char) D.38884;
  *code.3289 = D.38885;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39371>;
  <D.39364>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.39372>; else goto <D.39373>;
  <D.39372>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39374>; else goto <D.39375>;
    <D.39374>:
    code.3290 = code;
    code = code.3290 + 1;
    D.39377 = _amd64_rex_bits | 64;
    *code.3290 = D.39377;
    <D.39375>:
  }
  code.3291 = code;
  code = code.3291 + 1;
  *code.3291 = 53;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3292 = code;
        code = code.3292 + 1;
        D.39380 = imb.b[0];
        *code.3292 = D.39380;
        code.3293 = code;
        code = code.3293 + 1;
        D.39382 = imb.b[1];
        *code.3293 = D.39382;
        code.3294 = code;
        code = code.3294 + 1;
        D.39384 = imb.b[2];
        *code.3294 = D.39384;
        code.3295 = code;
        code = code.3295 + 1;
        D.39386 = imb.b[3];
        *code.3295 = D.39386;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39387>;
  <D.39373>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39388>; else goto <D.39389>;
    <D.39388>:
    code.3296 = code;
    code = code.3296 + 1;
    D.39391 = _amd64_rex_bits | 64;
    *code.3296 = D.39391;
    <D.39389>:
  }
  code.3297 = code;
  code = code.3297 + 1;
  *code.3297 = 129;
  code.3298 = code;
  code = code.3298 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.38884 = D.31571 | -16;
  D.38885 = (unsigned char) D.38884;
  *code.3298 = D.38885;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3299 = code;
        code = code.3299 + 1;
        D.39395 = imb.b[0];
        *code.3299 = D.39395;
        code.3300 = code;
        code = code.3300 + 1;
        D.39397 = imb.b[1];
        *code.3300 = D.39397;
        code.3301 = code;
        code = code.3301 + 1;
        D.39399 = imb.b[2];
        *code.3301 = D.39399;
        code.3302 = code;
        code = code.3302 + 1;
        D.39401 = imb.b[3];
        *code.3302 = D.39401;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39387>:
  <D.39371>:
  goto <D.25197>;
  <D.26159>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39402>; else goto <D.39403>;
    <D.39402>:
    code.3303 = code;
    code = code.3303 + 1;
    D.39405 = _amd64_rex_bits | 64;
    *code.3303 = D.39405;
    <D.39403>:
  }
  code.3304 = code;
  code = code.3304 + 1;
  *code.3304 = 247;
  code.3305 = code;
  code = code.3305 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39408 = D.31571 | -40;
  D.39409 = (unsigned char) D.39408;
  *code.3305 = D.39409;
  goto <D.25197>;
  <D.26161>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39410>; else goto <D.39411>;
    <D.39410>:
    code.3306 = code;
    code = code.3306 + 1;
    D.39413 = _amd64_rex_bits | 64;
    *code.3306 = D.39413;
    <D.39411>:
  }
  code.3307 = code;
  code = code.3307 + 1;
  *code.3307 = 247;
  code.3308 = code;
  code = code.3308 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39416 = D.31571 | -48;
  D.39417 = (unsigned char) D.39416;
  *code.3308 = D.39417;
  goto <D.25197>;
  <D.26163>:
  D.31490 = ins->sreg2;
  D.38921 = D.31490 != 1;
  D.38922 = (long int) D.38921;
  D.38923 = __builtin_expect (D.38922, 0);
  if (D.38923 != 0) goto <D.39418>; else goto <D.39419>;
  <D.39418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4662, "ins->sreg2 == AMD64_RCX");
  <D.39419>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39420>; else goto <D.39421>;
    <D.39420>:
    code.3309 = code;
    code = code.3309 + 1;
    D.39423 = _amd64_rex_bits | 64;
    *code.3309 = D.39423;
    <D.39421>:
  }
  code.3310 = code;
  code = code.3310 + 1;
  *code.3310 = 211;
  code.3311 = code;
  code = code.3311 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3311 = D.37855;
  goto <D.25197>;
  <D.26165>:
  D.31490 = ins->sreg2;
  D.38921 = D.31490 != 1;
  D.38922 = (long int) D.38921;
  D.38923 = __builtin_expect (D.38922, 0);
  if (D.38923 != 0) goto <D.39426>; else goto <D.39427>;
  <D.39426>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4666, "ins->sreg2 == AMD64_RCX");
  <D.39427>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39428>; else goto <D.39429>;
    <D.39428>:
    code.3312 = code;
    code = code.3312 + 1;
    D.39431 = _amd64_rex_bits | 64;
    *code.3312 = D.39431;
    <D.39429>:
  }
  code.3313 = code;
  code = code.3313 + 1;
  *code.3313 = 211;
  code.3314 = code;
  code = code.3314 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3314 = D.38949;
  goto <D.25197>;
  <D.26167>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39434>; else goto <D.39435>;
    <D.39434>:
    code.3315 = code;
    code = code.3315 + 1;
    D.39437 = _amd64_rex_bits | 64;
    *code.3315 = D.39437;
    <D.39435>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.39438>; else goto <D.39439>;
  <D.39438>:
  code.3316 = code;
  code = code.3316 + 1;
  *code.3316 = 209;
  code.3317 = code;
  code = code.3317 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3317 = D.38949;
  goto <D.39442>;
  <D.39439>:
  code.3318 = code;
  code = code.3318 + 1;
  *code.3318 = 193;
  code.3319 = code;
  code = code.3319 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.3319 = D.38949;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.39442>:
  goto <D.25197>;
  <D.26169>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39445>; else goto <D.39446>;
    <D.39445>:
    code.3320 = code;
    code = code.3320 + 1;
    D.39448 = _amd64_rex_bits | 64;
    *code.3320 = D.39448;
    <D.39446>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.39449>; else goto <D.39450>;
  <D.39449>:
  code.3321 = code;
  code = code.3321 + 1;
  *code.3321 = 209;
  code.3322 = code;
  code = code.3322 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3322 = D.37319;
  goto <D.39453>;
  <D.39450>:
  code.3323 = code;
  code = code.3323 + 1;
  *code.3323 = 193;
  code.3324 = code;
  code = code.3324 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3324 = D.37319;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.39453>:
  goto <D.25197>;
  <D.26171>:
  D.31490 = ins->sreg2;
  D.38921 = D.31490 != 1;
  D.38922 = (long int) D.38921;
  D.38923 = __builtin_expect (D.38922, 0);
  if (D.38923 != 0) goto <D.39456>; else goto <D.39457>;
  <D.39456>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4676, "ins->sreg2 == AMD64_RCX");
  <D.39457>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39458>; else goto <D.39459>;
    <D.39458>:
    code.3325 = code;
    code = code.3325 + 1;
    D.39461 = _amd64_rex_bits | 64;
    *code.3325 = D.39461;
    <D.39459>:
  }
  code.3326 = code;
  code = code.3326 + 1;
  *code.3326 = 211;
  code.3327 = code;
  code = code.3327 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.3327 = D.37319;
  goto <D.25197>;
  <D.26173>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39464>; else goto <D.39465>;
    <D.39464>:
    code.3328 = code;
    code = code.3328 + 1;
    D.39467 = _amd64_rex_bits | 64;
    *code.3328 = D.39467;
    <D.39465>:
  }
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 1) goto <D.39468>; else goto <D.39469>;
  <D.39468>:
  code.3329 = code;
  code = code.3329 + 1;
  *code.3329 = 209;
  code.3330 = code;
  code = code.3330 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3330 = D.37855;
  goto <D.39472>;
  <D.39469>:
  code.3331 = code;
  code = code.3331 + 1;
  *code.3331 = 193;
  code.3332 = code;
  code = code.3332 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.3332 = D.37855;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  <D.39472>:
  goto <D.25197>;
  <D.26175>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39476>; else goto <D.39477>;
    <D.39476>:
    iftmp.3333 = 4;
    goto <D.39478>;
    <D.39477>:
    iftmp.3333 = 0;
    <D.39478>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39479 = iftmp.3333 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39479;
    if (_amd64_rex_bits != 0) goto <D.39480>; else goto <D.39481>;
    <D.39480>:
    code.3334 = code;
    code = code.3334 + 1;
    D.39483 = _amd64_rex_bits | 64;
    *code.3334 = D.39483;
    <D.39481>:
  }
  code.3335 = code;
  code = code.3335 + 1;
  *code.3335 = 15;
  code.3336 = code;
  code = code.3336 + 1;
  *code.3336 = 175;
  code.3337 = code;
  code = code.3337 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3337 = D.33821;
  goto <D.25197>;
  <D.26177>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39488>; else goto <D.39489>;
    <D.39488>:
    iftmp.3338 = 4;
    goto <D.39490>;
    <D.39489>:
    iftmp.3338 = 0;
    <D.39490>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39491 = iftmp.3338 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39491;
    if (_amd64_rex_bits != 0) goto <D.39492>; else goto <D.39493>;
    <D.39492>:
    code.3339 = code;
    code = code.3339 + 1;
    D.39495 = _amd64_rex_bits | 64;
    *code.3339 = D.39495;
    <D.39493>:
  }
  code.3340 = code;
  code = code.3340 + 1;
  *code.3340 = 15;
  code.3341 = code;
  code = code.3341 + 1;
  *code.3341 = 175;
  code.3342 = code;
  code = code.3342 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3342 = D.33821;
  {
    struct MonoInst * tins;

    tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
    if (tins == 0B) goto <D.39499>; else goto <D.39500>;
    <D.39499>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, "OverflowException");
    code.3343 = code;
    code = code.3343 + 1;
    *code.3343 = 15;
    if (0 != 0) goto <D.39502>; else goto <D.39503>;
    <D.39502>:
    code.3344 = code;
    code = code.3344 + 1;
    D.38716 = 112;
    D.38717 = D.38716 + 16;
    *code.3344 = D.38717;
    goto <D.39505>;
    <D.39503>:
    code.3345 = code;
    code = code.3345 + 1;
    D.38720 = 112;
    D.38721 = D.38720 + 16;
    *code.3345 = D.38721;
    <D.39505>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3346 = code;
          code = code.3346 + 1;
          D.39508 = imb.b[0];
          *code.3346 = D.39508;
          code.3347 = code;
          code = code.3347 + 1;
          D.39510 = imb.b[1];
          *code.3347 = D.39510;
          code.3348 = code;
          code = code.3348 + 1;
          D.39512 = imb.b[2];
          *code.3348 = D.39512;
          code.3349 = code;
          code = code.3349 + 1;
          D.39514 = imb.b[3];
          *code.3349 = D.39514;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.39515>;
    <D.39500>:
    D.39516 = tins->data.op[1].many_blocks;
    D.39517 = *D.39516;
    D.39518 = D.39517->native_offset;
    if (D.39518 != 0) goto <D.39519>; else goto <D.39520>;
    <D.39519>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.39516 = tins->data.op[1].many_blocks;
      D.39517 = *D.39516;
      D.39518 = D.39517->native_offset;
      D.39521 = (sizetype) D.39518;
      D.39522 = D.31283 + D.39521;
      D.39523 = (long int) D.39522;
      code.211 = (long int) code;
      D.39524 = D.39523 - code.211;
      D.39525 = (unsigned int) D.39524;
      D.39526 = D.39525 + 4294967294;
      offset = (int) D.39526;
      offset.3350 = (unsigned int) offset;
      D.39528 = offset.3350 + 128;
      if (D.39528 <= 255) goto <D.39529>; else goto <D.39530>;
      <D.39529>:
      if (0 != 0) goto <D.39531>; else goto <D.39532>;
      <D.39531>:
      code.3351 = code;
      code = code.3351 + 1;
      D.38716 = 112;
      *code.3351 = D.38716;
      goto <D.39534>;
      <D.39532>:
      code.3352 = code;
      code = code.3352 + 1;
      D.38720 = 112;
      *code.3352 = D.38720;
      <D.39534>:
      D.39536 = (unsigned char) offset;
      *code = D.39536;
      code = code + 1;
      goto <D.39537>;
      <D.39530>:
      D.31283 = cfg->native_code;
      D.39516 = tins->data.op[1].many_blocks;
      D.39517 = *D.39516;
      D.39518 = D.39517->native_offset;
      D.39521 = (sizetype) D.39518;
      D.39522 = D.31283 + D.39521;
      D.39523 = (long int) D.39522;
      code.211 = (long int) code;
      D.39524 = D.39523 - code.211;
      D.39525 = (unsigned int) D.39524;
      D.39538 = D.39525 + 4294967290;
      offset = (int) D.39538;
      code.3353 = code;
      code = code.3353 + 1;
      *code.3353 = 15;
      if (0 != 0) goto <D.39540>; else goto <D.39541>;
      <D.39540>:
      code.3354 = code;
      code = code.3354 + 1;
      D.38716 = 112;
      D.38717 = D.38716 + 16;
      *code.3354 = D.38717;
      goto <D.39543>;
      <D.39541>:
      code.3355 = code;
      code = code.3355 + 1;
      D.38720 = 112;
      D.38721 = D.38720 + 16;
      *code.3355 = D.38721;
      <D.39543>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.3356 = code;
            code = code.3356 + 1;
            D.39546 = imb.b[0];
            *code.3356 = D.39546;
            code.3357 = code;
            code = code.3357 + 1;
            D.39548 = imb.b[1];
            *code.3357 = D.39548;
            code.3358 = code;
            code = code.3358 + 1;
            D.39550 = imb.b[2];
            *code.3358 = D.39550;
            code.3359 = code;
            code = code.3359 + 1;
            D.39552 = imb.b[3];
            *code.3359 = D.39552;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.39537>:
    }
    goto <D.39553>;
    <D.39520>:
    D.39516 = tins->data.op[1].many_blocks;
    D.39517 = *D.39516;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.39517);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.39556>; else goto <D.39554>;
    <D.39556>:
    D.39516 = tins->data.op[1].many_blocks;
    D.39517 = *D.39516;
    D.39557 = D.39517->max_offset;
    D.39558 = (unsigned int) D.39557;
    D.39559 = D.39558 - offset;
    D.39560 = (int) D.39559;
    if (D.39560 >= -128) goto <D.39561>; else goto <D.39554>;
    <D.39561>:
    D.39516 = tins->data.op[1].many_blocks;
    D.39517 = *D.39516;
    D.39557 = D.39517->max_offset;
    D.39558 = (unsigned int) D.39557;
    D.39559 = D.39558 - offset;
    D.39560 = (int) D.39559;
    if (D.39560 <= 127) goto <D.39562>; else goto <D.39554>;
    <D.39562>:
    if (0 != 0) goto <D.39563>; else goto <D.39564>;
    <D.39563>:
    code.3360 = code;
    code = code.3360 + 1;
    D.38716 = 112;
    *code.3360 = D.38716;
    goto <D.39566>;
    <D.39564>:
    code.3361 = code;
    code = code.3361 + 1;
    D.38720 = 112;
    *code.3361 = D.38720;
    <D.39566>:
    *code = 0;
    code = code + 1;
    goto <D.39555>;
    <D.39554>:
    code.3362 = code;
    code = code.3362 + 1;
    *code.3362 = 15;
    if (0 != 0) goto <D.39569>; else goto <D.39570>;
    <D.39569>:
    code.3363 = code;
    code = code.3363 + 1;
    D.38716 = 112;
    D.38717 = D.38716 + 16;
    *code.3363 = D.38717;
    goto <D.39572>;
    <D.39570>:
    code.3364 = code;
    code = code.3364 + 1;
    D.38720 = 112;
    D.38721 = D.38720 + 16;
    *code.3364 = D.38721;
    <D.39572>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3365 = code;
          code = code.3365 + 1;
          D.39575 = imb.b[0];
          *code.3365 = D.39575;
          code.3366 = code;
          code = code.3366 + 1;
          D.39577 = imb.b[1];
          *code.3366 = D.39577;
          code.3367 = code;
          code = code.3367 + 1;
          D.39579 = imb.b[2];
          *code.3367 = D.39579;
          code.3368 = code;
          code = code.3368 + 1;
          D.39581 = imb.b[3];
          *code.3368 = D.39581;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39555>:
    <D.39553>:
    <D.39515>:
  }
  goto <D.25197>;
  <D.26184>:
  <D.26185>:
  {
    int non_eax_reg;
    int saved_eax;
    int saved_edx;
    int size;

    saved_eax = 0;
    saved_edx = 0;
    D.31464 = ins->opcode;
    if (D.31464 == 602) goto <D.39583>; else goto <D.39584>;
    <D.39583>:
    iftmp.3369 = 4;
    goto <D.39585>;
    <D.39584>:
    iftmp.3369 = 8;
    <D.39585>:
    size = iftmp.3369;
    D.31490 = ins->sreg2;
    if (D.31490 == 0) goto <D.39586>; else goto <D.39587>;
    <D.39586>:
    non_eax_reg = ins->sreg1;
    goto <D.39588>;
    <D.39587>:
    D.31516 = ins->sreg1;
    if (D.31516 == 0) goto <D.39589>; else goto <D.39590>;
    <D.39589>:
    non_eax_reg = ins->sreg2;
    goto <D.39591>;
    <D.39590>:
    D.31589 = ins->dreg;
    if (D.31589 != 0) goto <D.39592>; else goto <D.39593>;
    <D.39592>:
    saved_eax = 1;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.39594>; else goto <D.39595>;
      <D.39594>:
      code.3370 = code;
      code = code.3370 + 1;
      D.39597 = _amd64_rex_bits | 64;
      *code.3370 = D.39597;
      <D.39595>:
    }
    code.3371 = code;
    code = code.3371 + 1;
    *code.3371 = 80;
    <D.39593>:
    if (size == 2) goto <D.39599>; else goto <D.39600>;
    <D.39599>:
    code.3372 = code;
    code = code.3372 + 1;
    *code.3372 = 102;
    <D.39600>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.39603>; else goto <D.39604>;
      <D.39603>:
      iftmp.3373 = 8;
      goto <D.39605>;
      <D.39604>:
      iftmp.3373 = 0;
      <D.39605>:
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.39606 = iftmp.3373 | D.33180;
      _amd64_rex_bits = (unsigned char) D.39606;
      D.39607 = _amd64_rex_bits != 0;
      D.39608 = size == 1;
      D.39609 = D.39607 | D.39608;
      if (D.39609 != 0) goto <D.39610>; else goto <D.39611>;
      <D.39610>:
      code.3374 = code;
      code = code.3374 + 1;
      D.39613 = _amd64_rex_bits | 64;
      *code.3374 = D.39613;
      <D.39611>:
    }
    switch (size) <default: <D.26197>, case 1: <D.26192>, case 2: <D.26194>, case 4: <D.26195>, case 8: <D.26196>>
    <D.26192>:
    code.3375 = code;
    code = code.3375 + 1;
    *code.3375 = 138;
    goto <D.26193>;
    <D.26194>:
    <D.26195>:
    <D.26196>:
    code.3376 = code;
    code = code.3376 + 1;
    *code.3376 = 139;
    goto <D.26193>;
    <D.26197>:
    __assert_fail ("0", "mini-amd64.c", 4706, &__PRETTY_FUNCTION__);
    <D.26193>:
    code.3377 = code;
    code = code.3377 + 1;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.39617 = D.31571 | -64;
    D.39618 = (unsigned char) D.39617;
    *code.3377 = D.39618;
    non_eax_reg = ins->sreg2;
    <D.39591>:
    <D.39588>:
    D.31589 = ins->dreg;
    if (D.31589 == 2) goto <D.39619>; else goto <D.39620>;
    <D.39619>:
    if (saved_eax == 0) goto <D.39621>; else goto <D.39622>;
    <D.39621>:
    saved_eax = 1;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.39623>; else goto <D.39624>;
      <D.39623>:
      code.3378 = code;
      code = code.3378 + 1;
      D.39626 = _amd64_rex_bits | 64;
      *code.3378 = D.39626;
      <D.39624>:
    }
    code.3379 = code;
    code = code.3379 + 1;
    *code.3379 = 80;
    <D.39622>:
    goto <D.39628>;
    <D.39620>:
    saved_edx = 1;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.39629>; else goto <D.39630>;
      <D.39629>:
      code.3380 = code;
      code = code.3380 + 1;
      D.39632 = _amd64_rex_bits | 64;
      *code.3380 = D.39632;
      <D.39630>:
    }
    code.3381 = code;
    code = code.3381 + 1;
    *code.3381 = 82;
    <D.39628>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.39635>; else goto <D.39636>;
      <D.39635>:
      iftmp.3382 = 8;
      goto <D.39637>;
      <D.39636>:
      iftmp.3382 = 0;
      <D.39637>:
      D.39638 = non_eax_reg > 7;
      D.39639 = (signed char) D.39638;
      D.39640 = iftmp.3382 | D.39639;
      _amd64_rex_bits = (unsigned char) D.39640;
      D.39641 = _amd64_rex_bits != 0;
      D.39608 = size == 1;
      D.39642 = D.39641 | D.39608;
      if (D.39642 != 0) goto <D.39643>; else goto <D.39644>;
      <D.39643>:
      code.3383 = code;
      code = code.3383 + 1;
      D.39646 = _amd64_rex_bits | 64;
      *code.3383 = D.39646;
      <D.39644>:
    }
    code.3384 = code;
    code = code.3384 + 1;
    *code.3384 = 247;
    code.3385 = code;
    code = code.3385 + 1;
    D.39649 = (signed char) non_eax_reg;
    D.39650 = D.39649 & 7;
    D.39651 = D.39650 | -32;
    D.39652 = (unsigned char) D.39651;
    *code.3385 = D.39652;
    D.31589 = ins->dreg;
    if (D.31589 != 0) goto <D.39653>; else goto <D.39654>;
    <D.39653>:
    if (size == 2) goto <D.39655>; else goto <D.39656>;
    <D.39655>:
    code.3386 = code;
    code = code.3386 + 1;
    *code.3386 = 102;
    <D.39656>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.39659>; else goto <D.39660>;
      <D.39659>:
      iftmp.3387 = 8;
      goto <D.39661>;
      <D.39660>:
      iftmp.3387 = 0;
      <D.39661>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.39663>; else goto <D.39664>;
      <D.39663>:
      iftmp.3388 = 4;
      goto <D.39665>;
      <D.39664>:
      iftmp.3388 = 0;
      <D.39665>:
      D.39666 = iftmp.3387 | iftmp.3388;
      _amd64_rex_bits = (unsigned char) D.39666;
      D.39667 = _amd64_rex_bits != 0;
      D.39608 = size == 1;
      D.39668 = D.39667 | D.39608;
      if (D.39668 != 0) goto <D.39669>; else goto <D.39670>;
      <D.39669>:
      code.3389 = code;
      code = code.3389 + 1;
      D.39672 = _amd64_rex_bits | 64;
      *code.3389 = D.39672;
      <D.39670>:
    }
    switch (size) <default: <D.26207>, case 1: <D.26202>, case 2: <D.26204>, case 4: <D.26205>, case 8: <D.26206>>
    <D.26202>:
    code.3390 = code;
    code = code.3390 + 1;
    *code.3390 = 138;
    goto <D.26203>;
    <D.26204>:
    <D.26205>:
    <D.26206>:
    code.3391 = code;
    code = code.3391 + 1;
    *code.3391 = 139;
    goto <D.26203>;
    <D.26207>:
    __assert_fail ("0", "mini-amd64.c", 4721, &__PRETTY_FUNCTION__);
    <D.26203>:
    code.3392 = code;
    code = code.3392 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.39676 = (unsigned char) D.33725;
    *code.3392 = D.39676;
    <D.39654>:
    if (saved_edx != 0) goto <D.39677>; else goto <D.39678>;
    <D.39677>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.39679>; else goto <D.39680>;
      <D.39679>:
      code.3393 = code;
      code = code.3393 + 1;
      D.39682 = _amd64_rex_bits | 64;
      *code.3393 = D.39682;
      <D.39680>:
    }
    code.3394 = code;
    code = code.3394 + 1;
    *code.3394 = 90;
    <D.39678>:
    if (saved_eax != 0) goto <D.39684>; else goto <D.39685>;
    <D.39684>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.39686>; else goto <D.39687>;
      <D.39686>:
      code.3395 = code;
      code = code.3395 + 1;
      D.39689 = _amd64_rex_bits | 64;
      *code.3395 = D.39689;
      <D.39687>:
    }
    code.3396 = code;
    code = code.3396 + 1;
    *code.3396 = 88;
    <D.39685>:
    {
      struct MonoInst * tins;

      tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
      if (tins == 0B) goto <D.39691>; else goto <D.39692>;
      <D.39691>:
      code.211 = (long int) code;
      D.31283 = cfg->native_code;
      D.31451 = (long int) D.31283;
      D.31452 = code.211 - D.31451;
      D.36947 = (int) D.31452;
      mono_add_patch_info (cfg, D.36947, 9, "OverflowException");
      code.3397 = code;
      code = code.3397 + 1;
      *code.3397 = 15;
      if (0 != 0) goto <D.39694>; else goto <D.39695>;
      <D.39694>:
      code.3398 = code;
      code = code.3398 + 1;
      D.38716 = 112;
      D.38717 = D.38716 + 16;
      *code.3398 = D.38717;
      goto <D.39697>;
      <D.39695>:
      code.3399 = code;
      code = code.3399 + 1;
      D.38720 = 112;
      D.38721 = D.38720 + 16;
      *code.3399 = D.38721;
      <D.39697>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.3400 = code;
            code = code.3400 + 1;
            D.39700 = imb.b[0];
            *code.3400 = D.39700;
            code.3401 = code;
            code = code.3401 + 1;
            D.39702 = imb.b[1];
            *code.3401 = D.39702;
            code.3402 = code;
            code = code.3402 + 1;
            D.39704 = imb.b[2];
            *code.3402 = D.39704;
            code.3403 = code;
            code = code.3403 + 1;
            D.39706 = imb.b[3];
            *code.3403 = D.39706;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.39707>;
      <D.39692>:
      D.39708 = tins->data.op[1].many_blocks;
      D.39709 = *D.39708;
      D.39710 = D.39709->native_offset;
      if (D.39710 != 0) goto <D.39711>; else goto <D.39712>;
      <D.39711>:
      {
        int offset;

        D.31283 = cfg->native_code;
        D.39708 = tins->data.op[1].many_blocks;
        D.39709 = *D.39708;
        D.39710 = D.39709->native_offset;
        D.39713 = (sizetype) D.39710;
        D.39714 = D.31283 + D.39713;
        D.39715 = (long int) D.39714;
        code.211 = (long int) code;
        D.39716 = D.39715 - code.211;
        D.39717 = (unsigned int) D.39716;
        D.39718 = D.39717 + 4294967294;
        offset = (int) D.39718;
        offset.3404 = (unsigned int) offset;
        D.39720 = offset.3404 + 128;
        if (D.39720 <= 255) goto <D.39721>; else goto <D.39722>;
        <D.39721>:
        if (0 != 0) goto <D.39723>; else goto <D.39724>;
        <D.39723>:
        code.3405 = code;
        code = code.3405 + 1;
        D.38716 = 112;
        *code.3405 = D.38716;
        goto <D.39726>;
        <D.39724>:
        code.3406 = code;
        code = code.3406 + 1;
        D.38720 = 112;
        *code.3406 = D.38720;
        <D.39726>:
        D.39728 = (unsigned char) offset;
        *code = D.39728;
        code = code + 1;
        goto <D.39729>;
        <D.39722>:
        D.31283 = cfg->native_code;
        D.39708 = tins->data.op[1].many_blocks;
        D.39709 = *D.39708;
        D.39710 = D.39709->native_offset;
        D.39713 = (sizetype) D.39710;
        D.39714 = D.31283 + D.39713;
        D.39715 = (long int) D.39714;
        code.211 = (long int) code;
        D.39716 = D.39715 - code.211;
        D.39717 = (unsigned int) D.39716;
        D.39730 = D.39717 + 4294967290;
        offset = (int) D.39730;
        code.3407 = code;
        code = code.3407 + 1;
        *code.3407 = 15;
        if (0 != 0) goto <D.39732>; else goto <D.39733>;
        <D.39732>:
        code.3408 = code;
        code = code.3408 + 1;
        D.38716 = 112;
        D.38717 = D.38716 + 16;
        *code.3408 = D.38717;
        goto <D.39735>;
        <D.39733>:
        code.3409 = code;
        code = code.3409 + 1;
        D.38720 = 112;
        D.38721 = D.38720 + 16;
        *code.3409 = D.38721;
        <D.39735>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = offset;
              code.3410 = code;
              code = code.3410 + 1;
              D.39738 = imb.b[0];
              *code.3410 = D.39738;
              code.3411 = code;
              code = code.3411 + 1;
              D.39740 = imb.b[1];
              *code.3411 = D.39740;
              code.3412 = code;
              code = code.3412 + 1;
              D.39742 = imb.b[2];
              *code.3412 = D.39742;
              code.3413 = code;
              code = code.3413 + 1;
              D.39744 = imb.b[3];
              *code.3413 = D.39744;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.39729>:
      }
      goto <D.39745>;
      <D.39712>:
      D.39708 = tins->data.op[1].many_blocks;
      D.39709 = *D.39708;
      code.211 = (long int) code;
      D.31283 = cfg->native_code;
      D.31451 = (long int) D.31283;
      D.31452 = code.211 - D.31451;
      D.36947 = (int) D.31452;
      mono_add_patch_info (cfg, D.36947, 0, D.39709);
      D.31286 = cfg->opt;
      D.31287 = D.31286 & 2;
      if (D.31287 != 0) goto <D.39748>; else goto <D.39746>;
      <D.39748>:
      D.39708 = tins->data.op[1].many_blocks;
      D.39709 = *D.39708;
      D.39749 = D.39709->max_offset;
      D.39750 = (unsigned int) D.39749;
      D.39751 = D.39750 - offset;
      D.39752 = (int) D.39751;
      if (D.39752 >= -128) goto <D.39753>; else goto <D.39746>;
      <D.39753>:
      D.39708 = tins->data.op[1].many_blocks;
      D.39709 = *D.39708;
      D.39749 = D.39709->max_offset;
      D.39750 = (unsigned int) D.39749;
      D.39751 = D.39750 - offset;
      D.39752 = (int) D.39751;
      if (D.39752 <= 127) goto <D.39754>; else goto <D.39746>;
      <D.39754>:
      if (0 != 0) goto <D.39755>; else goto <D.39756>;
      <D.39755>:
      code.3414 = code;
      code = code.3414 + 1;
      D.38716 = 112;
      *code.3414 = D.38716;
      goto <D.39758>;
      <D.39756>:
      code.3415 = code;
      code = code.3415 + 1;
      D.38720 = 112;
      *code.3415 = D.38720;
      <D.39758>:
      *code = 0;
      code = code + 1;
      goto <D.39747>;
      <D.39746>:
      code.3416 = code;
      code = code.3416 + 1;
      *code.3416 = 15;
      if (0 != 0) goto <D.39761>; else goto <D.39762>;
      <D.39761>:
      code.3417 = code;
      code = code.3417 + 1;
      D.38716 = 112;
      D.38717 = D.38716 + 16;
      *code.3417 = D.38717;
      goto <D.39764>;
      <D.39762>:
      code.3418 = code;
      code = code.3418 + 1;
      D.38720 = 112;
      D.38721 = D.38720 + 16;
      *code.3418 = D.38721;
      <D.39764>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.3419 = code;
            code = code.3419 + 1;
            D.39767 = imb.b[0];
            *code.3419 = D.39767;
            code.3420 = code;
            code = code.3420 + 1;
            D.39769 = imb.b[1];
            *code.3420 = D.39769;
            code.3421 = code;
            code = code.3421 + 1;
            D.39771 = imb.b[2];
            *code.3421 = D.39771;
            code.3422 = code;
            code = code.3422 + 1;
            D.39773 = imb.b[3];
            *code.3422 = D.39773;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.39747>:
      <D.39745>:
      <D.39707>:
    }
    goto <D.25197>;
  }
  <D.26215>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39775>; else goto <D.39776>;
    <D.39775>:
    iftmp.3423 = 4;
    goto <D.39777>;
    <D.39776>:
    iftmp.3423 = 0;
    <D.39777>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39778 = iftmp.3423 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39778;
    if (_amd64_rex_bits != 0) goto <D.39779>; else goto <D.39780>;
    <D.39779>:
    code.3424 = code;
    code = code.3424 + 1;
    D.39782 = _amd64_rex_bits | 64;
    *code.3424 = D.39782;
    <D.39780>:
  }
  code.3425 = code;
  code = code.3425 + 1;
  *code.3425 = 59;
  code.3426 = code;
  code = code.3426 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.3426 = D.33821;
  goto <D.25197>;
  <D.26217>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.39785>; else goto <D.39786>;
  <D.39785>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39787>; else goto <D.39788>;
    <D.39787>:
    code.3427 = code;
    code = code.3427 + 1;
    D.39790 = _amd64_rex_bits | 64;
    *code.3427 = D.39790;
    <D.39788>:
  }
  code.3428 = code;
  code = code.3428 + 1;
  *code.3428 = 131;
  code.3429 = code;
  code = code.3429 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.3429 = D.33839;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.39793>;
  <D.39786>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.39794>; else goto <D.39795>;
  <D.39794>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.39796>; else goto <D.39797>;
    <D.39796>:
    code.3430 = code;
    code = code.3430 + 1;
    D.39799 = _amd64_rex_bits | 64;
    *code.3430 = D.39799;
    <D.39797>:
  }
  code.3431 = code;
  code = code.3431 + 1;
  *code.3431 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3432 = code;
        code = code.3432 + 1;
        D.39802 = imb.b[0];
        *code.3432 = D.39802;
        code.3433 = code;
        code = code.3433 + 1;
        D.39804 = imb.b[1];
        *code.3433 = D.39804;
        code.3434 = code;
        code = code.3434 + 1;
        D.39806 = imb.b[2];
        *code.3434 = D.39806;
        code.3435 = code;
        code = code.3435 + 1;
        D.39808 = imb.b[3];
        *code.3435 = D.39808;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.39809>;
  <D.39795>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.39810>; else goto <D.39811>;
    <D.39810>:
    code.3436 = code;
    code = code.3436 + 1;
    D.39813 = _amd64_rex_bits | 64;
    *code.3436 = D.39813;
    <D.39811>:
  }
  code.3437 = code;
  code = code.3437 + 1;
  *code.3437 = 129;
  code.3438 = code;
  code = code.3438 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.3438 = D.33839;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.3439 = code;
        code = code.3439 + 1;
        D.39817 = imb.b[0];
        *code.3439 = D.39817;
        code.3440 = code;
        code = code.3440 + 1;
        D.39819 = imb.b[1];
        *code.3440 = D.39819;
        code.3441 = code;
        code = code.3441 + 1;
        D.39821 = imb.b[2];
        *code.3441 = D.39821;
        code.3442 = code;
        code = code.3442 + 1;
        D.39823 = imb.b[3];
        *code.3442 = D.39823;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39809>:
  <D.39793>:
  goto <D.25197>;
  <D.26223>:
  <D.26224>:
  <D.26225>:
  <D.26226>:
  <D.26227>:
  <D.26228>:
  <D.26229>:
  <D.26230>:
  <D.26231>:
  <D.26232>:
  <D.26233>:
  <D.26234>:
  <D.26235>:
  <D.26236>:
  <D.26237>:
  <D.26238>:
  <D.26239>:
  <D.26240>:
  <D.26241>:
  <D.26242>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.39827>; else goto <D.39828>;
  <D.39827>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.3443 = (unsigned int) offset;
    D.39836 = offset.3443 + 128;
    if (D.39836 <= 255) goto <D.39837>; else goto <D.39838>;
    <D.39837>:
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.39839 = mono_opcode_to_cond (D.31465);
    D.39840 = cc_signed_table[D.39839];
    if (D.39840 != 0) goto <D.39841>; else goto <D.39842>;
    <D.39841>:
    code.3444 = code;
    code = code.3444 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.39844 = mono_opcode_to_cond (D.31465);
    D.39845 = cc_table[D.39844];
    D.39846 = x86_cc_signed_map[D.39845];
    *code.3444 = D.39846;
    goto <D.39847>;
    <D.39842>:
    code.3445 = code;
    code = code.3445 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.39849 = mono_opcode_to_cond (D.31465);
    D.39850 = cc_table[D.39849];
    D.39851 = x86_cc_unsigned_map[D.39850];
    *code.3445 = D.39851;
    <D.39847>:
    D.39852 = (unsigned char) offset;
    *code = D.39852;
    code = code + 1;
    goto <D.39853>;
    <D.39838>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.3446 = code;
    code = code.3446 + 1;
    *code.3446 = 15;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.39856 = mono_opcode_to_cond (D.31465);
    D.39857 = cc_signed_table[D.39856];
    if (D.39857 != 0) goto <D.39858>; else goto <D.39859>;
    <D.39858>:
    code.3447 = code;
    code = code.3447 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.39861 = mono_opcode_to_cond (D.31465);
    D.39862 = cc_table[D.39861];
    D.39863 = x86_cc_signed_map[D.39862];
    D.39864 = D.39863 + 16;
    *code.3447 = D.39864;
    goto <D.39865>;
    <D.39859>:
    code.3448 = code;
    code = code.3448 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.39867 = mono_opcode_to_cond (D.31465);
    D.39868 = cc_table[D.39867];
    D.39869 = x86_cc_unsigned_map[D.39868];
    D.39870 = D.39869 + 16;
    *code.3448 = D.39870;
    <D.39865>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.3449 = code;
          code = code.3449 + 1;
          D.39872 = imb.b[0];
          *code.3449 = D.39872;
          code.3450 = code;
          code = code.3450 + 1;
          D.39874 = imb.b[1];
          *code.3450 = D.39874;
          code.3451 = code;
          code = code.3451 + 1;
          D.39876 = imb.b[2];
          *code.3451 = D.39876;
          code.3452 = code;
          code = code.3452 + 1;
          D.39878 = imb.b[3];
          *code.3452 = D.39878;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.39853>:
  }
  goto <D.39879>;
  <D.39828>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.39882>; else goto <D.39880>;
  <D.39882>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.39887>; else goto <D.39880>;
  <D.39887>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.39888>; else goto <D.39880>;
  <D.39888>:
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39889 = mono_opcode_to_cond (D.31465);
  D.39890 = cc_signed_table[D.39889];
  if (D.39890 != 0) goto <D.39891>; else goto <D.39892>;
  <D.39891>:
  code.3453 = code;
  code = code.3453 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39894 = mono_opcode_to_cond (D.31465);
  D.39895 = cc_table[D.39894];
  D.39896 = x86_cc_signed_map[D.39895];
  *code.3453 = D.39896;
  goto <D.39897>;
  <D.39892>:
  code.3454 = code;
  code = code.3454 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39899 = mono_opcode_to_cond (D.31465);
  D.39900 = cc_table[D.39899];
  D.39901 = x86_cc_unsigned_map[D.39900];
  *code.3454 = D.39901;
  <D.39897>:
  *code = 0;
  code = code + 1;
  goto <D.39881>;
  <D.39880>:
  code.3455 = code;
  code = code.3455 + 1;
  *code.3455 = 15;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39903 = mono_opcode_to_cond (D.31465);
  D.39904 = cc_signed_table[D.39903];
  if (D.39904 != 0) goto <D.39905>; else goto <D.39906>;
  <D.39905>:
  code.3456 = code;
  code = code.3456 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39908 = mono_opcode_to_cond (D.31465);
  D.39909 = cc_table[D.39908];
  D.39910 = x86_cc_signed_map[D.39909];
  D.39911 = D.39910 + 16;
  *code.3456 = D.39911;
  goto <D.39912>;
  <D.39906>:
  code.3457 = code;
  code = code.3457 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39914 = mono_opcode_to_cond (D.31465);
  D.39915 = cc_table[D.39914];
  D.39916 = x86_cc_unsigned_map[D.39915];
  D.39917 = D.39916 + 16;
  *code.3457 = D.39917;
  <D.39912>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3458 = code;
        code = code.3458 + 1;
        D.39919 = imb.b[0];
        *code.3458 = D.39919;
        code.3459 = code;
        code = code.3459 + 1;
        D.39921 = imb.b[1];
        *code.3459 = D.39921;
        code.3460 = code;
        code = code.3460 + 1;
        D.39923 = imb.b[2];
        *code.3460 = D.39923;
        code.3461 = code;
        code = code.3461 + 1;
        D.39925 = imb.b[3];
        *code.3461 = D.39925;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.39881>:
  <D.39879>:
  goto <D.25197>;
  <D.26246>:
  <D.26247>:
  <D.26248>:
  <D.26249>:
  <D.26250>:
  <D.26251>:
  <D.26252>:
  <D.26253>:
  <D.26254>:
  <D.26255>:
  <D.26256>:
  <D.26257>:
  <D.26258>:
  <D.26259>:
  <D.26260>:
  <D.26261>:
  <D.26262>:
  <D.26263>:
  <D.26264>:
  <D.26265>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.39929>; else goto <D.39930>;
  <D.39929>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4778, "ins->dreg == ins->sreg1");
  <D.39930>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.39932>; else goto <D.39933>;
    <D.39932>:
    iftmp.3462 = 12;
    goto <D.39934>;
    <D.39933>:
    iftmp.3462 = 8;
    <D.39934>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.39935 = iftmp.3462 | D.33811;
    _amd64_rex_bits = (unsigned char) D.39935;
    if (_amd64_rex_bits != 0) goto <D.39936>; else goto <D.39937>;
    <D.39936>:
    code.3463 = code;
    code = code.3463 + 1;
    D.39939 = _amd64_rex_bits | 64;
    *code.3463 = D.39939;
    <D.39937>:
  }
  code.3464 = code;
  code = code.3464 + 1;
  *code.3464 = 15;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39941 = mono_opcode_to_cond (D.31465);
  D.39942 = cc_signed_table[D.39941];
  if (D.39942 != 0) goto <D.39943>; else goto <D.39944>;
  <D.39943>:
  code.3465 = code;
  code = code.3465 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39946 = mono_opcode_to_cond (D.31465);
  D.39947 = cc_table[D.39946];
  D.39948 = x86_cc_signed_map[D.39947];
  D.39949 = D.39948 + 208;
  *code.3465 = D.39949;
  goto <D.39950>;
  <D.39944>:
  code.3466 = code;
  code = code.3466 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.39952 = mono_opcode_to_cond (D.31465);
  D.39953 = cc_table[D.39952];
  D.39954 = x86_cc_unsigned_map[D.39953];
  D.39955 = D.39954 + 208;
  *code.3466 = D.39955;
  <D.39950>:
  code.3467 = code;
  code = code.3467 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.3467 = D.39958;
  goto <D.25197>;
  <D.26267>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39960>; else goto <D.39961>;
    <D.39960>:
    iftmp.3468 = 9;
    goto <D.39962>;
    <D.39961>:
    iftmp.3468 = 8;
    <D.39962>:
    _amd64_rex_bits = iftmp.3468;
    if (_amd64_rex_bits != 0) goto <D.39963>; else goto <D.39964>;
    <D.39963>:
    code.3469 = code;
    code = code.3469 + 1;
    D.39966 = _amd64_rex_bits | 64;
    *code.3469 = D.39966;
    <D.39964>:
  }
  code.3470 = code;
  code = code.3470 + 1;
  *code.3470 = 247;
  code.3471 = code;
  code = code.3471 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39416 = D.31571 | -48;
  D.39417 = (unsigned char) D.39416;
  *code.3471 = D.39417;
  goto <D.25197>;
  <D.26269>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.39970>; else goto <D.39971>;
    <D.39970>:
    iftmp.3472 = 9;
    goto <D.39972>;
    <D.39971>:
    iftmp.3472 = 8;
    <D.39972>:
    _amd64_rex_bits = iftmp.3472;
    if (_amd64_rex_bits != 0) goto <D.39973>; else goto <D.39974>;
    <D.39973>:
    code.3473 = code;
    code = code.3473 + 1;
    D.39976 = _amd64_rex_bits | 64;
    *code.3473 = D.39976;
    <D.39974>:
  }
  code.3474 = code;
  code = code.3474 + 1;
  *code.3474 = 247;
  code.3475 = code;
  code = code.3475 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39408 = D.31571 | -40;
  D.39409 = (unsigned char) D.39408;
  *code.3475 = D.39409;
  goto <D.25197>;
  <D.26271>:
  <D.26272>:
  D.31535 = ins->data.op[0].const_val;
  D.39979 = (long unsigned int) D.31535;
  D.39980 = D.39979 >> 32;
  if (D.39980 == 0) goto <D.39981>; else goto <D.39982>;
  <D.39981>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.39983>; else goto <D.39984>;
    <D.39983>:
    code.3476 = code;
    code = code.3476 + 1;
    D.39986 = _amd64_rex_bits | 64;
    *code.3476 = D.39986;
    <D.39984>:
  }
  code.3477 = code;
  code = code.3477 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  D.32668 = D.31627 + 184;
  *code.3477 = D.32668;
  if (0 != 0) goto <D.39988>; else goto <D.39989>;
  <D.39988>:
  {
    union amd64_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.39979 = (long unsigned int) D.31535;
        imb.val = D.39979;
        code.3478 = code;
        code = code.3478 + 1;
        D.39991 = imb.b[0];
        *code.3478 = D.39991;
        code.3479 = code;
        code = code.3479 + 1;
        D.39993 = imb.b[1];
        *code.3479 = D.39993;
        code.3480 = code;
        code = code.3480 + 1;
        D.39995 = imb.b[2];
        *code.3480 = D.39995;
        code.3481 = code;
        code = code.3481 + 1;
        D.39997 = imb.b[3];
        *code.3481 = D.39997;
        code.3482 = code;
        code = code.3482 + 1;
        D.39999 = imb.b[4];
        *code.3482 = D.39999;
        code.3483 = code;
        code = code.3483 + 1;
        D.40001 = imb.b[5];
        *code.3483 = D.40001;
        code.3484 = code;
        code = code.3484 + 1;
        D.40003 = imb.b[6];
        *code.3484 = D.40003;
        code.3485 = code;
        code = code.3485 + 1;
        D.40005 = imb.b[7];
        *code.3485 = D.40005;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.40006>;
  <D.39989>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.3486 = code;
        code = code.3486 + 1;
        D.40008 = imb.b[0];
        *code.3486 = D.40008;
        code.3487 = code;
        code = code.3487 + 1;
        D.40010 = imb.b[1];
        *code.3487 = D.40010;
        code.3488 = code;
        code = code.3488 + 1;
        D.40012 = imb.b[2];
        *code.3488 = D.40012;
        code.3489 = code;
        code = code.3489 + 1;
        D.40014 = imb.b[3];
        *code.3489 = D.40014;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40006>:
  goto <D.40015>;
  <D.39982>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.40017>; else goto <D.40018>;
    <D.40017>:
    iftmp.3490 = 9;
    goto <D.40019>;
    <D.40018>:
    iftmp.3490 = 8;
    <D.40019>:
    _amd64_rex_bits = iftmp.3490;
    if (_amd64_rex_bits != 0) goto <D.40020>; else goto <D.40021>;
    <D.40020>:
    code.3491 = code;
    code = code.3491 + 1;
    D.40023 = _amd64_rex_bits | 64;
    *code.3491 = D.40023;
    <D.40021>:
  }
  code.3492 = code;
  code = code.3492 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  D.32668 = D.31627 + 184;
  *code.3492 = D.32668;
  if (1 != 0) goto <D.40025>; else goto <D.40026>;
  <D.40025>:
  {
    union amd64_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.39979 = (long unsigned int) D.31535;
        imb.val = D.39979;
        code.3493 = code;
        code = code.3493 + 1;
        D.40028 = imb.b[0];
        *code.3493 = D.40028;
        code.3494 = code;
        code = code.3494 + 1;
        D.40030 = imb.b[1];
        *code.3494 = D.40030;
        code.3495 = code;
        code = code.3495 + 1;
        D.40032 = imb.b[2];
        *code.3495 = D.40032;
        code.3496 = code;
        code = code.3496 + 1;
        D.40034 = imb.b[3];
        *code.3496 = D.40034;
        code.3497 = code;
        code = code.3497 + 1;
        D.40036 = imb.b[4];
        *code.3497 = D.40036;
        code.3498 = code;
        code = code.3498 + 1;
        D.40038 = imb.b[5];
        *code.3498 = D.40038;
        code.3499 = code;
        code = code.3499 + 1;
        D.40040 = imb.b[6];
        *code.3499 = D.40040;
        code.3500 = code;
        code = code.3500 + 1;
        D.40042 = imb.b[7];
        *code.3500 = D.40042;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.40043>;
  <D.40026>:
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.3501 = code;
        code = code.3501 + 1;
        D.40045 = imb.b[0];
        *code.3501 = D.40045;
        code.3502 = code;
        code = code.3502 + 1;
        D.40047 = imb.b[1];
        *code.3502 = D.40047;
        code.3503 = code;
        code = code.3503 + 1;
        D.40049 = imb.b[2];
        *code.3503 = D.40049;
        code.3504 = code;
        code = code.3504 + 1;
        D.40051 = imb.b[3];
        *code.3504 = D.40051;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40043>:
  <D.40015>:
  goto <D.25197>;
  <D.26279>:
  D.40052 = ins->data.op[0].p;
  D.40053 = ins->data.op[1].src;
  D.40054 = (long int) D.40053;
  D.40055 = (<unnamed type>) D.40054;
  offset.3505 = (int) offset;
  mono_add_patch_info (cfg, offset.3505, D.40055, D.40052);
  if (0 != 0) goto <D.40057>; else goto <D.40058>;
  <D.40057>:
  code.3506 = code;
  code = code.3506 + 1;
  *code.3506 = 102;
  <D.40058>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.40061>; else goto <D.40062>;
    <D.40061>:
    iftmp.3507 = 13;
    goto <D.40063>;
    <D.40062>:
    iftmp.3507 = 9;
    <D.40063>:
    _amd64_rex_bits = iftmp.3507;
    if (_amd64_rex_bits != 0) goto <D.40064>; else goto <D.40065>;
    <D.40064>:
    code.3508 = code;
    code = code.3508 + 1;
    D.40067 = _amd64_rex_bits | 64;
    *code.3508 = D.40067;
    <D.40065>:
  }
  switch (8) <default: <D.26286>, case 1: <D.26281>, case 2: <D.26283>, case 4: <D.26284>, case 8: <D.26285>>
  <D.26281>:
  code.3509 = code;
  code = code.3509 + 1;
  *code.3509 = 138;
  goto <D.26282>;
  <D.26283>:
  <D.26284>:
  <D.26285>:
  code.3510 = code;
  code = code.3510 + 1;
  *code.3510 = 139;
  goto <D.26282>;
  <D.26286>:
  __assert_fail ("0", "mini-amd64.c", 4799, &__PRETTY_FUNCTION__);
  <D.26282>:
  if (1 != 0) goto <D.40070>; else goto <D.40071>;
  <D.40070>:
  code.3511 = code;
  code = code.3511 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.3511 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3512 = code;
        code = code.3512 + 1;
        D.40074 = imb.b[0];
        *code.3512 = D.40074;
        code.3513 = code;
        code = code.3513 + 1;
        D.40076 = imb.b[1];
        *code.3513 = D.40076;
        code.3514 = code;
        code = code.3514 + 1;
        D.40078 = imb.b[2];
        *code.3514 = D.40078;
        code.3515 = code;
        code = code.3515 + 1;
        D.40080 = imb.b[3];
        *code.3515 = D.40080;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.40081>;
  <D.40071>:
  if (0 != 0) goto <D.40082>; else goto <D.40083>;
  <D.40082>:
  if (1 != 0) goto <D.40084>; else goto <D.40085>;
  <D.40084>:
  code.3516 = code;
  code = code.3516 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.3516 = D.32644;
  code.3517 = code;
  code = code.3517 + 1;
  *code.3517 = 36;
  goto <D.40088>;
  <D.40085>:
  if (1 != 0) goto <D.40089>; else goto <D.40090>;
  <D.40089>:
  code.3518 = code;
  code = code.3518 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.3518 = D.32735;
  code.3519 = code;
  code = code.3519 + 1;
  *code.3519 = 36;
  *code = 0;
  code = code + 1;
  goto <D.40093>;
  <D.40090>:
  code.3520 = code;
  code = code.3520 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.3520 = D.32740;
  code.3521 = code;
  code = code.3521 + 1;
  *code.3521 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3522 = code;
        code = code.3522 + 1;
        D.40097 = imb.b[0];
        *code.3522 = D.40097;
        code.3523 = code;
        code = code.3523 + 1;
        D.40099 = imb.b[1];
        *code.3523 = D.40099;
        code.3524 = code;
        code = code.3524 + 1;
        D.40101 = imb.b[2];
        *code.3524 = D.40101;
        code.3525 = code;
        code = code.3525 + 1;
        D.40103 = imb.b[3];
        *code.3525 = D.40103;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40093>:
  <D.40088>:
  goto <D.26289>;
  <D.40083>:
  if (1 != 0) goto <D.40104>; else goto <D.40105>;
  <D.40104>:
  code.3526 = code;
  code = code.3526 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  D.40107 = D.31627 << 3;
  *code.3526 = D.40107;
  goto <D.26289>;
  <D.40105>:
  if (1 != 0) goto <D.40108>; else goto <D.40109>;
  <D.40108>:
  code.3527 = code;
  code = code.3527 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.40111 = (unsigned char) D.32758;
  *code.3527 = D.40111;
  *code = 0;
  code = code + 1;
  goto <D.40112>;
  <D.40109>:
  code.3528 = code;
  code = code.3528 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.40114 = (unsigned char) D.32763;
  *code.3528 = D.40114;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3529 = code;
        code = code.3529 + 1;
        D.40116 = imb.b[0];
        *code.3529 = D.40116;
        code.3530 = code;
        code = code.3530 + 1;
        D.40118 = imb.b[1];
        *code.3530 = D.40118;
        code.3531 = code;
        code = code.3531 + 1;
        D.40120 = imb.b[2];
        *code.3531 = D.40120;
        code.3532 = code;
        code = code.3532 + 1;
        D.40122 = imb.b[3];
        *code.3532 = D.40122;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40112>:
  <D.26289>:
  <D.40081>:
  goto <D.25197>;
  <D.26291>:
  D.40052 = ins->data.op[0].p;
  D.40053 = ins->data.op[1].src;
  D.40054 = (long int) D.40053;
  D.40055 = (<unnamed type>) D.40054;
  offset.3505 = (int) offset;
  mono_add_patch_info (cfg, offset.3505, D.40055, D.40052);
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.40124>; else goto <D.40125>;
    <D.40124>:
    iftmp.3533 = 9;
    goto <D.40126>;
    <D.40125>:
    iftmp.3533 = 8;
    <D.40126>:
    _amd64_rex_bits = iftmp.3533;
    if (_amd64_rex_bits != 0) goto <D.40127>; else goto <D.40128>;
    <D.40127>:
    code.3534 = code;
    code = code.3534 + 1;
    D.40130 = _amd64_rex_bits | 64;
    *code.3534 = D.40130;
    <D.40128>:
  }
  code.3535 = code;
  code = code.3535 + 1;
  D.31589 = ins->dreg;
  D.31626 = (unsigned char) D.31589;
  D.31627 = D.31626 & 7;
  D.32668 = D.31627 + 184;
  *code.3535 = D.32668;
  if (1 != 0) goto <D.40132>; else goto <D.40133>;
  <D.40132>:
  {
    union amd64_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3536 = code;
        code = code.3536 + 1;
        D.40135 = imb.b[0];
        *code.3536 = D.40135;
        code.3537 = code;
        code = code.3537 + 1;
        D.40137 = imb.b[1];
        *code.3537 = D.40137;
        code.3538 = code;
        code = code.3538 + 1;
        D.40139 = imb.b[2];
        *code.3538 = D.40139;
        code.3539 = code;
        code = code.3539 + 1;
        D.40141 = imb.b[3];
        *code.3539 = D.40141;
        code.3540 = code;
        code = code.3540 + 1;
        D.40143 = imb.b[4];
        *code.3540 = D.40143;
        code.3541 = code;
        code = code.3541 + 1;
        D.40145 = imb.b[5];
        *code.3541 = D.40145;
        code.3542 = code;
        code = code.3542 + 1;
        D.40147 = imb.b[6];
        *code.3542 = D.40147;
        code.3543 = code;
        code = code.3543 + 1;
        D.40149 = imb.b[7];
        *code.3543 = D.40149;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.40150>;
  <D.40133>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3544 = code;
        code = code.3544 + 1;
        D.40152 = imb.b[0];
        *code.3544 = D.40152;
        code.3545 = code;
        code = code.3545 + 1;
        D.40154 = imb.b[1];
        *code.3545 = D.40154;
        code.3546 = code;
        code = code.3546 + 1;
        D.40156 = imb.b[2];
        *code.3546 = D.40156;
        code.3547 = code;
        code = code.3547 + 1;
        D.40158 = imb.b[3];
        *code.3547 = D.40158;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40150>:
  goto <D.25197>;
  <D.26295>:
  if (0 != 0) goto <D.40159>; else goto <D.40160>;
  <D.40159>:
  code.3548 = code;
  code = code.3548 + 1;
  *code.3548 = 102;
  <D.40160>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.40163>; else goto <D.40164>;
    <D.40163>:
    iftmp.3549 = 12;
    goto <D.40165>;
    <D.40164>:
    iftmp.3549 = 8;
    <D.40165>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.40166 = iftmp.3549 | D.33180;
    _amd64_rex_bits = (unsigned char) D.40166;
    if (_amd64_rex_bits != 0) goto <D.40167>; else goto <D.40168>;
    <D.40167>:
    code.3550 = code;
    code = code.3550 + 1;
    D.40170 = _amd64_rex_bits | 64;
    *code.3550 = D.40170;
    <D.40168>:
  }
  switch (8) <default: <D.26302>, case 1: <D.26297>, case 2: <D.26299>, case 4: <D.26300>, case 8: <D.26301>>
  <D.26297>:
  code.3551 = code;
  code = code.3551 + 1;
  *code.3551 = 138;
  goto <D.26298>;
  <D.26299>:
  <D.26300>:
  <D.26301>:
  code.3552 = code;
  code = code.3552 + 1;
  *code.3552 = 139;
  goto <D.26298>;
  <D.26302>:
  __assert_fail ("0", "mini-amd64.c", 4806, &__PRETTY_FUNCTION__);
  <D.26298>:
  code.3553 = code;
  code = code.3553 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.3553 = D.33727;
  goto <D.25197>;
  <D.26303>:
  code.3554 = code;
  code = code.3554 + 1;
  *code.3554 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.40176>; else goto <D.40177>;
    <D.40176>:
    iftmp.3555 = 4;
    goto <D.40178>;
    <D.40177>:
    iftmp.3555 = 0;
    <D.40178>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.40179 = iftmp.3555 | D.33180;
    _amd64_rex_bits = (unsigned char) D.40179;
    if (_amd64_rex_bits != 0) goto <D.40180>; else goto <D.40181>;
    <D.40180>:
    code.3556 = code;
    code = code.3556 + 1;
    D.40183 = _amd64_rex_bits | 64;
    *code.3556 = D.40183;
    <D.40181>:
  }
  code.3557 = code;
  code = code.3557 + 1;
  *code.3557 = 15;
  code.3558 = code;
  code = code.3558 + 1;
  *code.3558 = 90;
  code.3559 = code;
  code = code.3559 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.3559 = D.33727;
  goto <D.25197>;
  <D.26305>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  if (D.31589 != D.31516) goto <D.40187>; else goto <D.40188>;
  <D.40187>:
  code.3560 = code;
  code = code.3560 + 1;
  *code.3560 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.40191>; else goto <D.40192>;
    <D.40191>:
    iftmp.3561 = 4;
    goto <D.40193>;
    <D.40192>:
    iftmp.3561 = 0;
    <D.40193>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.40194 = iftmp.3561 | D.33180;
    _amd64_rex_bits = (unsigned char) D.40194;
    if (_amd64_rex_bits != 0) goto <D.40195>; else goto <D.40196>;
    <D.40195>:
    code.3562 = code;
    code = code.3562 + 1;
    D.40198 = _amd64_rex_bits | 64;
    *code.3562 = D.40198;
    <D.40196>:
  }
  code.3563 = code;
  code = code.3563 + 1;
  *code.3563 = 15;
  code.3564 = code;
  code = code.3564 + 1;
  *code.3564 = 16;
  code.3565 = code;
  code = code.3565 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.3565 = D.33727;
  <D.40188>:
  goto <D.25197>;
  <D.26307>:
  {
    struct MonoCallInst * call;
    int i;
    int save_area_offset;

    call = ins;
    D.31352 = cfg->prof_options;
    D.40202 = D.31352 & 4096;
    if (D.40202 != 0) goto <D.40203>; else goto <D.40204>;
    <D.40203>:
    code = mono_arch_instrument_epilog_full (cfg, mono_profiler_method_leave, code, 0, 1);
    <D.40204>:
    D.31456 = cfg->method;
    D.40205 = BIT_FIELD_REF <*D.31456, 8, 264>;
    D.40206 = D.40205 & 1;
    D.40207 = D.40206 != 0;
    D.40208 = (long int) D.40207;
    D.40209 = __builtin_expect (D.40208, 0);
    if (D.40209 != 0) goto <D.40210>; else goto <D.40211>;
    <D.40210>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4825, "!cfg->method->save_lmf");
    <D.40211>:
    save_area_offset = cfg->arch.reg_save_area_offset;
    i = 0;
    goto <D.26323>;
    <D.26322>:
    D.40212 = 61480 >> i;
    D.40213 = D.40212 & 1;
    if (D.40213 != 0) goto <D.40214>; else goto <D.40215>;
    <D.40214>:
    D.40216 = cfg->used_int_regs;
    D.40217 = 1 << i;
    D.40218 = (long unsigned int) D.40217;
    D.40219 = D.40216 & D.40218;
    if (D.40219 != 0) goto <D.40220>; else goto <D.40221>;
    <D.40220>:
    if (0 != 0) goto <D.40222>; else goto <D.40223>;
    <D.40222>:
    code.3566 = code;
    code = code.3566 + 1;
    *code.3566 = 102;
    <D.40223>:
    {
      unsigned char _amd64_rex_bits;

      if (i > 7) goto <D.40226>; else goto <D.40227>;
      <D.40226>:
      iftmp.3567 = 12;
      goto <D.40228>;
      <D.40227>:
      iftmp.3567 = 8;
      <D.40228>:
      D.40229 = cfg->frame_reg;
      D.40230 = D.40229 > 7;
      D.40231 = (signed char) D.40230;
      D.40232 = iftmp.3567 | D.40231;
      _amd64_rex_bits = (unsigned char) D.40232;
      if (_amd64_rex_bits != 0) goto <D.40233>; else goto <D.40234>;
      <D.40233>:
      code.3568 = code;
      code = code.3568 + 1;
      D.40236 = _amd64_rex_bits | 64;
      *code.3568 = D.40236;
      <D.40234>:
    }
    switch (8) <default: <D.26317>, case 1: <D.26312>, case 2: <D.26314>, case 4: <D.26315>, case 8: <D.26316>>
    <D.26312>:
    code.3569 = code;
    code = code.3569 + 1;
    *code.3569 = 138;
    goto <D.26313>;
    <D.26314>:
    <D.26315>:
    <D.26316>:
    code.3570 = code;
    code = code.3570 + 1;
    *code.3570 = 139;
    goto <D.26313>;
    <D.26317>:
    __assert_fail ("0", "mini-amd64.c", 4831, &__PRETTY_FUNCTION__);
    <D.26313>:
    D.40229 = cfg->frame_reg;
    if (D.40229 == 16) goto <D.40239>; else goto <D.40240>;
    <D.40239>:
    code.3571 = code;
    code = code.3571 + 1;
    D.40242 = i & 7;
    D.40243 = D.40242 << 3;
    D.40244 = (signed char) D.40243;
    D.40245 = D.40244 | 5;
    D.40246 = (unsigned char) D.40245;
    *code.3571 = D.40246;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.3572 = code;
          code = code.3572 + 1;
          D.40248 = imb.b[0];
          *code.3572 = D.40248;
          code.3573 = code;
          code = code.3573 + 1;
          D.40250 = imb.b[1];
          *code.3573 = D.40250;
          code.3574 = code;
          code = code.3574 + 1;
          D.40252 = imb.b[2];
          *code.3574 = D.40252;
          code.3575 = code;
          code = code.3575 + 1;
          D.40254 = imb.b[3];
          *code.3575 = D.40254;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.40255>;
    <D.40240>:
    D.40229 = cfg->frame_reg;
    D.40256 = D.40229 & 7;
    if (D.40256 == 4) goto <D.40257>; else goto <D.40258>;
    <D.40257>:
    if (save_area_offset == 0) goto <D.40259>; else goto <D.40260>;
    <D.40259>:
    code.3576 = code;
    code = code.3576 + 1;
    D.40242 = i & 7;
    D.40243 = D.40242 << 3;
    D.40244 = (signed char) D.40243;
    D.40262 = D.40244 | 4;
    D.40263 = (unsigned char) D.40262;
    *code.3576 = D.40263;
    code.3577 = code;
    code = code.3577 + 1;
    *code.3577 = 36;
    goto <D.40265>;
    <D.40260>:
    save_area_offset.3578 = (unsigned int) save_area_offset;
    D.40267 = save_area_offset.3578 + 128;
    if (D.40267 <= 255) goto <D.40268>; else goto <D.40269>;
    <D.40268>:
    code.3579 = code;
    code = code.3579 + 1;
    D.40242 = i & 7;
    D.40243 = D.40242 << 3;
    D.40244 = (signed char) D.40243;
    D.40271 = D.40244 | 68;
    D.40272 = (unsigned char) D.40271;
    *code.3579 = D.40272;
    code.3580 = code;
    code = code.3580 + 1;
    *code.3580 = 36;
    D.40274 = (unsigned char) save_area_offset;
    *code = D.40274;
    code = code + 1;
    goto <D.40275>;
    <D.40269>:
    code.3581 = code;
    code = code.3581 + 1;
    D.40242 = i & 7;
    D.40243 = D.40242 << 3;
    D.40244 = (signed char) D.40243;
    D.40277 = D.40244 | -124;
    D.40278 = (unsigned char) D.40277;
    *code.3581 = D.40278;
    code.3582 = code;
    code = code.3582 + 1;
    *code.3582 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.3583 = code;
          code = code.3583 + 1;
          D.40281 = imb.b[0];
          *code.3583 = D.40281;
          code.3584 = code;
          code = code.3584 + 1;
          D.40283 = imb.b[1];
          *code.3584 = D.40283;
          code.3585 = code;
          code = code.3585 + 1;
          D.40285 = imb.b[2];
          *code.3585 = D.40285;
          code.3586 = code;
          code = code.3586 + 1;
          D.40287 = imb.b[3];
          *code.3586 = D.40287;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40275>:
    <D.40265>:
    goto <D.26320>;
    <D.40258>:
    if (save_area_offset == 0) goto <D.40288>; else goto <D.40289>;
    <D.40288>:
    D.40229 = cfg->frame_reg;
    D.40256 = D.40229 & 7;
    if (D.40256 != 5) goto <D.40290>; else goto <D.40291>;
    <D.40290>:
    code.3587 = code;
    code = code.3587 + 1;
    D.40293 = (unsigned char) i;
    D.40294 = D.40293 & 7;
    D.40295 = D.40294 << 3;
    D.40229 = cfg->frame_reg;
    D.40296 = (unsigned char) D.40229;
    D.40297 = D.40296 & 7;
    D.40298 = D.40295 | D.40297;
    *code.3587 = D.40298;
    goto <D.26320>;
    <D.40291>:
    <D.40289>:
    save_area_offset.3578 = (unsigned int) save_area_offset;
    D.40267 = save_area_offset.3578 + 128;
    if (D.40267 <= 255) goto <D.40299>; else goto <D.40300>;
    <D.40299>:
    code.3588 = code;
    code = code.3588 + 1;
    D.40293 = (unsigned char) i;
    D.40294 = D.40293 & 7;
    D.40295 = D.40294 << 3;
    D.40229 = cfg->frame_reg;
    D.40296 = (unsigned char) D.40229;
    D.40297 = D.40296 & 7;
    D.40298 = D.40295 | D.40297;
    D.40302 = D.40298 | 64;
    *code.3588 = D.40302;
    D.40274 = (unsigned char) save_area_offset;
    *code = D.40274;
    code = code + 1;
    goto <D.40303>;
    <D.40300>:
    code.3589 = code;
    code = code.3589 + 1;
    D.40293 = (unsigned char) i;
    D.40294 = D.40293 & 7;
    D.40295 = D.40294 << 3;
    D.40229 = cfg->frame_reg;
    D.40296 = (unsigned char) D.40229;
    D.40297 = D.40296 & 7;
    D.40298 = D.40295 | D.40297;
    D.40305 = D.40298 | 128;
    *code.3589 = D.40305;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.3590 = code;
          code = code.3590 + 1;
          D.40307 = imb.b[0];
          *code.3590 = D.40307;
          code.3591 = code;
          code = code.3591 + 1;
          D.40309 = imb.b[1];
          *code.3591 = D.40309;
          code.3592 = code;
          code = code.3592 + 1;
          D.40311 = imb.b[2];
          *code.3592 = D.40311;
          code.3593 = code;
          code = code.3593 + 1;
          D.40313 = imb.b[3];
          *code.3593 = D.40313;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40303>:
    <D.26320>:
    <D.40255>:
    save_area_offset = save_area_offset + 8;
    <D.40221>:
    <D.40215>:
    i = i + 1;
    <D.26323>:
    if (i <= 16) goto <D.26322>; else goto <D.26324>;
    <D.26324>:
    D.40314 = cfg->arch.omit_fp;
    if (D.40314 != 0) goto <D.40315>; else goto <D.40316>;
    <D.40315>:
    D.40317 = cfg->arch.stack_alloc_size;
    if (D.40317 != 0) goto <D.40318>; else goto <D.40319>;
    <D.40318>:
    D.40317 = cfg->arch.stack_alloc_size;
    D.40320 = (unsigned int) D.40317;
    D.40321 = D.40320 + 128;
    if (D.40321 <= 255) goto <D.40322>; else goto <D.40323>;
    <D.40322>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40324>; else goto <D.40325>;
      <D.40324>:
      code.3594 = code;
      code = code.3594 + 1;
      D.40327 = _amd64_rex_bits | 64;
      *code.3594 = D.40327;
      <D.40325>:
    }
    code.3595 = code;
    code = code.3595 + 1;
    *code.3595 = 131;
    code.3596 = code;
    code = code.3596 + 1;
    *code.3596 = 196;
    D.40317 = cfg->arch.stack_alloc_size;
    D.40330 = (unsigned char) D.40317;
    *code = D.40330;
    code = code + 1;
    goto <D.40331>;
    <D.40323>:
    if (0 != 0) goto <D.40332>; else goto <D.40333>;
    <D.40332>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40334>; else goto <D.40335>;
      <D.40334>:
      code.3597 = code;
      code = code.3597 + 1;
      D.40337 = _amd64_rex_bits | 64;
      *code.3597 = D.40337;
      <D.40335>:
    }
    code.3598 = code;
    code = code.3598 + 1;
    *code.3598 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          D.40317 = cfg->arch.stack_alloc_size;
          imb.val = D.40317;
          code.3599 = code;
          code = code.3599 + 1;
          D.40340 = imb.b[0];
          *code.3599 = D.40340;
          code.3600 = code;
          code = code.3600 + 1;
          D.40342 = imb.b[1];
          *code.3600 = D.40342;
          code.3601 = code;
          code = code.3601 + 1;
          D.40344 = imb.b[2];
          *code.3601 = D.40344;
          code.3602 = code;
          code = code.3602 + 1;
          D.40346 = imb.b[3];
          *code.3602 = D.40346;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.40347>;
    <D.40333>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40348>; else goto <D.40349>;
      <D.40348>:
      code.3603 = code;
      code = code.3603 + 1;
      D.40351 = _amd64_rex_bits | 64;
      *code.3603 = D.40351;
      <D.40349>:
    }
    code.3604 = code;
    code = code.3604 + 1;
    *code.3604 = 129;
    code.3605 = code;
    code = code.3605 + 1;
    *code.3605 = 196;
    {
      union x86_imm_buf imb;

      try
        {
          D.40317 = cfg->arch.stack_alloc_size;
          imb.val = D.40317;
          code.3606 = code;
          code = code.3606 + 1;
          D.40355 = imb.b[0];
          *code.3606 = D.40355;
          code.3607 = code;
          code = code.3607 + 1;
          D.40357 = imb.b[1];
          *code.3607 = D.40357;
          code.3608 = code;
          code = code.3608 + 1;
          D.40359 = imb.b[2];
          *code.3608 = D.40359;
          code.3609 = code;
          code = code.3609 + 1;
          D.40361 = imb.b[3];
          *code.3609 = D.40361;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40347>:
    <D.40331>:
    <D.40319>:
    D.40362 = call->stack_usage;
    if (D.40362 != 0) goto <D.40363>; else goto <D.40364>;
    <D.40363>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 4840);
    <D.40364>:
    goto <D.40365>;
    <D.40316>:
    i = 0;
    goto <D.26352>;
    <D.26351>:
    if (0 != 0) goto <D.40366>; else goto <D.40367>;
    <D.40366>:
    code.3610 = code;
    code = code.3610 + 1;
    *code.3610 = 102;
    <D.40367>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40369>; else goto <D.40370>;
      <D.40369>:
      code.3611 = code;
      code = code.3611 + 1;
      D.40372 = _amd64_rex_bits | 64;
      *code.3611 = D.40372;
      <D.40370>:
    }
    switch (8) <default: <D.26336>, case 1: <D.26331>, case 2: <D.26333>, case 4: <D.26334>, case 8: <D.26335>>
    <D.26331>:
    code.3612 = code;
    code = code.3612 + 1;
    *code.3612 = 138;
    goto <D.26332>;
    <D.26333>:
    <D.26334>:
    <D.26335>:
    code.3613 = code;
    code = code.3613 + 1;
    *code.3613 = 139;
    goto <D.26332>;
    <D.26336>:
    __assert_fail ("0", "mini-amd64.c", 4844, &__PRETTY_FUNCTION__);
    <D.26332>:
    if (0 != 0) goto <D.40375>; else goto <D.40376>;
    <D.40375>:
    code.3614 = code;
    code = code.3614 + 1;
    *code.3614 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = i;
          code.3615 = code;
          code = code.3615 + 1;
          D.40379 = imb.b[0];
          *code.3615 = D.40379;
          code.3616 = code;
          code = code.3616 + 1;
          D.40381 = imb.b[1];
          *code.3616 = D.40381;
          code.3617 = code;
          code = code.3617 + 1;
          D.40383 = imb.b[2];
          *code.3617 = D.40383;
          code.3618 = code;
          code = code.3618 + 1;
          D.40385 = imb.b[3];
          *code.3618 = D.40385;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.40386>;
    <D.40376>:
    if (1 != 0) goto <D.40387>; else goto <D.40388>;
    <D.40387>:
    if (i == 0) goto <D.40389>; else goto <D.40390>;
    <D.40389>:
    code.3619 = code;
    code = code.3619 + 1;
    *code.3619 = 4;
    code.3620 = code;
    code = code.3620 + 1;
    *code.3620 = 36;
    goto <D.40393>;
    <D.40390>:
    i.3621 = (unsigned int) i;
    D.40395 = i.3621 + 128;
    if (D.40395 <= 255) goto <D.40396>; else goto <D.40397>;
    <D.40396>:
    code.3622 = code;
    code = code.3622 + 1;
    *code.3622 = 68;
    code.3623 = code;
    code = code.3623 + 1;
    *code.3623 = 36;
    D.40400 = (unsigned char) i;
    *code = D.40400;
    code = code + 1;
    goto <D.40401>;
    <D.40397>:
    code.3624 = code;
    code = code.3624 + 1;
    *code.3624 = 132;
    code.3625 = code;
    code = code.3625 + 1;
    *code.3625 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = i;
          code.3626 = code;
          code = code.3626 + 1;
          D.40405 = imb.b[0];
          *code.3626 = D.40405;
          code.3627 = code;
          code = code.3627 + 1;
          D.40407 = imb.b[1];
          *code.3627 = D.40407;
          code.3628 = code;
          code = code.3628 + 1;
          D.40409 = imb.b[2];
          *code.3628 = D.40409;
          code.3629 = code;
          code = code.3629 + 1;
          D.40411 = imb.b[3];
          *code.3629 = D.40411;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40401>:
    <D.40393>:
    goto <D.26339>;
    <D.40388>:
    if (i == 0) goto <D.40412>; else goto <D.40413>;
    <D.40412>:
    code.3630 = code;
    code = code.3630 + 1;
    *code.3630 = 4;
    goto <D.26339>;
    <D.40413>:
    i.3621 = (unsigned int) i;
    D.40395 = i.3621 + 128;
    if (D.40395 <= 255) goto <D.40415>; else goto <D.40416>;
    <D.40415>:
    code.3631 = code;
    code = code.3631 + 1;
    *code.3631 = 68;
    D.40400 = (unsigned char) i;
    *code = D.40400;
    code = code + 1;
    goto <D.40418>;
    <D.40416>:
    code.3632 = code;
    code = code.3632 + 1;
    *code.3632 = 132;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = i;
          code.3633 = code;
          code = code.3633 + 1;
          D.40421 = imb.b[0];
          *code.3633 = D.40421;
          code.3634 = code;
          code = code.3634 + 1;
          D.40423 = imb.b[1];
          *code.3634 = D.40423;
          code.3635 = code;
          code = code.3635 + 1;
          D.40425 = imb.b[2];
          *code.3635 = D.40425;
          code.3636 = code;
          code = code.3636 + 1;
          D.40427 = imb.b[3];
          *code.3636 = D.40427;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40418>:
    <D.26339>:
    <D.40386>:
    if (0 != 0) goto <D.40428>; else goto <D.40429>;
    <D.40428>:
    code.3637 = code;
    code = code.3637 + 1;
    *code.3637 = 102;
    <D.40429>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40431>; else goto <D.40432>;
      <D.40431>:
      code.3638 = code;
      code = code.3638 + 1;
      D.40434 = _amd64_rex_bits | 64;
      *code.3638 = D.40434;
      <D.40432>:
    }
    switch (8) <default: <D.26347>, case 1: <D.26342>, case 2: <D.26344>, case 4: <D.26345>, case 8: <D.26346>>
    <D.26342>:
    code.3639 = code;
    code = code.3639 + 1;
    *code.3639 = 136;
    goto <D.26343>;
    <D.26344>:
    <D.26345>:
    <D.26346>:
    code.3640 = code;
    code = code.3640 + 1;
    *code.3640 = 137;
    goto <D.26343>;
    <D.26347>:
    __assert_fail ("0", "mini-amd64.c", 4845, &__PRETTY_FUNCTION__);
    <D.26343>:
    if (0 != 0) goto <D.40437>; else goto <D.40438>;
    <D.40437>:
    if (i == -16) goto <D.40439>; else goto <D.40440>;
    <D.40439>:
    code.3641 = code;
    code = code.3641 + 1;
    *code.3641 = 4;
    code.3642 = code;
    code = code.3642 + 1;
    *code.3642 = 36;
    goto <D.40443>;
    <D.40440>:
    i.3621 = (unsigned int) i;
    D.40444 = i.3621 + 144;
    if (D.40444 <= 255) goto <D.40445>; else goto <D.40446>;
    <D.40445>:
    code.3643 = code;
    code = code.3643 + 1;
    *code.3643 = 68;
    code.3644 = code;
    code = code.3644 + 1;
    *code.3644 = 36;
    D.40449 = (unsigned char) i;
    D.40450 = D.40449 + 16;
    *code = D.40450;
    code = code + 1;
    goto <D.40451>;
    <D.40446>:
    code.3645 = code;
    code = code.3645 + 1;
    *code.3645 = 132;
    code.3646 = code;
    code = code.3646 + 1;
    *code.3646 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.40454 = i + 16;
          imb.val = D.40454;
          code.3647 = code;
          code = code.3647 + 1;
          D.40456 = imb.b[0];
          *code.3647 = D.40456;
          code.3648 = code;
          code = code.3648 + 1;
          D.40458 = imb.b[1];
          *code.3648 = D.40458;
          code.3649 = code;
          code = code.3649 + 1;
          D.40460 = imb.b[2];
          *code.3649 = D.40460;
          code.3650 = code;
          code = code.3650 + 1;
          D.40462 = imb.b[3];
          *code.3650 = D.40462;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40451>:
    <D.40443>:
    goto <D.26349>;
    <D.40438>:
    if (0 != 0) goto <D.40463>; else goto <D.40464>;
    <D.40463>:
    code.3651 = code;
    code = code.3651 + 1;
    *code.3651 = 5;
    goto <D.26349>;
    <D.40464>:
    i.3621 = (unsigned int) i;
    D.40444 = i.3621 + 144;
    if (D.40444 <= 255) goto <D.40466>; else goto <D.40467>;
    <D.40466>:
    code.3652 = code;
    code = code.3652 + 1;
    *code.3652 = 69;
    D.40449 = (unsigned char) i;
    D.40450 = D.40449 + 16;
    *code = D.40450;
    code = code + 1;
    goto <D.40469>;
    <D.40467>:
    code.3653 = code;
    code = code.3653 + 1;
    *code.3653 = 133;
    {
      union x86_imm_buf imb;

      try
        {
          D.40454 = i + 16;
          imb.val = D.40454;
          code.3654 = code;
          code = code.3654 + 1;
          D.40472 = imb.b[0];
          *code.3654 = D.40472;
          code.3655 = code;
          code = code.3655 + 1;
          D.40474 = imb.b[1];
          *code.3655 = D.40474;
          code.3656 = code;
          code = code.3656 + 1;
          D.40476 = imb.b[2];
          *code.3656 = D.40476;
          code.3657 = code;
          code = code.3657 + 1;
          D.40478 = imb.b[3];
          *code.3657 = D.40478;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40469>:
    <D.26349>:
    i.3621 = (unsigned int) i;
    D.40479 = i.3621 + 8;
    i = (int) D.40479;
    <D.26352>:
    i.3658 = (unsigned int) i;
    D.40362 = call->stack_usage;
    if (i.3658 < D.40362) goto <D.26351>; else goto <D.26353>;
    <D.26353>:
    code.3659 = code;
    code = code.3659 + 1;
    *code.3659 = 201;
    <D.40365>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    offset = (guint) D.31452;
    D.40482 = call->method;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 4, D.40482);
    D.31356 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.31357 = D.31356 & 64;
    if (D.31357 != 0) goto <D.40483>; else goto <D.40484>;
    <D.40483>:
    if (0 != 0) goto <D.40485>; else goto <D.40486>;
    <D.40485>:
    code.3660 = code;
    code = code.3660 + 1;
    *code.3660 = 102;
    <D.40486>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 13;
      if (_amd64_rex_bits != 0) goto <D.40488>; else goto <D.40489>;
      <D.40488>:
      code.3661 = code;
      code = code.3661 + 1;
      D.40491 = _amd64_rex_bits | 64;
      *code.3661 = D.40491;
      <D.40489>:
    }
    switch (8) <default: <D.26360>, case 1: <D.26355>, case 2: <D.26357>, case 4: <D.26358>, case 8: <D.26359>>
    <D.26355>:
    code.3662 = code;
    code = code.3662 + 1;
    *code.3662 = 138;
    goto <D.26356>;
    <D.26357>:
    <D.26358>:
    <D.26359>:
    code.3663 = code;
    code = code.3663 + 1;
    *code.3663 = 139;
    goto <D.26356>;
    <D.26360>:
    __assert_fail ("0", "mini-amd64.c", 4854, &__PRETTY_FUNCTION__);
    <D.26356>:
    if (1 != 0) goto <D.40494>; else goto <D.40495>;
    <D.40494>:
    code.3664 = code;
    code = code.3664 + 1;
    *code.3664 = 29;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3665 = code;
          code = code.3665 + 1;
          D.40498 = imb.b[0];
          *code.3665 = D.40498;
          code.3666 = code;
          code = code.3666 + 1;
          D.40500 = imb.b[1];
          *code.3666 = D.40500;
          code.3667 = code;
          code = code.3667 + 1;
          D.40502 = imb.b[2];
          *code.3667 = D.40502;
          code.3668 = code;
          code = code.3668 + 1;
          D.40504 = imb.b[3];
          *code.3668 = D.40504;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.40505>;
    <D.40495>:
    if (0 != 0) goto <D.40506>; else goto <D.40507>;
    <D.40506>:
    if (1 != 0) goto <D.40508>; else goto <D.40509>;
    <D.40508>:
    code.3669 = code;
    code = code.3669 + 1;
    *code.3669 = 28;
    code.3670 = code;
    code = code.3670 + 1;
    *code.3670 = 36;
    goto <D.40512>;
    <D.40509>:
    if (1 != 0) goto <D.40513>; else goto <D.40514>;
    <D.40513>:
    code.3671 = code;
    code = code.3671 + 1;
    *code.3671 = 92;
    code.3672 = code;
    code = code.3672 + 1;
    *code.3672 = 36;
    *code = 0;
    code = code + 1;
    goto <D.40517>;
    <D.40514>:
    code.3673 = code;
    code = code.3673 + 1;
    *code.3673 = 156;
    code.3674 = code;
    code = code.3674 + 1;
    *code.3674 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3675 = code;
          code = code.3675 + 1;
          D.40521 = imb.b[0];
          *code.3675 = D.40521;
          code.3676 = code;
          code = code.3676 + 1;
          D.40523 = imb.b[1];
          *code.3676 = D.40523;
          code.3677 = code;
          code = code.3677 + 1;
          D.40525 = imb.b[2];
          *code.3677 = D.40525;
          code.3678 = code;
          code = code.3678 + 1;
          D.40527 = imb.b[3];
          *code.3678 = D.40527;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40517>:
    <D.40512>:
    goto <D.26363>;
    <D.40507>:
    if (1 != 0) goto <D.40528>; else goto <D.40529>;
    <D.40528>:
    code.3679 = code;
    code = code.3679 + 1;
    *code.3679 = 24;
    goto <D.26363>;
    <D.40529>:
    if (1 != 0) goto <D.40531>; else goto <D.40532>;
    <D.40531>:
    code.3680 = code;
    code = code.3680 + 1;
    *code.3680 = 88;
    *code = 0;
    code = code + 1;
    goto <D.40534>;
    <D.40532>:
    code.3681 = code;
    code = code.3681 + 1;
    *code.3681 = 152;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3682 = code;
          code = code.3682 + 1;
          D.40537 = imb.b[0];
          *code.3682 = D.40537;
          code.3683 = code;
          code = code.3683 + 1;
          D.40539 = imb.b[1];
          *code.3683 = D.40539;
          code.3684 = code;
          code = code.3684 + 1;
          D.40541 = imb.b[2];
          *code.3684 = D.40541;
          code.3685 = code;
          code = code.3685 + 1;
          D.40543 = imb.b[3];
          *code.3685 = D.40543;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40534>:
    <D.26363>:
    <D.40505>:
    goto <D.40544>;
    <D.40484>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 9;
      if (_amd64_rex_bits != 0) goto <D.40545>; else goto <D.40546>;
      <D.40545>:
      code.3686 = code;
      code = code.3686 + 1;
      D.40548 = _amd64_rex_bits | 64;
      *code.3686 = D.40548;
      <D.40546>:
    }
    code.3687 = code;
    code = code.3687 + 1;
    *code.3687 = 187;
    if (1 != 0) goto <D.40550>; else goto <D.40551>;
    <D.40550>:
    {
      union amd64_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3688 = code;
          code = code.3688 + 1;
          D.40553 = imb.b[0];
          *code.3688 = D.40553;
          code.3689 = code;
          code = code.3689 + 1;
          D.40555 = imb.b[1];
          *code.3689 = D.40555;
          code.3690 = code;
          code = code.3690 + 1;
          D.40557 = imb.b[2];
          *code.3690 = D.40557;
          code.3691 = code;
          code = code.3691 + 1;
          D.40559 = imb.b[3];
          *code.3691 = D.40559;
          code.3692 = code;
          code = code.3692 + 1;
          D.40561 = imb.b[4];
          *code.3692 = D.40561;
          code.3693 = code;
          code = code.3693 + 1;
          D.40563 = imb.b[5];
          *code.3693 = D.40563;
          code.3694 = code;
          code = code.3694 + 1;
          D.40565 = imb.b[6];
          *code.3694 = D.40565;
          code.3695 = code;
          code = code.3695 + 1;
          D.40567 = imb.b[7];
          *code.3695 = D.40567;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.40568>;
    <D.40551>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.3696 = code;
          code = code.3696 + 1;
          D.40570 = imb.b[0];
          *code.3696 = D.40570;
          code.3697 = code;
          code = code.3697 + 1;
          D.40572 = imb.b[1];
          *code.3697 = D.40572;
          code.3698 = code;
          code = code.3698 + 1;
          D.40574 = imb.b[2];
          *code.3698 = D.40574;
          code.3699 = code;
          code = code.3699 + 1;
          D.40576 = imb.b[3];
          *code.3699 = D.40576;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.40568>:
    <D.40544>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 1;
      if (_amd64_rex_bits != 0) goto <D.40577>; else goto <D.40578>;
      <D.40577>:
      code.3700 = code;
      code = code.3700 + 1;
      D.40580 = _amd64_rex_bits | 64;
      *code.3700 = D.40580;
      <D.40578>:
    }
    code.3701 = code;
    code = code.3701 + 1;
    *code.3701 = 255;
    code.3702 = code;
    code = code.3702 + 1;
    *code.3702 = 227;
    D.36769 = ins->flags;
    D.40583 = D.36769 | 128;
    ins->flags = D.40583;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    ins->backend.pc_offset = D.36947;
    goto <D.25197>;
  }
  <D.26369>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.40584>; else goto <D.40585>;
    <D.40584>:
    code.3703 = code;
    code = code.3703 + 1;
    D.40587 = _amd64_rex_bits | 64;
    *code.3703 = D.40587;
    <D.40585>:
  }
  if (1 != 0) goto <D.40588>; else goto <D.40589>;
  <D.40588>:
  code.3704 = code;
  code = code.3704 + 1;
  *code.3704 = 131;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.40591>; else goto <D.40592>;
  <D.40591>:
  if (1 != 0) goto <D.40593>; else goto <D.40594>;
  <D.40593>:
  code.3705 = code;
  code = code.3705 + 1;
  *code.3705 = 60;
  code.3706 = code;
  code = code.3706 + 1;
  *code.3706 = 36;
  goto <D.40597>;
  <D.40594>:
  if (1 != 0) goto <D.40598>; else goto <D.40599>;
  <D.40598>:
  code.3707 = code;
  code = code.3707 + 1;
  *code.3707 = 124;
  code.3708 = code;
  code = code.3708 + 1;
  *code.3708 = 36;
  *code = 0;
  code = code + 1;
  goto <D.40602>;
  <D.40599>:
  code.3709 = code;
  code = code.3709 + 1;
  *code.3709 = 188;
  code.3710 = code;
  code = code.3710 + 1;
  *code.3710 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3711 = code;
        code = code.3711 + 1;
        D.40606 = imb.b[0];
        *code.3711 = D.40606;
        code.3712 = code;
        code = code.3712 + 1;
        D.40608 = imb.b[1];
        *code.3712 = D.40608;
        code.3713 = code;
        code = code.3713 + 1;
        D.40610 = imb.b[2];
        *code.3713 = D.40610;
        code.3714 = code;
        code = code.3714 + 1;
        D.40612 = imb.b[3];
        *code.3714 = D.40612;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40602>:
  <D.40597>:
  goto <D.26372>;
  <D.40592>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.40613>; else goto <D.40614>;
  <D.40613>:
  code.3715 = code;
  code = code.3715 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.3715 = D.35300;
  goto <D.26372>;
  <D.40614>:
  if (1 != 0) goto <D.40616>; else goto <D.40617>;
  <D.40616>:
  code.3716 = code;
  code = code.3716 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.3716 = D.35305;
  *code = 0;
  code = code + 1;
  goto <D.40619>;
  <D.40617>:
  code.3717 = code;
  code = code.3717 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.3717 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3718 = code;
        code = code.3718 + 1;
        D.40622 = imb.b[0];
        *code.3718 = D.40622;
        code.3719 = code;
        code = code.3719 + 1;
        D.40624 = imb.b[1];
        *code.3719 = D.40624;
        code.3720 = code;
        code = code.3720 + 1;
        D.40626 = imb.b[2];
        *code.3720 = D.40626;
        code.3721 = code;
        code = code.3721 + 1;
        D.40628 = imb.b[3];
        *code.3721 = D.40628;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40619>:
  <D.26372>:
  *code = 0;
  code = code + 1;
  goto <D.40629>;
  <D.40589>:
  code.3722 = code;
  code = code.3722 + 1;
  *code.3722 = 129;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.40631>; else goto <D.40632>;
  <D.40631>:
  if (1 != 0) goto <D.40633>; else goto <D.40634>;
  <D.40633>:
  code.3723 = code;
  code = code.3723 + 1;
  *code.3723 = 60;
  code.3724 = code;
  code = code.3724 + 1;
  *code.3724 = 36;
  goto <D.40637>;
  <D.40634>:
  if (1 != 0) goto <D.40638>; else goto <D.40639>;
  <D.40638>:
  code.3725 = code;
  code = code.3725 + 1;
  *code.3725 = 124;
  code.3726 = code;
  code = code.3726 + 1;
  *code.3726 = 36;
  *code = 0;
  code = code + 1;
  goto <D.40642>;
  <D.40639>:
  code.3727 = code;
  code = code.3727 + 1;
  *code.3727 = 188;
  code.3728 = code;
  code = code.3728 + 1;
  *code.3728 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3729 = code;
        code = code.3729 + 1;
        D.40646 = imb.b[0];
        *code.3729 = D.40646;
        code.3730 = code;
        code = code.3730 + 1;
        D.40648 = imb.b[1];
        *code.3730 = D.40648;
        code.3731 = code;
        code = code.3731 + 1;
        D.40650 = imb.b[2];
        *code.3731 = D.40650;
        code.3732 = code;
        code = code.3732 + 1;
        D.40652 = imb.b[3];
        *code.3732 = D.40652;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40642>:
  <D.40637>:
  goto <D.26375>;
  <D.40632>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.40653>; else goto <D.40654>;
  <D.40653>:
  code.3733 = code;
  code = code.3733 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35299 = D.31571 | 56;
  D.35300 = (unsigned char) D.35299;
  *code.3733 = D.35300;
  goto <D.26375>;
  <D.40654>:
  if (1 != 0) goto <D.40656>; else goto <D.40657>;
  <D.40656>:
  code.3734 = code;
  code = code.3734 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35304 = D.31571 | 120;
  D.35305 = (unsigned char) D.35304;
  *code.3734 = D.35305;
  *code = 0;
  code = code + 1;
  goto <D.40659>;
  <D.40657>:
  code.3735 = code;
  code = code.3735 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.35308 = D.31571 | -72;
  D.35309 = (unsigned char) D.35308;
  *code.3735 = D.35309;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3736 = code;
        code = code.3736 + 1;
        D.40662 = imb.b[0];
        *code.3736 = D.40662;
        code.3737 = code;
        code = code.3737 + 1;
        D.40664 = imb.b[1];
        *code.3737 = D.40664;
        code.3738 = code;
        code = code.3738 + 1;
        D.40666 = imb.b[2];
        *code.3738 = D.40666;
        code.3739 = code;
        code = code.3739 + 1;
        D.40668 = imb.b[3];
        *code.3739 = D.40668;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40659>:
  <D.26375>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3740 = code;
        code = code.3740 + 1;
        D.40670 = imb.b[0];
        *code.3740 = D.40670;
        code.3741 = code;
        code = code.3741 + 1;
        D.40672 = imb.b[1];
        *code.3741 = D.40672;
        code.3742 = code;
        code = code.3742 + 1;
        D.40674 = imb.b[2];
        *code.3742 = D.40674;
        code.3743 = code;
        code = code.3743 + 1;
        D.40676 = imb.b[3];
        *code.3743 = D.40676;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40629>:
  goto <D.25197>;
  <D.26378>:
  {
    unsigned char _amd64_rex_bits;

    D.40229 = cfg->frame_reg;
    if (D.40229 > 7) goto <D.40678>; else goto <D.40679>;
    <D.40678>:
    iftmp.3744 = 13;
    goto <D.40680>;
    <D.40679>:
    iftmp.3744 = 12;
    <D.40680>:
    _amd64_rex_bits = iftmp.3744;
    if (_amd64_rex_bits != 0) goto <D.40681>; else goto <D.40682>;
    <D.40681>:
    code.3745 = code;
    code = code.3745 + 1;
    D.40684 = _amd64_rex_bits | 64;
    *code.3745 = D.40684;
    <D.40682>:
  }
  code.3746 = code;
  code = code.3746 + 1;
  *code.3746 = 141;
  D.40229 = cfg->frame_reg;
  if (D.40229 == 16) goto <D.40686>; else goto <D.40687>;
  <D.40686>:
  code.3747 = code;
  code = code.3747 + 1;
  *code.3747 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        D.40689 = cfg->sig_cookie;
        imb.val = D.40689;
        code.3748 = code;
        code = code.3748 + 1;
        D.40691 = imb.b[0];
        *code.3748 = D.40691;
        code.3749 = code;
        code = code.3749 + 1;
        D.40693 = imb.b[1];
        *code.3749 = D.40693;
        code.3750 = code;
        code = code.3750 + 1;
        D.40695 = imb.b[2];
        *code.3750 = D.40695;
        code.3751 = code;
        code = code.3751 + 1;
        D.40697 = imb.b[3];
        *code.3751 = D.40697;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.40698>;
  <D.40687>:
  D.40229 = cfg->frame_reg;
  D.40256 = D.40229 & 7;
  if (D.40256 == 4) goto <D.40699>; else goto <D.40700>;
  <D.40699>:
  D.40689 = cfg->sig_cookie;
  if (D.40689 == 0) goto <D.40701>; else goto <D.40702>;
  <D.40701>:
  code.3752 = code;
  code = code.3752 + 1;
  *code.3752 = 28;
  code.3753 = code;
  code = code.3753 + 1;
  *code.3753 = 36;
  goto <D.40705>;
  <D.40702>:
  D.40689 = cfg->sig_cookie;
  D.40706 = (unsigned int) D.40689;
  D.40707 = D.40706 + 128;
  if (D.40707 <= 255) goto <D.40708>; else goto <D.40709>;
  <D.40708>:
  code.3754 = code;
  code = code.3754 + 1;
  *code.3754 = 92;
  code.3755 = code;
  code = code.3755 + 1;
  *code.3755 = 36;
  D.40689 = cfg->sig_cookie;
  D.40712 = (unsigned char) D.40689;
  *code = D.40712;
  code = code + 1;
  goto <D.40713>;
  <D.40709>:
  code.3756 = code;
  code = code.3756 + 1;
  *code.3756 = 156;
  code.3757 = code;
  code = code.3757 + 1;
  *code.3757 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.40689 = cfg->sig_cookie;
        imb.val = D.40689;
        code.3758 = code;
        code = code.3758 + 1;
        D.40717 = imb.b[0];
        *code.3758 = D.40717;
        code.3759 = code;
        code = code.3759 + 1;
        D.40719 = imb.b[1];
        *code.3759 = D.40719;
        code.3760 = code;
        code = code.3760 + 1;
        D.40721 = imb.b[2];
        *code.3760 = D.40721;
        code.3761 = code;
        code = code.3761 + 1;
        D.40723 = imb.b[3];
        *code.3761 = D.40723;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40713>:
  <D.40705>:
  goto <D.26382>;
  <D.40700>:
  D.40689 = cfg->sig_cookie;
  if (D.40689 == 0) goto <D.40724>; else goto <D.40725>;
  <D.40724>:
  D.40229 = cfg->frame_reg;
  D.40256 = D.40229 & 7;
  if (D.40256 != 5) goto <D.40726>; else goto <D.40727>;
  <D.40726>:
  code.3762 = code;
  code = code.3762 + 1;
  D.40229 = cfg->frame_reg;
  D.40296 = (unsigned char) D.40229;
  D.40297 = D.40296 & 7;
  D.40729 = D.40297 | 24;
  *code.3762 = D.40729;
  goto <D.26382>;
  <D.40727>:
  <D.40725>:
  D.40689 = cfg->sig_cookie;
  D.40706 = (unsigned int) D.40689;
  D.40707 = D.40706 + 128;
  if (D.40707 <= 255) goto <D.40730>; else goto <D.40731>;
  <D.40730>:
  code.3763 = code;
  code = code.3763 + 1;
  D.40229 = cfg->frame_reg;
  D.40296 = (unsigned char) D.40229;
  D.40297 = D.40296 & 7;
  D.40733 = D.40297 | 88;
  *code.3763 = D.40733;
  D.40689 = cfg->sig_cookie;
  D.40712 = (unsigned char) D.40689;
  *code = D.40712;
  code = code + 1;
  goto <D.40734>;
  <D.40731>:
  code.3764 = code;
  code = code.3764 + 1;
  D.40229 = cfg->frame_reg;
  D.40296 = (unsigned char) D.40229;
  D.40297 = D.40296 & 7;
  D.40736 = D.40297 | 152;
  *code.3764 = D.40736;
  {
    union x86_imm_buf imb;

    try
      {
        D.40689 = cfg->sig_cookie;
        imb.val = D.40689;
        code.3765 = code;
        code = code.3765 + 1;
        D.40738 = imb.b[0];
        *code.3765 = D.40738;
        code.3766 = code;
        code = code.3766 + 1;
        D.40740 = imb.b[1];
        *code.3766 = D.40740;
        code.3767 = code;
        code = code.3767 + 1;
        D.40742 = imb.b[2];
        *code.3767 = D.40742;
        code.3768 = code;
        code = code.3768 + 1;
        D.40744 = imb.b[3];
        *code.3768 = D.40744;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40734>:
  <D.26382>:
  <D.40698>:
  if (0 != 0) goto <D.40745>; else goto <D.40746>;
  <D.40745>:
  code.3769 = code;
  code = code.3769 + 1;
  *code.3769 = 102;
  <D.40746>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.40749>; else goto <D.40750>;
    <D.40749>:
    iftmp.3770 = 13;
    goto <D.40751>;
    <D.40750>:
    iftmp.3770 = 12;
    <D.40751>:
    _amd64_rex_bits = iftmp.3770;
    if (_amd64_rex_bits != 0) goto <D.40752>; else goto <D.40753>;
    <D.40752>:
    code.3771 = code;
    code = code.3771 + 1;
    D.40755 = _amd64_rex_bits | 64;
    *code.3771 = D.40755;
    <D.40753>:
  }
  switch (8) <default: <D.26390>, case 1: <D.26385>, case 2: <D.26387>, case 4: <D.26388>, case 8: <D.26389>>
  <D.26385>:
  code.3772 = code;
  code = code.3772 + 1;
  *code.3772 = 136;
  goto <D.26386>;
  <D.26387>:
  <D.26388>:
  <D.26389>:
  code.3773 = code;
  code = code.3773 + 1;
  *code.3773 = 137;
  goto <D.26386>;
  <D.26390>:
  __assert_fail ("0", "mini-amd64.c", 4868, &__PRETTY_FUNCTION__);
  <D.26386>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.40758>; else goto <D.40759>;
  <D.40758>:
  if (1 != 0) goto <D.40760>; else goto <D.40761>;
  <D.40760>:
  code.3774 = code;
  code = code.3774 + 1;
  *code.3774 = 28;
  code.3775 = code;
  code = code.3775 + 1;
  *code.3775 = 36;
  goto <D.40764>;
  <D.40761>:
  if (1 != 0) goto <D.40765>; else goto <D.40766>;
  <D.40765>:
  code.3776 = code;
  code = code.3776 + 1;
  *code.3776 = 92;
  code.3777 = code;
  code = code.3777 + 1;
  *code.3777 = 36;
  *code = 0;
  code = code + 1;
  goto <D.40769>;
  <D.40766>:
  code.3778 = code;
  code = code.3778 + 1;
  *code.3778 = 156;
  code.3779 = code;
  code = code.3779 + 1;
  *code.3779 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3780 = code;
        code = code.3780 + 1;
        D.40773 = imb.b[0];
        *code.3780 = D.40773;
        code.3781 = code;
        code = code.3781 + 1;
        D.40775 = imb.b[1];
        *code.3781 = D.40775;
        code.3782 = code;
        code = code.3782 + 1;
        D.40777 = imb.b[2];
        *code.3782 = D.40777;
        code.3783 = code;
        code = code.3783 + 1;
        D.40779 = imb.b[3];
        *code.3783 = D.40779;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40769>:
  <D.40764>:
  goto <D.26392>;
  <D.40759>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.40780>; else goto <D.40781>;
  <D.40780>:
  code.3784 = code;
  code = code.3784 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.40783 = D.31571 | 24;
  D.40784 = (unsigned char) D.40783;
  *code.3784 = D.40784;
  goto <D.26392>;
  <D.40781>:
  if (1 != 0) goto <D.40785>; else goto <D.40786>;
  <D.40785>:
  code.3785 = code;
  code = code.3785 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.40788 = D.31571 | 88;
  D.40789 = (unsigned char) D.40788;
  *code.3785 = D.40789;
  *code = 0;
  code = code + 1;
  goto <D.40790>;
  <D.40786>:
  code.3786 = code;
  code = code.3786 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.40792 = D.31571 | -104;
  D.40793 = (unsigned char) D.40792;
  *code.3786 = D.40793;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.3787 = code;
        code = code.3787 + 1;
        D.40795 = imb.b[0];
        *code.3787 = D.40795;
        code.3788 = code;
        code = code.3788 + 1;
        D.40797 = imb.b[1];
        *code.3788 = D.40797;
        code.3789 = code;
        code = code.3789 + 1;
        D.40799 = imb.b[2];
        *code.3789 = D.40799;
        code.3790 = code;
        code = code.3790 + 1;
        D.40801 = imb.b[3];
        *code.3790 = D.40801;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40790>:
  <D.26392>:
  goto <D.25197>;
  <D.26394>:
  <D.26395>:
  <D.26396>:
  <D.26397>:
  <D.26398>:
  <D.26399>:
  call = ins;
  D.40802 = call->signature;
  D.40803 = BIT_FIELD_REF <*D.40802, 16, 112>;
  D.40804 = D.40803 & 319;
  if (D.40804 == 261) goto <D.40805>; else goto <D.40806>;
  <D.40805>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.40807>; else goto <D.40808>;
    <D.40807>:
    code.3791 = code;
    code = code.3791 + 1;
    D.40810 = _amd64_rex_bits | 64;
    *code.3791 = D.40810;
    <D.40808>:
  }
  code.3792 = code;
  code = code.3792 + 1;
  *code.3792 = 51;
  code.3793 = code;
  code = code.3793 + 1;
  *code.3793 = 192;
  goto <D.40813>;
  <D.40806>:
  D.31456 = cfg->method;
  D.40814 = BIT_FIELD_REF <*D.31456, 8, 256>;
  D.40815 = D.40814 & 124;
  if (D.40815 == 24) goto <D.40816>; else goto <D.40817>;
  <D.40816>:
  D.31456 = cfg->method;
  D.40818 = D.31456->klass;
  D.40819 = D.40818->image;
  D.40820 = mono_defaults.corlib;
  if (D.40819 != D.40820) goto <D.40821>; else goto <D.40822>;
  <D.40821>:
  {
    guint32 nregs;
    guint32 i;

    nregs = 0;
    i = 0;
    goto <D.26404>;
    <D.26403>:
    D.40823 = call->used_fregs;
    i.3794 = (int) i;
    D.40825 = 1 << i.3794;
    D.40826 = (long unsigned int) D.40825;
    D.40827 = D.40823 & D.40826;
    if (D.40827 != 0) goto <D.40828>; else goto <D.40829>;
    <D.40828>:
    nregs = nregs + 1;
    <D.40829>:
    i = i + 1;
    <D.26404>:
    if (i <= 15) goto <D.26403>; else goto <D.26405>;
    <D.26405>:
    if (nregs == 0) goto <D.40830>; else goto <D.40831>;
    <D.40830>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40832>; else goto <D.40833>;
      <D.40832>:
      code.3795 = code;
      code = code.3795 + 1;
      D.40835 = _amd64_rex_bits | 64;
      *code.3795 = D.40835;
      <D.40833>:
    }
    code.3796 = code;
    code = code.3796 + 1;
    *code.3796 = 51;
    code.3797 = code;
    code = code.3797 + 1;
    *code.3797 = 192;
    goto <D.40838>;
    <D.40831>:
    {
      int _amd64_width_temp;

      D.40839 = (long unsigned int) nregs;
      nregs.3798 = (int) nregs;
      D.40841 = (long unsigned int) nregs.3798;
      D.40842 = D.40839 == D.40841;
      _amd64_width_temp = (int) D.40842;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.40844>; else goto <D.40845>;
        <D.40844>:
        iftmp.3799 = 8;
        goto <D.40846>;
        <D.40845>:
        iftmp.3799 = 0;
        <D.40846>:
        _amd64_rex_bits = iftmp.3799;
        if (_amd64_rex_bits != 0) goto <D.40847>; else goto <D.40848>;
        <D.40847>:
        code.3800 = code;
        code = code.3800 + 1;
        D.40850 = _amd64_rex_bits | 64;
        *code.3800 = D.40850;
        <D.40848>:
      }
      code.3801 = code;
      code = code.3801 + 1;
      *code.3801 = 184;
      if (_amd64_width_temp == 0) goto <D.40852>; else goto <D.40853>;
      <D.40852>:
      {
        union amd64_imm_buf imb;

        try
          {
            D.40839 = (long unsigned int) nregs;
            imb.val = D.40839;
            code.3802 = code;
            code = code.3802 + 1;
            D.40855 = imb.b[0];
            *code.3802 = D.40855;
            code.3803 = code;
            code = code.3803 + 1;
            D.40857 = imb.b[1];
            *code.3803 = D.40857;
            code.3804 = code;
            code = code.3804 + 1;
            D.40859 = imb.b[2];
            *code.3804 = D.40859;
            code.3805 = code;
            code = code.3805 + 1;
            D.40861 = imb.b[3];
            *code.3805 = D.40861;
            code.3806 = code;
            code = code.3806 + 1;
            D.40863 = imb.b[4];
            *code.3806 = D.40863;
            code.3807 = code;
            code = code.3807 + 1;
            D.40865 = imb.b[5];
            *code.3807 = D.40865;
            code.3808 = code;
            code = code.3808 + 1;
            D.40867 = imb.b[6];
            *code.3808 = D.40867;
            code.3809 = code;
            code = code.3809 + 1;
            D.40869 = imb.b[7];
            *code.3809 = D.40869;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.40870>;
      <D.40853>:
      {
        union x86_imm_buf imb;

        try
          {
            nregs.3798 = (int) nregs;
            imb.val = nregs.3798;
            code.3810 = code;
            code = code.3810 + 1;
            D.40872 = imb.b[0];
            *code.3810 = D.40872;
            code.3811 = code;
            code = code.3811 + 1;
            D.40874 = imb.b[1];
            *code.3811 = D.40874;
            code.3812 = code;
            code = code.3812 + 1;
            D.40876 = imb.b[2];
            *code.3812 = D.40876;
            code.3813 = code;
            code = code.3813 + 1;
            D.40878 = imb.b[3];
            *code.3813 = D.40878;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.40870>:
    }
    <D.40838>:
  }
  <D.40822>:
  <D.40817>:
  <D.40813>:
  D.36769 = ins->flags;
  D.36770 = (int) D.36769;
  D.36771 = D.36770 & 1;
  if (D.36771 != 0) goto <D.40879>; else goto <D.40880>;
  <D.40879>:
  D.40881 = call->method;
  code = emit_call (cfg, code, 3, D.40881, 0);
  goto <D.40882>;
  <D.40880>:
  D.40883 = call->fptr;
  code = emit_call (cfg, code, 1, D.40883, 0);
  <D.40882>:
  D.36769 = ins->flags;
  D.40583 = D.36769 | 128;
  ins->flags = D.40583;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  D.40884 = call->stack_usage;
  if (D.40884 != 0) goto <D.40885>; else goto <D.40886>;
  <D.40885>:
  D.40802 = call->signature;
  D.40887 = BIT_FIELD_REF <*D.40802, 8, 112>;
  D.40888 = D.40887 & 63;
  if (D.40888 != 2) goto <D.40889>; else goto <D.40890>;
  <D.40889>:
  D.40891 = cfg->arch.no_pushes;
  if (D.40891 == 0) goto <D.40892>; else goto <D.40893>;
  <D.40892>:
  D.40884 = call->stack_usage;
  D.40896 = (int) D.40884;
  if (D.40896 >= -128) goto <D.40897>; else goto <D.40894>;
  <D.40897>:
  D.40884 = call->stack_usage;
  D.40896 = (int) D.40884;
  if (D.40896 <= 127) goto <D.40898>; else goto <D.40894>;
  <D.40898>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.40899>; else goto <D.40900>;
    <D.40899>:
    code.3814 = code;
    code = code.3814 + 1;
    D.40902 = _amd64_rex_bits | 64;
    *code.3814 = D.40902;
    <D.40900>:
  }
  code.3815 = code;
  code = code.3815 + 1;
  *code.3815 = 131;
  code.3816 = code;
  code = code.3816 + 1;
  *code.3816 = 196;
  D.40884 = call->stack_usage;
  D.40905 = (unsigned char) D.40884;
  *code = D.40905;
  code = code + 1;
  goto <D.40895>;
  <D.40894>:
  if (0 != 0) goto <D.40906>; else goto <D.40907>;
  <D.40906>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.40908>; else goto <D.40909>;
    <D.40908>:
    code.3817 = code;
    code = code.3817 + 1;
    D.40911 = _amd64_rex_bits | 64;
    *code.3817 = D.40911;
    <D.40909>:
  }
  code.3818 = code;
  code = code.3818 + 1;
  *code.3818 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.40884 = call->stack_usage;
        D.40896 = (int) D.40884;
        imb.val = D.40896;
        code.3819 = code;
        code = code.3819 + 1;
        D.40914 = imb.b[0];
        *code.3819 = D.40914;
        code.3820 = code;
        code = code.3820 + 1;
        D.40916 = imb.b[1];
        *code.3820 = D.40916;
        code.3821 = code;
        code = code.3821 + 1;
        D.40918 = imb.b[2];
        *code.3821 = D.40918;
        code.3822 = code;
        code = code.3822 + 1;
        D.40920 = imb.b[3];
        *code.3822 = D.40920;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.40921>;
  <D.40907>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.40922>; else goto <D.40923>;
    <D.40922>:
    code.3823 = code;
    code = code.3823 + 1;
    D.40925 = _amd64_rex_bits | 64;
    *code.3823 = D.40925;
    <D.40923>:
  }
  code.3824 = code;
  code = code.3824 + 1;
  *code.3824 = 129;
  code.3825 = code;
  code = code.3825 + 1;
  *code.3825 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.40884 = call->stack_usage;
        D.40896 = (int) D.40884;
        imb.val = D.40896;
        code.3826 = code;
        code = code.3826 + 1;
        D.40929 = imb.b[0];
        *code.3826 = D.40929;
        code.3827 = code;
        code = code.3827 + 1;
        D.40931 = imb.b[1];
        *code.3827 = D.40931;
        code.3828 = code;
        code = code.3828 + 1;
        D.40933 = imb.b[2];
        *code.3828 = D.40933;
        code.3829 = code;
        code = code.3829 + 1;
        D.40935 = imb.b[3];
        *code.3829 = D.40935;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.40921>:
  <D.40895>:
  <D.40893>:
  <D.40890>:
  <D.40886>:
  code = emit_move_return_value (cfg, ins, code);
  goto <D.25197>;
  <D.26416>:
  <D.26417>:
  <D.26418>:
  <D.26419>:
  <D.26420>:
  <D.26421>:
  call = ins;
  D.31516 = ins->sreg1;
  D.40936 = 966 >> D.31516;
  D.40937 = D.40936 & 1;
  if (D.40937 != 0) goto <D.40938>; else goto <D.40939>;
  <D.40938>:
  if (0 != 0) goto <D.40940>; else goto <D.40941>;
  <D.40940>:
  code.3830 = code;
  code = code.3830 + 1;
  *code.3830 = 102;
  <D.40941>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.40944>; else goto <D.40945>;
    <D.40944>:
    iftmp.3831 = 13;
    goto <D.40946>;
    <D.40945>:
    iftmp.3831 = 12;
    <D.40946>:
    _amd64_rex_bits = iftmp.3831;
    if (_amd64_rex_bits != 0) goto <D.40947>; else goto <D.40948>;
    <D.40947>:
    code.3832 = code;
    code = code.3832 + 1;
    D.40950 = _amd64_rex_bits | 64;
    *code.3832 = D.40950;
    <D.40948>:
  }
  switch (8) <default: <D.26428>, case 1: <D.26423>, case 2: <D.26425>, case 4: <D.26426>, case 8: <D.26427>>
  <D.26423>:
  code.3833 = code;
  code = code.3833 + 1;
  *code.3833 = 138;
  goto <D.26424>;
  <D.26425>:
  <D.26426>:
  <D.26427>:
  code.3834 = code;
  code = code.3834 + 1;
  *code.3834 = 139;
  goto <D.26424>;
  <D.26428>:
  __assert_fail ("0", "mini-amd64.c", 4919, &__PRETTY_FUNCTION__);
  <D.26424>:
  code.3835 = code;
  code = code.3835 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39408 = D.31571 | -40;
  D.39409 = (unsigned char) D.39408;
  *code.3835 = D.39409;
  ins->sreg1 = 11;
  <D.40939>:
  D.40802 = call->signature;
  D.40803 = BIT_FIELD_REF <*D.40802, 16, 112>;
  D.40804 = D.40803 & 319;
  if (D.40804 == 261) goto <D.40954>; else goto <D.40955>;
  <D.40954>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.40956>; else goto <D.40957>;
  <D.40956>:
  if (0 != 0) goto <D.40958>; else goto <D.40959>;
  <D.40958>:
  code.3836 = code;
  code = code.3836 + 1;
  *code.3836 = 102;
  <D.40959>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 12;
    if (_amd64_rex_bits != 0) goto <D.40961>; else goto <D.40962>;
    <D.40961>:
    code.3837 = code;
    code = code.3837 + 1;
    D.40964 = _amd64_rex_bits | 64;
    *code.3837 = D.40964;
    <D.40962>:
  }
  switch (8) <default: <D.26435>, case 1: <D.26430>, case 2: <D.26432>, case 4: <D.26433>, case 8: <D.26434>>
  <D.26430>:
  code.3838 = code;
  code = code.3838 + 1;
  *code.3838 = 138;
  goto <D.26431>;
  <D.26432>:
  <D.26433>:
  <D.26434>:
  code.3839 = code;
  code = code.3839 + 1;
  *code.3839 = 139;
  goto <D.26431>;
  <D.26435>:
  __assert_fail ("0", "mini-amd64.c", 4928, &__PRETTY_FUNCTION__);
  <D.26431>:
  code.3840 = code;
  code = code.3840 + 1;
  *code.3840 = 216;
  ins->sreg1 = 11;
  <D.40957>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.40968>; else goto <D.40969>;
    <D.40968>:
    code.3841 = code;
    code = code.3841 + 1;
    D.40971 = _amd64_rex_bits | 64;
    *code.3841 = D.40971;
    <D.40969>:
  }
  code.3842 = code;
  code = code.3842 + 1;
  *code.3842 = 51;
  code.3843 = code;
  code = code.3843 + 1;
  *code.3843 = 192;
  goto <D.40974>;
  <D.40955>:
  D.31456 = cfg->method;
  D.40814 = BIT_FIELD_REF <*D.31456, 8, 256>;
  D.40815 = D.40814 & 124;
  if (D.40815 == 24) goto <D.40975>; else goto <D.40976>;
  <D.40975>:
  D.31456 = cfg->method;
  D.40818 = D.31456->klass;
  D.40819 = D.40818->image;
  D.40820 = mono_defaults.corlib;
  if (D.40819 != D.40820) goto <D.40977>; else goto <D.40978>;
  <D.40977>:
  {
    guint32 nregs;
    guint32 i;

    nregs = 0;
    i = 0;
    goto <D.26440>;
    <D.26439>:
    D.40823 = call->used_fregs;
    i.3844 = (int) i;
    D.40980 = 1 << i.3844;
    D.40981 = (long unsigned int) D.40980;
    D.40982 = D.40823 & D.40981;
    if (D.40982 != 0) goto <D.40983>; else goto <D.40984>;
    <D.40983>:
    nregs = nregs + 1;
    <D.40984>:
    i = i + 1;
    <D.26440>:
    if (i <= 15) goto <D.26439>; else goto <D.26441>;
    <D.26441>:
    D.31516 = ins->sreg1;
    if (D.31516 == 0) goto <D.40985>; else goto <D.40986>;
    <D.40985>:
    if (0 != 0) goto <D.40987>; else goto <D.40988>;
    <D.40987>:
    code.3845 = code;
    code = code.3845 + 1;
    *code.3845 = 102;
    <D.40988>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 12;
      if (_amd64_rex_bits != 0) goto <D.40990>; else goto <D.40991>;
      <D.40990>:
      code.3846 = code;
      code = code.3846 + 1;
      D.40993 = _amd64_rex_bits | 64;
      *code.3846 = D.40993;
      <D.40991>:
    }
    switch (8) <default: <D.26448>, case 1: <D.26443>, case 2: <D.26445>, case 4: <D.26446>, case 8: <D.26447>>
    <D.26443>:
    code.3847 = code;
    code = code.3847 + 1;
    *code.3847 = 138;
    goto <D.26444>;
    <D.26445>:
    <D.26446>:
    <D.26447>:
    code.3848 = code;
    code = code.3848 + 1;
    *code.3848 = 139;
    goto <D.26444>;
    <D.26448>:
    __assert_fail ("0", "mini-amd64.c", 4944, &__PRETTY_FUNCTION__);
    <D.26444>:
    code.3849 = code;
    code = code.3849 + 1;
    *code.3849 = 216;
    ins->sreg1 = 11;
    <D.40986>:
    if (nregs == 0) goto <D.40997>; else goto <D.40998>;
    <D.40997>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.40999>; else goto <D.41000>;
      <D.40999>:
      code.3850 = code;
      code = code.3850 + 1;
      D.41002 = _amd64_rex_bits | 64;
      *code.3850 = D.41002;
      <D.41000>:
    }
    code.3851 = code;
    code = code.3851 + 1;
    *code.3851 = 51;
    code.3852 = code;
    code = code.3852 + 1;
    *code.3852 = 192;
    goto <D.41005>;
    <D.40998>:
    {
      int _amd64_width_temp;

      D.41006 = (long unsigned int) nregs;
      nregs.3853 = (int) nregs;
      D.41008 = (long unsigned int) nregs.3853;
      D.41009 = D.41006 == D.41008;
      _amd64_width_temp = (int) D.41009;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.41011>; else goto <D.41012>;
        <D.41011>:
        iftmp.3854 = 8;
        goto <D.41013>;
        <D.41012>:
        iftmp.3854 = 0;
        <D.41013>:
        _amd64_rex_bits = iftmp.3854;
        if (_amd64_rex_bits != 0) goto <D.41014>; else goto <D.41015>;
        <D.41014>:
        code.3855 = code;
        code = code.3855 + 1;
        D.41017 = _amd64_rex_bits | 64;
        *code.3855 = D.41017;
        <D.41015>:
      }
      code.3856 = code;
      code = code.3856 + 1;
      *code.3856 = 184;
      if (_amd64_width_temp == 0) goto <D.41019>; else goto <D.41020>;
      <D.41019>:
      {
        union amd64_imm_buf imb;

        try
          {
            D.41006 = (long unsigned int) nregs;
            imb.val = D.41006;
            code.3857 = code;
            code = code.3857 + 1;
            D.41022 = imb.b[0];
            *code.3857 = D.41022;
            code.3858 = code;
            code = code.3858 + 1;
            D.41024 = imb.b[1];
            *code.3858 = D.41024;
            code.3859 = code;
            code = code.3859 + 1;
            D.41026 = imb.b[2];
            *code.3859 = D.41026;
            code.3860 = code;
            code = code.3860 + 1;
            D.41028 = imb.b[3];
            *code.3860 = D.41028;
            code.3861 = code;
            code = code.3861 + 1;
            D.41030 = imb.b[4];
            *code.3861 = D.41030;
            code.3862 = code;
            code = code.3862 + 1;
            D.41032 = imb.b[5];
            *code.3862 = D.41032;
            code.3863 = code;
            code = code.3863 + 1;
            D.41034 = imb.b[6];
            *code.3863 = D.41034;
            code.3864 = code;
            code = code.3864 + 1;
            D.41036 = imb.b[7];
            *code.3864 = D.41036;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41037>;
      <D.41020>:
      {
        union x86_imm_buf imb;

        try
          {
            nregs.3853 = (int) nregs;
            imb.val = nregs.3853;
            code.3865 = code;
            code = code.3865 + 1;
            D.41039 = imb.b[0];
            *code.3865 = D.41039;
            code.3866 = code;
            code = code.3866 + 1;
            D.41041 = imb.b[1];
            *code.3866 = D.41041;
            code.3867 = code;
            code = code.3867 + 1;
            D.41043 = imb.b[2];
            *code.3867 = D.41043;
            code.3868 = code;
            code = code.3868 + 1;
            D.41045 = imb.b[3];
            *code.3868 = D.41045;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.41037>:
    }
    <D.41005>:
  }
  <D.40978>:
  <D.40976>:
  <D.40974>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.41046>; else goto <D.41047>;
    <D.41046>:
    code.3869 = code;
    code = code.3869 + 1;
    D.41049 = _amd64_rex_bits | 64;
    *code.3869 = D.41049;
    <D.41047>:
  }
  code.3870 = code;
  code = code.3870 + 1;
  *code.3870 = 255;
  code.3871 = code;
  code = code.3871 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39416 = D.31571 | -48;
  D.39417 = (unsigned char) D.39416;
  *code.3871 = D.39417;
  D.36769 = ins->flags;
  D.40583 = D.36769 | 128;
  ins->flags = D.40583;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  D.40884 = call->stack_usage;
  if (D.40884 != 0) goto <D.41052>; else goto <D.41053>;
  <D.41052>:
  D.40802 = call->signature;
  D.40887 = BIT_FIELD_REF <*D.40802, 8, 112>;
  D.40888 = D.40887 & 63;
  if (D.40888 != 2) goto <D.41054>; else goto <D.41055>;
  <D.41054>:
  D.40891 = cfg->arch.no_pushes;
  if (D.40891 == 0) goto <D.41056>; else goto <D.41057>;
  <D.41056>:
  D.40884 = call->stack_usage;
  D.40896 = (int) D.40884;
  if (D.40896 >= -128) goto <D.41060>; else goto <D.41058>;
  <D.41060>:
  D.40884 = call->stack_usage;
  D.40896 = (int) D.40884;
  if (D.40896 <= 127) goto <D.41061>; else goto <D.41058>;
  <D.41061>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.41062>; else goto <D.41063>;
    <D.41062>:
    code.3872 = code;
    code = code.3872 + 1;
    D.41065 = _amd64_rex_bits | 64;
    *code.3872 = D.41065;
    <D.41063>:
  }
  code.3873 = code;
  code = code.3873 + 1;
  *code.3873 = 131;
  code.3874 = code;
  code = code.3874 + 1;
  *code.3874 = 196;
  D.40884 = call->stack_usage;
  D.40905 = (unsigned char) D.40884;
  *code = D.40905;
  code = code + 1;
  goto <D.41059>;
  <D.41058>:
  if (0 != 0) goto <D.41068>; else goto <D.41069>;
  <D.41068>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.41070>; else goto <D.41071>;
    <D.41070>:
    code.3875 = code;
    code = code.3875 + 1;
    D.41073 = _amd64_rex_bits | 64;
    *code.3875 = D.41073;
    <D.41071>:
  }
  code.3876 = code;
  code = code.3876 + 1;
  *code.3876 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.40884 = call->stack_usage;
        D.40896 = (int) D.40884;
        imb.val = D.40896;
        code.3877 = code;
        code = code.3877 + 1;
        D.41076 = imb.b[0];
        *code.3877 = D.41076;
        code.3878 = code;
        code = code.3878 + 1;
        D.41078 = imb.b[1];
        *code.3878 = D.41078;
        code.3879 = code;
        code = code.3879 + 1;
        D.41080 = imb.b[2];
        *code.3879 = D.41080;
        code.3880 = code;
        code = code.3880 + 1;
        D.41082 = imb.b[3];
        *code.3880 = D.41082;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.41083>;
  <D.41069>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.41084>; else goto <D.41085>;
    <D.41084>:
    code.3881 = code;
    code = code.3881 + 1;
    D.41087 = _amd64_rex_bits | 64;
    *code.3881 = D.41087;
    <D.41085>:
  }
  code.3882 = code;
  code = code.3882 + 1;
  *code.3882 = 129;
  code.3883 = code;
  code = code.3883 + 1;
  *code.3883 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.40884 = call->stack_usage;
        D.40896 = (int) D.40884;
        imb.val = D.40896;
        code.3884 = code;
        code = code.3884 + 1;
        D.41091 = imb.b[0];
        *code.3884 = D.41091;
        code.3885 = code;
        code = code.3885 + 1;
        D.41093 = imb.b[1];
        *code.3885 = D.41093;
        code.3886 = code;
        code = code.3886 + 1;
        D.41095 = imb.b[2];
        *code.3886 = D.41095;
        code.3887 = code;
        code = code.3887 + 1;
        D.41097 = imb.b[3];
        *code.3887 = D.41097;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41083>:
  <D.41059>:
  <D.41057>:
  <D.41055>:
  <D.41053>:
  code = emit_move_return_value (cfg, ins, code);
  goto <D.25197>;
  <D.26460>:
  <D.26461>:
  <D.26462>:
  <D.26463>:
  <D.26464>:
  <D.26465>:
  call = ins;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.41098>; else goto <D.41099>;
    <D.41098>:
    code.3888 = code;
    code = code.3888 + 1;
    D.41101 = _amd64_rex_bits | 64;
    *code.3888 = D.41101;
    <D.41099>:
  }
  code.3889 = code;
  code = code.3889 + 1;
  *code.3889 = 255;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.41103>; else goto <D.41104>;
  <D.41103>:
  code.3890 = code;
  code = code.3890 + 1;
  *code.3890 = 21;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.3891 = code;
        code = code.3891 + 1;
        D.41107 = imb.b[0];
        *code.3891 = D.41107;
        code.3892 = code;
        code = code.3892 + 1;
        D.41109 = imb.b[1];
        *code.3892 = D.41109;
        code.3893 = code;
        code = code.3893 + 1;
        D.41111 = imb.b[2];
        *code.3893 = D.41111;
        code.3894 = code;
        code = code.3894 + 1;
        D.41113 = imb.b[3];
        *code.3894 = D.41113;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.41114>;
  <D.41104>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.41115>; else goto <D.41116>;
  <D.41115>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.41117>; else goto <D.41118>;
  <D.41117>:
  code.3895 = code;
  code = code.3895 + 1;
  *code.3895 = 20;
  code.3896 = code;
  code = code.3896 + 1;
  *code.3896 = 36;
  goto <D.41121>;
  <D.41118>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.41122>; else goto <D.41123>;
  <D.41122>:
  code.3897 = code;
  code = code.3897 + 1;
  *code.3897 = 84;
  code.3898 = code;
  code = code.3898 + 1;
  *code.3898 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.41126>;
  <D.41123>:
  code.3899 = code;
  code = code.3899 + 1;
  *code.3899 = 148;
  code.3900 = code;
  code = code.3900 + 1;
  *code.3900 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.3901 = code;
        code = code.3901 + 1;
        D.41130 = imb.b[0];
        *code.3901 = D.41130;
        code.3902 = code;
        code = code.3902 + 1;
        D.41132 = imb.b[1];
        *code.3902 = D.41132;
        code.3903 = code;
        code = code.3903 + 1;
        D.41134 = imb.b[2];
        *code.3903 = D.41134;
        code.3904 = code;
        code = code.3904 + 1;
        D.41136 = imb.b[3];
        *code.3904 = D.41136;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41126>:
  <D.41121>:
  goto <D.26469>;
  <D.41116>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.41137>; else goto <D.41138>;
  <D.41137>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.41139>; else goto <D.41140>;
  <D.41139>:
  code.3905 = code;
  code = code.3905 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.41142 = D.31571 | 16;
  D.41143 = (unsigned char) D.41142;
  *code.3905 = D.41143;
  goto <D.26469>;
  <D.41140>:
  <D.41138>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.41144>; else goto <D.41145>;
  <D.41144>:
  code.3906 = code;
  code = code.3906 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.41147 = D.31571 | 80;
  D.41148 = (unsigned char) D.41147;
  *code.3906 = D.41148;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.41149>;
  <D.41145>:
  code.3907 = code;
  code = code.3907 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.41151 = D.31571 | -112;
  D.41152 = (unsigned char) D.41151;
  *code.3907 = D.41152;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.3908 = code;
        code = code.3908 + 1;
        D.41154 = imb.b[0];
        *code.3908 = D.41154;
        code.3909 = code;
        code = code.3909 + 1;
        D.41156 = imb.b[1];
        *code.3909 = D.41156;
        code.3910 = code;
        code = code.3910 + 1;
        D.41158 = imb.b[2];
        *code.3910 = D.41158;
        code.3911 = code;
        code = code.3911 + 1;
        D.41160 = imb.b[3];
        *code.3911 = D.41160;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41149>:
  <D.26469>:
  <D.41114>:
  D.36769 = ins->flags;
  D.40583 = D.36769 | 128;
  ins->flags = D.40583;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  D.40884 = call->stack_usage;
  if (D.40884 != 0) goto <D.41161>; else goto <D.41162>;
  <D.41161>:
  D.40802 = call->signature;
  D.40887 = BIT_FIELD_REF <*D.40802, 8, 112>;
  D.40888 = D.40887 & 63;
  if (D.40888 != 2) goto <D.41163>; else goto <D.41164>;
  <D.41163>:
  D.40891 = cfg->arch.no_pushes;
  if (D.40891 == 0) goto <D.41165>; else goto <D.41166>;
  <D.41165>:
  D.40884 = call->stack_usage;
  D.40896 = (int) D.40884;
  if (D.40896 >= -128) goto <D.41169>; else goto <D.41167>;
  <D.41169>:
  D.40884 = call->stack_usage;
  D.40896 = (int) D.40884;
  if (D.40896 <= 127) goto <D.41170>; else goto <D.41167>;
  <D.41170>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.41171>; else goto <D.41172>;
    <D.41171>:
    code.3912 = code;
    code = code.3912 + 1;
    D.41174 = _amd64_rex_bits | 64;
    *code.3912 = D.41174;
    <D.41172>:
  }
  code.3913 = code;
  code = code.3913 + 1;
  *code.3913 = 131;
  code.3914 = code;
  code = code.3914 + 1;
  *code.3914 = 196;
  D.40884 = call->stack_usage;
  D.40905 = (unsigned char) D.40884;
  *code = D.40905;
  code = code + 1;
  goto <D.41168>;
  <D.41167>:
  if (0 != 0) goto <D.41177>; else goto <D.41178>;
  <D.41177>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.41179>; else goto <D.41180>;
    <D.41179>:
    code.3915 = code;
    code = code.3915 + 1;
    D.41182 = _amd64_rex_bits | 64;
    *code.3915 = D.41182;
    <D.41180>:
  }
  code.3916 = code;
  code = code.3916 + 1;
  *code.3916 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.40884 = call->stack_usage;
        D.40896 = (int) D.40884;
        imb.val = D.40896;
        code.3917 = code;
        code = code.3917 + 1;
        D.41185 = imb.b[0];
        *code.3917 = D.41185;
        code.3918 = code;
        code = code.3918 + 1;
        D.41187 = imb.b[1];
        *code.3918 = D.41187;
        code.3919 = code;
        code = code.3919 + 1;
        D.41189 = imb.b[2];
        *code.3919 = D.41189;
        code.3920 = code;
        code = code.3920 + 1;
        D.41191 = imb.b[3];
        *code.3920 = D.41191;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.41192>;
  <D.41178>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.41193>; else goto <D.41194>;
    <D.41193>:
    code.3921 = code;
    code = code.3921 + 1;
    D.41196 = _amd64_rex_bits | 64;
    *code.3921 = D.41196;
    <D.41194>:
  }
  code.3922 = code;
  code = code.3922 + 1;
  *code.3922 = 129;
  code.3923 = code;
  code = code.3923 + 1;
  *code.3923 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.40884 = call->stack_usage;
        D.40896 = (int) D.40884;
        imb.val = D.40896;
        code.3924 = code;
        code = code.3924 + 1;
        D.41200 = imb.b[0];
        *code.3924 = D.41200;
        code.3925 = code;
        code = code.3925 + 1;
        D.41202 = imb.b[1];
        *code.3925 = D.41202;
        code.3926 = code;
        code = code.3926 + 1;
        D.41204 = imb.b[2];
        *code.3926 = D.41204;
        code.3927 = code;
        code = code.3927 + 1;
        D.41206 = imb.b[3];
        *code.3927 = D.41206;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41192>:
  <D.41168>:
  <D.41166>:
  <D.41164>:
  <D.41162>:
  code = emit_move_return_value (cfg, ins, code);
  goto <D.25197>;
  <D.26476>:
  {
    int i;
    struct MonoInst * var;

    var = cfg->dyn_call_var;
    D.41207 = var->opcode;
    D.41208 = D.41207 != 367;
    D.41209 = (long int) D.41208;
    D.41210 = __builtin_expect (D.41209, 0);
    if (D.41210 != 0) goto <D.41211>; else goto <D.41212>;
    <D.41211>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 4979, "var->opcode == OP_REGOFFSET");
    <D.41212>:
    if (0 != 0) goto <D.41213>; else goto <D.41214>;
    <D.41213>:
    code.3928 = code;
    code = code.3928 + 1;
    *code.3928 = 102;
    <D.41214>:
    {
      unsigned char _amd64_rex_bits;

      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.41217>; else goto <D.41218>;
      <D.41217>:
      iftmp.3929 = 13;
      goto <D.41219>;
      <D.41218>:
      iftmp.3929 = 12;
      <D.41219>:
      _amd64_rex_bits = iftmp.3929;
      if (_amd64_rex_bits != 0) goto <D.41220>; else goto <D.41221>;
      <D.41220>:
      code.3930 = code;
      code = code.3930 + 1;
      D.41223 = _amd64_rex_bits | 64;
      *code.3930 = D.41223;
      <D.41221>:
    }
    switch (8) <default: <D.26485>, case 1: <D.26480>, case 2: <D.26482>, case 4: <D.26483>, case 8: <D.26484>>
    <D.26480>:
    code.3931 = code;
    code = code.3931 + 1;
    *code.3931 = 138;
    goto <D.26481>;
    <D.26482>:
    <D.26483>:
    <D.26484>:
    code.3932 = code;
    code = code.3932 + 1;
    *code.3932 = 139;
    goto <D.26481>;
    <D.26485>:
    __assert_fail ("0", "mini-amd64.c", 4982, &__PRETTY_FUNCTION__);
    <D.26481>:
    code.3933 = code;
    code = code.3933 + 1;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.39408 = D.31571 | -40;
    D.39409 = (unsigned char) D.39408;
    *code.3933 = D.39409;
    if (0 != 0) goto <D.41227>; else goto <D.41228>;
    <D.41227>:
    code.3934 = code;
    code = code.3934 + 1;
    *code.3934 = 102;
    <D.41228>:
    {
      unsigned char _amd64_rex_bits;

      D.31490 = ins->sreg2;
      if (D.31490 > 7) goto <D.41231>; else goto <D.41232>;
      <D.41231>:
      iftmp.3935 = 13;
      goto <D.41233>;
      <D.41232>:
      iftmp.3935 = 12;
      <D.41233>:
      _amd64_rex_bits = iftmp.3935;
      if (_amd64_rex_bits != 0) goto <D.41234>; else goto <D.41235>;
      <D.41234>:
      code.3936 = code;
      code = code.3936 + 1;
      D.41237 = _amd64_rex_bits | 64;
      *code.3936 = D.41237;
      <D.41235>:
    }
    switch (8) <default: <D.26492>, case 1: <D.26487>, case 2: <D.26489>, case 4: <D.26490>, case 8: <D.26491>>
    <D.26487>:
    code.3937 = code;
    code = code.3937 + 1;
    *code.3937 = 138;
    goto <D.26488>;
    <D.26489>:
    <D.26490>:
    <D.26491>:
    code.3938 = code;
    code = code.3938 + 1;
    *code.3938 = 139;
    goto <D.26488>;
    <D.26492>:
    __assert_fail ("0", "mini-amd64.c", 4984, &__PRETTY_FUNCTION__);
    <D.26488>:
    code.3939 = code;
    code = code.3939 + 1;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.41241 = D.31501 | -48;
    D.41242 = (unsigned char) D.41241;
    *code.3939 = D.41242;
    if (0 != 0) goto <D.41243>; else goto <D.41244>;
    <D.41243>:
    code.3940 = code;
    code = code.3940 + 1;
    *code.3940 = 102;
    <D.41244>:
    {
      unsigned char _amd64_rex_bits;

      D.41247 = var->sreg1;
      if (D.41247 > 7) goto <D.41248>; else goto <D.41249>;
      <D.41248>:
      iftmp.3941 = 13;
      goto <D.41250>;
      <D.41249>:
      iftmp.3941 = 12;
      <D.41250>:
      _amd64_rex_bits = iftmp.3941;
      if (_amd64_rex_bits != 0) goto <D.41251>; else goto <D.41252>;
      <D.41251>:
      code.3942 = code;
      code = code.3942 + 1;
      D.41254 = _amd64_rex_bits | 64;
      *code.3942 = D.41254;
      <D.41252>:
    }
    switch (8) <default: <D.26499>, case 1: <D.26494>, case 2: <D.26496>, case 4: <D.26497>, case 8: <D.26498>>
    <D.26494>:
    code.3943 = code;
    code = code.3943 + 1;
    *code.3943 = 136;
    goto <D.26495>;
    <D.26496>:
    <D.26497>:
    <D.26498>:
    code.3944 = code;
    code = code.3944 + 1;
    *code.3944 = 137;
    goto <D.26495>;
    <D.26499>:
    __assert_fail ("0", "mini-amd64.c", 4987, &__PRETTY_FUNCTION__);
    <D.26495>:
    D.41247 = var->sreg1;
    D.41257 = D.41247 & 7;
    if (D.41257 == 4) goto <D.41258>; else goto <D.41259>;
    <D.41258>:
    D.41260 = var->data.op[0].const_val;
    if (D.41260 == 0) goto <D.41261>; else goto <D.41262>;
    <D.41261>:
    code.3945 = code;
    code = code.3945 + 1;
    *code.3945 = 28;
    code.3946 = code;
    code = code.3946 + 1;
    *code.3946 = 36;
    goto <D.41265>;
    <D.41262>:
    D.41260 = var->data.op[0].const_val;
    D.41266 = (unsigned int) D.41260;
    D.41267 = D.41266 + 128;
    if (D.41267 <= 255) goto <D.41268>; else goto <D.41269>;
    <D.41268>:
    code.3947 = code;
    code = code.3947 + 1;
    *code.3947 = 92;
    code.3948 = code;
    code = code.3948 + 1;
    *code.3948 = 36;
    D.41260 = var->data.op[0].const_val;
    D.41272 = (unsigned char) D.41260;
    *code = D.41272;
    code = code + 1;
    goto <D.41273>;
    <D.41269>:
    code.3949 = code;
    code = code.3949 + 1;
    *code.3949 = 156;
    code.3950 = code;
    code = code.3950 + 1;
    *code.3950 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.41260 = var->data.op[0].const_val;
          D.41276 = (int) D.41260;
          imb.val = D.41276;
          code.3951 = code;
          code = code.3951 + 1;
          D.41278 = imb.b[0];
          *code.3951 = D.41278;
          code.3952 = code;
          code = code.3952 + 1;
          D.41280 = imb.b[1];
          *code.3952 = D.41280;
          code.3953 = code;
          code = code.3953 + 1;
          D.41282 = imb.b[2];
          *code.3953 = D.41282;
          code.3954 = code;
          code = code.3954 + 1;
          D.41284 = imb.b[3];
          *code.3954 = D.41284;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41273>:
    <D.41265>:
    goto <D.26501>;
    <D.41259>:
    D.41260 = var->data.op[0].const_val;
    if (D.41260 == 0) goto <D.41285>; else goto <D.41286>;
    <D.41285>:
    D.41247 = var->sreg1;
    D.41257 = D.41247 & 7;
    if (D.41257 != 5) goto <D.41287>; else goto <D.41288>;
    <D.41287>:
    code.3955 = code;
    code = code.3955 + 1;
    D.41247 = var->sreg1;
    D.41290 = (signed char) D.41247;
    D.41291 = D.41290 & 7;
    D.41292 = D.41291 | 24;
    D.41293 = (unsigned char) D.41292;
    *code.3955 = D.41293;
    goto <D.26501>;
    <D.41288>:
    <D.41286>:
    D.41260 = var->data.op[0].const_val;
    D.41266 = (unsigned int) D.41260;
    D.41267 = D.41266 + 128;
    if (D.41267 <= 255) goto <D.41294>; else goto <D.41295>;
    <D.41294>:
    code.3956 = code;
    code = code.3956 + 1;
    D.41247 = var->sreg1;
    D.41290 = (signed char) D.41247;
    D.41291 = D.41290 & 7;
    D.41297 = D.41291 | 88;
    D.41298 = (unsigned char) D.41297;
    *code.3956 = D.41298;
    D.41260 = var->data.op[0].const_val;
    D.41272 = (unsigned char) D.41260;
    *code = D.41272;
    code = code + 1;
    goto <D.41299>;
    <D.41295>:
    code.3957 = code;
    code = code.3957 + 1;
    D.41247 = var->sreg1;
    D.41290 = (signed char) D.41247;
    D.41291 = D.41290 & 7;
    D.41301 = D.41291 | -104;
    D.41302 = (unsigned char) D.41301;
    *code.3957 = D.41302;
    {
      union x86_imm_buf imb;

      try
        {
          D.41260 = var->data.op[0].const_val;
          D.41276 = (int) D.41260;
          imb.val = D.41276;
          code.3958 = code;
          code = code.3958 + 1;
          D.41304 = imb.b[0];
          *code.3958 = D.41304;
          code.3959 = code;
          code = code.3959 + 1;
          D.41306 = imb.b[1];
          *code.3959 = D.41306;
          code.3960 = code;
          code = code.3960 + 1;
          D.41308 = imb.b[2];
          *code.3960 = D.41308;
          code.3961 = code;
          code = code.3961 + 1;
          D.41310 = imb.b[3];
          *code.3961 = D.41310;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41299>:
    <D.26501>:
    i = 0;
    goto <D.26515>;
    <D.26514>:
    if (0 != 0) goto <D.41311>; else goto <D.41312>;
    <D.41311>:
    code.3962 = code;
    code = code.3962 + 1;
    *code.3962 = 102;
    <D.41312>:
    {
      unsigned char _amd64_rex_bits;

      D.41315 = param_regs[i];
      if (D.41315 > 7) goto <D.41316>; else goto <D.41317>;
      <D.41316>:
      iftmp.3963 = 13;
      goto <D.41318>;
      <D.41317>:
      iftmp.3963 = 9;
      <D.41318>:
      _amd64_rex_bits = iftmp.3963;
      if (_amd64_rex_bits != 0) goto <D.41319>; else goto <D.41320>;
      <D.41319>:
      code.3964 = code;
      code = code.3964 + 1;
      D.41322 = _amd64_rex_bits | 64;
      *code.3964 = D.41322;
      <D.41320>:
    }
    switch (8) <default: <D.26509>, case 1: <D.26504>, case 2: <D.26506>, case 4: <D.26507>, case 8: <D.26508>>
    <D.26504>:
    code.3965 = code;
    code = code.3965 + 1;
    *code.3965 = 138;
    goto <D.26505>;
    <D.26506>:
    <D.26507>:
    <D.26508>:
    code.3966 = code;
    code = code.3966 + 1;
    *code.3966 = 139;
    goto <D.26505>;
    <D.26509>:
    __assert_fail ("0", "mini-amd64.c", 4991, &__PRETTY_FUNCTION__);
    <D.26505>:
    if (0 != 0) goto <D.41325>; else goto <D.41326>;
    <D.41325>:
    code.3967 = code;
    code = code.3967 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41331 = D.41330 | 5;
    *code.3967 = D.41331;
    {
      union x86_imm_buf imb;

      try
        {
          i.3968 = (unsigned int) i;
          D.41333 = i.3968 * 8;
          D.41334 = (int) D.41333;
          imb.val = D.41334;
          code.3969 = code;
          code = code.3969 + 1;
          D.41336 = imb.b[0];
          *code.3969 = D.41336;
          code.3970 = code;
          code = code.3970 + 1;
          D.41338 = imb.b[1];
          *code.3970 = D.41338;
          code.3971 = code;
          code = code.3971 + 1;
          D.41340 = imb.b[2];
          *code.3971 = D.41340;
          code.3972 = code;
          code = code.3972 + 1;
          D.41342 = imb.b[3];
          *code.3972 = D.41342;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.41343>;
    <D.41326>:
    if (0 != 0) goto <D.41344>; else goto <D.41345>;
    <D.41344>:
    D.41346 = (long unsigned int) i;
    D.41347 = D.41346 * 8;
    if (D.41347 == 0) goto <D.41348>; else goto <D.41349>;
    <D.41348>:
    code.3973 = code;
    code = code.3973 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41351 = D.41330 | 4;
    *code.3973 = D.41351;
    code.3974 = code;
    code = code.3974 + 1;
    *code.3974 = 36;
    goto <D.41353>;
    <D.41349>:
    i.3968 = (unsigned int) i;
    D.41333 = i.3968 * 8;
    D.41334 = (int) D.41333;
    if (D.41334 >= -128) goto <D.41356>; else goto <D.41354>;
    <D.41356>:
    i.3968 = (unsigned int) i;
    D.41333 = i.3968 * 8;
    D.41334 = (int) D.41333;
    if (D.41334 <= 127) goto <D.41357>; else goto <D.41354>;
    <D.41357>:
    code.3975 = code;
    code = code.3975 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41359 = D.41330 | 68;
    *code.3975 = D.41359;
    code.3976 = code;
    code = code.3976 + 1;
    *code.3976 = 36;
    D.41346 = (long unsigned int) i;
    D.41361 = (unsigned char) D.41346;
    D.41362 = D.41361 * 8;
    *code = D.41362;
    code = code + 1;
    goto <D.41355>;
    <D.41354>:
    code.3977 = code;
    code = code.3977 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41364 = D.41330 | 132;
    *code.3977 = D.41364;
    code.3978 = code;
    code = code.3978 + 1;
    *code.3978 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          i.3968 = (unsigned int) i;
          D.41333 = i.3968 * 8;
          D.41334 = (int) D.41333;
          imb.val = D.41334;
          code.3979 = code;
          code = code.3979 + 1;
          D.41367 = imb.b[0];
          *code.3979 = D.41367;
          code.3980 = code;
          code = code.3980 + 1;
          D.41369 = imb.b[1];
          *code.3980 = D.41369;
          code.3981 = code;
          code = code.3981 + 1;
          D.41371 = imb.b[2];
          *code.3981 = D.41371;
          code.3982 = code;
          code = code.3982 + 1;
          D.41373 = imb.b[3];
          *code.3982 = D.41373;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41355>:
    <D.41353>:
    goto <D.26512>;
    <D.41345>:
    D.41346 = (long unsigned int) i;
    D.41347 = D.41346 * 8;
    if (D.41347 == 0) goto <D.41374>; else goto <D.41375>;
    <D.41374>:
    code.3983 = code;
    code = code.3983 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41377 = D.41330 | 3;
    *code.3983 = D.41377;
    goto <D.26512>;
    <D.41375>:
    i.3968 = (unsigned int) i;
    D.41333 = i.3968 * 8;
    D.41334 = (int) D.41333;
    if (D.41334 >= -128) goto <D.41380>; else goto <D.41378>;
    <D.41380>:
    i.3968 = (unsigned int) i;
    D.41333 = i.3968 * 8;
    D.41334 = (int) D.41333;
    if (D.41334 <= 127) goto <D.41381>; else goto <D.41378>;
    <D.41381>:
    code.3984 = code;
    code = code.3984 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41383 = D.41330 | 67;
    *code.3984 = D.41383;
    D.41346 = (long unsigned int) i;
    D.41361 = (unsigned char) D.41346;
    D.41362 = D.41361 * 8;
    *code = D.41362;
    code = code + 1;
    goto <D.41379>;
    <D.41378>:
    code.3985 = code;
    code = code.3985 + 1;
    D.41315 = param_regs[i];
    D.41328 = (unsigned char) D.41315;
    D.41329 = D.41328 & 7;
    D.41330 = D.41329 << 3;
    D.41385 = D.41330 | 131;
    *code.3985 = D.41385;
    {
      union x86_imm_buf imb;

      try
        {
          i.3968 = (unsigned int) i;
          D.41333 = i.3968 * 8;
          D.41334 = (int) D.41333;
          imb.val = D.41334;
          code.3986 = code;
          code = code.3986 + 1;
          D.41387 = imb.b[0];
          *code.3986 = D.41387;
          code.3987 = code;
          code = code.3987 + 1;
          D.41389 = imb.b[1];
          *code.3987 = D.41389;
          code.3988 = code;
          code = code.3988 + 1;
          D.41391 = imb.b[2];
          *code.3988 = D.41391;
          code.3989 = code;
          code = code.3989 + 1;
          D.41393 = imb.b[3];
          *code.3989 = D.41393;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41379>:
    <D.26512>:
    <D.41343>:
    i = i + 1;
    <D.26515>:
    if (i <= 5) goto <D.26514>; else goto <D.26516>;
    <D.26516>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 1;
      if (_amd64_rex_bits != 0) goto <D.41394>; else goto <D.41395>;
      <D.41394>:
      code.3990 = code;
      code = code.3990 + 1;
      D.41397 = _amd64_rex_bits | 64;
      *code.3990 = D.41397;
      <D.41395>:
    }
    code.3991 = code;
    code = code.3991 + 1;
    *code.3991 = 255;
    code.3992 = code;
    code = code.3992 + 1;
    *code.3992 = 210;
    D.36769 = ins->flags;
    D.40583 = D.36769 | 128;
    ins->flags = D.40583;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    ins->backend.pc_offset = D.36947;
    if (0 != 0) goto <D.41400>; else goto <D.41401>;
    <D.41400>:
    code.3993 = code;
    code = code.3993 + 1;
    *code.3993 = 102;
    <D.41401>:
    {
      unsigned char _amd64_rex_bits;

      D.41247 = var->sreg1;
      if (D.41247 > 7) goto <D.41404>; else goto <D.41405>;
      <D.41404>:
      iftmp.3994 = 13;
      goto <D.41406>;
      <D.41405>:
      iftmp.3994 = 12;
      <D.41406>:
      _amd64_rex_bits = iftmp.3994;
      if (_amd64_rex_bits != 0) goto <D.41407>; else goto <D.41408>;
      <D.41407>:
      code.3995 = code;
      code = code.3995 + 1;
      D.41410 = _amd64_rex_bits | 64;
      *code.3995 = D.41410;
      <D.41408>:
    }
    switch (8) <default: <D.26524>, case 1: <D.26519>, case 2: <D.26521>, case 4: <D.26522>, case 8: <D.26523>>
    <D.26519>:
    code.3996 = code;
    code = code.3996 + 1;
    *code.3996 = 138;
    goto <D.26520>;
    <D.26521>:
    <D.26522>:
    <D.26523>:
    code.3997 = code;
    code = code.3997 + 1;
    *code.3997 = 139;
    goto <D.26520>;
    <D.26524>:
    __assert_fail ("0", "mini-amd64.c", 5000, &__PRETTY_FUNCTION__);
    <D.26520>:
    D.41247 = var->sreg1;
    if (D.41247 == 16) goto <D.41413>; else goto <D.41414>;
    <D.41413>:
    code.3998 = code;
    code = code.3998 + 1;
    *code.3998 = 29;
    {
      union x86_imm_buf imb;

      try
        {
          D.41260 = var->data.op[0].const_val;
          D.41276 = (int) D.41260;
          imb.val = D.41276;
          code.3999 = code;
          code = code.3999 + 1;
          D.41417 = imb.b[0];
          *code.3999 = D.41417;
          code.4000 = code;
          code = code.4000 + 1;
          D.41419 = imb.b[1];
          *code.4000 = D.41419;
          code.4001 = code;
          code = code.4001 + 1;
          D.41421 = imb.b[2];
          *code.4001 = D.41421;
          code.4002 = code;
          code = code.4002 + 1;
          D.41423 = imb.b[3];
          *code.4002 = D.41423;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.41424>;
    <D.41414>:
    D.41247 = var->sreg1;
    D.41257 = D.41247 & 7;
    if (D.41257 == 4) goto <D.41425>; else goto <D.41426>;
    <D.41425>:
    D.41260 = var->data.op[0].const_val;
    if (D.41260 == 0) goto <D.41427>; else goto <D.41428>;
    <D.41427>:
    code.4003 = code;
    code = code.4003 + 1;
    *code.4003 = 28;
    code.4004 = code;
    code = code.4004 + 1;
    *code.4004 = 36;
    goto <D.41431>;
    <D.41428>:
    D.41260 = var->data.op[0].const_val;
    D.41266 = (unsigned int) D.41260;
    D.41267 = D.41266 + 128;
    if (D.41267 <= 255) goto <D.41432>; else goto <D.41433>;
    <D.41432>:
    code.4005 = code;
    code = code.4005 + 1;
    *code.4005 = 92;
    code.4006 = code;
    code = code.4006 + 1;
    *code.4006 = 36;
    D.41260 = var->data.op[0].const_val;
    D.41272 = (unsigned char) D.41260;
    *code = D.41272;
    code = code + 1;
    goto <D.41436>;
    <D.41433>:
    code.4007 = code;
    code = code.4007 + 1;
    *code.4007 = 156;
    code.4008 = code;
    code = code.4008 + 1;
    *code.4008 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.41260 = var->data.op[0].const_val;
          D.41276 = (int) D.41260;
          imb.val = D.41276;
          code.4009 = code;
          code = code.4009 + 1;
          D.41440 = imb.b[0];
          *code.4009 = D.41440;
          code.4010 = code;
          code = code.4010 + 1;
          D.41442 = imb.b[1];
          *code.4010 = D.41442;
          code.4011 = code;
          code = code.4011 + 1;
          D.41444 = imb.b[2];
          *code.4011 = D.41444;
          code.4012 = code;
          code = code.4012 + 1;
          D.41446 = imb.b[3];
          *code.4012 = D.41446;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41436>:
    <D.41431>:
    goto <D.26527>;
    <D.41426>:
    D.41260 = var->data.op[0].const_val;
    if (D.41260 == 0) goto <D.41447>; else goto <D.41448>;
    <D.41447>:
    D.41247 = var->sreg1;
    D.41257 = D.41247 & 7;
    if (D.41257 != 5) goto <D.41449>; else goto <D.41450>;
    <D.41449>:
    code.4013 = code;
    code = code.4013 + 1;
    D.41247 = var->sreg1;
    D.41290 = (signed char) D.41247;
    D.41291 = D.41290 & 7;
    D.41292 = D.41291 | 24;
    D.41293 = (unsigned char) D.41292;
    *code.4013 = D.41293;
    goto <D.26527>;
    <D.41450>:
    <D.41448>:
    D.41260 = var->data.op[0].const_val;
    D.41266 = (unsigned int) D.41260;
    D.41267 = D.41266 + 128;
    if (D.41267 <= 255) goto <D.41452>; else goto <D.41453>;
    <D.41452>:
    code.4014 = code;
    code = code.4014 + 1;
    D.41247 = var->sreg1;
    D.41290 = (signed char) D.41247;
    D.41291 = D.41290 & 7;
    D.41297 = D.41291 | 88;
    D.41298 = (unsigned char) D.41297;
    *code.4014 = D.41298;
    D.41260 = var->data.op[0].const_val;
    D.41272 = (unsigned char) D.41260;
    *code = D.41272;
    code = code + 1;
    goto <D.41455>;
    <D.41453>:
    code.4015 = code;
    code = code.4015 + 1;
    D.41247 = var->sreg1;
    D.41290 = (signed char) D.41247;
    D.41291 = D.41290 & 7;
    D.41301 = D.41291 | -104;
    D.41302 = (unsigned char) D.41301;
    *code.4015 = D.41302;
    {
      union x86_imm_buf imb;

      try
        {
          D.41260 = var->data.op[0].const_val;
          D.41276 = (int) D.41260;
          imb.val = D.41276;
          code.4016 = code;
          code = code.4016 + 1;
          D.41458 = imb.b[0];
          *code.4016 = D.41458;
          code.4017 = code;
          code = code.4017 + 1;
          D.41460 = imb.b[1];
          *code.4017 = D.41460;
          code.4018 = code;
          code = code.4018 + 1;
          D.41462 = imb.b[2];
          *code.4018 = D.41462;
          code.4019 = code;
          code = code.4019 + 1;
          D.41464 = imb.b[3];
          *code.4019 = D.41464;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41455>:
    <D.26527>:
    <D.41424>:
    if (0 != 0) goto <D.41465>; else goto <D.41466>;
    <D.41465>:
    code.4020 = code;
    code = code.4020 + 1;
    *code.4020 = 102;
    <D.41466>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 9;
      if (_amd64_rex_bits != 0) goto <D.41468>; else goto <D.41469>;
      <D.41468>:
      code.4021 = code;
      code = code.4021 + 1;
      D.41471 = _amd64_rex_bits | 64;
      *code.4021 = D.41471;
      <D.41469>:
    }
    switch (8) <default: <D.26535>, case 1: <D.26530>, case 2: <D.26532>, case 4: <D.26533>, case 8: <D.26534>>
    <D.26530>:
    code.4022 = code;
    code = code.4022 + 1;
    *code.4022 = 136;
    goto <D.26531>;
    <D.26532>:
    <D.26533>:
    <D.26534>:
    code.4023 = code;
    code = code.4023 + 1;
    *code.4023 = 137;
    goto <D.26531>;
    <D.26535>:
    __assert_fail ("0", "mini-amd64.c", 5001, &__PRETTY_FUNCTION__);
    <D.26531>:
    if (0 != 0) goto <D.41474>; else goto <D.41475>;
    <D.41474>:
    if (0 != 0) goto <D.41476>; else goto <D.41477>;
    <D.41476>:
    code.4024 = code;
    code = code.4024 + 1;
    *code.4024 = 4;
    code.4025 = code;
    code = code.4025 + 1;
    *code.4025 = 36;
    goto <D.41480>;
    <D.41477>:
    if (1 != 0) goto <D.41481>; else goto <D.41482>;
    <D.41481>:
    code.4026 = code;
    code = code.4026 + 1;
    *code.4026 = 68;
    code.4027 = code;
    code = code.4027 + 1;
    *code.4027 = 36;
    *code = 48;
    code = code + 1;
    goto <D.41485>;
    <D.41482>:
    code.4028 = code;
    code = code.4028 + 1;
    *code.4028 = 132;
    code.4029 = code;
    code = code.4029 + 1;
    *code.4029 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 48;
          code.4030 = code;
          code = code.4030 + 1;
          D.41489 = imb.b[0];
          *code.4030 = D.41489;
          code.4031 = code;
          code = code.4031 + 1;
          D.41491 = imb.b[1];
          *code.4031 = D.41491;
          code.4032 = code;
          code = code.4032 + 1;
          D.41493 = imb.b[2];
          *code.4032 = D.41493;
          code.4033 = code;
          code = code.4033 + 1;
          D.41495 = imb.b[3];
          *code.4033 = D.41495;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41485>:
    <D.41480>:
    goto <D.26537>;
    <D.41475>:
    if (0 != 0) goto <D.41496>; else goto <D.41497>;
    <D.41496>:
    code.4034 = code;
    code = code.4034 + 1;
    *code.4034 = 3;
    goto <D.26537>;
    <D.41497>:
    if (1 != 0) goto <D.41499>; else goto <D.41500>;
    <D.41499>:
    code.4035 = code;
    code = code.4035 + 1;
    *code.4035 = 67;
    *code = 48;
    code = code + 1;
    goto <D.41502>;
    <D.41500>:
    code.4036 = code;
    code = code.4036 + 1;
    *code.4036 = 131;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 48;
          code.4037 = code;
          code = code.4037 + 1;
          D.41505 = imb.b[0];
          *code.4037 = D.41505;
          code.4038 = code;
          code = code.4038 + 1;
          D.41507 = imb.b[1];
          *code.4038 = D.41507;
          code.4039 = code;
          code = code.4039 + 1;
          D.41509 = imb.b[2];
          *code.4039 = D.41509;
          code.4040 = code;
          code = code.4040 + 1;
          D.41511 = imb.b[3];
          *code.4040 = D.41511;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41502>:
    <D.26537>:
    goto <D.25197>;
  }
  <D.26539>:
  {
    struct MonoInst * lmf_var;

    lmf_var = cfg->lmf_var;
    if (0 != 0) goto <D.41512>; else goto <D.41513>;
    <D.41512>:
    code.4041 = code;
    code = code.4041 + 1;
    *code.4041 = 102;
    <D.41513>:
    {
      unsigned char _amd64_rex_bits;

      D.41516 = lmf_var->sreg1;
      if (D.41516 > 7) goto <D.41517>; else goto <D.41518>;
      <D.41517>:
      iftmp.4042 = 9;
      goto <D.41519>;
      <D.41518>:
      iftmp.4042 = 8;
      <D.41519>:
      _amd64_rex_bits = iftmp.4042;
      if (_amd64_rex_bits != 0) goto <D.41520>; else goto <D.41521>;
      <D.41520>:
      code.4043 = code;
      code = code.4043 + 1;
      D.41523 = _amd64_rex_bits | 64;
      *code.4043 = D.41523;
      <D.41521>:
    }
    switch (8) <default: <D.26547>, case 1: <D.26542>, case 2: <D.26544>, case 4: <D.26545>, case 8: <D.26546>>
    <D.26542>:
    code.4044 = code;
    code = code.4044 + 1;
    *code.4044 = 136;
    goto <D.26543>;
    <D.26544>:
    <D.26545>:
    <D.26546>:
    code.4045 = code;
    code = code.4045 + 1;
    *code.4045 = 137;
    goto <D.26543>;
    <D.26547>:
    __assert_fail ("0", "mini-amd64.c", 5006, &__PRETTY_FUNCTION__);
    <D.26543>:
    D.41516 = lmf_var->sreg1;
    D.41526 = D.41516 & 7;
    if (D.41526 == 4) goto <D.41527>; else goto <D.41528>;
    <D.41527>:
    D.41529 = lmf_var->data.op[0].const_val;
    if (D.41529 == -32) goto <D.41530>; else goto <D.41531>;
    <D.41530>:
    code.4046 = code;
    code = code.4046 + 1;
    *code.4046 = 36;
    code.4047 = code;
    code = code.4047 + 1;
    *code.4047 = 36;
    goto <D.41534>;
    <D.41531>:
    D.41529 = lmf_var->data.op[0].const_val;
    D.41537 = (unsigned int) D.41529;
    D.41538 = D.41537 + 32;
    D.41539 = (int) D.41538;
    if (D.41539 >= -128) goto <D.41540>; else goto <D.41535>;
    <D.41540>:
    D.41529 = lmf_var->data.op[0].const_val;
    D.41537 = (unsigned int) D.41529;
    D.41538 = D.41537 + 32;
    D.41539 = (int) D.41538;
    if (D.41539 <= 127) goto <D.41541>; else goto <D.41535>;
    <D.41541>:
    code.4048 = code;
    code = code.4048 + 1;
    *code.4048 = 100;
    code.4049 = code;
    code = code.4049 + 1;
    *code.4049 = 36;
    D.41529 = lmf_var->data.op[0].const_val;
    D.41544 = (unsigned char) D.41529;
    D.41545 = D.41544 + 32;
    *code = D.41545;
    code = code + 1;
    goto <D.41536>;
    <D.41535>:
    code.4050 = code;
    code = code.4050 + 1;
    *code.4050 = 164;
    code.4051 = code;
    code = code.4051 + 1;
    *code.4051 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.41529 = lmf_var->data.op[0].const_val;
          D.41537 = (unsigned int) D.41529;
          D.41538 = D.41537 + 32;
          D.41539 = (int) D.41538;
          imb.val = D.41539;
          code.4052 = code;
          code = code.4052 + 1;
          D.41549 = imb.b[0];
          *code.4052 = D.41549;
          code.4053 = code;
          code = code.4053 + 1;
          D.41551 = imb.b[1];
          *code.4053 = D.41551;
          code.4054 = code;
          code = code.4054 + 1;
          D.41553 = imb.b[2];
          *code.4054 = D.41553;
          code.4055 = code;
          code = code.4055 + 1;
          D.41555 = imb.b[3];
          *code.4055 = D.41555;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41536>:
    <D.41534>:
    goto <D.26549>;
    <D.41528>:
    D.41529 = lmf_var->data.op[0].const_val;
    if (D.41529 == -32) goto <D.41556>; else goto <D.41557>;
    <D.41556>:
    D.41516 = lmf_var->sreg1;
    D.41526 = D.41516 & 7;
    if (D.41526 != 5) goto <D.41558>; else goto <D.41559>;
    <D.41558>:
    code.4056 = code;
    code = code.4056 + 1;
    D.41516 = lmf_var->sreg1;
    D.41561 = (signed char) D.41516;
    D.41562 = D.41561 & 7;
    D.41563 = D.41562 | 32;
    D.41564 = (unsigned char) D.41563;
    *code.4056 = D.41564;
    goto <D.26549>;
    <D.41559>:
    <D.41557>:
    D.41529 = lmf_var->data.op[0].const_val;
    D.41537 = (unsigned int) D.41529;
    D.41538 = D.41537 + 32;
    D.41539 = (int) D.41538;
    if (D.41539 >= -128) goto <D.41567>; else goto <D.41565>;
    <D.41567>:
    D.41529 = lmf_var->data.op[0].const_val;
    D.41537 = (unsigned int) D.41529;
    D.41538 = D.41537 + 32;
    D.41539 = (int) D.41538;
    if (D.41539 <= 127) goto <D.41568>; else goto <D.41565>;
    <D.41568>:
    code.4057 = code;
    code = code.4057 + 1;
    D.41516 = lmf_var->sreg1;
    D.41561 = (signed char) D.41516;
    D.41562 = D.41561 & 7;
    D.41570 = D.41562 | 96;
    D.41571 = (unsigned char) D.41570;
    *code.4057 = D.41571;
    D.41529 = lmf_var->data.op[0].const_val;
    D.41544 = (unsigned char) D.41529;
    D.41545 = D.41544 + 32;
    *code = D.41545;
    code = code + 1;
    goto <D.41566>;
    <D.41565>:
    code.4058 = code;
    code = code.4058 + 1;
    D.41516 = lmf_var->sreg1;
    D.41561 = (signed char) D.41516;
    D.41562 = D.41561 & 7;
    D.41573 = D.41562 | -96;
    D.41574 = (unsigned char) D.41573;
    *code.4058 = D.41574;
    {
      union x86_imm_buf imb;

      try
        {
          D.41529 = lmf_var->data.op[0].const_val;
          D.41537 = (unsigned int) D.41529;
          D.41538 = D.41537 + 32;
          D.41539 = (int) D.41538;
          imb.val = D.41539;
          code.4059 = code;
          code = code.4059 + 1;
          D.41576 = imb.b[0];
          *code.4059 = D.41576;
          code.4060 = code;
          code = code.4060 + 1;
          D.41578 = imb.b[1];
          *code.4060 = D.41578;
          code.4061 = code;
          code = code.4061 + 1;
          D.41580 = imb.b[2];
          *code.4061 = D.41580;
          code.4062 = code;
          code = code.4062 + 1;
          D.41582 = imb.b[3];
          *code.4062 = D.41582;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41566>:
    <D.26549>:
    goto <D.25197>;
  }
  <D.26551>:
  D.40891 = cfg->arch.no_pushes;
  D.41583 = D.40891 != 0;
  D.41584 = (long int) D.41583;
  D.41585 = __builtin_expect (D.41584, 0);
  if (D.41585 != 0) goto <D.41586>; else goto <D.41587>;
  <D.41586>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5010, "!cfg->arch.no_pushes");
  <D.41587>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.41588>; else goto <D.41589>;
    <D.41588>:
    code.4063 = code;
    code = code.4063 + 1;
    D.41591 = _amd64_rex_bits | 64;
    *code.4063 = D.41591;
    <D.41589>:
  }
  code.4064 = code;
  code = code.4064 + 1;
  D.31516 = ins->sreg1;
  D.31565 = (unsigned char) D.31516;
  D.31566 = D.31565 & 7;
  D.41593 = D.31566 + 80;
  *code.4064 = D.41593;
  goto <D.25197>;
  <D.26553>:
  D.40891 = cfg->arch.no_pushes;
  D.41583 = D.40891 != 0;
  D.41584 = (long int) D.41583;
  D.41585 = __builtin_expect (D.41584, 0);
  if (D.41585 != 0) goto <D.41594>; else goto <D.41595>;
  <D.41594>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5014, "!cfg->arch.no_pushes");
  <D.41595>:
  D.31647 = ins->data.op[1].const_val;
  D.32320 = (unsigned long) D.31647;
  D.32321 = D.32320 + 2147483648;
  D.32322 = D.32321 > 4294967295;
  D.32323 = (long int) D.32322;
  D.32324 = __builtin_expect (D.32323, 0);
  if (D.32324 != 0) goto <D.41596>; else goto <D.41597>;
  <D.41596>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5015, "amd64_is_imm32 (ins->inst_imm)");
  <D.41597>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.41598>; else goto <D.41599>;
    <D.41598>:
    code.4065 = code;
    code = code.4065 + 1;
    D.41601 = _amd64_rex_bits | 64;
    *code.4065 = D.41601;
    <D.41599>:
  }
  {
    int _imm;

    D.31647 = ins->data.op[1].const_val;
    _imm = (int) D.31647;
    _imm.4066 = (unsigned int) _imm;
    D.41603 = _imm.4066 + 128;
    if (D.41603 <= 255) goto <D.41604>; else goto <D.41605>;
    <D.41604>:
    code.4067 = code;
    code = code.4067 + 1;
    *code.4067 = 106;
    D.41607 = (unsigned char) _imm;
    *code = D.41607;
    code = code + 1;
    goto <D.41608>;
    <D.41605>:
    code.4068 = code;
    code = code.4068 + 1;
    *code.4068 = 104;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = _imm;
          code.4069 = code;
          code = code.4069 + 1;
          D.41611 = imb.b[0];
          *code.4069 = D.41611;
          code.4070 = code;
          code = code.4070 + 1;
          D.41613 = imb.b[1];
          *code.4070 = D.41613;
          code.4071 = code;
          code = code.4071 + 1;
          D.41615 = imb.b[2];
          *code.4071 = D.41615;
          code.4072 = code;
          code = code.4072 + 1;
          D.41617 = imb.b[3];
          *code.4072 = D.41617;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41608>:
  }
  goto <D.25197>;
  <D.26557>:
  D.40891 = cfg->arch.no_pushes;
  D.41583 = D.40891 != 0;
  D.41584 = (long int) D.41583;
  D.41585 = __builtin_expect (D.41584, 0);
  if (D.41585 != 0) goto <D.41618>; else goto <D.41619>;
  <D.41618>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5019, "!cfg->arch.no_pushes");
  <D.41619>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.41620>; else goto <D.41621>;
    <D.41620>:
    code.4073 = code;
    code = code.4073 + 1;
    D.41623 = _amd64_rex_bits | 64;
    *code.4073 = D.41623;
    <D.41621>:
  }
  code.4074 = code;
  code = code.4074 + 1;
  *code.4074 = 255;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.41625>; else goto <D.41626>;
  <D.41625>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.41627>; else goto <D.41628>;
  <D.41627>:
  code.4075 = code;
  code = code.4075 + 1;
  *code.4075 = 52;
  code.4076 = code;
  code = code.4076 + 1;
  *code.4076 = 36;
  goto <D.41631>;
  <D.41628>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.41632>; else goto <D.41633>;
  <D.41632>:
  code.4077 = code;
  code = code.4077 + 1;
  *code.4077 = 116;
  code.4078 = code;
  code = code.4078 + 1;
  *code.4078 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.41636>;
  <D.41633>:
  code.4079 = code;
  code = code.4079 + 1;
  *code.4079 = 180;
  code.4080 = code;
  code = code.4080 + 1;
  *code.4080 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4081 = code;
        code = code.4081 + 1;
        D.41640 = imb.b[0];
        *code.4081 = D.41640;
        code.4082 = code;
        code = code.4082 + 1;
        D.41642 = imb.b[1];
        *code.4082 = D.41642;
        code.4083 = code;
        code = code.4083 + 1;
        D.41644 = imb.b[2];
        *code.4083 = D.41644;
        code.4084 = code;
        code = code.4084 + 1;
        D.41646 = imb.b[3];
        *code.4084 = D.41646;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41636>:
  <D.41631>:
  goto <D.26560>;
  <D.41626>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.41647>; else goto <D.41648>;
  <D.41647>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.41649>; else goto <D.41650>;
  <D.41649>:
  code.4085 = code;
  code = code.4085 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34727 = D.31571 | 48;
  D.34728 = (unsigned char) D.34727;
  *code.4085 = D.34728;
  goto <D.26560>;
  <D.41650>:
  <D.41648>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.41652>; else goto <D.41653>;
  <D.41652>:
  code.4086 = code;
  code = code.4086 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34732 = D.31571 | 112;
  D.34733 = (unsigned char) D.34732;
  *code.4086 = D.34733;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.41655>;
  <D.41653>:
  code.4087 = code;
  code = code.4087 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.34736 = D.31571 | -80;
  D.34737 = (unsigned char) D.34736;
  *code.4087 = D.34737;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4088 = code;
        code = code.4088 + 1;
        D.41658 = imb.b[0];
        *code.4088 = D.41658;
        code.4089 = code;
        code = code.4089 + 1;
        D.41660 = imb.b[1];
        *code.4089 = D.41660;
        code.4090 = code;
        code = code.4090 + 1;
        D.41662 = imb.b[2];
        *code.4090 = D.41662;
        code.4091 = code;
        code = code.4091 + 1;
        D.41664 = imb.b[3];
        *code.4091 = D.41664;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41655>:
  <D.26560>:
  goto <D.25197>;
  <D.26562>:
  {
    int size;

    D.31647 = ins->data.op[1].const_val;
    D.41665 = (unsigned int) D.31647;
    D.41666 = D.41665 + 7;
    D.41667 = (int) D.41666;
    size = D.41667 & -8;
    D.40891 = cfg->arch.no_pushes;
    D.41583 = D.40891 != 0;
    D.41584 = (long int) D.41583;
    D.41585 = __builtin_expect (D.41584, 0);
    if (D.41585 != 0) goto <D.41668>; else goto <D.41669>;
    <D.41668>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5025, "!cfg->arch.no_pushes");
    <D.41669>:
    size.4092 = (unsigned int) size;
    D.41671 = size.4092 + 128;
    if (D.41671 <= 255) goto <D.41672>; else goto <D.41673>;
    <D.41672>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.41674>; else goto <D.41675>;
      <D.41674>:
      code.4093 = code;
      code = code.4093 + 1;
      D.41677 = _amd64_rex_bits | 64;
      *code.4093 = D.41677;
      <D.41675>:
    }
    code.4094 = code;
    code = code.4094 + 1;
    *code.4094 = 131;
    code.4095 = code;
    code = code.4095 + 1;
    *code.4095 = 236;
    D.41680 = (unsigned char) size;
    *code = D.41680;
    code = code + 1;
    goto <D.41681>;
    <D.41673>:
    if (0 != 0) goto <D.41682>; else goto <D.41683>;
    <D.41682>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.41684>; else goto <D.41685>;
      <D.41684>:
      code.4096 = code;
      code = code.4096 + 1;
      D.41687 = _amd64_rex_bits | 64;
      *code.4096 = D.41687;
      <D.41685>:
    }
    code.4097 = code;
    code = code.4097 + 1;
    *code.4097 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = size;
          code.4098 = code;
          code = code.4098 + 1;
          D.41690 = imb.b[0];
          *code.4098 = D.41690;
          code.4099 = code;
          code = code.4099 + 1;
          D.41692 = imb.b[1];
          *code.4099 = D.41692;
          code.4100 = code;
          code = code.4100 + 1;
          D.41694 = imb.b[2];
          *code.4100 = D.41694;
          code.4101 = code;
          code = code.4101 + 1;
          D.41696 = imb.b[3];
          *code.4101 = D.41696;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.41697>;
    <D.41683>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.41698>; else goto <D.41699>;
      <D.41698>:
      code.4102 = code;
      code = code.4102 + 1;
      D.41701 = _amd64_rex_bits | 64;
      *code.4102 = D.41701;
      <D.41699>:
    }
    code.4103 = code;
    code = code.4103 + 1;
    *code.4103 = 129;
    code.4104 = code;
    code = code.4104 + 1;
    *code.4104 = 236;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = size;
          code.4105 = code;
          code = code.4105 + 1;
          D.41705 = imb.b[0];
          *code.4105 = D.41705;
          code.4106 = code;
          code = code.4106 + 1;
          D.41707 = imb.b[1];
          *code.4106 = D.41707;
          code.4107 = code;
          code = code.4107 + 1;
          D.41709 = imb.b[2];
          *code.4107 = D.41709;
          code.4108 = code;
          code = code.4108 + 1;
          D.41711 = imb.b[3];
          *code.4108 = D.41711;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41697>:
    <D.41681>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41712>; else goto <D.41713>;
      <D.41712>:
      code.4109 = code;
      code = code.4109 + 1;
      D.41715 = _amd64_rex_bits | 64;
      *code.4109 = D.41715;
      <D.41713>:
    }
    code.4110 = code;
    code = code.4110 + 1;
    *code.4110 = 87;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41717>; else goto <D.41718>;
      <D.41717>:
      code.4111 = code;
      code = code.4111 + 1;
      D.41720 = _amd64_rex_bits | 64;
      *code.4111 = D.41720;
      <D.41718>:
    }
    code.4112 = code;
    code = code.4112 + 1;
    *code.4112 = 86;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41722>; else goto <D.41723>;
      <D.41722>:
      code.4113 = code;
      code = code.4113 + 1;
      D.41725 = _amd64_rex_bits | 64;
      *code.4113 = D.41725;
      <D.41723>:
    }
    code.4114 = code;
    code = code.4114 + 1;
    *code.4114 = 81;
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 != 0) goto <D.41727>; else goto <D.41728>;
    <D.41727>:
    {
      unsigned char _amd64_rex_bits;

      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.41730>; else goto <D.41731>;
      <D.41730>:
      iftmp.4115 = 9;
      goto <D.41732>;
      <D.41731>:
      iftmp.4115 = 8;
      <D.41732>:
      _amd64_rex_bits = iftmp.4115;
      if (_amd64_rex_bits != 0) goto <D.41733>; else goto <D.41734>;
      <D.41733>:
      code.4116 = code;
      code = code.4116 + 1;
      D.41736 = _amd64_rex_bits | 64;
      *code.4116 = D.41736;
      <D.41734>:
    }
    code.4117 = code;
    code = code.4117 + 1;
    *code.4117 = 141;
    D.31516 = ins->sreg1;
    if (D.31516 == 16) goto <D.41738>; else goto <D.41739>;
    <D.41738>:
    code.4118 = code;
    code = code.4118 + 1;
    *code.4118 = 53;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.4119 = code;
          code = code.4119 + 1;
          D.41742 = imb.b[0];
          *code.4119 = D.41742;
          code.4120 = code;
          code = code.4120 + 1;
          D.41744 = imb.b[1];
          *code.4120 = D.41744;
          code.4121 = code;
          code = code.4121 + 1;
          D.41746 = imb.b[2];
          *code.4121 = D.41746;
          code.4122 = code;
          code = code.4122 + 1;
          D.41748 = imb.b[3];
          *code.4122 = D.41748;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.41749>;
    <D.41739>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.41750>; else goto <D.41751>;
    <D.41750>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.41752>; else goto <D.41753>;
    <D.41752>:
    code.4123 = code;
    code = code.4123 + 1;
    *code.4123 = 52;
    code.4124 = code;
    code = code.4124 + 1;
    *code.4124 = 36;
    goto <D.41756>;
    <D.41753>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.41757>; else goto <D.41758>;
    <D.41757>:
    code.4125 = code;
    code = code.4125 + 1;
    *code.4125 = 116;
    code.4126 = code;
    code = code.4126 + 1;
    *code.4126 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.41761>;
    <D.41758>:
    code.4127 = code;
    code = code.4127 + 1;
    *code.4127 = 180;
    code.4128 = code;
    code = code.4128 + 1;
    *code.4128 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.4129 = code;
          code = code.4129 + 1;
          D.41765 = imb.b[0];
          *code.4129 = D.41765;
          code.4130 = code;
          code = code.4130 + 1;
          D.41767 = imb.b[1];
          *code.4130 = D.41767;
          code.4131 = code;
          code = code.4131 + 1;
          D.41769 = imb.b[2];
          *code.4131 = D.41769;
          code.4132 = code;
          code = code.4132 + 1;
          D.41771 = imb.b[3];
          *code.4132 = D.41771;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41761>:
    <D.41756>:
    goto <D.26575>;
    <D.41751>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.41772>; else goto <D.41773>;
    <D.41772>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.41774>; else goto <D.41775>;
    <D.41774>:
    code.4133 = code;
    code = code.4133 + 1;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.34727 = D.31571 | 48;
    D.34728 = (unsigned char) D.34727;
    *code.4133 = D.34728;
    goto <D.26575>;
    <D.41775>:
    <D.41773>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.41777>; else goto <D.41778>;
    <D.41777>:
    code.4134 = code;
    code = code.4134 + 1;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.34732 = D.31571 | 112;
    D.34733 = (unsigned char) D.34732;
    *code.4134 = D.34733;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.41780>;
    <D.41778>:
    code.4135 = code;
    code = code.4135 + 1;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.34736 = D.31571 | -80;
    D.34737 = (unsigned char) D.34736;
    *code.4135 = D.34737;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.4136 = code;
          code = code.4136 + 1;
          D.41783 = imb.b[0];
          *code.4136 = D.41783;
          code.4137 = code;
          code = code.4137 + 1;
          D.41785 = imb.b[1];
          *code.4137 = D.41785;
          code.4138 = code;
          code = code.4138 + 1;
          D.41787 = imb.b[2];
          *code.4138 = D.41787;
          code.4139 = code;
          code = code.4139 + 1;
          D.41789 = imb.b[3];
          *code.4139 = D.41789;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41780>:
    <D.26575>:
    <D.41749>:
    goto <D.41790>;
    <D.41728>:
    if (0 != 0) goto <D.41791>; else goto <D.41792>;
    <D.41791>:
    code.4140 = code;
    code = code.4140 + 1;
    *code.4140 = 102;
    <D.41792>:
    {
      unsigned char _amd64_rex_bits;

      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.41795>; else goto <D.41796>;
      <D.41795>:
      iftmp.4141 = 9;
      goto <D.41797>;
      <D.41796>:
      iftmp.4141 = 8;
      <D.41797>:
      _amd64_rex_bits = iftmp.4141;
      if (_amd64_rex_bits != 0) goto <D.41798>; else goto <D.41799>;
      <D.41798>:
      code.4142 = code;
      code = code.4142 + 1;
      D.41801 = _amd64_rex_bits | 64;
      *code.4142 = D.41801;
      <D.41799>:
    }
    switch (8) <default: <D.26583>, case 1: <D.26578>, case 2: <D.26580>, case 4: <D.26581>, case 8: <D.26582>>
    <D.26578>:
    code.4143 = code;
    code = code.4143 + 1;
    *code.4143 = 138;
    goto <D.26579>;
    <D.26580>:
    <D.26581>:
    <D.26582>:
    code.4144 = code;
    code = code.4144 + 1;
    *code.4144 = 139;
    goto <D.26579>;
    <D.26583>:
    __assert_fail ("0", "mini-amd64.c", 5034, &__PRETTY_FUNCTION__);
    <D.26579>:
    code.4145 = code;
    code = code.4145 + 1;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.38884 = D.31571 | -16;
    D.38885 = (unsigned char) D.38884;
    *code.4145 = D.38885;
    <D.41790>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.41805>; else goto <D.41806>;
      <D.41805>:
      code.4146 = code;
      code = code.4146 + 1;
      D.41808 = _amd64_rex_bits | 64;
      *code.4146 = D.41808;
      <D.41806>:
    }
    code.4147 = code;
    code = code.4147 + 1;
    *code.4147 = 141;
    if (0 != 0) goto <D.41810>; else goto <D.41811>;
    <D.41810>:
    code.4148 = code;
    code = code.4148 + 1;
    *code.4148 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 24;
          code.4149 = code;
          code = code.4149 + 1;
          D.41814 = imb.b[0];
          *code.4149 = D.41814;
          code.4150 = code;
          code = code.4150 + 1;
          D.41816 = imb.b[1];
          *code.4150 = D.41816;
          code.4151 = code;
          code = code.4151 + 1;
          D.41818 = imb.b[2];
          *code.4151 = D.41818;
          code.4152 = code;
          code = code.4152 + 1;
          D.41820 = imb.b[3];
          *code.4152 = D.41820;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.41821>;
    <D.41811>:
    if (1 != 0) goto <D.41822>; else goto <D.41823>;
    <D.41822>:
    if (0 != 0) goto <D.41824>; else goto <D.41825>;
    <D.41824>:
    code.4153 = code;
    code = code.4153 + 1;
    *code.4153 = 60;
    code.4154 = code;
    code = code.4154 + 1;
    *code.4154 = 36;
    goto <D.41828>;
    <D.41825>:
    if (1 != 0) goto <D.41829>; else goto <D.41830>;
    <D.41829>:
    code.4155 = code;
    code = code.4155 + 1;
    *code.4155 = 124;
    code.4156 = code;
    code = code.4156 + 1;
    *code.4156 = 36;
    *code = 24;
    code = code + 1;
    goto <D.41833>;
    <D.41830>:
    code.4157 = code;
    code = code.4157 + 1;
    *code.4157 = 188;
    code.4158 = code;
    code = code.4158 + 1;
    *code.4158 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 24;
          code.4159 = code;
          code = code.4159 + 1;
          D.41837 = imb.b[0];
          *code.4159 = D.41837;
          code.4160 = code;
          code = code.4160 + 1;
          D.41839 = imb.b[1];
          *code.4160 = D.41839;
          code.4161 = code;
          code = code.4161 + 1;
          D.41841 = imb.b[2];
          *code.4161 = D.41841;
          code.4162 = code;
          code = code.4162 + 1;
          D.41843 = imb.b[3];
          *code.4162 = D.41843;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41833>:
    <D.41828>:
    goto <D.26587>;
    <D.41823>:
    if (0 != 0) goto <D.41844>; else goto <D.41845>;
    <D.41844>:
    code.4163 = code;
    code = code.4163 + 1;
    *code.4163 = 60;
    goto <D.26587>;
    <D.41845>:
    if (1 != 0) goto <D.41847>; else goto <D.41848>;
    <D.41847>:
    code.4164 = code;
    code = code.4164 + 1;
    *code.4164 = 124;
    *code = 24;
    code = code + 1;
    goto <D.41850>;
    <D.41848>:
    code.4165 = code;
    code = code.4165 + 1;
    *code.4165 = 188;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 24;
          code.4166 = code;
          code = code.4166 + 1;
          D.41853 = imb.b[0];
          *code.4166 = D.41853;
          code.4167 = code;
          code = code.4167 + 1;
          D.41855 = imb.b[1];
          *code.4167 = D.41855;
          code.4168 = code;
          code = code.4168 + 1;
          D.41857 = imb.b[2];
          *code.4168 = D.41857;
          code.4169 = code;
          code = code.4169 + 1;
          D.41859 = imb.b[3];
          *code.4169 = D.41859;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.41850>:
    <D.26587>:
    <D.41821>:
    {
      int _amd64_width_temp;

      _amd64_width_temp = 1;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.41861>; else goto <D.41862>;
        <D.41861>:
        iftmp.4170 = 8;
        goto <D.41863>;
        <D.41862>:
        iftmp.4170 = 0;
        <D.41863>:
        _amd64_rex_bits = iftmp.4170;
        if (_amd64_rex_bits != 0) goto <D.41864>; else goto <D.41865>;
        <D.41864>:
        code.4171 = code;
        code = code.4171 + 1;
        D.41867 = _amd64_rex_bits | 64;
        *code.4171 = D.41867;
        <D.41865>:
      }
      code.4172 = code;
      code = code.4172 + 1;
      *code.4172 = 185;
      if (_amd64_width_temp == 0) goto <D.41869>; else goto <D.41870>;
      <D.41869>:
      {
        union amd64_imm_buf imb;

        try
          {
            D.41871 = size >> 3;
            D.41872 = (long unsigned int) D.41871;
            imb.val = D.41872;
            code.4173 = code;
            code = code.4173 + 1;
            D.41874 = imb.b[0];
            *code.4173 = D.41874;
            code.4174 = code;
            code = code.4174 + 1;
            D.41876 = imb.b[1];
            *code.4174 = D.41876;
            code.4175 = code;
            code = code.4175 + 1;
            D.41878 = imb.b[2];
            *code.4175 = D.41878;
            code.4176 = code;
            code = code.4176 + 1;
            D.41880 = imb.b[3];
            *code.4176 = D.41880;
            code.4177 = code;
            code = code.4177 + 1;
            D.41882 = imb.b[4];
            *code.4177 = D.41882;
            code.4178 = code;
            code = code.4178 + 1;
            D.41884 = imb.b[5];
            *code.4178 = D.41884;
            code.4179 = code;
            code = code.4179 + 1;
            D.41886 = imb.b[6];
            *code.4179 = D.41886;
            code.4180 = code;
            code = code.4180 + 1;
            D.41888 = imb.b[7];
            *code.4180 = D.41888;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.41889>;
      <D.41870>:
      {
        union x86_imm_buf imb;

        try
          {
            D.41871 = size >> 3;
            imb.val = D.41871;
            code.4181 = code;
            code = code.4181 + 1;
            D.41891 = imb.b[0];
            *code.4181 = D.41891;
            code.4182 = code;
            code = code.4182 + 1;
            D.41893 = imb.b[1];
            *code.4182 = D.41893;
            code.4183 = code;
            code = code.4183 + 1;
            D.41895 = imb.b[2];
            *code.4183 = D.41895;
            code.4184 = code;
            code = code.4184 + 1;
            D.41897 = imb.b[3];
            *code.4184 = D.41897;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.41889>:
    }
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41898>; else goto <D.41899>;
      <D.41898>:
      code.4185 = code;
      code = code.4185 + 1;
      D.41901 = _amd64_rex_bits | 64;
      *code.4185 = D.41901;
      <D.41899>:
    }
    code.4186 = code;
    code = code.4186 + 1;
    *code.4186 = 252;
    code.4187 = code;
    code = code.4187 + 1;
    *code.4187 = 243;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.41904>; else goto <D.41905>;
      <D.41904>:
      code.4188 = code;
      code = code.4188 + 1;
      D.41907 = _amd64_rex_bits | 64;
      *code.4188 = D.41907;
      <D.41905>:
    }
    code.4189 = code;
    code = code.4189 + 1;
    *code.4189 = 165;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41909>; else goto <D.41910>;
      <D.41909>:
      code.4190 = code;
      code = code.4190 + 1;
      D.41912 = _amd64_rex_bits | 64;
      *code.4190 = D.41912;
      <D.41910>:
    }
    code.4191 = code;
    code = code.4191 + 1;
    *code.4191 = 89;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41914>; else goto <D.41915>;
      <D.41914>:
      code.4192 = code;
      code = code.4192 + 1;
      D.41917 = _amd64_rex_bits | 64;
      *code.4192 = D.41917;
      <D.41915>:
    }
    code.4193 = code;
    code = code.4193 + 1;
    *code.4193 = 94;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.41919>; else goto <D.41920>;
      <D.41919>:
      code.4194 = code;
      code = code.4194 + 1;
      D.41922 = _amd64_rex_bits | 64;
      *code.4194 = D.41922;
      <D.41920>:
    }
    code.4195 = code;
    code = code.4195 + 1;
    *code.4195 = 95;
    goto <D.25197>;
  }
  <D.26598>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.41925>; else goto <D.41926>;
    <D.41925>:
    iftmp.4196 = 12;
    goto <D.41927>;
    <D.41926>:
    iftmp.4196 = 8;
    <D.41927>:
    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.41929>; else goto <D.41930>;
    <D.41929>:
    iftmp.4197 = 2;
    goto <D.41931>;
    <D.41930>:
    iftmp.4197 = 0;
    <D.41931>:
    D.41932 = iftmp.4196 | iftmp.4197;
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.41933 = D.41932 | D.33180;
    _amd64_rex_bits = (unsigned char) D.41933;
    if (_amd64_rex_bits != 0) goto <D.41934>; else goto <D.41935>;
    <D.41934>:
    code.4198 = code;
    code = code.4198 + 1;
    D.41937 = _amd64_rex_bits | 64;
    *code.4198 = D.41937;
    <D.41935>:
  }
  code.4199 = code;
  code = code.4199 + 1;
  *code.4199 = 141;
  if (0 != 0) goto <D.41939>; else goto <D.41940>;
  <D.41939>:
  code.4200 = code;
  code = code.4200 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.4200 = D.32644;
  code.4201 = code;
  code = code.4201 + 1;
  D.41943 = ins->backend.shift_amount;
  D.41944 = D.41943 << 6;
  D.41945 = (signed char) D.41944;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.41946 = D.41945 | D.33673;
  D.41947 = D.41946 | 5;
  D.41948 = (unsigned char) D.41947;
  *code.4201 = D.41948;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.4202 = code;
        code = code.4202 + 1;
        D.41950 = imb.b[0];
        *code.4202 = D.41950;
        code.4203 = code;
        code = code.4203 + 1;
        D.41952 = imb.b[1];
        *code.4203 = D.41952;
        code.4204 = code;
        code = code.4204 + 1;
        D.41954 = imb.b[2];
        *code.4204 = D.41954;
        code.4205 = code;
        code = code.4205 + 1;
        D.41956 = imb.b[3];
        *code.4205 = D.41956;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.41957>;
  <D.41940>:
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 0) goto <D.41960>; else goto <D.41958>;
  <D.41960>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.41961>; else goto <D.41958>;
  <D.41961>:
  code.4206 = code;
  code = code.4206 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.4206 = D.32644;
  code.4207 = code;
  code = code.4207 + 1;
  D.41943 = ins->backend.shift_amount;
  D.41944 = D.41943 << 6;
  D.41945 = (signed char) D.41944;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.41946 = D.41945 | D.33673;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.41964 = D.41946 | D.31571;
  D.41965 = (unsigned char) D.41964;
  *code.4207 = D.41965;
  goto <D.41959>;
  <D.41958>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.41966>; else goto <D.41967>;
  <D.41966>:
  code.4208 = code;
  code = code.4208 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.4208 = D.32735;
  code.4209 = code;
  code = code.4209 + 1;
  D.41943 = ins->backend.shift_amount;
  D.41944 = D.41943 << 6;
  D.41945 = (signed char) D.41944;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.41946 = D.41945 | D.33673;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.41964 = D.41946 | D.31571;
  D.41965 = (unsigned char) D.41964;
  *code.4209 = D.41965;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.41970>;
  <D.41967>:
  code.4210 = code;
  code = code.4210 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.4210 = D.32740;
  code.4211 = code;
  code = code.4211 + 1;
  D.41943 = ins->backend.shift_amount;
  D.41944 = D.41943 << 6;
  D.41945 = (signed char) D.41944;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.41946 = D.41945 | D.33673;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.41964 = D.41946 | D.31571;
  D.41965 = (unsigned char) D.41964;
  *code.4211 = D.41965;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.4212 = code;
        code = code.4212 + 1;
        D.41974 = imb.b[0];
        *code.4212 = D.41974;
        code.4213 = code;
        code = code.4213 + 1;
        D.41976 = imb.b[1];
        *code.4213 = D.41976;
        code.4214 = code;
        code = code.4214 + 1;
        D.41978 = imb.b[2];
        *code.4214 = D.41978;
        code.4215 = code;
        code = code.4215 + 1;
        D.41980 = imb.b[3];
        *code.4215 = D.41980;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.41970>:
  <D.41959>:
  <D.41957>:
  goto <D.25197>;
  <D.26602>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.41982>; else goto <D.41983>;
    <D.41982>:
    iftmp.4216 = 12;
    goto <D.41984>;
    <D.41983>:
    iftmp.4216 = 8;
    <D.41984>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.41985 = iftmp.4216 | D.33180;
    _amd64_rex_bits = (unsigned char) D.41985;
    if (_amd64_rex_bits != 0) goto <D.41986>; else goto <D.41987>;
    <D.41986>:
    code.4217 = code;
    code = code.4217 + 1;
    D.41989 = _amd64_rex_bits | 64;
    *code.4217 = D.41989;
    <D.41987>:
  }
  code.4218 = code;
  code = code.4218 + 1;
  *code.4218 = 141;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.41991>; else goto <D.41992>;
  <D.41991>:
  code.4219 = code;
  code = code.4219 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.4219 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.4220 = code;
        code = code.4220 + 1;
        D.41995 = imb.b[0];
        *code.4220 = D.41995;
        code.4221 = code;
        code = code.4221 + 1;
        D.41997 = imb.b[1];
        *code.4221 = D.41997;
        code.4222 = code;
        code = code.4222 + 1;
        D.41999 = imb.b[2];
        *code.4222 = D.41999;
        code.4223 = code;
        code = code.4223 + 1;
        D.42001 = imb.b[3];
        *code.4223 = D.42001;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42002>;
  <D.41992>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.42003>; else goto <D.42004>;
  <D.42003>:
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 0) goto <D.42005>; else goto <D.42006>;
  <D.42005>:
  code.4224 = code;
  code = code.4224 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.4224 = D.32644;
  code.4225 = code;
  code = code.4225 + 1;
  *code.4225 = 36;
  goto <D.42009>;
  <D.42006>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.42010>; else goto <D.42011>;
  <D.42010>:
  code.4226 = code;
  code = code.4226 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.4226 = D.32735;
  code.4227 = code;
  code = code.4227 + 1;
  *code.4227 = 36;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.42014>;
  <D.42011>:
  code.4228 = code;
  code = code.4228 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.4228 = D.32740;
  code.4229 = code;
  code = code.4229 + 1;
  *code.4229 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.4230 = code;
        code = code.4230 + 1;
        D.42018 = imb.b[0];
        *code.4230 = D.42018;
        code.4231 = code;
        code = code.4231 + 1;
        D.42020 = imb.b[1];
        *code.4231 = D.42020;
        code.4232 = code;
        code = code.4232 + 1;
        D.42022 = imb.b[2];
        *code.4232 = D.42022;
        code.4233 = code;
        code = code.4233 + 1;
        D.42024 = imb.b[3];
        *code.4233 = D.42024;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42014>:
  <D.42009>:
  goto <D.26606>;
  <D.42004>:
  D.31647 = ins->data.op[1].const_val;
  if (D.31647 == 0) goto <D.42025>; else goto <D.42026>;
  <D.42025>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.42027>; else goto <D.42028>;
  <D.42027>:
  code.4234 = code;
  code = code.4234 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.4234 = D.33228;
  goto <D.26606>;
  <D.42028>:
  <D.42026>:
  D.31647 = ins->data.op[1].const_val;
  D.33824 = (unsigned int) D.31647;
  D.33825 = D.33824 + 128;
  if (D.33825 <= 255) goto <D.42030>; else goto <D.42031>;
  <D.42030>:
  code.4235 = code;
  code = code.4235 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.4235 = D.33233;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.42033>;
  <D.42031>:
  code.4236 = code;
  code = code.4236 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.4236 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31647 = ins->data.op[1].const_val;
        D.31736 = (int) D.31647;
        imb.val = D.31736;
        code.4237 = code;
        code = code.4237 + 1;
        D.42036 = imb.b[0];
        *code.4237 = D.42036;
        code.4238 = code;
        code = code.4238 + 1;
        D.42038 = imb.b[1];
        *code.4238 = D.42038;
        code.4239 = code;
        code = code.4239 + 1;
        D.42040 = imb.b[2];
        *code.4239 = D.42040;
        code.4240 = code;
        code = code.4240 + 1;
        D.42042 = imb.b[3];
        *code.4240 = D.42042;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42033>:
  <D.26606>:
  <D.42002>:
  goto <D.25197>;
  <D.26608>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42044>; else goto <D.42045>;
    <D.42044>:
    iftmp.4241 = 4;
    goto <D.42046>;
    <D.42045>:
    iftmp.4241 = 0;
    <D.42046>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.42047 = iftmp.4241 | D.33811;
    _amd64_rex_bits = (unsigned char) D.42047;
    if (_amd64_rex_bits != 0) goto <D.42048>; else goto <D.42049>;
    <D.42048>:
    code.4242 = code;
    code = code.4242 + 1;
    D.42051 = _amd64_rex_bits | 64;
    *code.4242 = D.42051;
    <D.42049>:
  }
  if (0 != 0) goto <D.42052>; else goto <D.42053>;
  <D.42052>:
  code.4243 = code;
  code = code.4243 + 1;
  *code.4243 = 134;
  goto <D.42055>;
  <D.42053>:
  code.4244 = code;
  code = code.4244 + 1;
  *code.4244 = 135;
  <D.42055>:
  code.4245 = code;
  code = code.4245 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.42058 = D.33673 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.42059 = D.42058 | D.31571;
  D.42060 = (unsigned char) D.42059;
  *code.4245 = D.42060;
  goto <D.25197>;
  <D.26610>:
  if (1 != 0) goto <D.42061>; else goto <D.42062>;
  <D.42061>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42064>; else goto <D.42065>;
    <D.42064>:
    iftmp.4246 = 9;
    goto <D.42066>;
    <D.42065>:
    iftmp.4246 = 8;
    <D.42066>:
    _amd64_rex_bits = iftmp.4246;
    if (_amd64_rex_bits != 0) goto <D.42067>; else goto <D.42068>;
    <D.42067>:
    code.4247 = code;
    code = code.4247 + 1;
    D.42070 = _amd64_rex_bits | 64;
    *code.4247 = D.42070;
    <D.42068>:
  }
  code.4248 = code;
  code = code.4248 + 1;
  *code.4248 = 131;
  code.4249 = code;
  code = code.4249 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39617 = D.31571 | -64;
  D.39618 = (unsigned char) D.39617;
  *code.4249 = D.39618;
  *code = 15;
  code = code + 1;
  goto <D.42073>;
  <D.42062>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.42074>; else goto <D.42075>;
  <D.42074>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42076>; else goto <D.42077>;
    <D.42076>:
    code.4250 = code;
    code = code.4250 + 1;
    D.42079 = _amd64_rex_bits | 64;
    *code.4250 = D.42079;
    <D.42077>:
  }
  code.4251 = code;
  code = code.4251 + 1;
  *code.4251 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 15;
        code.4252 = code;
        code = code.4252 + 1;
        D.42082 = imb.b[0];
        *code.4252 = D.42082;
        code.4253 = code;
        code = code.4253 + 1;
        D.42084 = imb.b[1];
        *code.4253 = D.42084;
        code.4254 = code;
        code = code.4254 + 1;
        D.42086 = imb.b[2];
        *code.4254 = D.42086;
        code.4255 = code;
        code = code.4255 + 1;
        D.42088 = imb.b[3];
        *code.4255 = D.42088;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42089>;
  <D.42075>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42091>; else goto <D.42092>;
    <D.42091>:
    iftmp.4256 = 9;
    goto <D.42093>;
    <D.42092>:
    iftmp.4256 = 8;
    <D.42093>:
    _amd64_rex_bits = iftmp.4256;
    if (_amd64_rex_bits != 0) goto <D.42094>; else goto <D.42095>;
    <D.42094>:
    code.4257 = code;
    code = code.4257 + 1;
    D.42097 = _amd64_rex_bits | 64;
    *code.4257 = D.42097;
    <D.42095>:
  }
  code.4258 = code;
  code = code.4258 + 1;
  *code.4258 = 129;
  code.4259 = code;
  code = code.4259 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.39617 = D.31571 | -64;
  D.39618 = (unsigned char) D.39617;
  *code.4259 = D.39618;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 15;
        code.4260 = code;
        code = code.4260 + 1;
        D.42101 = imb.b[0];
        *code.4260 = D.42101;
        code.4261 = code;
        code = code.4261 + 1;
        D.42103 = imb.b[1];
        *code.4261 = D.42103;
        code.4262 = code;
        code = code.4262 + 1;
        D.42105 = imb.b[2];
        *code.4262 = D.42105;
        code.4263 = code;
        code = code.4263 + 1;
        D.42107 = imb.b[3];
        *code.4263 = D.42107;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42089>:
  <D.42073>:
  if (1 != 0) goto <D.42108>; else goto <D.42109>;
  <D.42108>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42111>; else goto <D.42112>;
    <D.42111>:
    iftmp.4264 = 9;
    goto <D.42113>;
    <D.42112>:
    iftmp.4264 = 8;
    <D.42113>:
    _amd64_rex_bits = iftmp.4264;
    if (_amd64_rex_bits != 0) goto <D.42114>; else goto <D.42115>;
    <D.42114>:
    code.4265 = code;
    code = code.4265 + 1;
    D.42117 = _amd64_rex_bits | 64;
    *code.4265 = D.42117;
    <D.42115>:
  }
  code.4266 = code;
  code = code.4266 + 1;
  *code.4266 = 131;
  code.4267 = code;
  code = code.4267 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.4267 = D.37432;
  *code = 240;
  code = code + 1;
  goto <D.42120>;
  <D.42109>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.42121>; else goto <D.42122>;
  <D.42121>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42123>; else goto <D.42124>;
    <D.42123>:
    code.4268 = code;
    code = code.4268 + 1;
    D.42126 = _amd64_rex_bits | 64;
    *code.4268 = D.42126;
    <D.42124>:
  }
  code.4269 = code;
  code = code.4269 + 1;
  *code.4269 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.4270 = code;
        code = code.4270 + 1;
        D.42129 = imb.b[0];
        *code.4270 = D.42129;
        code.4271 = code;
        code = code.4271 + 1;
        D.42131 = imb.b[1];
        *code.4271 = D.42131;
        code.4272 = code;
        code = code.4272 + 1;
        D.42133 = imb.b[2];
        *code.4272 = D.42133;
        code.4273 = code;
        code = code.4273 + 1;
        D.42135 = imb.b[3];
        *code.4273 = D.42135;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42136>;
  <D.42122>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42138>; else goto <D.42139>;
    <D.42138>:
    iftmp.4274 = 9;
    goto <D.42140>;
    <D.42139>:
    iftmp.4274 = 8;
    <D.42140>:
    _amd64_rex_bits = iftmp.4274;
    if (_amd64_rex_bits != 0) goto <D.42141>; else goto <D.42142>;
    <D.42141>:
    code.4275 = code;
    code = code.4275 + 1;
    D.42144 = _amd64_rex_bits | 64;
    *code.4275 = D.42144;
    <D.42142>:
  }
  code.4276 = code;
  code = code.4276 + 1;
  *code.4276 = 129;
  code.4277 = code;
  code = code.4277 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.4277 = D.37432;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.4278 = code;
        code = code.4278 + 1;
        D.42148 = imb.b[0];
        *code.4278 = D.42148;
        code.4279 = code;
        code = code.4279 + 1;
        D.42150 = imb.b[1];
        *code.4279 = D.42150;
        code.4280 = code;
        code = code.4280 + 1;
        D.42152 = imb.b[2];
        *code.4280 = D.42152;
        code.4281 = code;
        code = code.4281 + 1;
        D.42154 = imb.b[3];
        *code.4281 = D.42154;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42136>:
  <D.42120>:
  code = mono_emit_stack_alloc (cfg, code, ins);
  if (0 != 0) goto <D.42155>; else goto <D.42156>;
  <D.42155>:
  code.4282 = code;
  code = code.4282 + 1;
  *code.4282 = 102;
  <D.42156>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.42159>; else goto <D.42160>;
    <D.42159>:
    iftmp.4283 = 12;
    goto <D.42161>;
    <D.42160>:
    iftmp.4283 = 8;
    <D.42161>:
    _amd64_rex_bits = iftmp.4283;
    if (_amd64_rex_bits != 0) goto <D.42162>; else goto <D.42163>;
    <D.42162>:
    code.4284 = code;
    code = code.4284 + 1;
    D.42165 = _amd64_rex_bits | 64;
    *code.4284 = D.42165;
    <D.42163>:
  }
  switch (8) <default: <D.26627>, case 1: <D.26622>, case 2: <D.26624>, case 4: <D.26625>, case 8: <D.26626>>
  <D.26622>:
  code.4285 = code;
  code = code.4285 + 1;
  *code.4285 = 138;
  goto <D.26623>;
  <D.26624>:
  <D.26625>:
  <D.26626>:
  code.4286 = code;
  code = code.4286 + 1;
  *code.4286 = 139;
  goto <D.26623>;
  <D.26627>:
  __assert_fail ("0", "mini-amd64.c", 5059, &__PRETTY_FUNCTION__);
  <D.26623>:
  code.4287 = code;
  code = code.4287 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.42169 = D.32642 | -60;
  D.42170 = (unsigned char) D.42169;
  *code.4287 = D.42170;
  D.42171 = cfg->param_area;
  if (D.42171 != 0) goto <D.42172>; else goto <D.42173>;
  <D.42172>:
  D.40891 = cfg->arch.no_pushes;
  if (D.40891 != 0) goto <D.42174>; else goto <D.42175>;
  <D.42174>:
  D.42171 = cfg->param_area;
  D.42178 = (int) D.42171;
  if (D.42178 >= -128) goto <D.42179>; else goto <D.42176>;
  <D.42179>:
  D.42171 = cfg->param_area;
  D.42178 = (int) D.42171;
  if (D.42178 <= 127) goto <D.42180>; else goto <D.42176>;
  <D.42180>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.42182>; else goto <D.42183>;
    <D.42182>:
    iftmp.4288 = 9;
    goto <D.42184>;
    <D.42183>:
    iftmp.4288 = 8;
    <D.42184>:
    _amd64_rex_bits = iftmp.4288;
    if (_amd64_rex_bits != 0) goto <D.42185>; else goto <D.42186>;
    <D.42185>:
    code.4289 = code;
    code = code.4289 + 1;
    D.42188 = _amd64_rex_bits | 64;
    *code.4289 = D.42188;
    <D.42186>:
  }
  code.4290 = code;
  code = code.4290 + 1;
  *code.4290 = 131;
  code.4291 = code;
  code = code.4291 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.4291 = D.35110;
  D.42171 = cfg->param_area;
  D.42191 = (unsigned char) D.42171;
  *code = D.42191;
  code = code + 1;
  goto <D.42177>;
  <D.42176>:
  D.31589 = ins->dreg;
  if (D.31589 == 0) goto <D.42192>; else goto <D.42193>;
  <D.42192>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42194>; else goto <D.42195>;
    <D.42194>:
    code.4292 = code;
    code = code.4292 + 1;
    D.42197 = _amd64_rex_bits | 64;
    *code.4292 = D.42197;
    <D.42195>:
  }
  code.4293 = code;
  code = code.4293 + 1;
  *code.4293 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.42171 = cfg->param_area;
        D.42178 = (int) D.42171;
        imb.val = D.42178;
        code.4294 = code;
        code = code.4294 + 1;
        D.42200 = imb.b[0];
        *code.4294 = D.42200;
        code.4295 = code;
        code = code.4295 + 1;
        D.42202 = imb.b[1];
        *code.4295 = D.42202;
        code.4296 = code;
        code = code.4296 + 1;
        D.42204 = imb.b[2];
        *code.4296 = D.42204;
        code.4297 = code;
        code = code.4297 + 1;
        D.42206 = imb.b[3];
        *code.4297 = D.42206;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42207>;
  <D.42193>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.42209>; else goto <D.42210>;
    <D.42209>:
    iftmp.4298 = 9;
    goto <D.42211>;
    <D.42210>:
    iftmp.4298 = 8;
    <D.42211>:
    _amd64_rex_bits = iftmp.4298;
    if (_amd64_rex_bits != 0) goto <D.42212>; else goto <D.42213>;
    <D.42212>:
    code.4299 = code;
    code = code.4299 + 1;
    D.42215 = _amd64_rex_bits | 64;
    *code.4299 = D.42215;
    <D.42213>:
  }
  code.4300 = code;
  code = code.4300 + 1;
  *code.4300 = 129;
  code.4301 = code;
  code = code.4301 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.4301 = D.35110;
  {
    union x86_imm_buf imb;

    try
      {
        D.42171 = cfg->param_area;
        D.42178 = (int) D.42171;
        imb.val = D.42178;
        code.4302 = code;
        code = code.4302 + 1;
        D.42219 = imb.b[0];
        *code.4302 = D.42219;
        code.4303 = code;
        code = code.4303 + 1;
        D.42221 = imb.b[1];
        *code.4303 = D.42221;
        code.4304 = code;
        code = code.4304 + 1;
        D.42223 = imb.b[2];
        *code.4304 = D.42223;
        code.4305 = code;
        code = code.4305 + 1;
        D.42225 = imb.b[3];
        *code.4305 = D.42225;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42207>:
  <D.42177>:
  <D.42175>:
  <D.42173>:
  goto <D.25197>;
  <D.26633>:
  {
    guint32 size;

    D.31647 = ins->data.op[1].const_val;
    size = (guint32) D.31647;
    D.42226 = size + 15;
    size = D.42226 & 4294967280;
    D.36769 = ins->flags;
    D.36770 = (int) D.36769;
    D.36771 = D.36770 & 1;
    if (D.36771 != 0) goto <D.42227>; else goto <D.42228>;
    <D.42227>:
    if (size <= 63) goto <D.42229>; else goto <D.42230>;
    <D.42229>:
    {
      int i;

      size.4306 = (int) size;
      D.42232 = size.4306 >= -128;
      size.4306 = (int) size;
      D.42233 = size.4306 <= 127;
      D.42234 = D.42232 & D.42233;
      if (D.42234 != 0) goto <D.42235>; else goto <D.42236>;
      <D.42235>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.42237>; else goto <D.42238>;
        <D.42237>:
        code.4307 = code;
        code = code.4307 + 1;
        D.42240 = _amd64_rex_bits | 64;
        *code.4307 = D.42240;
        <D.42238>:
      }
      code.4308 = code;
      code = code.4308 + 1;
      *code.4308 = 131;
      code.4309 = code;
      code = code.4309 + 1;
      *code.4309 = 236;
      D.42243 = (unsigned char) size;
      *code = D.42243;
      code = code + 1;
      goto <D.42244>;
      <D.42236>:
      if (0 != 0) goto <D.42245>; else goto <D.42246>;
      <D.42245>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.42247>; else goto <D.42248>;
        <D.42247>:
        code.4310 = code;
        code = code.4310 + 1;
        D.42250 = _amd64_rex_bits | 64;
        *code.4310 = D.42250;
        <D.42248>:
      }
      code.4311 = code;
      code = code.4311 + 1;
      *code.4311 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            size.4306 = (int) size;
            imb.val = size.4306;
            code.4312 = code;
            code = code.4312 + 1;
            D.42253 = imb.b[0];
            *code.4312 = D.42253;
            code.4313 = code;
            code = code.4313 + 1;
            D.42255 = imb.b[1];
            *code.4313 = D.42255;
            code.4314 = code;
            code = code.4314 + 1;
            D.42257 = imb.b[2];
            *code.4314 = D.42257;
            code.4315 = code;
            code = code.4315 + 1;
            D.42259 = imb.b[3];
            *code.4315 = D.42259;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42260>;
      <D.42246>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.42261>; else goto <D.42262>;
        <D.42261>:
        code.4316 = code;
        code = code.4316 + 1;
        D.42264 = _amd64_rex_bits | 64;
        *code.4316 = D.42264;
        <D.42262>:
      }
      code.4317 = code;
      code = code.4317 + 1;
      *code.4317 = 129;
      code.4318 = code;
      code = code.4318 + 1;
      *code.4318 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            size.4306 = (int) size;
            imb.val = size.4306;
            code.4319 = code;
            code = code.4319 + 1;
            D.42268 = imb.b[0];
            *code.4319 = D.42268;
            code.4320 = code;
            code = code.4320 + 1;
            D.42270 = imb.b[1];
            *code.4320 = D.42270;
            code.4321 = code;
            code = code.4321 + 1;
            D.42272 = imb.b[2];
            *code.4321 = D.42272;
            code.4322 = code;
            code = code.4322 + 1;
            D.42274 = imb.b[3];
            *code.4322 = D.42274;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.42260>:
      <D.42244>:
      {
        unsigned char _amd64_rex_bits;

        D.31589 = ins->dreg;
        if (D.31589 > 7) goto <D.42276>; else goto <D.42277>;
        <D.42276>:
        iftmp.4323 = 12;
        goto <D.42278>;
        <D.42277>:
        iftmp.4323 = 8;
        <D.42278>:
        D.31589 = ins->dreg;
        D.31590 = D.31589 > 7;
        D.32040 = (signed char) D.31590;
        D.42279 = iftmp.4323 | D.32040;
        _amd64_rex_bits = (unsigned char) D.42279;
        if (_amd64_rex_bits != 0) goto <D.42280>; else goto <D.42281>;
        <D.42280>:
        code.4324 = code;
        code = code.4324 + 1;
        D.42283 = _amd64_rex_bits | 64;
        *code.4324 = D.42283;
        <D.42281>:
      }
      code.4325 = code;
      code = code.4325 + 1;
      *code.4325 = 51;
      code.4326 = code;
      code = code.4326 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.33725 = D.32642 | -64;
      D.31589 = ins->dreg;
      D.31631 = (signed char) D.31589;
      D.31632 = D.31631 & 7;
      D.37520 = D.33725 | D.31632;
      D.37521 = (unsigned char) D.37520;
      *code.4326 = D.37521;
      i = 0;
      goto <D.26653>;
      <D.26652>:
      if (0 != 0) goto <D.42286>; else goto <D.42287>;
      <D.42286>:
      code.4327 = code;
      code = code.4327 + 1;
      *code.4327 = 102;
      <D.42287>:
      {
        unsigned char _amd64_rex_bits;

        D.31589 = ins->dreg;
        if (D.31589 > 7) goto <D.42290>; else goto <D.42291>;
        <D.42290>:
        iftmp.4328 = 12;
        goto <D.42292>;
        <D.42291>:
        iftmp.4328 = 8;
        <D.42292>:
        _amd64_rex_bits = iftmp.4328;
        if (_amd64_rex_bits != 0) goto <D.42293>; else goto <D.42294>;
        <D.42293>:
        code.4329 = code;
        code = code.4329 + 1;
        D.42296 = _amd64_rex_bits | 64;
        *code.4329 = D.42296;
        <D.42294>:
      }
      switch (8) <default: <D.26648>, case 1: <D.26643>, case 2: <D.26645>, case 4: <D.26646>, case 8: <D.26647>>
      <D.26643>:
      code.4330 = code;
      code = code.4330 + 1;
      *code.4330 = 136;
      goto <D.26644>;
      <D.26645>:
      <D.26646>:
      <D.26647>:
      code.4331 = code;
      code = code.4331 + 1;
      *code.4331 = 137;
      goto <D.26644>;
      <D.26648>:
      __assert_fail ("0", "mini-amd64.c", 5075, &__PRETTY_FUNCTION__);
      <D.26644>:
      if (1 != 0) goto <D.42299>; else goto <D.42300>;
      <D.42299>:
      if (i == 0) goto <D.42301>; else goto <D.42302>;
      <D.42301>:
      code.4332 = code;
      code = code.4332 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.32643 = D.32642 | 4;
      D.32644 = (unsigned char) D.32643;
      *code.4332 = D.32644;
      code.4333 = code;
      code = code.4333 + 1;
      *code.4333 = 36;
      goto <D.42305>;
      <D.42302>:
      i.4334 = (unsigned int) i;
      D.42307 = i.4334 + 128;
      if (D.42307 <= 255) goto <D.42308>; else goto <D.42309>;
      <D.42308>:
      code.4335 = code;
      code = code.4335 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.32734 = D.32642 | 68;
      D.32735 = (unsigned char) D.32734;
      *code.4335 = D.32735;
      code.4336 = code;
      code = code.4336 + 1;
      *code.4336 = 36;
      D.42312 = (unsigned char) i;
      *code = D.42312;
      code = code + 1;
      goto <D.42313>;
      <D.42309>:
      code.4337 = code;
      code = code.4337 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.32739 = D.32642 | -124;
      D.32740 = (unsigned char) D.32739;
      *code.4337 = D.32740;
      code.4338 = code;
      code = code.4338 + 1;
      *code.4338 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = i;
            code.4339 = code;
            code = code.4339 + 1;
            D.42317 = imb.b[0];
            *code.4339 = D.42317;
            code.4340 = code;
            code = code.4340 + 1;
            D.42319 = imb.b[1];
            *code.4340 = D.42319;
            code.4341 = code;
            code = code.4341 + 1;
            D.42321 = imb.b[2];
            *code.4341 = D.42321;
            code.4342 = code;
            code = code.4342 + 1;
            D.42323 = imb.b[3];
            *code.4342 = D.42323;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.42313>:
      <D.42305>:
      goto <D.26650>;
      <D.42300>:
      if (i == 0) goto <D.42324>; else goto <D.42325>;
      <D.42324>:
      code.4343 = code;
      code = code.4343 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.32643 = D.32642 | 4;
      D.32644 = (unsigned char) D.32643;
      *code.4343 = D.32644;
      goto <D.26650>;
      <D.42325>:
      i.4334 = (unsigned int) i;
      D.42307 = i.4334 + 128;
      if (D.42307 <= 255) goto <D.42327>; else goto <D.42328>;
      <D.42327>:
      code.4344 = code;
      code = code.4344 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.32734 = D.32642 | 68;
      D.32735 = (unsigned char) D.32734;
      *code.4344 = D.32735;
      D.42312 = (unsigned char) i;
      *code = D.42312;
      code = code + 1;
      goto <D.42330>;
      <D.42328>:
      code.4345 = code;
      code = code.4345 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.32739 = D.32642 | -124;
      D.32740 = (unsigned char) D.32739;
      *code.4345 = D.32740;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = i;
            code.4346 = code;
            code = code.4346 + 1;
            D.42333 = imb.b[0];
            *code.4346 = D.42333;
            code.4347 = code;
            code = code.4347 + 1;
            D.42335 = imb.b[1];
            *code.4347 = D.42335;
            code.4348 = code;
            code = code.4348 + 1;
            D.42337 = imb.b[2];
            *code.4348 = D.42337;
            code.4349 = code;
            code = code.4349 + 1;
            D.42339 = imb.b[3];
            *code.4349 = D.42339;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.42330>:
      <D.26650>:
      i = i + 8;
      <D.26653>:
      i.4350 = (unsigned int) i;
      if (i.4350 < size) goto <D.26652>; else goto <D.26654>;
      <D.26654>:
      if (0 != 0) goto <D.42341>; else goto <D.42342>;
      <D.42341>:
      code.4351 = code;
      code = code.4351 + 1;
      *code.4351 = 102;
      <D.42342>:
      {
        unsigned char _amd64_rex_bits;

        D.31589 = ins->dreg;
        if (D.31589 > 7) goto <D.42345>; else goto <D.42346>;
        <D.42345>:
        iftmp.4352 = 12;
        goto <D.42347>;
        <D.42346>:
        iftmp.4352 = 8;
        <D.42347>:
        _amd64_rex_bits = iftmp.4352;
        if (_amd64_rex_bits != 0) goto <D.42348>; else goto <D.42349>;
        <D.42348>:
        code.4353 = code;
        code = code.4353 + 1;
        D.42351 = _amd64_rex_bits | 64;
        *code.4353 = D.42351;
        <D.42349>:
      }
      switch (8) <default: <D.26661>, case 1: <D.26656>, case 2: <D.26658>, case 4: <D.26659>, case 8: <D.26660>>
      <D.26656>:
      code.4354 = code;
      code = code.4354 + 1;
      *code.4354 = 138;
      goto <D.26657>;
      <D.26658>:
      <D.26659>:
      <D.26660>:
      code.4355 = code;
      code = code.4355 + 1;
      *code.4355 = 139;
      goto <D.26657>;
      <D.26661>:
      __assert_fail ("0", "mini-amd64.c", 5076, &__PRETTY_FUNCTION__);
      <D.26657>:
      code.4356 = code;
      code = code.4356 + 1;
      D.31589 = ins->dreg;
      D.31598 = D.31589 & 7;
      D.32641 = D.31598 << 3;
      D.32642 = (signed char) D.32641;
      D.42169 = D.32642 | -60;
      D.42170 = (unsigned char) D.42169;
      *code.4356 = D.42170;
    }
    goto <D.42355>;
    <D.42230>:
    {
      int _amd64_width_temp;

      D.42356 = (long unsigned int) size;
      size.4306 = (int) size;
      D.42357 = (long unsigned int) size.4306;
      D.42358 = D.42356 == D.42357;
      _amd64_width_temp = (int) D.42358;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.42360>; else goto <D.42361>;
        <D.42360>:
        iftmp.4357 = 8;
        goto <D.42362>;
        <D.42361>:
        iftmp.4357 = 0;
        <D.42362>:
        D.31589 = ins->dreg;
        D.31590 = D.31589 > 7;
        D.32040 = (signed char) D.31590;
        D.42363 = iftmp.4357 | D.32040;
        _amd64_rex_bits = (unsigned char) D.42363;
        if (_amd64_rex_bits != 0) goto <D.42364>; else goto <D.42365>;
        <D.42364>:
        code.4358 = code;
        code = code.4358 + 1;
        D.42367 = _amd64_rex_bits | 64;
        *code.4358 = D.42367;
        <D.42365>:
      }
      code.4359 = code;
      code = code.4359 + 1;
      D.31589 = ins->dreg;
      D.31626 = (unsigned char) D.31589;
      D.31627 = D.31626 & 7;
      D.32668 = D.31627 + 184;
      *code.4359 = D.32668;
      if (_amd64_width_temp == 0) goto <D.42369>; else goto <D.42370>;
      <D.42369>:
      {
        union amd64_imm_buf imb;

        try
          {
            D.42356 = (long unsigned int) size;
            imb.val = D.42356;
            code.4360 = code;
            code = code.4360 + 1;
            D.42372 = imb.b[0];
            *code.4360 = D.42372;
            code.4361 = code;
            code = code.4361 + 1;
            D.42374 = imb.b[1];
            *code.4361 = D.42374;
            code.4362 = code;
            code = code.4362 + 1;
            D.42376 = imb.b[2];
            *code.4362 = D.42376;
            code.4363 = code;
            code = code.4363 + 1;
            D.42378 = imb.b[3];
            *code.4363 = D.42378;
            code.4364 = code;
            code = code.4364 + 1;
            D.42380 = imb.b[4];
            *code.4364 = D.42380;
            code.4365 = code;
            code = code.4365 + 1;
            D.42382 = imb.b[5];
            *code.4365 = D.42382;
            code.4366 = code;
            code = code.4366 + 1;
            D.42384 = imb.b[6];
            *code.4366 = D.42384;
            code.4367 = code;
            code = code.4367 + 1;
            D.42386 = imb.b[7];
            *code.4367 = D.42386;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.42387>;
      <D.42370>:
      {
        union x86_imm_buf imb;

        try
          {
            size.4306 = (int) size;
            imb.val = size.4306;
            code.4368 = code;
            code = code.4368 + 1;
            D.42389 = imb.b[0];
            *code.4368 = D.42389;
            code.4369 = code;
            code = code.4369 + 1;
            D.42391 = imb.b[1];
            *code.4369 = D.42391;
            code.4370 = code;
            code = code.4370 + 1;
            D.42393 = imb.b[2];
            *code.4370 = D.42393;
            code.4371 = code;
            code = code.4371 + 1;
            D.42395 = imb.b[3];
            *code.4371 = D.42395;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.42387>:
    }
    D.31589 = ins->dreg;
    ins->sreg1 = D.31589;
    code = mono_emit_stack_alloc (cfg, code, ins);
    if (0 != 0) goto <D.42396>; else goto <D.42397>;
    <D.42396>:
    code.4372 = code;
    code = code.4372 + 1;
    *code.4372 = 102;
    <D.42397>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.42400>; else goto <D.42401>;
      <D.42400>:
      iftmp.4373 = 12;
      goto <D.42402>;
      <D.42401>:
      iftmp.4373 = 8;
      <D.42402>:
      _amd64_rex_bits = iftmp.4373;
      if (_amd64_rex_bits != 0) goto <D.42403>; else goto <D.42404>;
      <D.42403>:
      code.4374 = code;
      code = code.4374 + 1;
      D.42406 = _amd64_rex_bits | 64;
      *code.4374 = D.42406;
      <D.42404>:
    }
    switch (8) <default: <D.26672>, case 1: <D.26667>, case 2: <D.26669>, case 4: <D.26670>, case 8: <D.26671>>
    <D.26667>:
    code.4375 = code;
    code = code.4375 + 1;
    *code.4375 = 138;
    goto <D.26668>;
    <D.26669>:
    <D.26670>:
    <D.26671>:
    code.4376 = code;
    code = code.4376 + 1;
    *code.4376 = 139;
    goto <D.26668>;
    <D.26672>:
    __assert_fail ("0", "mini-amd64.c", 5082, &__PRETTY_FUNCTION__);
    <D.26668>:
    code.4377 = code;
    code = code.4377 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.42169 = D.32642 | -60;
    D.42170 = (unsigned char) D.42169;
    *code.4377 = D.42170;
    <D.42355>:
    goto <D.42410>;
    <D.42228>:
    size.4306 = (int) size;
    D.42232 = size.4306 >= -128;
    size.4306 = (int) size;
    D.42233 = size.4306 <= 127;
    D.42234 = D.42232 & D.42233;
    if (D.42234 != 0) goto <D.42411>; else goto <D.42412>;
    <D.42411>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42413>; else goto <D.42414>;
      <D.42413>:
      code.4378 = code;
      code = code.4378 + 1;
      D.42416 = _amd64_rex_bits | 64;
      *code.4378 = D.42416;
      <D.42414>:
    }
    code.4379 = code;
    code = code.4379 + 1;
    *code.4379 = 131;
    code.4380 = code;
    code = code.4380 + 1;
    *code.4380 = 236;
    D.42243 = (unsigned char) size;
    *code = D.42243;
    code = code + 1;
    goto <D.42419>;
    <D.42412>:
    if (0 != 0) goto <D.42420>; else goto <D.42421>;
    <D.42420>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42422>; else goto <D.42423>;
      <D.42422>:
      code.4381 = code;
      code = code.4381 + 1;
      D.42425 = _amd64_rex_bits | 64;
      *code.4381 = D.42425;
      <D.42423>:
    }
    code.4382 = code;
    code = code.4382 + 1;
    *code.4382 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          size.4306 = (int) size;
          imb.val = size.4306;
          code.4383 = code;
          code = code.4383 + 1;
          D.42428 = imb.b[0];
          *code.4383 = D.42428;
          code.4384 = code;
          code = code.4384 + 1;
          D.42430 = imb.b[1];
          *code.4384 = D.42430;
          code.4385 = code;
          code = code.4385 + 1;
          D.42432 = imb.b[2];
          *code.4385 = D.42432;
          code.4386 = code;
          code = code.4386 + 1;
          D.42434 = imb.b[3];
          *code.4386 = D.42434;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.42435>;
    <D.42421>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42436>; else goto <D.42437>;
      <D.42436>:
      code.4387 = code;
      code = code.4387 + 1;
      D.42439 = _amd64_rex_bits | 64;
      *code.4387 = D.42439;
      <D.42437>:
    }
    code.4388 = code;
    code = code.4388 + 1;
    *code.4388 = 129;
    code.4389 = code;
    code = code.4389 + 1;
    *code.4389 = 236;
    {
      union x86_imm_buf imb;

      try
        {
          size.4306 = (int) size;
          imb.val = size.4306;
          code.4390 = code;
          code = code.4390 + 1;
          D.42443 = imb.b[0];
          *code.4390 = D.42443;
          code.4391 = code;
          code = code.4391 + 1;
          D.42445 = imb.b[1];
          *code.4391 = D.42445;
          code.4392 = code;
          code = code.4392 + 1;
          D.42447 = imb.b[2];
          *code.4392 = D.42447;
          code.4393 = code;
          code = code.4393 + 1;
          D.42449 = imb.b[3];
          *code.4393 = D.42449;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42435>:
    <D.42419>:
    if (0 != 0) goto <D.42450>; else goto <D.42451>;
    <D.42450>:
    code.4394 = code;
    code = code.4394 + 1;
    *code.4394 = 102;
    <D.42451>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.42454>; else goto <D.42455>;
      <D.42454>:
      iftmp.4395 = 12;
      goto <D.42456>;
      <D.42455>:
      iftmp.4395 = 8;
      <D.42456>:
      _amd64_rex_bits = iftmp.4395;
      if (_amd64_rex_bits != 0) goto <D.42457>; else goto <D.42458>;
      <D.42457>:
      code.4396 = code;
      code = code.4396 + 1;
      D.42460 = _amd64_rex_bits | 64;
      *code.4396 = D.42460;
      <D.42458>:
    }
    switch (8) <default: <D.26684>, case 1: <D.26679>, case 2: <D.26681>, case 4: <D.26682>, case 8: <D.26683>>
    <D.26679>:
    code.4397 = code;
    code = code.4397 + 1;
    *code.4397 = 138;
    goto <D.26680>;
    <D.26681>:
    <D.26682>:
    <D.26683>:
    code.4398 = code;
    code = code.4398 + 1;
    *code.4398 = 139;
    goto <D.26680>;
    <D.26684>:
    __assert_fail ("0", "mini-amd64.c", 5086, &__PRETTY_FUNCTION__);
    <D.26680>:
    code.4399 = code;
    code = code.4399 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.42169 = D.32642 | -60;
    D.42170 = (unsigned char) D.42169;
    *code.4399 = D.42170;
    <D.42410>:
    D.42171 = cfg->param_area;
    if (D.42171 != 0) goto <D.42464>; else goto <D.42465>;
    <D.42464>:
    D.40891 = cfg->arch.no_pushes;
    if (D.40891 != 0) goto <D.42466>; else goto <D.42467>;
    <D.42466>:
    D.42171 = cfg->param_area;
    D.42178 = (int) D.42171;
    if (D.42178 >= -128) goto <D.42470>; else goto <D.42468>;
    <D.42470>:
    D.42171 = cfg->param_area;
    D.42178 = (int) D.42171;
    if (D.42178 <= 127) goto <D.42471>; else goto <D.42468>;
    <D.42471>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.42473>; else goto <D.42474>;
      <D.42473>:
      iftmp.4400 = 9;
      goto <D.42475>;
      <D.42474>:
      iftmp.4400 = 8;
      <D.42475>:
      _amd64_rex_bits = iftmp.4400;
      if (_amd64_rex_bits != 0) goto <D.42476>; else goto <D.42477>;
      <D.42476>:
      code.4401 = code;
      code = code.4401 + 1;
      D.42479 = _amd64_rex_bits | 64;
      *code.4401 = D.42479;
      <D.42477>:
    }
    code.4402 = code;
    code = code.4402 + 1;
    *code.4402 = 131;
    code.4403 = code;
    code = code.4403 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.4403 = D.35110;
    D.42171 = cfg->param_area;
    D.42191 = (unsigned char) D.42171;
    *code = D.42191;
    code = code + 1;
    goto <D.42469>;
    <D.42468>:
    D.31589 = ins->dreg;
    if (D.31589 == 0) goto <D.42482>; else goto <D.42483>;
    <D.42482>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42484>; else goto <D.42485>;
      <D.42484>:
      code.4404 = code;
      code = code.4404 + 1;
      D.42487 = _amd64_rex_bits | 64;
      *code.4404 = D.42487;
      <D.42485>:
    }
    code.4405 = code;
    code = code.4405 + 1;
    *code.4405 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          D.42171 = cfg->param_area;
          D.42178 = (int) D.42171;
          imb.val = D.42178;
          code.4406 = code;
          code = code.4406 + 1;
          D.42490 = imb.b[0];
          *code.4406 = D.42490;
          code.4407 = code;
          code = code.4407 + 1;
          D.42492 = imb.b[1];
          *code.4407 = D.42492;
          code.4408 = code;
          code = code.4408 + 1;
          D.42494 = imb.b[2];
          *code.4408 = D.42494;
          code.4409 = code;
          code = code.4409 + 1;
          D.42496 = imb.b[3];
          *code.4409 = D.42496;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.42497>;
    <D.42483>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.42499>; else goto <D.42500>;
      <D.42499>:
      iftmp.4410 = 9;
      goto <D.42501>;
      <D.42500>:
      iftmp.4410 = 8;
      <D.42501>:
      _amd64_rex_bits = iftmp.4410;
      if (_amd64_rex_bits != 0) goto <D.42502>; else goto <D.42503>;
      <D.42502>:
      code.4411 = code;
      code = code.4411 + 1;
      D.42505 = _amd64_rex_bits | 64;
      *code.4411 = D.42505;
      <D.42503>:
    }
    code.4412 = code;
    code = code.4412 + 1;
    *code.4412 = 129;
    code.4413 = code;
    code = code.4413 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.4413 = D.35110;
    {
      union x86_imm_buf imb;

      try
        {
          D.42171 = cfg->param_area;
          D.42178 = (int) D.42171;
          imb.val = D.42178;
          code.4414 = code;
          code = code.4414 + 1;
          D.42509 = imb.b[0];
          *code.4414 = D.42509;
          code.4415 = code;
          code = code.4415 + 1;
          D.42511 = imb.b[1];
          *code.4415 = D.42511;
          code.4416 = code;
          code = code.4416 + 1;
          D.42513 = imb.b[2];
          *code.4416 = D.42513;
          code.4417 = code;
          code = code.4417 + 1;
          D.42515 = imb.b[3];
          *code.4417 = D.42515;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42497>:
    <D.42469>:
    <D.42467>:
    <D.42465>:
    goto <D.25197>;
  }
  <D.26690>:
  if (0 != 0) goto <D.42516>; else goto <D.42517>;
  <D.42516>:
  code.4418 = code;
  code = code.4418 + 1;
  *code.4418 = 102;
  <D.42517>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42520>; else goto <D.42521>;
    <D.42520>:
    iftmp.4419 = 9;
    goto <D.42522>;
    <D.42521>:
    iftmp.4419 = 8;
    <D.42522>:
    _amd64_rex_bits = iftmp.4419;
    if (_amd64_rex_bits != 0) goto <D.42523>; else goto <D.42524>;
    <D.42523>:
    code.4420 = code;
    code = code.4420 + 1;
    D.42526 = _amd64_rex_bits | 64;
    *code.4420 = D.42526;
    <D.42524>:
  }
  switch (8) <default: <D.26697>, case 1: <D.26692>, case 2: <D.26694>, case 4: <D.26695>, case 8: <D.26696>>
  <D.26692>:
  code.4421 = code;
  code = code.4421 + 1;
  *code.4421 = 138;
  goto <D.26693>;
  <D.26694>:
  <D.26695>:
  <D.26696>:
  code.4422 = code;
  code = code.4422 + 1;
  *code.4422 = 139;
  goto <D.26693>;
  <D.26697>:
  __assert_fail ("0", "mini-amd64.c", 5093, &__PRETTY_FUNCTION__);
  <D.26693>:
  code.4423 = code;
  code = code.4423 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.4423 = D.33839;
  code = emit_call (cfg, code, 7, "mono_arch_throw_exception", 0);
  D.36769 = ins->flags;
  D.40583 = D.36769 | 128;
  ins->flags = D.40583;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  goto <D.25197>;
  <D.26698>:
  if (0 != 0) goto <D.42530>; else goto <D.42531>;
  <D.42530>:
  code.4424 = code;
  code = code.4424 + 1;
  *code.4424 = 102;
  <D.42531>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.42534>; else goto <D.42535>;
    <D.42534>:
    iftmp.4425 = 9;
    goto <D.42536>;
    <D.42535>:
    iftmp.4425 = 8;
    <D.42536>:
    _amd64_rex_bits = iftmp.4425;
    if (_amd64_rex_bits != 0) goto <D.42537>; else goto <D.42538>;
    <D.42537>:
    code.4426 = code;
    code = code.4426 + 1;
    D.42540 = _amd64_rex_bits | 64;
    *code.4426 = D.42540;
    <D.42538>:
  }
  switch (8) <default: <D.26705>, case 1: <D.26700>, case 2: <D.26702>, case 4: <D.26703>, case 8: <D.26704>>
  <D.26700>:
  code.4427 = code;
  code = code.4427 + 1;
  *code.4427 = 138;
  goto <D.26701>;
  <D.26702>:
  <D.26703>:
  <D.26704>:
  code.4428 = code;
  code = code.4428 + 1;
  *code.4428 = 139;
  goto <D.26701>;
  <D.26705>:
  __assert_fail ("0", "mini-amd64.c", 5101, &__PRETTY_FUNCTION__);
  <D.26701>:
  code.4429 = code;
  code = code.4429 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.4429 = D.33839;
  code = emit_call (cfg, code, 7, "mono_arch_rethrow_exception", 0);
  D.36769 = ins->flags;
  D.40583 = D.36769 | 128;
  ins->flags = D.40583;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  goto <D.25197>;
  <D.26706>:
  if (1 != 0) goto <D.42544>; else goto <D.42545>;
  <D.42544>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42546>; else goto <D.42547>;
    <D.42546>:
    code.4430 = code;
    code = code.4430 + 1;
    D.42549 = _amd64_rex_bits | 64;
    *code.4430 = D.42549;
    <D.42547>:
  }
  code.4431 = code;
  code = code.4431 + 1;
  *code.4431 = 131;
  code.4432 = code;
  code = code.4432 + 1;
  *code.4432 = 236;
  *code = 8;
  code = code + 1;
  goto <D.42552>;
  <D.42545>:
  if (0 != 0) goto <D.42553>; else goto <D.42554>;
  <D.42553>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42555>; else goto <D.42556>;
    <D.42555>:
    code.4433 = code;
    code = code.4433 + 1;
    D.42558 = _amd64_rex_bits | 64;
    *code.4433 = D.42558;
    <D.42556>:
  }
  code.4434 = code;
  code = code.4434 + 1;
  *code.4434 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.4435 = code;
        code = code.4435 + 1;
        D.42561 = imb.b[0];
        *code.4435 = D.42561;
        code.4436 = code;
        code = code.4436 + 1;
        D.42563 = imb.b[1];
        *code.4436 = D.42563;
        code.4437 = code;
        code = code.4437 + 1;
        D.42565 = imb.b[2];
        *code.4437 = D.42565;
        code.4438 = code;
        code = code.4438 + 1;
        D.42567 = imb.b[3];
        *code.4438 = D.42567;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42568>;
  <D.42554>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42569>; else goto <D.42570>;
    <D.42569>:
    code.4439 = code;
    code = code.4439 + 1;
    D.42572 = _amd64_rex_bits | 64;
    *code.4439 = D.42572;
    <D.42570>:
  }
  code.4440 = code;
  code = code.4440 + 1;
  *code.4440 = 129;
  code.4441 = code;
  code = code.4441 + 1;
  *code.4441 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.4442 = code;
        code = code.4442 + 1;
        D.42576 = imb.b[0];
        *code.4442 = D.42576;
        code.4443 = code;
        code = code.4443 + 1;
        D.42578 = imb.b[1];
        *code.4443 = D.42578;
        code.4444 = code;
        code = code.4444 + 1;
        D.42580 = imb.b[2];
        *code.4444 = D.42580;
        code.4445 = code;
        code = code.4445 + 1;
        D.42582 = imb.b[3];
        *code.4445 = D.42582;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42568>:
  <D.42552>:
  D.42583 = ins->data.op[0].target_block;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.42583);
  code.4446 = code;
  code = code.4446 + 1;
  *code.4446 = 232;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4447 = code;
        code = code.4447 + 1;
        D.42586 = imb.b[0];
        *code.4447 = D.42586;
        code.4448 = code;
        code = code.4448 + 1;
        D.42588 = imb.b[1];
        *code.4448 = D.42588;
        code.4449 = code;
        code = code.4449 + 1;
        D.42590 = imb.b[2];
        *code.4449 = D.42590;
        code.4450 = code;
        code = code.4450 + 1;
        D.42592 = imb.b[3];
        *code.4450 = D.42592;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.42593 = ins->data.op[1].exception_clause;
  mono_cfg_add_try_hole (cfg, D.42593, code, bb);
  if (1 != 0) goto <D.42594>; else goto <D.42595>;
  <D.42594>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42596>; else goto <D.42597>;
    <D.42596>:
    code.4451 = code;
    code = code.4451 + 1;
    D.42599 = _amd64_rex_bits | 64;
    *code.4451 = D.42599;
    <D.42597>:
  }
  code.4452 = code;
  code = code.4452 + 1;
  *code.4452 = 131;
  code.4453 = code;
  code = code.4453 + 1;
  *code.4453 = 196;
  *code = 8;
  code = code + 1;
  goto <D.42602>;
  <D.42595>:
  if (0 != 0) goto <D.42603>; else goto <D.42604>;
  <D.42603>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42605>; else goto <D.42606>;
    <D.42605>:
    code.4454 = code;
    code = code.4454 + 1;
    D.42608 = _amd64_rex_bits | 64;
    *code.4454 = D.42608;
    <D.42606>:
  }
  code.4455 = code;
  code = code.4455 + 1;
  *code.4455 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.4456 = code;
        code = code.4456 + 1;
        D.42611 = imb.b[0];
        *code.4456 = D.42611;
        code.4457 = code;
        code = code.4457 + 1;
        D.42613 = imb.b[1];
        *code.4457 = D.42613;
        code.4458 = code;
        code = code.4458 + 1;
        D.42615 = imb.b[2];
        *code.4458 = D.42615;
        code.4459 = code;
        code = code.4459 + 1;
        D.42617 = imb.b[3];
        *code.4459 = D.42617;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42618>;
  <D.42604>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.42619>; else goto <D.42620>;
    <D.42619>:
    code.4460 = code;
    code = code.4460 + 1;
    D.42622 = _amd64_rex_bits | 64;
    *code.4460 = D.42622;
    <D.42620>:
  }
  code.4461 = code;
  code = code.4461 + 1;
  *code.4461 = 129;
  code.4462 = code;
  code = code.4462 + 1;
  *code.4462 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.4463 = code;
        code = code.4463 + 1;
        D.42626 = imb.b[0];
        *code.4463 = D.42626;
        code.4464 = code;
        code = code.4464 + 1;
        D.42628 = imb.b[1];
        *code.4464 = D.42628;
        code.4465 = code;
        code = code.4465 + 1;
        D.42630 = imb.b[2];
        *code.4465 = D.42630;
        code.4466 = code;
        code = code.4466 + 1;
        D.42632 = imb.b[3];
        *code.4466 = D.42632;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42618>:
  <D.42602>:
  goto <D.25197>;
  <D.26718>:
  {
    struct MonoInst * spvar;

    D.42633 = bb->region;
    D.42634 = (int) D.42633;
    spvar = mono_find_spvar_for_region (cfg, D.42634);
    if (0 != 0) goto <D.42635>; else goto <D.42636>;
    <D.42635>:
    code.4467 = code;
    code = code.4467 + 1;
    *code.4467 = 102;
    <D.42636>:
    {
      unsigned char _amd64_rex_bits;

      D.42639 = spvar->sreg1;
      if (D.42639 > 7) goto <D.42640>; else goto <D.42641>;
      <D.42640>:
      iftmp.4468 = 9;
      goto <D.42642>;
      <D.42641>:
      iftmp.4468 = 8;
      <D.42642>:
      _amd64_rex_bits = iftmp.4468;
      if (_amd64_rex_bits != 0) goto <D.42643>; else goto <D.42644>;
      <D.42643>:
      code.4469 = code;
      code = code.4469 + 1;
      D.42646 = _amd64_rex_bits | 64;
      *code.4469 = D.42646;
      <D.42644>:
    }
    switch (8) <default: <D.26726>, case 1: <D.26721>, case 2: <D.26723>, case 4: <D.26724>, case 8: <D.26725>>
    <D.26721>:
    code.4470 = code;
    code = code.4470 + 1;
    *code.4470 = 136;
    goto <D.26722>;
    <D.26723>:
    <D.26724>:
    <D.26725>:
    code.4471 = code;
    code = code.4471 + 1;
    *code.4471 = 137;
    goto <D.26722>;
    <D.26726>:
    __assert_fail ("0", "mini-amd64.c", 5122, &__PRETTY_FUNCTION__);
    <D.26722>:
    D.42639 = spvar->sreg1;
    D.42649 = D.42639 & 7;
    if (D.42649 == 4) goto <D.42650>; else goto <D.42651>;
    <D.42650>:
    D.42652 = spvar->data.op[0].const_val;
    if (D.42652 == 0) goto <D.42653>; else goto <D.42654>;
    <D.42653>:
    code.4472 = code;
    code = code.4472 + 1;
    *code.4472 = 36;
    code.4473 = code;
    code = code.4473 + 1;
    *code.4473 = 36;
    goto <D.42657>;
    <D.42654>:
    D.42652 = spvar->data.op[0].const_val;
    D.42658 = (unsigned int) D.42652;
    D.42659 = D.42658 + 128;
    if (D.42659 <= 255) goto <D.42660>; else goto <D.42661>;
    <D.42660>:
    code.4474 = code;
    code = code.4474 + 1;
    *code.4474 = 100;
    code.4475 = code;
    code = code.4475 + 1;
    *code.4475 = 36;
    D.42652 = spvar->data.op[0].const_val;
    D.42664 = (unsigned char) D.42652;
    *code = D.42664;
    code = code + 1;
    goto <D.42665>;
    <D.42661>:
    code.4476 = code;
    code = code.4476 + 1;
    *code.4476 = 164;
    code.4477 = code;
    code = code.4477 + 1;
    *code.4477 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.42652 = spvar->data.op[0].const_val;
          D.42668 = (int) D.42652;
          imb.val = D.42668;
          code.4478 = code;
          code = code.4478 + 1;
          D.42670 = imb.b[0];
          *code.4478 = D.42670;
          code.4479 = code;
          code = code.4479 + 1;
          D.42672 = imb.b[1];
          *code.4479 = D.42672;
          code.4480 = code;
          code = code.4480 + 1;
          D.42674 = imb.b[2];
          *code.4480 = D.42674;
          code.4481 = code;
          code = code.4481 + 1;
          D.42676 = imb.b[3];
          *code.4481 = D.42676;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42665>:
    <D.42657>:
    goto <D.26728>;
    <D.42651>:
    D.42652 = spvar->data.op[0].const_val;
    if (D.42652 == 0) goto <D.42677>; else goto <D.42678>;
    <D.42677>:
    D.42639 = spvar->sreg1;
    D.42649 = D.42639 & 7;
    if (D.42649 != 5) goto <D.42679>; else goto <D.42680>;
    <D.42679>:
    code.4482 = code;
    code = code.4482 + 1;
    D.42639 = spvar->sreg1;
    D.42682 = (signed char) D.42639;
    D.42683 = D.42682 & 7;
    D.42684 = D.42683 | 32;
    D.42685 = (unsigned char) D.42684;
    *code.4482 = D.42685;
    goto <D.26728>;
    <D.42680>:
    <D.42678>:
    D.42652 = spvar->data.op[0].const_val;
    D.42658 = (unsigned int) D.42652;
    D.42659 = D.42658 + 128;
    if (D.42659 <= 255) goto <D.42686>; else goto <D.42687>;
    <D.42686>:
    code.4483 = code;
    code = code.4483 + 1;
    D.42639 = spvar->sreg1;
    D.42682 = (signed char) D.42639;
    D.42683 = D.42682 & 7;
    D.42689 = D.42683 | 96;
    D.42690 = (unsigned char) D.42689;
    *code.4483 = D.42690;
    D.42652 = spvar->data.op[0].const_val;
    D.42664 = (unsigned char) D.42652;
    *code = D.42664;
    code = code + 1;
    goto <D.42691>;
    <D.42687>:
    code.4484 = code;
    code = code.4484 + 1;
    D.42639 = spvar->sreg1;
    D.42682 = (signed char) D.42639;
    D.42683 = D.42682 & 7;
    D.42693 = D.42683 | -96;
    D.42694 = (unsigned char) D.42693;
    *code.4484 = D.42694;
    {
      union x86_imm_buf imb;

      try
        {
          D.42652 = spvar->data.op[0].const_val;
          D.42668 = (int) D.42652;
          imb.val = D.42668;
          code.4485 = code;
          code = code.4485 + 1;
          D.42696 = imb.b[0];
          *code.4485 = D.42696;
          code.4486 = code;
          code = code.4486 + 1;
          D.42698 = imb.b[1];
          *code.4486 = D.42698;
          code.4487 = code;
          code = code.4487 + 1;
          D.42700 = imb.b[2];
          *code.4487 = D.42700;
          code.4488 = code;
          code = code.4488 + 1;
          D.42702 = imb.b[3];
          *code.4488 = D.42702;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42691>:
    <D.26728>:
    D.42633 = bb->region;
    D.42703 = D.42633 & 240;
    if (D.42703 == 16) goto <D.42704>; else goto <D.42705>;
    <D.42704>:
    D.42171 = cfg->param_area;
    if (D.42171 != 0) goto <D.42706>; else goto <D.42707>;
    <D.42706>:
    D.40891 = cfg->arch.no_pushes;
    if (D.40891 != 0) goto <D.42708>; else goto <D.42709>;
    <D.42708>:
    D.42171 = cfg->param_area;
    D.42710 = D.42171 + 15;
    D.42711 = D.42710 & 4294967280;
    D.42712 = D.42711 + 128;
    if (D.42712 <= 255) goto <D.42713>; else goto <D.42714>;
    <D.42713>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42715>; else goto <D.42716>;
      <D.42715>:
      code.4489 = code;
      code = code.4489 + 1;
      D.42718 = _amd64_rex_bits | 64;
      *code.4489 = D.42718;
      <D.42716>:
    }
    code.4490 = code;
    code = code.4490 + 1;
    *code.4490 = 131;
    code.4491 = code;
    code = code.4491 + 1;
    *code.4491 = 236;
    D.42171 = cfg->param_area;
    D.42191 = (unsigned char) D.42171;
    D.42721 = D.42191 + 15;
    D.42722 = D.42721 & 240;
    *code = D.42722;
    code = code + 1;
    goto <D.42723>;
    <D.42714>:
    if (0 != 0) goto <D.42724>; else goto <D.42725>;
    <D.42724>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42726>; else goto <D.42727>;
      <D.42726>:
      code.4492 = code;
      code = code.4492 + 1;
      D.42729 = _amd64_rex_bits | 64;
      *code.4492 = D.42729;
      <D.42727>:
    }
    code.4493 = code;
    code = code.4493 + 1;
    *code.4493 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          D.42171 = cfg->param_area;
          D.42710 = D.42171 + 15;
          D.42731 = (int) D.42710;
          D.42732 = D.42731 & -16;
          imb.val = D.42732;
          code.4494 = code;
          code = code.4494 + 1;
          D.42734 = imb.b[0];
          *code.4494 = D.42734;
          code.4495 = code;
          code = code.4495 + 1;
          D.42736 = imb.b[1];
          *code.4495 = D.42736;
          code.4496 = code;
          code = code.4496 + 1;
          D.42738 = imb.b[2];
          *code.4496 = D.42738;
          code.4497 = code;
          code = code.4497 + 1;
          D.42740 = imb.b[3];
          *code.4497 = D.42740;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.42741>;
    <D.42725>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.42742>; else goto <D.42743>;
      <D.42742>:
      code.4498 = code;
      code = code.4498 + 1;
      D.42745 = _amd64_rex_bits | 64;
      *code.4498 = D.42745;
      <D.42743>:
    }
    code.4499 = code;
    code = code.4499 + 1;
    *code.4499 = 129;
    code.4500 = code;
    code = code.4500 + 1;
    *code.4500 = 236;
    {
      union x86_imm_buf imb;

      try
        {
          D.42171 = cfg->param_area;
          D.42710 = D.42171 + 15;
          D.42731 = (int) D.42710;
          D.42732 = D.42731 & -16;
          imb.val = D.42732;
          code.4501 = code;
          code = code.4501 + 1;
          D.42749 = imb.b[0];
          *code.4501 = D.42749;
          code.4502 = code;
          code = code.4502 + 1;
          D.42751 = imb.b[1];
          *code.4502 = D.42751;
          code.4503 = code;
          code = code.4503 + 1;
          D.42753 = imb.b[2];
          *code.4503 = D.42753;
          code.4504 = code;
          code = code.4504 + 1;
          D.42755 = imb.b[3];
          *code.4504 = D.42755;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42741>:
    <D.42723>:
    <D.42709>:
    <D.42707>:
    <D.42705>:
    goto <D.25197>;
  }
  <D.26735>:
  {
    struct MonoInst * spvar;

    D.42633 = bb->region;
    D.42634 = (int) D.42633;
    spvar = mono_find_spvar_for_region (cfg, D.42634);
    if (0 != 0) goto <D.42756>; else goto <D.42757>;
    <D.42756>:
    code.4505 = code;
    code = code.4505 + 1;
    *code.4505 = 102;
    <D.42757>:
    {
      unsigned char _amd64_rex_bits;

      D.42760 = spvar->sreg1;
      if (D.42760 > 7) goto <D.42761>; else goto <D.42762>;
      <D.42761>:
      iftmp.4506 = 9;
      goto <D.42763>;
      <D.42762>:
      iftmp.4506 = 8;
      <D.42763>:
      _amd64_rex_bits = iftmp.4506;
      if (_amd64_rex_bits != 0) goto <D.42764>; else goto <D.42765>;
      <D.42764>:
      code.4507 = code;
      code = code.4507 + 1;
      D.42767 = _amd64_rex_bits | 64;
      *code.4507 = D.42767;
      <D.42765>:
    }
    switch (8) <default: <D.26743>, case 1: <D.26738>, case 2: <D.26740>, case 4: <D.26741>, case 8: <D.26742>>
    <D.26738>:
    code.4508 = code;
    code = code.4508 + 1;
    *code.4508 = 138;
    goto <D.26739>;
    <D.26740>:
    <D.26741>:
    <D.26742>:
    code.4509 = code;
    code = code.4509 + 1;
    *code.4509 = 139;
    goto <D.26739>;
    <D.26743>:
    __assert_fail ("0", "mini-amd64.c", 5133, &__PRETTY_FUNCTION__);
    <D.26739>:
    D.42760 = spvar->sreg1;
    if (D.42760 == 16) goto <D.42770>; else goto <D.42771>;
    <D.42770>:
    code.4510 = code;
    code = code.4510 + 1;
    *code.4510 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          D.42773 = spvar->data.op[0].const_val;
          D.42774 = (int) D.42773;
          imb.val = D.42774;
          code.4511 = code;
          code = code.4511 + 1;
          D.42776 = imb.b[0];
          *code.4511 = D.42776;
          code.4512 = code;
          code = code.4512 + 1;
          D.42778 = imb.b[1];
          *code.4512 = D.42778;
          code.4513 = code;
          code = code.4513 + 1;
          D.42780 = imb.b[2];
          *code.4513 = D.42780;
          code.4514 = code;
          code = code.4514 + 1;
          D.42782 = imb.b[3];
          *code.4514 = D.42782;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.42783>;
    <D.42771>:
    D.42760 = spvar->sreg1;
    D.42784 = D.42760 & 7;
    if (D.42784 == 4) goto <D.42785>; else goto <D.42786>;
    <D.42785>:
    D.42773 = spvar->data.op[0].const_val;
    if (D.42773 == 0) goto <D.42787>; else goto <D.42788>;
    <D.42787>:
    code.4515 = code;
    code = code.4515 + 1;
    *code.4515 = 36;
    code.4516 = code;
    code = code.4516 + 1;
    *code.4516 = 36;
    goto <D.42791>;
    <D.42788>:
    D.42773 = spvar->data.op[0].const_val;
    D.42792 = (unsigned int) D.42773;
    D.42793 = D.42792 + 128;
    if (D.42793 <= 255) goto <D.42794>; else goto <D.42795>;
    <D.42794>:
    code.4517 = code;
    code = code.4517 + 1;
    *code.4517 = 100;
    code.4518 = code;
    code = code.4518 + 1;
    *code.4518 = 36;
    D.42773 = spvar->data.op[0].const_val;
    D.42798 = (unsigned char) D.42773;
    *code = D.42798;
    code = code + 1;
    goto <D.42799>;
    <D.42795>:
    code.4519 = code;
    code = code.4519 + 1;
    *code.4519 = 164;
    code.4520 = code;
    code = code.4520 + 1;
    *code.4520 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.42773 = spvar->data.op[0].const_val;
          D.42774 = (int) D.42773;
          imb.val = D.42774;
          code.4521 = code;
          code = code.4521 + 1;
          D.42803 = imb.b[0];
          *code.4521 = D.42803;
          code.4522 = code;
          code = code.4522 + 1;
          D.42805 = imb.b[1];
          *code.4522 = D.42805;
          code.4523 = code;
          code = code.4523 + 1;
          D.42807 = imb.b[2];
          *code.4523 = D.42807;
          code.4524 = code;
          code = code.4524 + 1;
          D.42809 = imb.b[3];
          *code.4524 = D.42809;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42799>:
    <D.42791>:
    goto <D.26746>;
    <D.42786>:
    D.42773 = spvar->data.op[0].const_val;
    if (D.42773 == 0) goto <D.42810>; else goto <D.42811>;
    <D.42810>:
    D.42760 = spvar->sreg1;
    D.42784 = D.42760 & 7;
    if (D.42784 != 5) goto <D.42812>; else goto <D.42813>;
    <D.42812>:
    code.4525 = code;
    code = code.4525 + 1;
    D.42760 = spvar->sreg1;
    D.42815 = (signed char) D.42760;
    D.42816 = D.42815 & 7;
    D.42817 = D.42816 | 32;
    D.42818 = (unsigned char) D.42817;
    *code.4525 = D.42818;
    goto <D.26746>;
    <D.42813>:
    <D.42811>:
    D.42773 = spvar->data.op[0].const_val;
    D.42792 = (unsigned int) D.42773;
    D.42793 = D.42792 + 128;
    if (D.42793 <= 255) goto <D.42819>; else goto <D.42820>;
    <D.42819>:
    code.4526 = code;
    code = code.4526 + 1;
    D.42760 = spvar->sreg1;
    D.42815 = (signed char) D.42760;
    D.42816 = D.42815 & 7;
    D.42822 = D.42816 | 96;
    D.42823 = (unsigned char) D.42822;
    *code.4526 = D.42823;
    D.42773 = spvar->data.op[0].const_val;
    D.42798 = (unsigned char) D.42773;
    *code = D.42798;
    code = code + 1;
    goto <D.42824>;
    <D.42820>:
    code.4527 = code;
    code = code.4527 + 1;
    D.42760 = spvar->sreg1;
    D.42815 = (signed char) D.42760;
    D.42816 = D.42815 & 7;
    D.42826 = D.42816 | -96;
    D.42827 = (unsigned char) D.42826;
    *code.4527 = D.42827;
    {
      union x86_imm_buf imb;

      try
        {
          D.42773 = spvar->data.op[0].const_val;
          D.42774 = (int) D.42773;
          imb.val = D.42774;
          code.4528 = code;
          code = code.4528 + 1;
          D.42829 = imb.b[0];
          *code.4528 = D.42829;
          code.4529 = code;
          code = code.4529 + 1;
          D.42831 = imb.b[1];
          *code.4529 = D.42831;
          code.4530 = code;
          code = code.4530 + 1;
          D.42833 = imb.b[2];
          *code.4530 = D.42833;
          code.4531 = code;
          code = code.4531 + 1;
          D.42835 = imb.b[3];
          *code.4531 = D.42835;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42824>:
    <D.26746>:
    <D.42783>:
    code.4532 = code;
    code = code.4532 + 1;
    *code.4532 = 195;
    goto <D.25197>;
  }
  <D.26748>:
  {
    struct MonoInst * spvar;

    D.42633 = bb->region;
    D.42634 = (int) D.42633;
    spvar = mono_find_spvar_for_region (cfg, D.42634);
    if (0 != 0) goto <D.42837>; else goto <D.42838>;
    <D.42837>:
    code.4533 = code;
    code = code.4533 + 1;
    *code.4533 = 102;
    <D.42838>:
    {
      unsigned char _amd64_rex_bits;

      D.42841 = spvar->sreg1;
      if (D.42841 > 7) goto <D.42842>; else goto <D.42843>;
      <D.42842>:
      iftmp.4534 = 9;
      goto <D.42844>;
      <D.42843>:
      iftmp.4534 = 8;
      <D.42844>:
      _amd64_rex_bits = iftmp.4534;
      if (_amd64_rex_bits != 0) goto <D.42845>; else goto <D.42846>;
      <D.42845>:
      code.4535 = code;
      code = code.4535 + 1;
      D.42848 = _amd64_rex_bits | 64;
      *code.4535 = D.42848;
      <D.42846>:
    }
    switch (8) <default: <D.26756>, case 1: <D.26751>, case 2: <D.26753>, case 4: <D.26754>, case 8: <D.26755>>
    <D.26751>:
    code.4536 = code;
    code = code.4536 + 1;
    *code.4536 = 138;
    goto <D.26752>;
    <D.26753>:
    <D.26754>:
    <D.26755>:
    code.4537 = code;
    code = code.4537 + 1;
    *code.4537 = 139;
    goto <D.26752>;
    <D.26756>:
    __assert_fail ("0", "mini-amd64.c", 5139, &__PRETTY_FUNCTION__);
    <D.26752>:
    D.42841 = spvar->sreg1;
    if (D.42841 == 16) goto <D.42851>; else goto <D.42852>;
    <D.42851>:
    code.4538 = code;
    code = code.4538 + 1;
    *code.4538 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          D.42854 = spvar->data.op[0].const_val;
          D.42855 = (int) D.42854;
          imb.val = D.42855;
          code.4539 = code;
          code = code.4539 + 1;
          D.42857 = imb.b[0];
          *code.4539 = D.42857;
          code.4540 = code;
          code = code.4540 + 1;
          D.42859 = imb.b[1];
          *code.4540 = D.42859;
          code.4541 = code;
          code = code.4541 + 1;
          D.42861 = imb.b[2];
          *code.4541 = D.42861;
          code.4542 = code;
          code = code.4542 + 1;
          D.42863 = imb.b[3];
          *code.4542 = D.42863;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.42864>;
    <D.42852>:
    D.42841 = spvar->sreg1;
    D.42865 = D.42841 & 7;
    if (D.42865 == 4) goto <D.42866>; else goto <D.42867>;
    <D.42866>:
    D.42854 = spvar->data.op[0].const_val;
    if (D.42854 == 0) goto <D.42868>; else goto <D.42869>;
    <D.42868>:
    code.4543 = code;
    code = code.4543 + 1;
    *code.4543 = 36;
    code.4544 = code;
    code = code.4544 + 1;
    *code.4544 = 36;
    goto <D.42872>;
    <D.42869>:
    D.42854 = spvar->data.op[0].const_val;
    D.42873 = (unsigned int) D.42854;
    D.42874 = D.42873 + 128;
    if (D.42874 <= 255) goto <D.42875>; else goto <D.42876>;
    <D.42875>:
    code.4545 = code;
    code = code.4545 + 1;
    *code.4545 = 100;
    code.4546 = code;
    code = code.4546 + 1;
    *code.4546 = 36;
    D.42854 = spvar->data.op[0].const_val;
    D.42879 = (unsigned char) D.42854;
    *code = D.42879;
    code = code + 1;
    goto <D.42880>;
    <D.42876>:
    code.4547 = code;
    code = code.4547 + 1;
    *code.4547 = 164;
    code.4548 = code;
    code = code.4548 + 1;
    *code.4548 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.42854 = spvar->data.op[0].const_val;
          D.42855 = (int) D.42854;
          imb.val = D.42855;
          code.4549 = code;
          code = code.4549 + 1;
          D.42884 = imb.b[0];
          *code.4549 = D.42884;
          code.4550 = code;
          code = code.4550 + 1;
          D.42886 = imb.b[1];
          *code.4550 = D.42886;
          code.4551 = code;
          code = code.4551 + 1;
          D.42888 = imb.b[2];
          *code.4551 = D.42888;
          code.4552 = code;
          code = code.4552 + 1;
          D.42890 = imb.b[3];
          *code.4552 = D.42890;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42880>:
    <D.42872>:
    goto <D.26759>;
    <D.42867>:
    D.42854 = spvar->data.op[0].const_val;
    if (D.42854 == 0) goto <D.42891>; else goto <D.42892>;
    <D.42891>:
    D.42841 = spvar->sreg1;
    D.42865 = D.42841 & 7;
    if (D.42865 != 5) goto <D.42893>; else goto <D.42894>;
    <D.42893>:
    code.4553 = code;
    code = code.4553 + 1;
    D.42841 = spvar->sreg1;
    D.42896 = (signed char) D.42841;
    D.42897 = D.42896 & 7;
    D.42898 = D.42897 | 32;
    D.42899 = (unsigned char) D.42898;
    *code.4553 = D.42899;
    goto <D.26759>;
    <D.42894>:
    <D.42892>:
    D.42854 = spvar->data.op[0].const_val;
    D.42873 = (unsigned int) D.42854;
    D.42874 = D.42873 + 128;
    if (D.42874 <= 255) goto <D.42900>; else goto <D.42901>;
    <D.42900>:
    code.4554 = code;
    code = code.4554 + 1;
    D.42841 = spvar->sreg1;
    D.42896 = (signed char) D.42841;
    D.42897 = D.42896 & 7;
    D.42903 = D.42897 | 96;
    D.42904 = (unsigned char) D.42903;
    *code.4554 = D.42904;
    D.42854 = spvar->data.op[0].const_val;
    D.42879 = (unsigned char) D.42854;
    *code = D.42879;
    code = code + 1;
    goto <D.42905>;
    <D.42901>:
    code.4555 = code;
    code = code.4555 + 1;
    D.42841 = spvar->sreg1;
    D.42896 = (signed char) D.42841;
    D.42897 = D.42896 & 7;
    D.42907 = D.42897 | -96;
    D.42908 = (unsigned char) D.42907;
    *code.4555 = D.42908;
    {
      union x86_imm_buf imb;

      try
        {
          D.42854 = spvar->data.op[0].const_val;
          D.42855 = (int) D.42854;
          imb.val = D.42855;
          code.4556 = code;
          code = code.4556 + 1;
          D.42910 = imb.b[0];
          *code.4556 = D.42910;
          code.4557 = code;
          code = code.4557 + 1;
          D.42912 = imb.b[1];
          *code.4557 = D.42912;
          code.4558 = code;
          code = code.4558 + 1;
          D.42914 = imb.b[2];
          *code.4558 = D.42914;
          code.4559 = code;
          code = code.4559 + 1;
          D.42916 = imb.b[3];
          *code.4559 = D.42916;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42905>:
    <D.26759>:
    <D.42864>:
    code.4560 = code;
    code = code.4560 + 1;
    *code.4560 = 195;
    goto <D.25197>;
  }
  <D.26761>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  ins->data.op[0].const_val = D.31452;
  goto <D.25197>;
  <D.26762>:
  D.42583 = ins->data.op[0].target_block;
  D.42918 = D.42583->native_offset;
  if (D.42918 != 0) goto <D.42919>; else goto <D.42920>;
  <D.42919>:
  D.31283 = cfg->native_code;
  D.42583 = ins->data.op[0].target_block;
  D.42918 = D.42583->native_offset;
  D.42921 = (sizetype) D.42918;
  D.42922 = D.31283 + D.42921;
  D.42923 = (long int) D.42922;
  code.211 = (long int) code;
  D.42924 = D.42923 - code.211;
  D.42925 = (unsigned long) D.42924;
  D.42926 = D.42925 + 2147483648;
  if (D.42926 <= 4294967295) goto <D.42927>; else goto <D.42928>;
  <D.42927>:
  {
    int t;

    D.31283 = cfg->native_code;
    D.42583 = ins->data.op[0].target_block;
    D.42918 = D.42583->native_offset;
    D.42921 = (sizetype) D.42918;
    D.42922 = D.31283 + D.42921;
    D.42923 = (long int) D.42922;
    code.211 = (long int) code;
    D.42924 = D.42923 - code.211;
    D.42929 = (unsigned int) D.42924;
    D.42930 = D.42929 + 4294967294;
    t = (int) D.42930;
    t.4561 = (unsigned int) t;
    D.42932 = t.4561 + 128;
    if (D.42932 <= 255) goto <D.42933>; else goto <D.42934>;
    <D.42933>:
    code.4562 = code;
    code = code.4562 + 1;
    *code.4562 = 235;
    D.42936 = (unsigned char) t;
    *code = D.42936;
    code = code + 1;
    goto <D.42937>;
    <D.42934>:
    D.31283 = cfg->native_code;
    D.42583 = ins->data.op[0].target_block;
    D.42918 = D.42583->native_offset;
    D.42921 = (sizetype) D.42918;
    D.42922 = D.31283 + D.42921;
    D.42923 = (long int) D.42922;
    code.211 = (long int) code;
    D.42924 = D.42923 - code.211;
    D.42929 = (unsigned int) D.42924;
    D.42938 = D.42929 + 4294967291;
    t = (int) D.42938;
    code.4563 = code;
    code = code.4563 + 1;
    *code.4563 = 233;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = t;
          code.4564 = code;
          code = code.4564 + 1;
          D.42941 = imb.b[0];
          *code.4564 = D.42941;
          code.4565 = code;
          code = code.4565 + 1;
          D.42943 = imb.b[1];
          *code.4565 = D.42943;
          code.4566 = code;
          code = code.4566 + 1;
          D.42945 = imb.b[2];
          *code.4566 = D.42945;
          code.4567 = code;
          code = code.4567 + 1;
          D.42947 = imb.b[3];
          *code.4567 = D.42947;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.42937>:
  }
  goto <D.42948>;
  <D.42928>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 1;
    if (_amd64_rex_bits != 0) goto <D.42949>; else goto <D.42950>;
    <D.42949>:
    code.4568 = code;
    code = code.4568 + 1;
    D.42952 = _amd64_rex_bits | 64;
    *code.4568 = D.42952;
    <D.42950>:
  }
  code.4569 = code;
  code = code.4569 + 1;
  *code.4569 = 255;
  if (1 != 0) goto <D.42954>; else goto <D.42955>;
  <D.42954>:
  code.4570 = code;
  code = code.4570 + 1;
  *code.4570 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4571 = code;
        code = code.4571 + 1;
        D.42958 = imb.b[0];
        *code.4571 = D.42958;
        code.4572 = code;
        code = code.4572 + 1;
        D.42960 = imb.b[1];
        *code.4572 = D.42960;
        code.4573 = code;
        code = code.4573 + 1;
        D.42962 = imb.b[2];
        *code.4573 = D.42962;
        code.4574 = code;
        code = code.4574 + 1;
        D.42964 = imb.b[3];
        *code.4574 = D.42964;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.42965>;
  <D.42955>:
  if (0 != 0) goto <D.42966>; else goto <D.42967>;
  <D.42966>:
  if (1 != 0) goto <D.42968>; else goto <D.42969>;
  <D.42968>:
  code.4575 = code;
  code = code.4575 + 1;
  *code.4575 = 36;
  code.4576 = code;
  code = code.4576 + 1;
  *code.4576 = 36;
  goto <D.42972>;
  <D.42969>:
  if (1 != 0) goto <D.42973>; else goto <D.42974>;
  <D.42973>:
  code.4577 = code;
  code = code.4577 + 1;
  *code.4577 = 100;
  code.4578 = code;
  code = code.4578 + 1;
  *code.4578 = 36;
  *code = 0;
  code = code + 1;
  goto <D.42977>;
  <D.42974>:
  code.4579 = code;
  code = code.4579 + 1;
  *code.4579 = 164;
  code.4580 = code;
  code = code.4580 + 1;
  *code.4580 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4581 = code;
        code = code.4581 + 1;
        D.42981 = imb.b[0];
        *code.4581 = D.42981;
        code.4582 = code;
        code = code.4582 + 1;
        D.42983 = imb.b[1];
        *code.4582 = D.42983;
        code.4583 = code;
        code = code.4583 + 1;
        D.42985 = imb.b[2];
        *code.4583 = D.42985;
        code.4584 = code;
        code = code.4584 + 1;
        D.42987 = imb.b[3];
        *code.4584 = D.42987;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42977>:
  <D.42972>:
  goto <D.26768>;
  <D.42967>:
  if (1 != 0) goto <D.42988>; else goto <D.42989>;
  <D.42988>:
  code.4585 = code;
  code = code.4585 + 1;
  *code.4585 = 32;
  goto <D.26768>;
  <D.42989>:
  if (1 != 0) goto <D.42991>; else goto <D.42992>;
  <D.42991>:
  code.4586 = code;
  code = code.4586 + 1;
  *code.4586 = 96;
  *code = 0;
  code = code + 1;
  goto <D.42994>;
  <D.42992>:
  code.4587 = code;
  code = code.4587 + 1;
  *code.4587 = 160;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4588 = code;
        code = code.4588 + 1;
        D.42997 = imb.b[0];
        *code.4588 = D.42997;
        code.4589 = code;
        code = code.4589 + 1;
        D.42999 = imb.b[1];
        *code.4589 = D.42999;
        code.4590 = code;
        code = code.4590 + 1;
        D.43001 = imb.b[2];
        *code.4590 = D.43001;
        code.4591 = code;
        code = code.4591 + 1;
        D.43003 = imb.b[3];
        *code.4591 = D.43003;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.42994>:
  <D.26768>:
  <D.42965>:
  D.31283 = cfg->native_code;
  D.42583 = ins->data.op[0].target_block;
  D.42918 = D.42583->native_offset;
  D.42921 = (sizetype) D.42918;
  D.42922 = D.31283 + D.42921;
  D.43004 = (long unsigned int) D.42922;
  MEM[(guint64 *)code] = D.43004;
  code = code + 8;
  <D.42948>:
  goto <D.43005>;
  <D.42920>:
  D.42583 = ins->data.op[0].target_block;
  offset.3505 = (int) offset;
  mono_add_patch_info (cfg, offset.3505, 0, D.42583);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.43008>; else goto <D.43006>;
  <D.43008>:
  D.42583 = ins->data.op[0].target_block;
  D.43009 = D.42583->max_offset;
  D.43010 = (unsigned int) D.43009;
  D.43011 = D.43010 - offset;
  D.43012 = (int) D.43011;
  if (D.43012 >= -128) goto <D.43013>; else goto <D.43006>;
  <D.43013>:
  D.42583 = ins->data.op[0].target_block;
  D.43009 = D.42583->max_offset;
  D.43010 = (unsigned int) D.43009;
  D.43011 = D.43010 - offset;
  D.43012 = (int) D.43011;
  if (D.43012 <= 127) goto <D.43014>; else goto <D.43006>;
  <D.43014>:
  code.4592 = code;
  code = code.4592 + 1;
  *code.4592 = 235;
  *code = 0;
  code = code + 1;
  goto <D.43007>;
  <D.43006>:
  code.4593 = code;
  code = code.4593 + 1;
  *code.4593 = 233;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.4594 = code;
        code = code.4594 + 1;
        D.43018 = imb.b[0];
        *code.4594 = D.43018;
        code.4595 = code;
        code = code.4595 + 1;
        D.43020 = imb.b[1];
        *code.4595 = D.43020;
        code.4596 = code;
        code = code.4596 + 1;
        D.43022 = imb.b[2];
        *code.4596 = D.43022;
        code.4597 = code;
        code = code.4597 + 1;
        D.43024 = imb.b[3];
        *code.4597 = D.43024;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43007>:
  <D.43005>:
  goto <D.25197>;
  <D.26771>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    _amd64_rex_bits = (unsigned char) D.31517;
    if (_amd64_rex_bits != 0) goto <D.43025>; else goto <D.43026>;
    <D.43025>:
    code.4598 = code;
    code = code.4598 + 1;
    D.43028 = _amd64_rex_bits | 64;
    *code.4598 = D.43028;
    <D.43026>:
  }
  code.4599 = code;
  code = code.4599 + 1;
  *code.4599 = 255;
  code.4600 = code;
  code = code.4600 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.4600 = D.37432;
  goto <D.25197>;
  <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>:
  <D.26788>:
  <D.26789>:
  <D.26790>:
  <D.26791>:
  <D.26792>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (1 != 0) goto <D.43031>; else goto <D.43032>;
    <D.43031>:
    code.4601 = code;
    code = code.4601 + 1;
    D.43034 = _amd64_rex_bits | 64;
    *code.4601 = D.43034;
    <D.43032>:
  }
  if (0 != 0) goto <D.43035>; else goto <D.43036>;
  <D.43035>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5187, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
  <D.43036>:
  code.4602 = code;
  code = code.4602 + 1;
  *code.4602 = 15;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.43038 = mono_opcode_to_cond (D.31465);
  D.43039 = cc_signed_table[D.43038];
  if (D.43039 != 0) goto <D.43040>; else goto <D.43041>;
  <D.43040>:
  code.4603 = code;
  code = code.4603 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.43043 = mono_opcode_to_cond (D.31465);
  D.43044 = cc_table[D.43043];
  D.43045 = x86_cc_signed_map[D.43044];
  D.43046 = D.43045 + 32;
  *code.4603 = D.43046;
  goto <D.43047>;
  <D.43041>:
  code.4604 = code;
  code = code.4604 + 1;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.43049 = mono_opcode_to_cond (D.31465);
  D.43050 = cc_table[D.43049];
  D.43051 = x86_cc_unsigned_map[D.43050];
  D.43052 = D.43051 + 32;
  *code.4604 = D.43052;
  <D.43047>:
  code.4605 = code;
  code = code.4605 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.4605 = D.35110;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43055>; else goto <D.43056>;
    <D.43055>:
    iftmp.4606 = 12;
    goto <D.43057>;
    <D.43056>:
    iftmp.4606 = 8;
    <D.43057>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.43058 = iftmp.4606 | D.32040;
    _amd64_rex_bits = (unsigned char) D.43058;
    if (_amd64_rex_bits != 0) goto <D.43059>; else goto <D.43060>;
    <D.43059>:
    code.4607 = code;
    code = code.4607 + 1;
    D.43062 = _amd64_rex_bits | 64;
    *code.4607 = D.43062;
    <D.43060>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.43063>; else goto <D.43064>;
    <D.43063>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5188, "(0) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.43064>:
    code.4608 = code;
    code = code.4608 + 1;
    *code.4608 = 15;
    if (0 != 0) goto <D.43066>; else goto <D.43067>;
    <D.43066>:
    op = op + 8;
    <D.43067>:
    if (0 != 0) goto <D.43068>; else goto <D.43069>;
    <D.43068>:
    op = op + 1;
    <D.43069>:
    code.4609 = code;
    code = code.4609 + 1;
    *code.4609 = op;
    code.4610 = code;
    code = code.4610 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.4610 = D.37521;
  }
  goto <D.25197>;
  <D.26796>:
  <D.26797>:
  <D.26798>:
  <D.26799>:
  <D.26800>:
  <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>:
  {
    struct MonoInst * tins;

    D.43072 = ins->data.op[1].p;
    tins = mono_branch_optimize_exception_target (cfg, bb, D.43072);
    if (tins == 0B) goto <D.43073>; else goto <D.43074>;
    <D.43073>:
    D.43072 = ins->data.op[1].p;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, D.43072);
    code.4611 = code;
    code = code.4611 + 1;
    *code.4611 = 15;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43076 = mono_opcode_to_cond (D.31465);
    D.43077 = cc_signed_table[D.43076];
    if (D.43077 != 0) goto <D.43078>; else goto <D.43079>;
    <D.43078>:
    code.4612 = code;
    code = code.4612 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43081 = mono_opcode_to_cond (D.31465);
    D.43082 = cc_table[D.43081];
    D.43083 = x86_cc_signed_map[D.43082];
    D.43084 = D.43083 + 16;
    *code.4612 = D.43084;
    goto <D.43085>;
    <D.43079>:
    code.4613 = code;
    code = code.4613 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43087 = mono_opcode_to_cond (D.31465);
    D.43088 = cc_table[D.43087];
    D.43089 = x86_cc_unsigned_map[D.43088];
    D.43090 = D.43089 + 16;
    *code.4613 = D.43090;
    <D.43085>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4614 = code;
          code = code.4614 + 1;
          D.43092 = imb.b[0];
          *code.4614 = D.43092;
          code.4615 = code;
          code = code.4615 + 1;
          D.43094 = imb.b[1];
          *code.4615 = D.43094;
          code.4616 = code;
          code = code.4616 + 1;
          D.43096 = imb.b[2];
          *code.4616 = D.43096;
          code.4617 = code;
          code = code.4617 + 1;
          D.43098 = imb.b[3];
          *code.4617 = D.43098;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.43099>;
    <D.43074>:
    D.43100 = tins->data.op[1].many_blocks;
    D.43101 = *D.43100;
    D.43102 = D.43101->native_offset;
    if (D.43102 != 0) goto <D.43103>; else goto <D.43104>;
    <D.43103>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.43100 = tins->data.op[1].many_blocks;
      D.43101 = *D.43100;
      D.43102 = D.43101->native_offset;
      D.43105 = (sizetype) D.43102;
      D.43106 = D.31283 + D.43105;
      D.43107 = (long int) D.43106;
      code.211 = (long int) code;
      D.43108 = D.43107 - code.211;
      D.43109 = (unsigned int) D.43108;
      D.43110 = D.43109 + 4294967294;
      offset = (int) D.43110;
      offset.4618 = (unsigned int) offset;
      D.43112 = offset.4618 + 128;
      if (D.43112 <= 255) goto <D.43113>; else goto <D.43114>;
      <D.43113>:
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43115 = mono_opcode_to_cond (D.31465);
      D.43116 = cc_signed_table[D.43115];
      if (D.43116 != 0) goto <D.43117>; else goto <D.43118>;
      <D.43117>:
      code.4619 = code;
      code = code.4619 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43120 = mono_opcode_to_cond (D.31465);
      D.43121 = cc_table[D.43120];
      D.43122 = x86_cc_signed_map[D.43121];
      *code.4619 = D.43122;
      goto <D.43123>;
      <D.43118>:
      code.4620 = code;
      code = code.4620 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43125 = mono_opcode_to_cond (D.31465);
      D.43126 = cc_table[D.43125];
      D.43127 = x86_cc_unsigned_map[D.43126];
      *code.4620 = D.43127;
      <D.43123>:
      D.43128 = (unsigned char) offset;
      *code = D.43128;
      code = code + 1;
      goto <D.43129>;
      <D.43114>:
      D.31283 = cfg->native_code;
      D.43100 = tins->data.op[1].many_blocks;
      D.43101 = *D.43100;
      D.43102 = D.43101->native_offset;
      D.43105 = (sizetype) D.43102;
      D.43106 = D.31283 + D.43105;
      D.43107 = (long int) D.43106;
      code.211 = (long int) code;
      D.43108 = D.43107 - code.211;
      D.43109 = (unsigned int) D.43108;
      D.43130 = D.43109 + 4294967290;
      offset = (int) D.43130;
      code.4621 = code;
      code = code.4621 + 1;
      *code.4621 = 15;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43132 = mono_opcode_to_cond (D.31465);
      D.43133 = cc_signed_table[D.43132];
      if (D.43133 != 0) goto <D.43134>; else goto <D.43135>;
      <D.43134>:
      code.4622 = code;
      code = code.4622 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43137 = mono_opcode_to_cond (D.31465);
      D.43138 = cc_table[D.43137];
      D.43139 = x86_cc_signed_map[D.43138];
      D.43140 = D.43139 + 16;
      *code.4622 = D.43140;
      goto <D.43141>;
      <D.43135>:
      code.4623 = code;
      code = code.4623 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43143 = mono_opcode_to_cond (D.31465);
      D.43144 = cc_table[D.43143];
      D.43145 = x86_cc_unsigned_map[D.43144];
      D.43146 = D.43145 + 16;
      *code.4623 = D.43146;
      <D.43141>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.4624 = code;
            code = code.4624 + 1;
            D.43148 = imb.b[0];
            *code.4624 = D.43148;
            code.4625 = code;
            code = code.4625 + 1;
            D.43150 = imb.b[1];
            *code.4625 = D.43150;
            code.4626 = code;
            code = code.4626 + 1;
            D.43152 = imb.b[2];
            *code.4626 = D.43152;
            code.4627 = code;
            code = code.4627 + 1;
            D.43154 = imb.b[3];
            *code.4627 = D.43154;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.43129>:
    }
    goto <D.43155>;
    <D.43104>:
    D.43100 = tins->data.op[1].many_blocks;
    D.43101 = *D.43100;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.43101);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.43158>; else goto <D.43156>;
    <D.43158>:
    D.43100 = tins->data.op[1].many_blocks;
    D.43101 = *D.43100;
    D.43159 = D.43101->max_offset;
    D.43160 = (unsigned int) D.43159;
    D.43161 = D.43160 - offset;
    D.43162 = (int) D.43161;
    if (D.43162 >= -128) goto <D.43163>; else goto <D.43156>;
    <D.43163>:
    D.43100 = tins->data.op[1].many_blocks;
    D.43101 = *D.43100;
    D.43159 = D.43101->max_offset;
    D.43160 = (unsigned int) D.43159;
    D.43161 = D.43160 - offset;
    D.43162 = (int) D.43161;
    if (D.43162 <= 127) goto <D.43164>; else goto <D.43156>;
    <D.43164>:
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43165 = mono_opcode_to_cond (D.31465);
    D.43166 = cc_signed_table[D.43165];
    if (D.43166 != 0) goto <D.43167>; else goto <D.43168>;
    <D.43167>:
    code.4628 = code;
    code = code.4628 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43170 = mono_opcode_to_cond (D.31465);
    D.43171 = cc_table[D.43170];
    D.43172 = x86_cc_signed_map[D.43171];
    *code.4628 = D.43172;
    goto <D.43173>;
    <D.43168>:
    code.4629 = code;
    code = code.4629 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43175 = mono_opcode_to_cond (D.31465);
    D.43176 = cc_table[D.43175];
    D.43177 = x86_cc_unsigned_map[D.43176];
    *code.4629 = D.43177;
    <D.43173>:
    *code = 0;
    code = code + 1;
    goto <D.43157>;
    <D.43156>:
    code.4630 = code;
    code = code.4630 + 1;
    *code.4630 = 15;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43179 = mono_opcode_to_cond (D.31465);
    D.43180 = cc_signed_table[D.43179];
    if (D.43180 != 0) goto <D.43181>; else goto <D.43182>;
    <D.43181>:
    code.4631 = code;
    code = code.4631 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43184 = mono_opcode_to_cond (D.31465);
    D.43185 = cc_table[D.43184];
    D.43186 = x86_cc_signed_map[D.43185];
    D.43187 = D.43186 + 16;
    *code.4631 = D.43187;
    goto <D.43188>;
    <D.43182>:
    code.4632 = code;
    code = code.4632 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43190 = mono_opcode_to_cond (D.31465);
    D.43191 = cc_table[D.43190];
    D.43192 = x86_cc_unsigned_map[D.43191];
    D.43193 = D.43192 + 16;
    *code.4632 = D.43193;
    <D.43188>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4633 = code;
          code = code.4633 + 1;
          D.43195 = imb.b[0];
          *code.4633 = D.43195;
          code.4634 = code;
          code = code.4634 + 1;
          D.43197 = imb.b[1];
          *code.4634 = D.43197;
          code.4635 = code;
          code = code.4635 + 1;
          D.43199 = imb.b[2];
          *code.4635 = D.43199;
          code.4636 = code;
          code = code.4636 + 1;
          D.43201 = imb.b[3];
          *code.4636 = D.43201;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43157>:
    <D.43155>:
    <D.43099>:
  }
  goto <D.25197>;
  <D.26821>:
  <D.26822>:
  <D.26823>:
  <D.26824>:
  {
    struct MonoInst * tins;

    D.43072 = ins->data.op[1].p;
    tins = mono_branch_optimize_exception_target (cfg, bb, D.43072);
    if (tins == 0B) goto <D.43202>; else goto <D.43203>;
    <D.43202>:
    D.43072 = ins->data.op[1].p;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, D.43072);
    code.4637 = code;
    code = code.4637 + 1;
    *code.4637 = 15;
    D.31464 = ins->opcode;
    if (D.31464 <= 459) goto <D.43205>; else goto <D.43206>;
    <D.43205>:
    code.4638 = code;
    code = code.4638 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43208 = D.31465 + -455;
    D.43209 = branch_cc_table[D.43208];
    D.43210 = x86_cc_signed_map[D.43209];
    D.43211 = D.43210 + 16;
    *code.4638 = D.43211;
    goto <D.43212>;
    <D.43206>:
    code.4639 = code;
    code = code.4639 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43208 = D.31465 + -455;
    D.43209 = branch_cc_table[D.43208];
    D.43214 = x86_cc_unsigned_map[D.43209];
    D.43215 = D.43214 + 16;
    *code.4639 = D.43215;
    <D.43212>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4640 = code;
          code = code.4640 + 1;
          D.43217 = imb.b[0];
          *code.4640 = D.43217;
          code.4641 = code;
          code = code.4641 + 1;
          D.43219 = imb.b[1];
          *code.4641 = D.43219;
          code.4642 = code;
          code = code.4642 + 1;
          D.43221 = imb.b[2];
          *code.4642 = D.43221;
          code.4643 = code;
          code = code.4643 + 1;
          D.43223 = imb.b[3];
          *code.4643 = D.43223;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.43224>;
    <D.43203>:
    D.43225 = tins->data.op[1].many_blocks;
    D.43226 = *D.43225;
    D.43227 = D.43226->native_offset;
    if (D.43227 != 0) goto <D.43228>; else goto <D.43229>;
    <D.43228>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.43225 = tins->data.op[1].many_blocks;
      D.43226 = *D.43225;
      D.43227 = D.43226->native_offset;
      D.43230 = (sizetype) D.43227;
      D.43231 = D.31283 + D.43230;
      D.43232 = (long int) D.43231;
      code.211 = (long int) code;
      D.43233 = D.43232 - code.211;
      D.43234 = (unsigned int) D.43233;
      D.43235 = D.43234 + 4294967294;
      offset = (int) D.43235;
      offset.4644 = (unsigned int) offset;
      D.43237 = offset.4644 + 128;
      if (D.43237 <= 255) goto <D.43238>; else goto <D.43239>;
      <D.43238>:
      D.31464 = ins->opcode;
      if (D.31464 <= 459) goto <D.43240>; else goto <D.43241>;
      <D.43240>:
      code.4645 = code;
      code = code.4645 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43208 = D.31465 + -455;
      D.43209 = branch_cc_table[D.43208];
      D.43210 = x86_cc_signed_map[D.43209];
      *code.4645 = D.43210;
      goto <D.43243>;
      <D.43241>:
      code.4646 = code;
      code = code.4646 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43208 = D.31465 + -455;
      D.43209 = branch_cc_table[D.43208];
      D.43214 = x86_cc_unsigned_map[D.43209];
      *code.4646 = D.43214;
      <D.43243>:
      D.43245 = (unsigned char) offset;
      *code = D.43245;
      code = code + 1;
      goto <D.43246>;
      <D.43239>:
      D.31283 = cfg->native_code;
      D.43225 = tins->data.op[1].many_blocks;
      D.43226 = *D.43225;
      D.43227 = D.43226->native_offset;
      D.43230 = (sizetype) D.43227;
      D.43231 = D.31283 + D.43230;
      D.43232 = (long int) D.43231;
      code.211 = (long int) code;
      D.43233 = D.43232 - code.211;
      D.43234 = (unsigned int) D.43233;
      D.43247 = D.43234 + 4294967290;
      offset = (int) D.43247;
      code.4647 = code;
      code = code.4647 + 1;
      *code.4647 = 15;
      D.31464 = ins->opcode;
      if (D.31464 <= 459) goto <D.43249>; else goto <D.43250>;
      <D.43249>:
      code.4648 = code;
      code = code.4648 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43208 = D.31465 + -455;
      D.43209 = branch_cc_table[D.43208];
      D.43210 = x86_cc_signed_map[D.43209];
      D.43211 = D.43210 + 16;
      *code.4648 = D.43211;
      goto <D.43252>;
      <D.43250>:
      code.4649 = code;
      code = code.4649 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43208 = D.31465 + -455;
      D.43209 = branch_cc_table[D.43208];
      D.43214 = x86_cc_unsigned_map[D.43209];
      D.43215 = D.43214 + 16;
      *code.4649 = D.43215;
      <D.43252>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.4650 = code;
            code = code.4650 + 1;
            D.43255 = imb.b[0];
            *code.4650 = D.43255;
            code.4651 = code;
            code = code.4651 + 1;
            D.43257 = imb.b[1];
            *code.4651 = D.43257;
            code.4652 = code;
            code = code.4652 + 1;
            D.43259 = imb.b[2];
            *code.4652 = D.43259;
            code.4653 = code;
            code = code.4653 + 1;
            D.43261 = imb.b[3];
            *code.4653 = D.43261;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.43246>:
    }
    goto <D.43262>;
    <D.43229>:
    D.43225 = tins->data.op[1].many_blocks;
    D.43226 = *D.43225;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.43226);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.43265>; else goto <D.43263>;
    <D.43265>:
    D.43225 = tins->data.op[1].many_blocks;
    D.43226 = *D.43225;
    D.43266 = D.43226->max_offset;
    D.43267 = (unsigned int) D.43266;
    D.43268 = D.43267 - offset;
    D.43269 = (int) D.43268;
    if (D.43269 >= -128) goto <D.43270>; else goto <D.43263>;
    <D.43270>:
    D.43225 = tins->data.op[1].many_blocks;
    D.43226 = *D.43225;
    D.43266 = D.43226->max_offset;
    D.43267 = (unsigned int) D.43266;
    D.43268 = D.43267 - offset;
    D.43269 = (int) D.43268;
    if (D.43269 <= 127) goto <D.43271>; else goto <D.43263>;
    <D.43271>:
    D.31464 = ins->opcode;
    if (D.31464 <= 459) goto <D.43272>; else goto <D.43273>;
    <D.43272>:
    code.4654 = code;
    code = code.4654 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43208 = D.31465 + -455;
    D.43209 = branch_cc_table[D.43208];
    D.43210 = x86_cc_signed_map[D.43209];
    *code.4654 = D.43210;
    goto <D.43275>;
    <D.43273>:
    code.4655 = code;
    code = code.4655 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43208 = D.31465 + -455;
    D.43209 = branch_cc_table[D.43208];
    D.43214 = x86_cc_unsigned_map[D.43209];
    *code.4655 = D.43214;
    <D.43275>:
    *code = 0;
    code = code + 1;
    goto <D.43264>;
    <D.43263>:
    code.4656 = code;
    code = code.4656 + 1;
    *code.4656 = 15;
    D.31464 = ins->opcode;
    if (D.31464 <= 459) goto <D.43278>; else goto <D.43279>;
    <D.43278>:
    code.4657 = code;
    code = code.4657 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43208 = D.31465 + -455;
    D.43209 = branch_cc_table[D.43208];
    D.43210 = x86_cc_signed_map[D.43209];
    D.43211 = D.43210 + 16;
    *code.4657 = D.43211;
    goto <D.43281>;
    <D.43279>:
    code.4658 = code;
    code = code.4658 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43208 = D.31465 + -455;
    D.43209 = branch_cc_table[D.43208];
    D.43214 = x86_cc_unsigned_map[D.43209];
    D.43215 = D.43214 + 16;
    *code.4658 = D.43215;
    <D.43281>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4659 = code;
          code = code.4659 + 1;
          D.43284 = imb.b[0];
          *code.4659 = D.43284;
          code.4660 = code;
          code = code.4660 + 1;
          D.43286 = imb.b[1];
          *code.4660 = D.43286;
          code.4661 = code;
          code = code.4661 + 1;
          D.43288 = imb.b[2];
          *code.4661 = D.43288;
          code.4662 = code;
          code = code.4662 + 1;
          D.43290 = imb.b[3];
          *code.4662 = D.43290;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43264>:
    <D.43262>:
    <D.43224>:
  }
  goto <D.25197>;
  <D.26830>:
  <D.26831>:
  <D.26832>:
  <D.26833>:
  {
    struct MonoInst * tins;

    D.43072 = ins->data.op[1].p;
    tins = mono_branch_optimize_exception_target (cfg, bb, D.43072);
    if (tins == 0B) goto <D.43291>; else goto <D.43292>;
    <D.43291>:
    D.43072 = ins->data.op[1].p;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, D.43072);
    code.4663 = code;
    code = code.4663 + 1;
    *code.4663 = 15;
    D.31464 = ins->opcode;
    if (D.31464 <= 473) goto <D.43294>; else goto <D.43295>;
    <D.43294>:
    code.4664 = code;
    code = code.4664 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43297 = D.31465 + -469;
    D.43298 = branch_cc_table[D.43297];
    D.43299 = x86_cc_signed_map[D.43298];
    D.43300 = D.43299 + 16;
    *code.4664 = D.43300;
    goto <D.43301>;
    <D.43295>:
    code.4665 = code;
    code = code.4665 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43297 = D.31465 + -469;
    D.43298 = branch_cc_table[D.43297];
    D.43303 = x86_cc_unsigned_map[D.43298];
    D.43304 = D.43303 + 16;
    *code.4665 = D.43304;
    <D.43301>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4666 = code;
          code = code.4666 + 1;
          D.43306 = imb.b[0];
          *code.4666 = D.43306;
          code.4667 = code;
          code = code.4667 + 1;
          D.43308 = imb.b[1];
          *code.4667 = D.43308;
          code.4668 = code;
          code = code.4668 + 1;
          D.43310 = imb.b[2];
          *code.4668 = D.43310;
          code.4669 = code;
          code = code.4669 + 1;
          D.43312 = imb.b[3];
          *code.4669 = D.43312;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.43313>;
    <D.43292>:
    D.43314 = tins->data.op[1].many_blocks;
    D.43315 = *D.43314;
    D.43316 = D.43315->native_offset;
    if (D.43316 != 0) goto <D.43317>; else goto <D.43318>;
    <D.43317>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.43314 = tins->data.op[1].many_blocks;
      D.43315 = *D.43314;
      D.43316 = D.43315->native_offset;
      D.43319 = (sizetype) D.43316;
      D.43320 = D.31283 + D.43319;
      D.43321 = (long int) D.43320;
      code.211 = (long int) code;
      D.43322 = D.43321 - code.211;
      D.43323 = (unsigned int) D.43322;
      D.43324 = D.43323 + 4294967294;
      offset = (int) D.43324;
      offset.4670 = (unsigned int) offset;
      D.43326 = offset.4670 + 128;
      if (D.43326 <= 255) goto <D.43327>; else goto <D.43328>;
      <D.43327>:
      D.31464 = ins->opcode;
      if (D.31464 <= 473) goto <D.43329>; else goto <D.43330>;
      <D.43329>:
      code.4671 = code;
      code = code.4671 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43297 = D.31465 + -469;
      D.43298 = branch_cc_table[D.43297];
      D.43299 = x86_cc_signed_map[D.43298];
      *code.4671 = D.43299;
      goto <D.43332>;
      <D.43330>:
      code.4672 = code;
      code = code.4672 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43297 = D.31465 + -469;
      D.43298 = branch_cc_table[D.43297];
      D.43303 = x86_cc_unsigned_map[D.43298];
      *code.4672 = D.43303;
      <D.43332>:
      D.43334 = (unsigned char) offset;
      *code = D.43334;
      code = code + 1;
      goto <D.43335>;
      <D.43328>:
      D.31283 = cfg->native_code;
      D.43314 = tins->data.op[1].many_blocks;
      D.43315 = *D.43314;
      D.43316 = D.43315->native_offset;
      D.43319 = (sizetype) D.43316;
      D.43320 = D.31283 + D.43319;
      D.43321 = (long int) D.43320;
      code.211 = (long int) code;
      D.43322 = D.43321 - code.211;
      D.43323 = (unsigned int) D.43322;
      D.43336 = D.43323 + 4294967290;
      offset = (int) D.43336;
      code.4673 = code;
      code = code.4673 + 1;
      *code.4673 = 15;
      D.31464 = ins->opcode;
      if (D.31464 <= 473) goto <D.43338>; else goto <D.43339>;
      <D.43338>:
      code.4674 = code;
      code = code.4674 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43297 = D.31465 + -469;
      D.43298 = branch_cc_table[D.43297];
      D.43299 = x86_cc_signed_map[D.43298];
      D.43300 = D.43299 + 16;
      *code.4674 = D.43300;
      goto <D.43341>;
      <D.43339>:
      code.4675 = code;
      code = code.4675 + 1;
      D.31464 = ins->opcode;
      D.31465 = (int) D.31464;
      D.43297 = D.31465 + -469;
      D.43298 = branch_cc_table[D.43297];
      D.43303 = x86_cc_unsigned_map[D.43298];
      D.43304 = D.43303 + 16;
      *code.4675 = D.43304;
      <D.43341>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.4676 = code;
            code = code.4676 + 1;
            D.43344 = imb.b[0];
            *code.4676 = D.43344;
            code.4677 = code;
            code = code.4677 + 1;
            D.43346 = imb.b[1];
            *code.4677 = D.43346;
            code.4678 = code;
            code = code.4678 + 1;
            D.43348 = imb.b[2];
            *code.4678 = D.43348;
            code.4679 = code;
            code = code.4679 + 1;
            D.43350 = imb.b[3];
            *code.4679 = D.43350;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.43335>:
    }
    goto <D.43351>;
    <D.43318>:
    D.43314 = tins->data.op[1].many_blocks;
    D.43315 = *D.43314;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.43315);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.43354>; else goto <D.43352>;
    <D.43354>:
    D.43314 = tins->data.op[1].many_blocks;
    D.43315 = *D.43314;
    D.43355 = D.43315->max_offset;
    D.43356 = (unsigned int) D.43355;
    D.43357 = D.43356 - offset;
    D.43358 = (int) D.43357;
    if (D.43358 >= -128) goto <D.43359>; else goto <D.43352>;
    <D.43359>:
    D.43314 = tins->data.op[1].many_blocks;
    D.43315 = *D.43314;
    D.43355 = D.43315->max_offset;
    D.43356 = (unsigned int) D.43355;
    D.43357 = D.43356 - offset;
    D.43358 = (int) D.43357;
    if (D.43358 <= 127) goto <D.43360>; else goto <D.43352>;
    <D.43360>:
    D.31464 = ins->opcode;
    if (D.31464 <= 473) goto <D.43361>; else goto <D.43362>;
    <D.43361>:
    code.4680 = code;
    code = code.4680 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43297 = D.31465 + -469;
    D.43298 = branch_cc_table[D.43297];
    D.43299 = x86_cc_signed_map[D.43298];
    *code.4680 = D.43299;
    goto <D.43364>;
    <D.43362>:
    code.4681 = code;
    code = code.4681 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43297 = D.31465 + -469;
    D.43298 = branch_cc_table[D.43297];
    D.43303 = x86_cc_unsigned_map[D.43298];
    *code.4681 = D.43303;
    <D.43364>:
    *code = 0;
    code = code + 1;
    goto <D.43353>;
    <D.43352>:
    code.4682 = code;
    code = code.4682 + 1;
    *code.4682 = 15;
    D.31464 = ins->opcode;
    if (D.31464 <= 473) goto <D.43367>; else goto <D.43368>;
    <D.43367>:
    code.4683 = code;
    code = code.4683 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43297 = D.31465 + -469;
    D.43298 = branch_cc_table[D.43297];
    D.43299 = x86_cc_signed_map[D.43298];
    D.43300 = D.43299 + 16;
    *code.4683 = D.43300;
    goto <D.43370>;
    <D.43368>:
    code.4684 = code;
    code = code.4684 + 1;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    D.43297 = D.31465 + -469;
    D.43298 = branch_cc_table[D.43297];
    D.43303 = x86_cc_unsigned_map[D.43298];
    D.43304 = D.43303 + 16;
    *code.4684 = D.43304;
    <D.43370>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4685 = code;
          code = code.4685 + 1;
          D.43373 = imb.b[0];
          *code.4685 = D.43373;
          code.4686 = code;
          code = code.4686 + 1;
          D.43375 = imb.b[1];
          *code.4686 = D.43375;
          code.4687 = code;
          code = code.4687 + 1;
          D.43377 = imb.b[2];
          *code.4687 = D.43377;
          code.4688 = code;
          code = code.4688 + 1;
          D.43379 = imb.b[3];
          *code.4688 = D.43379;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43353>:
    <D.43351>:
    <D.43313>:
  }
  goto <D.25197>;
  <D.26839>:
  {
    double d;

    D.40052 = ins->data.op[0].p;
    d = MEM[(double *)D.40052];
    if (d == 0.0) goto <D.43382>; else goto <D.43380>;
    <D.43382>:
    D.43383 = __signbit (d);
    if (D.43383 == 0) goto <D.43384>; else goto <D.43380>;
    <D.43384>:
    code.4689 = code;
    code = code.4689 + 1;
    *code.4689 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.43387>; else goto <D.43388>;
      <D.43387>:
      iftmp.4690 = 4;
      goto <D.43389>;
      <D.43388>:
      iftmp.4690 = 0;
      <D.43389>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.43390 = iftmp.4690 | D.32040;
      _amd64_rex_bits = (unsigned char) D.43390;
      if (_amd64_rex_bits != 0) goto <D.43391>; else goto <D.43392>;
      <D.43391>:
      code.4691 = code;
      code = code.4691 + 1;
      D.43394 = _amd64_rex_bits | 64;
      *code.4691 = D.43394;
      <D.43392>:
    }
    code.4692 = code;
    code = code.4692 + 1;
    *code.4692 = 15;
    code.4693 = code;
    code = code.4693 + 1;
    *code.4693 = 87;
    code.4694 = code;
    code = code.4694 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.4694 = D.37521;
    goto <D.43381>;
    <D.43380>:
    D.40052 = ins->data.op[0].p;
    offset.3505 = (int) offset;
    mono_add_patch_info (cfg, offset.3505, 21, D.40052);
    code.4695 = code;
    code = code.4695 + 1;
    *code.4695 = 242;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.43400>; else goto <D.43401>;
      <D.43400>:
      iftmp.4696 = 4;
      goto <D.43402>;
      <D.43401>:
      iftmp.4696 = 0;
      <D.43402>:
      _amd64_rex_bits = iftmp.4696;
      if (_amd64_rex_bits != 0) goto <D.43403>; else goto <D.43404>;
      <D.43403>:
      code.4697 = code;
      code = code.4697 + 1;
      D.43406 = _amd64_rex_bits | 64;
      *code.4697 = D.43406;
      <D.43404>:
    }
    code.4698 = code;
    code = code.4698 + 1;
    *code.4698 = 15;
    code.4699 = code;
    code = code.4699 + 1;
    *code.4699 = 16;
    if (1 != 0) goto <D.43409>; else goto <D.43410>;
    <D.43409>:
    code.4700 = code;
    code = code.4700 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32713 = D.32642 | 5;
    D.32714 = (unsigned char) D.32713;
    *code.4700 = D.32714;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4701 = code;
          code = code.4701 + 1;
          D.43413 = imb.b[0];
          *code.4701 = D.43413;
          code.4702 = code;
          code = code.4702 + 1;
          D.43415 = imb.b[1];
          *code.4702 = D.43415;
          code.4703 = code;
          code = code.4703 + 1;
          D.43417 = imb.b[2];
          *code.4703 = D.43417;
          code.4704 = code;
          code = code.4704 + 1;
          D.43419 = imb.b[3];
          *code.4704 = D.43419;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.43420>;
    <D.43410>:
    if (0 != 0) goto <D.43421>; else goto <D.43422>;
    <D.43421>:
    if (1 != 0) goto <D.43423>; else goto <D.43424>;
    <D.43423>:
    code.4705 = code;
    code = code.4705 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.4705 = D.32644;
    code.4706 = code;
    code = code.4706 + 1;
    *code.4706 = 36;
    goto <D.43427>;
    <D.43424>:
    if (1 != 0) goto <D.43428>; else goto <D.43429>;
    <D.43428>:
    code.4707 = code;
    code = code.4707 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.4707 = D.32735;
    code.4708 = code;
    code = code.4708 + 1;
    *code.4708 = 36;
    *code = 0;
    code = code + 1;
    goto <D.43432>;
    <D.43429>:
    code.4709 = code;
    code = code.4709 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.4709 = D.32740;
    code.4710 = code;
    code = code.4710 + 1;
    *code.4710 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4711 = code;
          code = code.4711 + 1;
          D.43436 = imb.b[0];
          *code.4711 = D.43436;
          code.4712 = code;
          code = code.4712 + 1;
          D.43438 = imb.b[1];
          *code.4712 = D.43438;
          code.4713 = code;
          code = code.4713 + 1;
          D.43440 = imb.b[2];
          *code.4713 = D.43440;
          code.4714 = code;
          code = code.4714 + 1;
          D.43442 = imb.b[3];
          *code.4714 = D.43442;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43432>:
    <D.43427>:
    goto <D.26845>;
    <D.43422>:
    if (1 != 0) goto <D.43443>; else goto <D.43444>;
    <D.43443>:
    code.4715 = code;
    code = code.4715 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.40107 = D.31627 << 3;
    *code.4715 = D.40107;
    goto <D.26845>;
    <D.43444>:
    if (1 != 0) goto <D.43446>; else goto <D.43447>;
    <D.43446>:
    code.4716 = code;
    code = code.4716 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.40111 = (unsigned char) D.32758;
    *code.4716 = D.40111;
    *code = 0;
    code = code + 1;
    goto <D.43449>;
    <D.43447>:
    code.4717 = code;
    code = code.4717 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.40114 = (unsigned char) D.32763;
    *code.4717 = D.40114;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4718 = code;
          code = code.4718 + 1;
          D.43452 = imb.b[0];
          *code.4718 = D.43452;
          code.4719 = code;
          code = code.4719 + 1;
          D.43454 = imb.b[1];
          *code.4719 = D.43454;
          code.4720 = code;
          code = code.4720 + 1;
          D.43456 = imb.b[2];
          *code.4720 = D.43456;
          code.4721 = code;
          code = code.4721 + 1;
          D.43458 = imb.b[3];
          *code.4721 = D.43458;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43449>:
    <D.26845>:
    <D.43420>:
    <D.43381>:
    goto <D.25197>;
  }
  <D.26847>:
  {
    float f;

    D.40052 = ins->data.op[0].p;
    f = MEM[(float *)D.40052];
    if (f == 0.0) goto <D.43461>; else goto <D.43459>;
    <D.43461>:
    D.43462 = __signbitf (f);
    if (D.43462 == 0) goto <D.43463>; else goto <D.43459>;
    <D.43463>:
    code.4722 = code;
    code = code.4722 + 1;
    *code.4722 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.43466>; else goto <D.43467>;
      <D.43466>:
      iftmp.4723 = 4;
      goto <D.43468>;
      <D.43467>:
      iftmp.4723 = 0;
      <D.43468>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.43469 = iftmp.4723 | D.32040;
      _amd64_rex_bits = (unsigned char) D.43469;
      if (_amd64_rex_bits != 0) goto <D.43470>; else goto <D.43471>;
      <D.43470>:
      code.4724 = code;
      code = code.4724 + 1;
      D.43473 = _amd64_rex_bits | 64;
      *code.4724 = D.43473;
      <D.43471>:
    }
    code.4725 = code;
    code = code.4725 + 1;
    *code.4725 = 15;
    code.4726 = code;
    code = code.4726 + 1;
    *code.4726 = 87;
    code.4727 = code;
    code = code.4727 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.4727 = D.37521;
    goto <D.43460>;
    <D.43459>:
    D.40052 = ins->data.op[0].p;
    offset.3505 = (int) offset;
    mono_add_patch_info (cfg, offset.3505, 20, D.40052);
    code.4728 = code;
    code = code.4728 + 1;
    *code.4728 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.43479>; else goto <D.43480>;
      <D.43479>:
      iftmp.4729 = 4;
      goto <D.43481>;
      <D.43480>:
      iftmp.4729 = 0;
      <D.43481>:
      _amd64_rex_bits = iftmp.4729;
      if (_amd64_rex_bits != 0) goto <D.43482>; else goto <D.43483>;
      <D.43482>:
      code.4730 = code;
      code = code.4730 + 1;
      D.43485 = _amd64_rex_bits | 64;
      *code.4730 = D.43485;
      <D.43483>:
    }
    code.4731 = code;
    code = code.4731 + 1;
    *code.4731 = 15;
    code.4732 = code;
    code = code.4732 + 1;
    *code.4732 = 16;
    if (1 != 0) goto <D.43488>; else goto <D.43489>;
    <D.43488>:
    code.4733 = code;
    code = code.4733 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32713 = D.32642 | 5;
    D.32714 = (unsigned char) D.32713;
    *code.4733 = D.32714;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4734 = code;
          code = code.4734 + 1;
          D.43492 = imb.b[0];
          *code.4734 = D.43492;
          code.4735 = code;
          code = code.4735 + 1;
          D.43494 = imb.b[1];
          *code.4735 = D.43494;
          code.4736 = code;
          code = code.4736 + 1;
          D.43496 = imb.b[2];
          *code.4736 = D.43496;
          code.4737 = code;
          code = code.4737 + 1;
          D.43498 = imb.b[3];
          *code.4737 = D.43498;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.43499>;
    <D.43489>:
    if (0 != 0) goto <D.43500>; else goto <D.43501>;
    <D.43500>:
    if (1 != 0) goto <D.43502>; else goto <D.43503>;
    <D.43502>:
    code.4738 = code;
    code = code.4738 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.4738 = D.32644;
    code.4739 = code;
    code = code.4739 + 1;
    *code.4739 = 36;
    goto <D.43506>;
    <D.43503>:
    if (1 != 0) goto <D.43507>; else goto <D.43508>;
    <D.43507>:
    code.4740 = code;
    code = code.4740 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.4740 = D.32735;
    code.4741 = code;
    code = code.4741 + 1;
    *code.4741 = 36;
    *code = 0;
    code = code + 1;
    goto <D.43511>;
    <D.43508>:
    code.4742 = code;
    code = code.4742 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.4742 = D.32740;
    code.4743 = code;
    code = code.4743 + 1;
    *code.4743 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4744 = code;
          code = code.4744 + 1;
          D.43515 = imb.b[0];
          *code.4744 = D.43515;
          code.4745 = code;
          code = code.4745 + 1;
          D.43517 = imb.b[1];
          *code.4745 = D.43517;
          code.4746 = code;
          code = code.4746 + 1;
          D.43519 = imb.b[2];
          *code.4746 = D.43519;
          code.4747 = code;
          code = code.4747 + 1;
          D.43521 = imb.b[3];
          *code.4747 = D.43521;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43511>:
    <D.43506>:
    goto <D.26853>;
    <D.43501>:
    if (1 != 0) goto <D.43522>; else goto <D.43523>;
    <D.43522>:
    code.4748 = code;
    code = code.4748 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.40107 = D.31627 << 3;
    *code.4748 = D.40107;
    goto <D.26853>;
    <D.43523>:
    if (1 != 0) goto <D.43525>; else goto <D.43526>;
    <D.43525>:
    code.4749 = code;
    code = code.4749 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.40111 = (unsigned char) D.32758;
    *code.4749 = D.40111;
    *code = 0;
    code = code + 1;
    goto <D.43528>;
    <D.43526>:
    code.4750 = code;
    code = code.4750 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.40114 = (unsigned char) D.32763;
    *code.4750 = D.40114;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.4751 = code;
          code = code.4751 + 1;
          D.43531 = imb.b[0];
          *code.4751 = D.43531;
          code.4752 = code;
          code = code.4752 + 1;
          D.43533 = imb.b[1];
          *code.4752 = D.43533;
          code.4753 = code;
          code = code.4753 + 1;
          D.43535 = imb.b[2];
          *code.4753 = D.43535;
          code.4754 = code;
          code = code.4754 + 1;
          D.43537 = imb.b[3];
          *code.4754 = D.43537;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.43528>:
    <D.26853>:
    <D.43499>:
    code.4755 = code;
    code = code.4755 + 1;
    *code.4755 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.43540>; else goto <D.43541>;
      <D.43540>:
      iftmp.4756 = 4;
      goto <D.43542>;
      <D.43541>:
      iftmp.4756 = 0;
      <D.43542>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.43543 = iftmp.4756 | D.32040;
      _amd64_rex_bits = (unsigned char) D.43543;
      if (_amd64_rex_bits != 0) goto <D.43544>; else goto <D.43545>;
      <D.43544>:
      code.4757 = code;
      code = code.4757 + 1;
      D.43547 = _amd64_rex_bits | 64;
      *code.4757 = D.43547;
      <D.43545>:
    }
    code.4758 = code;
    code = code.4758 + 1;
    *code.4758 = 15;
    code.4759 = code;
    code = code.4759 + 1;
    *code.4759 = 90;
    code.4760 = code;
    code = code.4760 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.4760 = D.37521;
    <D.43460>:
    goto <D.25197>;
  }
  <D.26856>:
  code.4761 = code;
  code = code.4761 + 1;
  *code.4761 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.43553>; else goto <D.43554>;
    <D.43553>:
    iftmp.4762 = 4;
    goto <D.43555>;
    <D.43554>:
    iftmp.4762 = 0;
    <D.43555>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.43556 = iftmp.4762 | D.32040;
    _amd64_rex_bits = (unsigned char) D.43556;
    if (_amd64_rex_bits != 0) goto <D.43557>; else goto <D.43558>;
    <D.43557>:
    code.4763 = code;
    code = code.4763 + 1;
    D.43560 = _amd64_rex_bits | 64;
    *code.4763 = D.43560;
    <D.43558>:
  }
  code.4764 = code;
  code = code.4764 + 1;
  *code.4764 = 15;
  code.4765 = code;
  code = code.4765 + 1;
  *code.4765 = 17;
  D.31589 = ins->dreg;
  if (D.31589 == 16) goto <D.43563>; else goto <D.43564>;
  <D.43563>:
  code.4766 = code;
  code = code.4766 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.4766 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4767 = code;
        code = code.4767 + 1;
        D.43567 = imb.b[0];
        *code.4767 = D.43567;
        code.4768 = code;
        code = code.4768 + 1;
        D.43569 = imb.b[1];
        *code.4768 = D.43569;
        code.4769 = code;
        code = code.4769 + 1;
        D.43571 = imb.b[2];
        *code.4769 = D.43571;
        code.4770 = code;
        code = code.4770 + 1;
        D.43573 = imb.b[3];
        *code.4770 = D.43573;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.43574>;
  <D.43564>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.43575>; else goto <D.43576>;
  <D.43575>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43577>; else goto <D.43578>;
  <D.43577>:
  code.4771 = code;
  code = code.4771 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.4771 = D.32056;
  code.4772 = code;
  code = code.4772 + 1;
  *code.4772 = 36;
  goto <D.43581>;
  <D.43578>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43582>; else goto <D.43583>;
  <D.43582>:
  code.4773 = code;
  code = code.4773 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.4773 = D.32063;
  code.4774 = code;
  code = code.4774 + 1;
  *code.4774 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43586>;
  <D.43583>:
  code.4775 = code;
  code = code.4775 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.4775 = D.32068;
  code.4776 = code;
  code = code.4776 + 1;
  *code.4776 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4777 = code;
        code = code.4777 + 1;
        D.43590 = imb.b[0];
        *code.4777 = D.43590;
        code.4778 = code;
        code = code.4778 + 1;
        D.43592 = imb.b[1];
        *code.4778 = D.43592;
        code.4779 = code;
        code = code.4779 + 1;
        D.43594 = imb.b[2];
        *code.4779 = D.43594;
        code.4780 = code;
        code = code.4780 + 1;
        D.43596 = imb.b[3];
        *code.4780 = D.43596;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43586>:
  <D.43581>:
  goto <D.26860>;
  <D.43576>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43597>; else goto <D.43598>;
  <D.43597>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.43599>; else goto <D.43600>;
  <D.43599>:
  code.4781 = code;
  code = code.4781 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.4781 = D.32084;
  goto <D.26860>;
  <D.43600>:
  <D.43598>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43602>; else goto <D.43603>;
  <D.43602>:
  code.4782 = code;
  code = code.4782 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.4782 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43605>;
  <D.43603>:
  code.4783 = code;
  code = code.4783 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.4783 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4784 = code;
        code = code.4784 + 1;
        D.43608 = imb.b[0];
        *code.4784 = D.43608;
        code.4785 = code;
        code = code.4785 + 1;
        D.43610 = imb.b[1];
        *code.4785 = D.43610;
        code.4786 = code;
        code = code.4786 + 1;
        D.43612 = imb.b[2];
        *code.4786 = D.43612;
        code.4787 = code;
        code = code.4787 + 1;
        D.43614 = imb.b[3];
        *code.4787 = D.43614;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43605>:
  <D.26860>:
  <D.43574>:
  goto <D.25197>;
  <D.26862>:
  code.4788 = code;
  code = code.4788 + 1;
  *code.4788 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43617>; else goto <D.43618>;
    <D.43617>:
    iftmp.4789 = 4;
    goto <D.43619>;
    <D.43618>:
    iftmp.4789 = 0;
    <D.43619>:
    D.43620 = ins->sreg1;
    D.43621 = D.43620 != 16;
    D.43622 = D.43620 > 7;
    D.43623 = D.43621 & D.43622;
    D.43624 = (int) D.43623;
    D.43625 = (signed char) D.43624;
    D.43626 = iftmp.4789 | D.43625;
    _amd64_rex_bits = (unsigned char) D.43626;
    if (_amd64_rex_bits != 0) goto <D.43627>; else goto <D.43628>;
    <D.43627>:
    code.4790 = code;
    code = code.4790 + 1;
    D.43630 = _amd64_rex_bits | 64;
    *code.4790 = D.43630;
    <D.43628>:
  }
  code.4791 = code;
  code = code.4791 + 1;
  *code.4791 = 15;
  code.4792 = code;
  code = code.4792 + 1;
  *code.4792 = 16;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.43633>; else goto <D.43634>;
  <D.43633>:
  code.4793 = code;
  code = code.4793 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.4793 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4794 = code;
        code = code.4794 + 1;
        D.43637 = imb.b[0];
        *code.4794 = D.43637;
        code.4795 = code;
        code = code.4795 + 1;
        D.43639 = imb.b[1];
        *code.4795 = D.43639;
        code.4796 = code;
        code = code.4796 + 1;
        D.43641 = imb.b[2];
        *code.4796 = D.43641;
        code.4797 = code;
        code = code.4797 + 1;
        D.43643 = imb.b[3];
        *code.4797 = D.43643;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.43644>;
  <D.43634>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.43645>; else goto <D.43646>;
  <D.43645>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43647>; else goto <D.43648>;
  <D.43647>:
  code.4798 = code;
  code = code.4798 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.4798 = D.32644;
  code.4799 = code;
  code = code.4799 + 1;
  *code.4799 = 36;
  goto <D.43651>;
  <D.43648>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43652>; else goto <D.43653>;
  <D.43652>:
  code.4800 = code;
  code = code.4800 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.4800 = D.32735;
  code.4801 = code;
  code = code.4801 + 1;
  *code.4801 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43656>;
  <D.43653>:
  code.4802 = code;
  code = code.4802 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.4802 = D.32740;
  code.4803 = code;
  code = code.4803 + 1;
  *code.4803 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4804 = code;
        code = code.4804 + 1;
        D.43660 = imb.b[0];
        *code.4804 = D.43660;
        code.4805 = code;
        code = code.4805 + 1;
        D.43662 = imb.b[1];
        *code.4805 = D.43662;
        code.4806 = code;
        code = code.4806 + 1;
        D.43664 = imb.b[2];
        *code.4806 = D.43664;
        code.4807 = code;
        code = code.4807 + 1;
        D.43666 = imb.b[3];
        *code.4807 = D.43666;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43656>:
  <D.43651>:
  goto <D.26866>;
  <D.43646>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43667>; else goto <D.43668>;
  <D.43667>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.43669>; else goto <D.43670>;
  <D.43669>:
  code.4808 = code;
  code = code.4808 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.4808 = D.33228;
  goto <D.26866>;
  <D.43670>:
  <D.43668>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43672>; else goto <D.43673>;
  <D.43672>:
  code.4809 = code;
  code = code.4809 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.4809 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43675>;
  <D.43673>:
  code.4810 = code;
  code = code.4810 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.4810 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4811 = code;
        code = code.4811 + 1;
        D.43678 = imb.b[0];
        *code.4811 = D.43678;
        code.4812 = code;
        code = code.4812 + 1;
        D.43680 = imb.b[1];
        *code.4812 = D.43680;
        code.4813 = code;
        code = code.4813 + 1;
        D.43682 = imb.b[2];
        *code.4813 = D.43682;
        code.4814 = code;
        code = code.4814 + 1;
        D.43684 = imb.b[3];
        *code.4814 = D.43684;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43675>:
  <D.26866>:
  <D.43644>:
  goto <D.25197>;
  <D.26868>:
  code.4815 = code;
  code = code.4815 + 1;
  *code.4815 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.43687>; else goto <D.43688>;
    <D.43687>:
    iftmp.4816 = 5;
    goto <D.43689>;
    <D.43688>:
    iftmp.4816 = 4;
    <D.43689>:
    _amd64_rex_bits = iftmp.4816;
    if (_amd64_rex_bits != 0) goto <D.43690>; else goto <D.43691>;
    <D.43690>:
    code.4817 = code;
    code = code.4817 + 1;
    D.43693 = _amd64_rex_bits | 64;
    *code.4817 = D.43693;
    <D.43691>:
  }
  code.4818 = code;
  code = code.4818 + 1;
  *code.4818 = 15;
  code.4819 = code;
  code = code.4819 + 1;
  *code.4819 = 90;
  code.4820 = code;
  code = code.4820 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.4820 = D.33839;
  code.4821 = code;
  code = code.4821 + 1;
  *code.4821 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43699>; else goto <D.43700>;
    <D.43699>:
    iftmp.4822 = 5;
    goto <D.43701>;
    <D.43700>:
    iftmp.4822 = 4;
    <D.43701>:
    _amd64_rex_bits = iftmp.4822;
    if (_amd64_rex_bits != 0) goto <D.43702>; else goto <D.43703>;
    <D.43702>:
    code.4823 = code;
    code = code.4823 + 1;
    D.43705 = _amd64_rex_bits | 64;
    *code.4823 = D.43705;
    <D.43703>:
  }
  code.4824 = code;
  code = code.4824 + 1;
  *code.4824 = 15;
  code.4825 = code;
  code = code.4825 + 1;
  *code.4825 = 17;
  D.31589 = ins->dreg;
  if (D.31589 == 16) goto <D.43708>; else goto <D.43709>;
  <D.43708>:
  code.4826 = code;
  code = code.4826 + 1;
  *code.4826 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4827 = code;
        code = code.4827 + 1;
        D.43712 = imb.b[0];
        *code.4827 = D.43712;
        code.4828 = code;
        code = code.4828 + 1;
        D.43714 = imb.b[1];
        *code.4828 = D.43714;
        code.4829 = code;
        code = code.4829 + 1;
        D.43716 = imb.b[2];
        *code.4829 = D.43716;
        code.4830 = code;
        code = code.4830 + 1;
        D.43718 = imb.b[3];
        *code.4830 = D.43718;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.43719>;
  <D.43709>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.43720>; else goto <D.43721>;
  <D.43720>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43722>; else goto <D.43723>;
  <D.43722>:
  code.4831 = code;
  code = code.4831 + 1;
  *code.4831 = 60;
  code.4832 = code;
  code = code.4832 + 1;
  *code.4832 = 36;
  goto <D.43726>;
  <D.43723>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43727>; else goto <D.43728>;
  <D.43727>:
  code.4833 = code;
  code = code.4833 + 1;
  *code.4833 = 124;
  code.4834 = code;
  code = code.4834 + 1;
  *code.4834 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43731>;
  <D.43728>:
  code.4835 = code;
  code = code.4835 + 1;
  *code.4835 = 188;
  code.4836 = code;
  code = code.4836 + 1;
  *code.4836 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4837 = code;
        code = code.4837 + 1;
        D.43735 = imb.b[0];
        *code.4837 = D.43735;
        code.4838 = code;
        code = code.4838 + 1;
        D.43737 = imb.b[1];
        *code.4838 = D.43737;
        code.4839 = code;
        code = code.4839 + 1;
        D.43739 = imb.b[2];
        *code.4839 = D.43739;
        code.4840 = code;
        code = code.4840 + 1;
        D.43741 = imb.b[3];
        *code.4840 = D.43741;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43731>:
  <D.43726>:
  goto <D.26873>;
  <D.43721>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43742>; else goto <D.43743>;
  <D.43742>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.43744>; else goto <D.43745>;
  <D.43744>:
  code.4841 = code;
  code = code.4841 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.43747 = D.31632 | 56;
  D.43748 = (unsigned char) D.43747;
  *code.4841 = D.43748;
  goto <D.26873>;
  <D.43745>:
  <D.43743>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43749>; else goto <D.43750>;
  <D.43749>:
  code.4842 = code;
  code = code.4842 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.43752 = D.31632 | 120;
  D.43753 = (unsigned char) D.43752;
  *code.4842 = D.43753;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43754>;
  <D.43750>:
  code.4843 = code;
  code = code.4843 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.43756 = D.31632 | -72;
  D.43757 = (unsigned char) D.43756;
  *code.4843 = D.43757;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4844 = code;
        code = code.4844 + 1;
        D.43759 = imb.b[0];
        *code.4844 = D.43759;
        code.4845 = code;
        code = code.4845 + 1;
        D.43761 = imb.b[1];
        *code.4845 = D.43761;
        code.4846 = code;
        code = code.4846 + 1;
        D.43763 = imb.b[2];
        *code.4846 = D.43763;
        code.4847 = code;
        code = code.4847 + 1;
        D.43765 = imb.b[3];
        *code.4847 = D.43765;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43754>:
  <D.26873>:
  <D.43719>:
  goto <D.25197>;
  <D.26875>:
  code.4848 = code;
  code = code.4848 + 1;
  *code.4848 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43768>; else goto <D.43769>;
    <D.43768>:
    iftmp.4849 = 4;
    goto <D.43770>;
    <D.43769>:
    iftmp.4849 = 0;
    <D.43770>:
    D.43771 = ins->sreg1;
    D.43772 = D.43771 != 16;
    D.43773 = D.43771 > 7;
    D.43774 = D.43772 & D.43773;
    D.43775 = (int) D.43774;
    D.43776 = (signed char) D.43775;
    D.43777 = iftmp.4849 | D.43776;
    _amd64_rex_bits = (unsigned char) D.43777;
    if (_amd64_rex_bits != 0) goto <D.43778>; else goto <D.43779>;
    <D.43778>:
    code.4850 = code;
    code = code.4850 + 1;
    D.43781 = _amd64_rex_bits | 64;
    *code.4850 = D.43781;
    <D.43779>:
  }
  code.4851 = code;
  code = code.4851 + 1;
  *code.4851 = 15;
  code.4852 = code;
  code = code.4852 + 1;
  *code.4852 = 16;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.43784>; else goto <D.43785>;
  <D.43784>:
  code.4853 = code;
  code = code.4853 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.4853 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4854 = code;
        code = code.4854 + 1;
        D.43788 = imb.b[0];
        *code.4854 = D.43788;
        code.4855 = code;
        code = code.4855 + 1;
        D.43790 = imb.b[1];
        *code.4855 = D.43790;
        code.4856 = code;
        code = code.4856 + 1;
        D.43792 = imb.b[2];
        *code.4856 = D.43792;
        code.4857 = code;
        code = code.4857 + 1;
        D.43794 = imb.b[3];
        *code.4857 = D.43794;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.43795>;
  <D.43785>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.43796>; else goto <D.43797>;
  <D.43796>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43798>; else goto <D.43799>;
  <D.43798>:
  code.4858 = code;
  code = code.4858 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.4858 = D.32644;
  code.4859 = code;
  code = code.4859 + 1;
  *code.4859 = 36;
  goto <D.43802>;
  <D.43799>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43803>; else goto <D.43804>;
  <D.43803>:
  code.4860 = code;
  code = code.4860 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.4860 = D.32735;
  code.4861 = code;
  code = code.4861 + 1;
  *code.4861 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43807>;
  <D.43804>:
  code.4862 = code;
  code = code.4862 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.4862 = D.32740;
  code.4863 = code;
  code = code.4863 + 1;
  *code.4863 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4864 = code;
        code = code.4864 + 1;
        D.43811 = imb.b[0];
        *code.4864 = D.43811;
        code.4865 = code;
        code = code.4865 + 1;
        D.43813 = imb.b[1];
        *code.4865 = D.43813;
        code.4866 = code;
        code = code.4866 + 1;
        D.43815 = imb.b[2];
        *code.4866 = D.43815;
        code.4867 = code;
        code = code.4867 + 1;
        D.43817 = imb.b[3];
        *code.4867 = D.43817;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43807>:
  <D.43802>:
  goto <D.26879>;
  <D.43797>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.43818>; else goto <D.43819>;
  <D.43818>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.43820>; else goto <D.43821>;
  <D.43820>:
  code.4868 = code;
  code = code.4868 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.4868 = D.33228;
  goto <D.26879>;
  <D.43821>:
  <D.43819>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.43823>; else goto <D.43824>;
  <D.43823>:
  code.4869 = code;
  code = code.4869 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.4869 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.43826>;
  <D.43824>:
  code.4870 = code;
  code = code.4870 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.4870 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.4871 = code;
        code = code.4871 + 1;
        D.43829 = imb.b[0];
        *code.4871 = D.43829;
        code.4872 = code;
        code = code.4872 + 1;
        D.43831 = imb.b[1];
        *code.4872 = D.43831;
        code.4873 = code;
        code = code.4873 + 1;
        D.43833 = imb.b[2];
        *code.4873 = D.43833;
        code.4874 = code;
        code = code.4874 + 1;
        D.43835 = imb.b[3];
        *code.4874 = D.43835;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.43826>:
  <D.26879>:
  <D.43795>:
  code.4875 = code;
  code = code.4875 + 1;
  *code.4875 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43838>; else goto <D.43839>;
    <D.43838>:
    iftmp.4876 = 4;
    goto <D.43840>;
    <D.43839>:
    iftmp.4876 = 0;
    <D.43840>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.43841 = iftmp.4876 | D.32040;
    _amd64_rex_bits = (unsigned char) D.43841;
    if (_amd64_rex_bits != 0) goto <D.43842>; else goto <D.43843>;
    <D.43842>:
    code.4877 = code;
    code = code.4877 + 1;
    D.43845 = _amd64_rex_bits | 64;
    *code.4877 = D.43845;
    <D.43843>:
  }
  code.4878 = code;
  code = code.4878 + 1;
  *code.4878 = 15;
  code.4879 = code;
  code = code.4879 + 1;
  *code.4879 = 90;
  code.4880 = code;
  code = code.4880 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.4880 = D.37521;
  goto <D.25197>;
  <D.26882>:
  code.4881 = code;
  code = code.4881 + 1;
  *code.4881 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43851>; else goto <D.43852>;
    <D.43851>:
    iftmp.4882 = 4;
    goto <D.43853>;
    <D.43852>:
    iftmp.4882 = 0;
    <D.43853>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.43854 = iftmp.4882 | D.33180;
    _amd64_rex_bits = (unsigned char) D.43854;
    if (_amd64_rex_bits != 0) goto <D.43855>; else goto <D.43856>;
    <D.43855>:
    code.4883 = code;
    code = code.4883 + 1;
    D.43858 = _amd64_rex_bits | 64;
    *code.4883 = D.43858;
    <D.43856>:
  }
  code.4884 = code;
  code = code.4884 + 1;
  *code.4884 = 15;
  code.4885 = code;
  code = code.4885 + 1;
  *code.4885 = 42;
  code.4886 = code;
  code = code.4886 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.4886 = D.33727;
  code.4887 = code;
  code = code.4887 + 1;
  *code.4887 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43864>; else goto <D.43865>;
    <D.43864>:
    iftmp.4888 = 4;
    goto <D.43866>;
    <D.43865>:
    iftmp.4888 = 0;
    <D.43866>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.43867 = iftmp.4888 | D.32040;
    _amd64_rex_bits = (unsigned char) D.43867;
    if (_amd64_rex_bits != 0) goto <D.43868>; else goto <D.43869>;
    <D.43868>:
    code.4889 = code;
    code = code.4889 + 1;
    D.43871 = _amd64_rex_bits | 64;
    *code.4889 = D.43871;
    <D.43869>:
  }
  code.4890 = code;
  code = code.4890 + 1;
  *code.4890 = 15;
  code.4891 = code;
  code = code.4891 + 1;
  *code.4891 = 90;
  code.4892 = code;
  code = code.4892 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.4892 = D.37521;
  goto <D.25197>;
  <D.26885>:
  code.4893 = code;
  code = code.4893 + 1;
  *code.4893 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43877>; else goto <D.43878>;
    <D.43877>:
    iftmp.4894 = 4;
    goto <D.43879>;
    <D.43878>:
    iftmp.4894 = 0;
    <D.43879>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.43880 = iftmp.4894 | D.33180;
    _amd64_rex_bits = (unsigned char) D.43880;
    if (_amd64_rex_bits != 0) goto <D.43881>; else goto <D.43882>;
    <D.43881>:
    code.4895 = code;
    code = code.4895 + 1;
    D.43884 = _amd64_rex_bits | 64;
    *code.4895 = D.43884;
    <D.43882>:
  }
  code.4896 = code;
  code = code.4896 + 1;
  *code.4896 = 15;
  code.4897 = code;
  code = code.4897 + 1;
  *code.4897 = 42;
  code.4898 = code;
  code = code.4898 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.4898 = D.33727;
  goto <D.25197>;
  <D.26887>:
  code.4899 = code;
  code = code.4899 + 1;
  *code.4899 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43890>; else goto <D.43891>;
    <D.43890>:
    iftmp.4900 = 12;
    goto <D.43892>;
    <D.43891>:
    iftmp.4900 = 8;
    <D.43892>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.43893 = iftmp.4900 | D.33180;
    _amd64_rex_bits = (unsigned char) D.43893;
    if (_amd64_rex_bits != 0) goto <D.43894>; else goto <D.43895>;
    <D.43894>:
    code.4901 = code;
    code = code.4901 + 1;
    D.43897 = _amd64_rex_bits | 64;
    *code.4901 = D.43897;
    <D.43895>:
  }
  code.4902 = code;
  code = code.4902 + 1;
  *code.4902 = 15;
  code.4903 = code;
  code = code.4903 + 1;
  *code.4903 = 42;
  code.4904 = code;
  code = code.4904 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.4904 = D.33727;
  code.4905 = code;
  code = code.4905 + 1;
  *code.4905 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43903>; else goto <D.43904>;
    <D.43903>:
    iftmp.4906 = 4;
    goto <D.43905>;
    <D.43904>:
    iftmp.4906 = 0;
    <D.43905>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.43906 = iftmp.4906 | D.32040;
    _amd64_rex_bits = (unsigned char) D.43906;
    if (_amd64_rex_bits != 0) goto <D.43907>; else goto <D.43908>;
    <D.43907>:
    code.4907 = code;
    code = code.4907 + 1;
    D.43910 = _amd64_rex_bits | 64;
    *code.4907 = D.43910;
    <D.43908>:
  }
  code.4908 = code;
  code = code.4908 + 1;
  *code.4908 = 15;
  code.4909 = code;
  code = code.4909 + 1;
  *code.4909 = 90;
  code.4910 = code;
  code = code.4910 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.4910 = D.37521;
  goto <D.25197>;
  <D.26890>:
  code.4911 = code;
  code = code.4911 + 1;
  *code.4911 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43916>; else goto <D.43917>;
    <D.43916>:
    iftmp.4912 = 12;
    goto <D.43918>;
    <D.43917>:
    iftmp.4912 = 8;
    <D.43918>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.43919 = iftmp.4912 | D.33180;
    _amd64_rex_bits = (unsigned char) D.43919;
    if (_amd64_rex_bits != 0) goto <D.43920>; else goto <D.43921>;
    <D.43920>:
    code.4913 = code;
    code = code.4913 + 1;
    D.43923 = _amd64_rex_bits | 64;
    *code.4913 = D.43923;
    <D.43921>:
  }
  code.4914 = code;
  code = code.4914 + 1;
  *code.4914 = 15;
  code.4915 = code;
  code = code.4915 + 1;
  *code.4915 = 42;
  code.4916 = code;
  code = code.4916 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.4916 = D.33727;
  goto <D.25197>;
  <D.26892>:
  code.4917 = code;
  code = code.4917 + 1;
  *code.4917 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43929>; else goto <D.43930>;
    <D.43929>:
    iftmp.4918 = 4;
    goto <D.43931>;
    <D.43930>:
    iftmp.4918 = 0;
    <D.43931>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.43932 = iftmp.4918 | D.33180;
    _amd64_rex_bits = (unsigned char) D.43932;
    if (_amd64_rex_bits != 0) goto <D.43933>; else goto <D.43934>;
    <D.43933>:
    code.4919 = code;
    code = code.4919 + 1;
    D.43936 = _amd64_rex_bits | 64;
    *code.4919 = D.43936;
    <D.43934>:
  }
  code.4920 = code;
  code = code.4920 + 1;
  *code.4920 = 15;
  code.4921 = code;
  code = code.4921 + 1;
  *code.4921 = 90;
  code.4922 = code;
  code = code.4922 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.4922 = D.33727;
  code.4923 = code;
  code = code.4923 + 1;
  *code.4923 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.43942>; else goto <D.43943>;
    <D.43942>:
    iftmp.4924 = 4;
    goto <D.43944>;
    <D.43943>:
    iftmp.4924 = 0;
    <D.43944>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.43945 = iftmp.4924 | D.32040;
    _amd64_rex_bits = (unsigned char) D.43945;
    if (_amd64_rex_bits != 0) goto <D.43946>; else goto <D.43947>;
    <D.43946>:
    code.4925 = code;
    code = code.4925 + 1;
    D.43949 = _amd64_rex_bits | 64;
    *code.4925 = D.43949;
    <D.43947>:
  }
  code.4926 = code;
  code = code.4926 + 1;
  *code.4926 = 15;
  code.4927 = code;
  code = code.4927 + 1;
  *code.4927 = 90;
  code.4928 = code;
  code = code.4928 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.4928 = D.37521;
  goto <D.25197>;
  <D.26895>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 1, 1);
  goto <D.25197>;
  <D.26896>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 1, 0);
  goto <D.25197>;
  <D.26897>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 2, 1);
  goto <D.25197>;
  <D.26898>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 2, 0);
  goto <D.25197>;
  <D.26899>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 4, 0);
  goto <D.25197>;
  <D.26900>:
  <D.26901>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 4, 1);
  goto <D.25197>;
  <D.26902>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_float_to_int (cfg, code, D.31589, D.31516, 8, 1);
  goto <D.25197>;
  <D.26903>:
  {
    guint8 * br[2];

    try
      {
        {
          unsigned char _amd64_rex_bits;

          D.31516 = ins->sreg1;
          if (D.31516 > 7) goto <D.43954>; else goto <D.43955>;
          <D.43954>:
          iftmp.4929 = 12;
          goto <D.43956>;
          <D.43955>:
          iftmp.4929 = 8;
          <D.43956>:
          D.31516 = ins->sreg1;
          D.31517 = D.31516 > 7;
          D.33180 = (signed char) D.31517;
          D.43957 = iftmp.4929 | D.33180;
          _amd64_rex_bits = (unsigned char) D.43957;
          if (_amd64_rex_bits != 0) goto <D.43958>; else goto <D.43959>;
          <D.43958>:
          code.4930 = code;
          code = code.4930 + 1;
          D.43961 = _amd64_rex_bits | 64;
          *code.4930 = D.43961;
          <D.43959>:
        }
        code.4931 = code;
        code = code.4931 + 1;
        *code.4931 = 133;
        code.4932 = code;
        code = code.4932 + 1;
        D.31516 = ins->sreg1;
        D.31532 = D.31516 & 7;
        D.32053 = D.31532 << 3;
        D.32054 = (signed char) D.32053;
        D.33819 = D.32054 | -64;
        D.31516 = ins->sreg1;
        D.31570 = (signed char) D.31516;
        D.31571 = D.31570 & 7;
        D.33956 = D.33819 | D.31571;
        D.33957 = (unsigned char) D.33956;
        *code.4932 = D.33957;
        br[0] = code;
        if (1 != 0) goto <D.43964>; else goto <D.43965>;
        <D.43964>:
        code.4933 = code;
        code = code.4933 + 1;
        D.43967 = 120;
        *code.4933 = D.43967;
        goto <D.43968>;
        <D.43965>:
        code.4934 = code;
        code = code.4934 + 1;
        D.43970 = 120;
        *code.4934 = D.43970;
        <D.43968>:
        *code = 0;
        code = code + 1;
        code.4935 = code;
        code = code.4935 + 1;
        *code.4935 = 242;
        {
          unsigned char _amd64_rex_bits;

          D.31589 = ins->dreg;
          if (D.31589 > 7) goto <D.43973>; else goto <D.43974>;
          <D.43973>:
          iftmp.4936 = 12;
          goto <D.43975>;
          <D.43974>:
          iftmp.4936 = 8;
          <D.43975>:
          D.31516 = ins->sreg1;
          D.31517 = D.31516 > 7;
          D.33180 = (signed char) D.31517;
          D.43976 = iftmp.4936 | D.33180;
          _amd64_rex_bits = (unsigned char) D.43976;
          if (_amd64_rex_bits != 0) goto <D.43977>; else goto <D.43978>;
          <D.43977>:
          code.4937 = code;
          code = code.4937 + 1;
          D.43980 = _amd64_rex_bits | 64;
          *code.4937 = D.43980;
          <D.43978>:
        }
        code.4938 = code;
        code = code.4938 + 1;
        *code.4938 = 15;
        code.4939 = code;
        code = code.4939 + 1;
        *code.4939 = 42;
        code.4940 = code;
        code = code.4940 + 1;
        D.31589 = ins->dreg;
        D.31598 = D.31589 & 7;
        D.32641 = D.31598 << 3;
        D.32642 = (signed char) D.32641;
        D.33725 = D.32642 | -64;
        D.31516 = ins->sreg1;
        D.31570 = (signed char) D.31516;
        D.31571 = D.31570 & 7;
        D.33726 = D.33725 | D.31571;
        D.33727 = (unsigned char) D.33726;
        *code.4940 = D.33727;
        br[1] = code;
        code.4941 = code;
        code = code.4941 + 1;
        *code.4941 = 235;
        *code = 0;
        code = code + 1;
        D.43985 = br[0];
        amd64_patch (D.43985, code);
        if (0 != 0) goto <D.43986>; else goto <D.43987>;
        <D.43986>:
        code.4942 = code;
        code = code.4942 + 1;
        *code.4942 = 102;
        <D.43987>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.43989>; else goto <D.43990>;
          <D.43989>:
          code.4943 = code;
          code = code.4943 + 1;
          D.43992 = _amd64_rex_bits | 64;
          *code.4943 = D.43992;
          <D.43990>:
        }
        switch (8) <default: <D.26913>, case 1: <D.26908>, case 2: <D.26910>, case 4: <D.26911>, case 8: <D.26912>>
        <D.26908>:
        code.4944 = code;
        code = code.4944 + 1;
        *code.4944 = 136;
        goto <D.26909>;
        <D.26910>:
        <D.26911>:
        <D.26912>:
        code.4945 = code;
        code = code.4945 + 1;
        *code.4945 = 137;
        goto <D.26909>;
        <D.26913>:
        __assert_fail ("0", "mini-amd64.c", 5322, &__PRETTY_FUNCTION__);
        <D.26909>:
        if (1 != 0) goto <D.43995>; else goto <D.43996>;
        <D.43995>:
        if (0 != 0) goto <D.43997>; else goto <D.43998>;
        <D.43997>:
        code.4946 = code;
        code = code.4946 + 1;
        *code.4946 = 4;
        code.4947 = code;
        code = code.4947 + 1;
        *code.4947 = 36;
        goto <D.44001>;
        <D.43998>:
        if (1 != 0) goto <D.44002>; else goto <D.44003>;
        <D.44002>:
        code.4948 = code;
        code = code.4948 + 1;
        *code.4948 = 68;
        code.4949 = code;
        code = code.4949 + 1;
        *code.4949 = 36;
        *code = 248;
        code = code + 1;
        goto <D.44006>;
        <D.44003>:
        code.4950 = code;
        code = code.4950 + 1;
        *code.4950 = 132;
        code.4951 = code;
        code = code.4951 + 1;
        *code.4951 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.4952 = code;
              code = code.4952 + 1;
              D.44010 = imb.b[0];
              *code.4952 = D.44010;
              code.4953 = code;
              code = code.4953 + 1;
              D.44012 = imb.b[1];
              *code.4953 = D.44012;
              code.4954 = code;
              code = code.4954 + 1;
              D.44014 = imb.b[2];
              *code.4954 = D.44014;
              code.4955 = code;
              code = code.4955 + 1;
              D.44016 = imb.b[3];
              *code.4955 = D.44016;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44006>:
        <D.44001>:
        goto <D.26915>;
        <D.43996>:
        if (0 != 0) goto <D.44017>; else goto <D.44018>;
        <D.44017>:
        code.4956 = code;
        code = code.4956 + 1;
        *code.4956 = 4;
        goto <D.26915>;
        <D.44018>:
        if (1 != 0) goto <D.44020>; else goto <D.44021>;
        <D.44020>:
        code.4957 = code;
        code = code.4957 + 1;
        *code.4957 = 68;
        *code = 248;
        code = code + 1;
        goto <D.44023>;
        <D.44021>:
        code.4958 = code;
        code = code.4958 + 1;
        *code.4958 = 132;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.4959 = code;
              code = code.4959 + 1;
              D.44026 = imb.b[0];
              *code.4959 = D.44026;
              code.4960 = code;
              code = code.4960 + 1;
              D.44028 = imb.b[1];
              *code.4960 = D.44028;
              code.4961 = code;
              code = code.4961 + 1;
              D.44030 = imb.b[2];
              *code.4961 = D.44030;
              code.4962 = code;
              code = code.4962 + 1;
              D.44032 = imb.b[3];
              *code.4962 = D.44032;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44023>:
        <D.26915>:
        if (0 != 0) goto <D.44033>; else goto <D.44034>;
        <D.44033>:
        code.4963 = code;
        code = code.4963 + 1;
        *code.4963 = 102;
        <D.44034>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44036>; else goto <D.44037>;
          <D.44036>:
          code.4964 = code;
          code = code.4964 + 1;
          D.44039 = _amd64_rex_bits | 64;
          *code.4964 = D.44039;
          <D.44037>:
        }
        switch (8) <default: <D.26923>, case 1: <D.26918>, case 2: <D.26920>, case 4: <D.26921>, case 8: <D.26922>>
        <D.26918>:
        code.4965 = code;
        code = code.4965 + 1;
        *code.4965 = 136;
        goto <D.26919>;
        <D.26920>:
        <D.26921>:
        <D.26922>:
        code.4966 = code;
        code = code.4966 + 1;
        *code.4966 = 137;
        goto <D.26919>;
        <D.26923>:
        __assert_fail ("0", "mini-amd64.c", 5323, &__PRETTY_FUNCTION__);
        <D.26919>:
        if (1 != 0) goto <D.44042>; else goto <D.44043>;
        <D.44042>:
        if (0 != 0) goto <D.44044>; else goto <D.44045>;
        <D.44044>:
        code.4967 = code;
        code = code.4967 + 1;
        *code.4967 = 12;
        code.4968 = code;
        code = code.4968 + 1;
        *code.4968 = 36;
        goto <D.44048>;
        <D.44045>:
        if (1 != 0) goto <D.44049>; else goto <D.44050>;
        <D.44049>:
        code.4969 = code;
        code = code.4969 + 1;
        *code.4969 = 76;
        code.4970 = code;
        code = code.4970 + 1;
        *code.4970 = 36;
        *code = 240;
        code = code + 1;
        goto <D.44053>;
        <D.44050>:
        code.4971 = code;
        code = code.4971 + 1;
        *code.4971 = 140;
        code.4972 = code;
        code = code.4972 + 1;
        *code.4972 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -16;
              code.4973 = code;
              code = code.4973 + 1;
              D.44057 = imb.b[0];
              *code.4973 = D.44057;
              code.4974 = code;
              code = code.4974 + 1;
              D.44059 = imb.b[1];
              *code.4974 = D.44059;
              code.4975 = code;
              code = code.4975 + 1;
              D.44061 = imb.b[2];
              *code.4975 = D.44061;
              code.4976 = code;
              code = code.4976 + 1;
              D.44063 = imb.b[3];
              *code.4976 = D.44063;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44053>:
        <D.44048>:
        goto <D.26925>;
        <D.44043>:
        if (0 != 0) goto <D.44064>; else goto <D.44065>;
        <D.44064>:
        code.4977 = code;
        code = code.4977 + 1;
        *code.4977 = 12;
        goto <D.26925>;
        <D.44065>:
        if (1 != 0) goto <D.44067>; else goto <D.44068>;
        <D.44067>:
        code.4978 = code;
        code = code.4978 + 1;
        *code.4978 = 76;
        *code = 240;
        code = code + 1;
        goto <D.44070>;
        <D.44068>:
        code.4979 = code;
        code = code.4979 + 1;
        *code.4979 = 140;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -16;
              code.4980 = code;
              code = code.4980 + 1;
              D.44073 = imb.b[0];
              *code.4980 = D.44073;
              code.4981 = code;
              code = code.4981 + 1;
              D.44075 = imb.b[1];
              *code.4981 = D.44075;
              code.4982 = code;
              code = code.4982 + 1;
              D.44077 = imb.b[2];
              *code.4982 = D.44077;
              code.4983 = code;
              code = code.4983 + 1;
              D.44079 = imb.b[3];
              *code.4983 = D.44079;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44070>:
        <D.26925>:
        if (0 != 0) goto <D.44080>; else goto <D.44081>;
        <D.44080>:
        code.4984 = code;
        code = code.4984 + 1;
        *code.4984 = 102;
        <D.44081>:
        {
          unsigned char _amd64_rex_bits;

          D.31516 = ins->sreg1;
          if (D.31516 > 7) goto <D.44084>; else goto <D.44085>;
          <D.44084>:
          iftmp.4985 = 9;
          goto <D.44086>;
          <D.44085>:
          iftmp.4985 = 8;
          <D.44086>:
          _amd64_rex_bits = iftmp.4985;
          if (_amd64_rex_bits != 0) goto <D.44087>; else goto <D.44088>;
          <D.44087>:
          code.4986 = code;
          code = code.4986 + 1;
          D.44090 = _amd64_rex_bits | 64;
          *code.4986 = D.44090;
          <D.44088>:
        }
        switch (8) <default: <D.26933>, case 1: <D.26928>, case 2: <D.26930>, case 4: <D.26931>, case 8: <D.26932>>
        <D.26928>:
        code.4987 = code;
        code = code.4987 + 1;
        *code.4987 = 138;
        goto <D.26929>;
        <D.26930>:
        <D.26931>:
        <D.26932>:
        code.4988 = code;
        code = code.4988 + 1;
        *code.4988 = 139;
        goto <D.26929>;
        <D.26933>:
        __assert_fail ("0", "mini-amd64.c", 5324, &__PRETTY_FUNCTION__);
        <D.26929>:
        code.4989 = code;
        code = code.4989 + 1;
        D.31516 = ins->sreg1;
        D.31570 = (signed char) D.31516;
        D.31571 = D.31570 & 7;
        D.38822 = D.31571 | -56;
        D.38823 = (unsigned char) D.38822;
        *code.4989 = D.38823;
        if (0 != 0) goto <D.44094>; else goto <D.44095>;
        <D.44094>:
        code.4990 = code;
        code = code.4990 + 1;
        *code.4990 = 102;
        <D.44095>:
        {
          unsigned char _amd64_rex_bits;

          D.31516 = ins->sreg1;
          if (D.31516 > 7) goto <D.44098>; else goto <D.44099>;
          <D.44098>:
          iftmp.4991 = 9;
          goto <D.44100>;
          <D.44099>:
          iftmp.4991 = 8;
          <D.44100>:
          _amd64_rex_bits = iftmp.4991;
          if (_amd64_rex_bits != 0) goto <D.44101>; else goto <D.44102>;
          <D.44101>:
          code.4992 = code;
          code = code.4992 + 1;
          D.44104 = _amd64_rex_bits | 64;
          *code.4992 = D.44104;
          <D.44102>:
        }
        switch (8) <default: <D.26940>, case 1: <D.26935>, case 2: <D.26937>, case 4: <D.26938>, case 8: <D.26939>>
        <D.26935>:
        code.4993 = code;
        code = code.4993 + 1;
        *code.4993 = 138;
        goto <D.26936>;
        <D.26937>:
        <D.26938>:
        <D.26939>:
        code.4994 = code;
        code = code.4994 + 1;
        *code.4994 = 139;
        goto <D.26936>;
        <D.26940>:
        __assert_fail ("0", "mini-amd64.c", 5325, &__PRETTY_FUNCTION__);
        <D.26936>:
        code.4995 = code;
        code = code.4995 + 1;
        D.31516 = ins->sreg1;
        D.31570 = (signed char) D.31516;
        D.31571 = D.31570 & 7;
        D.39617 = D.31571 | -64;
        D.39618 = (unsigned char) D.39617;
        *code.4995 = D.39618;
        if (1 != 0) goto <D.44108>; else goto <D.44109>;
        <D.44108>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44110>; else goto <D.44111>;
          <D.44110>:
          code.4996 = code;
          code = code.4996 + 1;
          D.44113 = _amd64_rex_bits | 64;
          *code.4996 = D.44113;
          <D.44111>:
        }
        code.4997 = code;
        code = code.4997 + 1;
        *code.4997 = 131;
        code.4998 = code;
        code = code.4998 + 1;
        *code.4998 = 225;
        *code = 1;
        code = code + 1;
        goto <D.44116>;
        <D.44109>:
        if (0 != 0) goto <D.44117>; else goto <D.44118>;
        <D.44117>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44119>; else goto <D.44120>;
          <D.44119>:
          code.4999 = code;
          code = code.4999 + 1;
          D.44122 = _amd64_rex_bits | 64;
          *code.4999 = D.44122;
          <D.44120>:
        }
        code.5000 = code;
        code = code.5000 + 1;
        *code.5000 = 37;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1;
              code.5001 = code;
              code = code.5001 + 1;
              D.44125 = imb.b[0];
              *code.5001 = D.44125;
              code.5002 = code;
              code = code.5002 + 1;
              D.44127 = imb.b[1];
              *code.5002 = D.44127;
              code.5003 = code;
              code = code.5003 + 1;
              D.44129 = imb.b[2];
              *code.5003 = D.44129;
              code.5004 = code;
              code = code.5004 + 1;
              D.44131 = imb.b[3];
              *code.5004 = D.44131;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.44132>;
        <D.44118>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44133>; else goto <D.44134>;
          <D.44133>:
          code.5005 = code;
          code = code.5005 + 1;
          D.44136 = _amd64_rex_bits | 64;
          *code.5005 = D.44136;
          <D.44134>:
        }
        code.5006 = code;
        code = code.5006 + 1;
        *code.5006 = 129;
        code.5007 = code;
        code = code.5007 + 1;
        *code.5007 = 225;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1;
              code.5008 = code;
              code = code.5008 + 1;
              D.44140 = imb.b[0];
              *code.5008 = D.44140;
              code.5009 = code;
              code = code.5009 + 1;
              D.44142 = imb.b[1];
              *code.5009 = D.44142;
              code.5010 = code;
              code = code.5010 + 1;
              D.44144 = imb.b[2];
              *code.5010 = D.44144;
              code.5011 = code;
              code = code.5011 + 1;
              D.44146 = imb.b[3];
              *code.5011 = D.44146;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44132>:
        <D.44116>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44147>; else goto <D.44148>;
          <D.44147>:
          code.5012 = code;
          code = code.5012 + 1;
          D.44150 = _amd64_rex_bits | 64;
          *code.5012 = D.44150;
          <D.44148>:
        }
        if (1 != 0) goto <D.44151>; else goto <D.44152>;
        <D.44151>:
        code.5013 = code;
        code = code.5013 + 1;
        *code.5013 = 209;
        code.5014 = code;
        code = code.5014 + 1;
        *code.5014 = 232;
        goto <D.44155>;
        <D.44152>:
        code.5015 = code;
        code = code.5015 + 1;
        *code.5015 = 193;
        code.5016 = code;
        code = code.5016 + 1;
        *code.5016 = 232;
        *code = 1;
        code = code + 1;
        <D.44155>:
        if (1 != 0) goto <D.44158>; else goto <D.44159>;
        <D.44158>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44160>; else goto <D.44161>;
          <D.44160>:
          code.5017 = code;
          code = code.5017 + 1;
          D.44163 = _amd64_rex_bits | 64;
          *code.5017 = D.44163;
          <D.44161>:
        }
        code.5018 = code;
        code = code.5018 + 1;
        *code.5018 = 131;
        code.5019 = code;
        code = code.5019 + 1;
        *code.5019 = 200;
        *code = 1;
        code = code + 1;
        goto <D.44166>;
        <D.44159>:
        if (1 != 0) goto <D.44167>; else goto <D.44168>;
        <D.44167>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44169>; else goto <D.44170>;
          <D.44169>:
          code.5020 = code;
          code = code.5020 + 1;
          D.44172 = _amd64_rex_bits | 64;
          *code.5020 = D.44172;
          <D.44170>:
        }
        code.5021 = code;
        code = code.5021 + 1;
        *code.5021 = 13;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1;
              code.5022 = code;
              code = code.5022 + 1;
              D.44175 = imb.b[0];
              *code.5022 = D.44175;
              code.5023 = code;
              code = code.5023 + 1;
              D.44177 = imb.b[1];
              *code.5023 = D.44177;
              code.5024 = code;
              code = code.5024 + 1;
              D.44179 = imb.b[2];
              *code.5024 = D.44179;
              code.5025 = code;
              code = code.5025 + 1;
              D.44181 = imb.b[3];
              *code.5025 = D.44181;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.44182>;
        <D.44168>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44183>; else goto <D.44184>;
          <D.44183>:
          code.5026 = code;
          code = code.5026 + 1;
          D.44186 = _amd64_rex_bits | 64;
          *code.5026 = D.44186;
          <D.44184>:
        }
        code.5027 = code;
        code = code.5027 + 1;
        *code.5027 = 129;
        code.5028 = code;
        code = code.5028 + 1;
        *code.5028 = 200;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1;
              code.5029 = code;
              code = code.5029 + 1;
              D.44190 = imb.b[0];
              *code.5029 = D.44190;
              code.5030 = code;
              code = code.5030 + 1;
              D.44192 = imb.b[1];
              *code.5030 = D.44192;
              code.5031 = code;
              code = code.5031 + 1;
              D.44194 = imb.b[2];
              *code.5031 = D.44194;
              code.5032 = code;
              code = code.5032 + 1;
              D.44196 = imb.b[3];
              *code.5032 = D.44196;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44182>:
        <D.44166>:
        code.5033 = code;
        code = code.5033 + 1;
        *code.5033 = 242;
        {
          unsigned char _amd64_rex_bits;

          D.31589 = ins->dreg;
          if (D.31589 > 7) goto <D.44199>; else goto <D.44200>;
          <D.44199>:
          iftmp.5034 = 12;
          goto <D.44201>;
          <D.44200>:
          iftmp.5034 = 8;
          <D.44201>:
          _amd64_rex_bits = iftmp.5034;
          if (_amd64_rex_bits != 0) goto <D.44202>; else goto <D.44203>;
          <D.44202>:
          code.5035 = code;
          code = code.5035 + 1;
          D.44205 = _amd64_rex_bits | 64;
          *code.5035 = D.44205;
          <D.44203>:
        }
        code.5036 = code;
        code = code.5036 + 1;
        *code.5036 = 15;
        code.5037 = code;
        code = code.5037 + 1;
        *code.5037 = 42;
        code.5038 = code;
        code = code.5038 + 1;
        D.31589 = ins->dreg;
        D.31598 = D.31589 & 7;
        D.32641 = D.31598 << 3;
        D.32642 = (signed char) D.32641;
        D.33725 = D.32642 | -64;
        D.39676 = (unsigned char) D.33725;
        *code.5038 = D.39676;
        code.5039 = code;
        code = code.5039 + 1;
        *code.5039 = 242;
        {
          unsigned char _amd64_rex_bits;

          D.31589 = ins->dreg;
          if (D.31589 > 7) goto <D.44211>; else goto <D.44212>;
          <D.44211>:
          iftmp.5040 = 4;
          goto <D.44213>;
          <D.44212>:
          iftmp.5040 = 0;
          <D.44213>:
          D.31589 = ins->dreg;
          D.31590 = D.31589 > 7;
          D.32040 = (signed char) D.31590;
          D.44214 = iftmp.5040 | D.32040;
          _amd64_rex_bits = (unsigned char) D.44214;
          if (_amd64_rex_bits != 0) goto <D.44215>; else goto <D.44216>;
          <D.44215>:
          code.5041 = code;
          code = code.5041 + 1;
          D.44218 = _amd64_rex_bits | 64;
          *code.5041 = D.44218;
          <D.44216>:
        }
        code.5042 = code;
        code = code.5042 + 1;
        *code.5042 = 15;
        code.5043 = code;
        code = code.5043 + 1;
        *code.5043 = 88;
        code.5044 = code;
        code = code.5044 + 1;
        D.31589 = ins->dreg;
        D.31598 = D.31589 & 7;
        D.32641 = D.31598 << 3;
        D.32642 = (signed char) D.32641;
        D.33725 = D.32642 | -64;
        D.31589 = ins->dreg;
        D.31631 = (signed char) D.31589;
        D.31632 = D.31631 & 7;
        D.37520 = D.33725 | D.31632;
        D.37521 = (unsigned char) D.37520;
        *code.5044 = D.37521;
        if (0 != 0) goto <D.44222>; else goto <D.44223>;
        <D.44222>:
        code.5045 = code;
        code = code.5045 + 1;
        *code.5045 = 102;
        <D.44223>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44225>; else goto <D.44226>;
          <D.44225>:
          code.5046 = code;
          code = code.5046 + 1;
          D.44228 = _amd64_rex_bits | 64;
          *code.5046 = D.44228;
          <D.44226>:
        }
        switch (8) <default: <D.26960>, case 1: <D.26955>, case 2: <D.26957>, case 4: <D.26958>, case 8: <D.26959>>
        <D.26955>:
        code.5047 = code;
        code = code.5047 + 1;
        *code.5047 = 138;
        goto <D.26956>;
        <D.26957>:
        <D.26958>:
        <D.26959>:
        code.5048 = code;
        code = code.5048 + 1;
        *code.5048 = 139;
        goto <D.26956>;
        <D.26960>:
        __assert_fail ("0", "mini-amd64.c", 5332, &__PRETTY_FUNCTION__);
        <D.26956>:
        if (0 != 0) goto <D.44231>; else goto <D.44232>;
        <D.44231>:
        code.5049 = code;
        code = code.5049 + 1;
        *code.5049 = 13;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -16;
              code.5050 = code;
              code = code.5050 + 1;
              D.44235 = imb.b[0];
              *code.5050 = D.44235;
              code.5051 = code;
              code = code.5051 + 1;
              D.44237 = imb.b[1];
              *code.5051 = D.44237;
              code.5052 = code;
              code = code.5052 + 1;
              D.44239 = imb.b[2];
              *code.5052 = D.44239;
              code.5053 = code;
              code = code.5053 + 1;
              D.44241 = imb.b[3];
              *code.5053 = D.44241;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.44242>;
        <D.44232>:
        if (1 != 0) goto <D.44243>; else goto <D.44244>;
        <D.44243>:
        if (0 != 0) goto <D.44245>; else goto <D.44246>;
        <D.44245>:
        code.5054 = code;
        code = code.5054 + 1;
        *code.5054 = 12;
        code.5055 = code;
        code = code.5055 + 1;
        *code.5055 = 36;
        goto <D.44249>;
        <D.44246>:
        if (1 != 0) goto <D.44250>; else goto <D.44251>;
        <D.44250>:
        code.5056 = code;
        code = code.5056 + 1;
        *code.5056 = 76;
        code.5057 = code;
        code = code.5057 + 1;
        *code.5057 = 36;
        *code = 240;
        code = code + 1;
        goto <D.44254>;
        <D.44251>:
        code.5058 = code;
        code = code.5058 + 1;
        *code.5058 = 140;
        code.5059 = code;
        code = code.5059 + 1;
        *code.5059 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -16;
              code.5060 = code;
              code = code.5060 + 1;
              D.44258 = imb.b[0];
              *code.5060 = D.44258;
              code.5061 = code;
              code = code.5061 + 1;
              D.44260 = imb.b[1];
              *code.5061 = D.44260;
              code.5062 = code;
              code = code.5062 + 1;
              D.44262 = imb.b[2];
              *code.5062 = D.44262;
              code.5063 = code;
              code = code.5063 + 1;
              D.44264 = imb.b[3];
              *code.5063 = D.44264;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44254>:
        <D.44249>:
        goto <D.26963>;
        <D.44244>:
        if (0 != 0) goto <D.44265>; else goto <D.44266>;
        <D.44265>:
        code.5064 = code;
        code = code.5064 + 1;
        *code.5064 = 12;
        goto <D.26963>;
        <D.44266>:
        if (1 != 0) goto <D.44268>; else goto <D.44269>;
        <D.44268>:
        code.5065 = code;
        code = code.5065 + 1;
        *code.5065 = 76;
        *code = 240;
        code = code + 1;
        goto <D.44271>;
        <D.44269>:
        code.5066 = code;
        code = code.5066 + 1;
        *code.5066 = 140;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -16;
              code.5067 = code;
              code = code.5067 + 1;
              D.44274 = imb.b[0];
              *code.5067 = D.44274;
              code.5068 = code;
              code = code.5068 + 1;
              D.44276 = imb.b[1];
              *code.5068 = D.44276;
              code.5069 = code;
              code = code.5069 + 1;
              D.44278 = imb.b[2];
              *code.5069 = D.44278;
              code.5070 = code;
              code = code.5070 + 1;
              D.44280 = imb.b[3];
              *code.5070 = D.44280;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44271>:
        <D.26963>:
        <D.44242>:
        if (0 != 0) goto <D.44281>; else goto <D.44282>;
        <D.44281>:
        code.5071 = code;
        code = code.5071 + 1;
        *code.5071 = 102;
        <D.44282>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.44284>; else goto <D.44285>;
          <D.44284>:
          code.5072 = code;
          code = code.5072 + 1;
          D.44287 = _amd64_rex_bits | 64;
          *code.5072 = D.44287;
          <D.44285>:
        }
        switch (8) <default: <D.26971>, case 1: <D.26966>, case 2: <D.26968>, case 4: <D.26969>, case 8: <D.26970>>
        <D.26966>:
        code.5073 = code;
        code = code.5073 + 1;
        *code.5073 = 138;
        goto <D.26967>;
        <D.26968>:
        <D.26969>:
        <D.26970>:
        code.5074 = code;
        code = code.5074 + 1;
        *code.5074 = 139;
        goto <D.26967>;
        <D.26971>:
        __assert_fail ("0", "mini-amd64.c", 5333, &__PRETTY_FUNCTION__);
        <D.26967>:
        if (0 != 0) goto <D.44290>; else goto <D.44291>;
        <D.44290>:
        code.5075 = code;
        code = code.5075 + 1;
        *code.5075 = 5;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.5076 = code;
              code = code.5076 + 1;
              D.44294 = imb.b[0];
              *code.5076 = D.44294;
              code.5077 = code;
              code = code.5077 + 1;
              D.44296 = imb.b[1];
              *code.5077 = D.44296;
              code.5078 = code;
              code = code.5078 + 1;
              D.44298 = imb.b[2];
              *code.5078 = D.44298;
              code.5079 = code;
              code = code.5079 + 1;
              D.44300 = imb.b[3];
              *code.5079 = D.44300;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.44301>;
        <D.44291>:
        if (1 != 0) goto <D.44302>; else goto <D.44303>;
        <D.44302>:
        if (0 != 0) goto <D.44304>; else goto <D.44305>;
        <D.44304>:
        code.5080 = code;
        code = code.5080 + 1;
        *code.5080 = 4;
        code.5081 = code;
        code = code.5081 + 1;
        *code.5081 = 36;
        goto <D.44308>;
        <D.44305>:
        if (1 != 0) goto <D.44309>; else goto <D.44310>;
        <D.44309>:
        code.5082 = code;
        code = code.5082 + 1;
        *code.5082 = 68;
        code.5083 = code;
        code = code.5083 + 1;
        *code.5083 = 36;
        *code = 248;
        code = code + 1;
        goto <D.44313>;
        <D.44310>:
        code.5084 = code;
        code = code.5084 + 1;
        *code.5084 = 132;
        code.5085 = code;
        code = code.5085 + 1;
        *code.5085 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.5086 = code;
              code = code.5086 + 1;
              D.44317 = imb.b[0];
              *code.5086 = D.44317;
              code.5087 = code;
              code = code.5087 + 1;
              D.44319 = imb.b[1];
              *code.5087 = D.44319;
              code.5088 = code;
              code = code.5088 + 1;
              D.44321 = imb.b[2];
              *code.5088 = D.44321;
              code.5089 = code;
              code = code.5089 + 1;
              D.44323 = imb.b[3];
              *code.5089 = D.44323;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44313>:
        <D.44308>:
        goto <D.26974>;
        <D.44303>:
        if (0 != 0) goto <D.44324>; else goto <D.44325>;
        <D.44324>:
        code.5090 = code;
        code = code.5090 + 1;
        *code.5090 = 4;
        goto <D.26974>;
        <D.44325>:
        if (1 != 0) goto <D.44327>; else goto <D.44328>;
        <D.44327>:
        code.5091 = code;
        code = code.5091 + 1;
        *code.5091 = 68;
        *code = 248;
        code = code + 1;
        goto <D.44330>;
        <D.44328>:
        code.5092 = code;
        code = code.5092 + 1;
        *code.5092 = 132;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.5093 = code;
              code = code.5093 + 1;
              D.44333 = imb.b[0];
              *code.5093 = D.44333;
              code.5094 = code;
              code = code.5094 + 1;
              D.44335 = imb.b[1];
              *code.5094 = D.44335;
              code.5095 = code;
              code = code.5095 + 1;
              D.44337 = imb.b[2];
              *code.5095 = D.44337;
              code.5096 = code;
              code = code.5096 + 1;
              D.44339 = imb.b[3];
              *code.5096 = D.44339;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.44330>:
        <D.26974>:
        <D.44301>:
        D.44340 = br[1];
        amd64_patch (D.44340, code);
        goto <D.25197>;
      }
    finally
      {
        br = {CLOBBER};
      }
  }
  <D.26976>:
  if (1 != 0) goto <D.44341>; else goto <D.44342>;
  <D.44341>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.44344>; else goto <D.44345>;
    <D.44344>:
    iftmp.5097 = 9;
    goto <D.44346>;
    <D.44345>:
    iftmp.5097 = 8;
    <D.44346>:
    _amd64_rex_bits = iftmp.5097;
    if (_amd64_rex_bits != 0) goto <D.44347>; else goto <D.44348>;
    <D.44347>:
    code.5098 = code;
    code = code.5098 + 1;
    D.44350 = _amd64_rex_bits | 64;
    *code.5098 = D.44350;
    <D.44348>:
  }
  code.5099 = code;
  code = code.5099 + 1;
  *code.5099 = 131;
  code.5100 = code;
  code = code.5100 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.5100 = D.33839;
  *code = 0;
  code = code + 1;
  goto <D.44353>;
  <D.44342>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.44354>; else goto <D.44355>;
  <D.44354>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.44356>; else goto <D.44357>;
    <D.44356>:
    code.5101 = code;
    code = code.5101 + 1;
    D.44359 = _amd64_rex_bits | 64;
    *code.5101 = D.44359;
    <D.44357>:
  }
  code.5102 = code;
  code = code.5102 + 1;
  *code.5102 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5103 = code;
        code = code.5103 + 1;
        D.44362 = imb.b[0];
        *code.5103 = D.44362;
        code.5104 = code;
        code = code.5104 + 1;
        D.44364 = imb.b[1];
        *code.5104 = D.44364;
        code.5105 = code;
        code = code.5105 + 1;
        D.44366 = imb.b[2];
        *code.5105 = D.44366;
        code.5106 = code;
        code = code.5106 + 1;
        D.44368 = imb.b[3];
        *code.5106 = D.44368;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.44369>;
  <D.44355>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.44371>; else goto <D.44372>;
    <D.44371>:
    iftmp.5107 = 9;
    goto <D.44373>;
    <D.44372>:
    iftmp.5107 = 8;
    <D.44373>:
    _amd64_rex_bits = iftmp.5107;
    if (_amd64_rex_bits != 0) goto <D.44374>; else goto <D.44375>;
    <D.44374>:
    code.5108 = code;
    code = code.5108 + 1;
    D.44377 = _amd64_rex_bits | 64;
    *code.5108 = D.44377;
    <D.44375>:
  }
  code.5109 = code;
  code = code.5109 + 1;
  *code.5109 = 129;
  code.5110 = code;
  code = code.5110 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.5110 = D.33839;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5111 = code;
        code = code.5111 + 1;
        D.44381 = imb.b[0];
        *code.5111 = D.44381;
        code.5112 = code;
        code = code.5112 + 1;
        D.44383 = imb.b[1];
        *code.5112 = D.44383;
        code.5113 = code;
        code = code.5113 + 1;
        D.44385 = imb.b[2];
        *code.5113 = D.44385;
        code.5114 = code;
        code = code.5114 + 1;
        D.44387 = imb.b[3];
        *code.5114 = D.44387;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44369>:
  <D.44353>:
  {
    struct MonoInst * tins;

    tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
    if (tins == 0B) goto <D.44388>; else goto <D.44389>;
    <D.44388>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, "OverflowException");
    code.5115 = code;
    code = code.5115 + 1;
    *code.5115 = 15;
    if (1 != 0) goto <D.44391>; else goto <D.44392>;
    <D.44391>:
    code.5116 = code;
    code = code.5116 + 1;
    D.44394 = 124;
    D.44395 = D.44394 + 16;
    *code.5116 = D.44395;
    goto <D.44396>;
    <D.44392>:
    code.5117 = code;
    code = code.5117 + 1;
    D.44398 = 114;
    D.44399 = D.44398 + 16;
    *code.5117 = D.44399;
    <D.44396>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5118 = code;
          code = code.5118 + 1;
          D.44401 = imb.b[0];
          *code.5118 = D.44401;
          code.5119 = code;
          code = code.5119 + 1;
          D.44403 = imb.b[1];
          *code.5119 = D.44403;
          code.5120 = code;
          code = code.5120 + 1;
          D.44405 = imb.b[2];
          *code.5120 = D.44405;
          code.5121 = code;
          code = code.5121 + 1;
          D.44407 = imb.b[3];
          *code.5121 = D.44407;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.44408>;
    <D.44389>:
    D.44409 = tins->data.op[1].many_blocks;
    D.44410 = *D.44409;
    D.44411 = D.44410->native_offset;
    if (D.44411 != 0) goto <D.44412>; else goto <D.44413>;
    <D.44412>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.44409 = tins->data.op[1].many_blocks;
      D.44410 = *D.44409;
      D.44411 = D.44410->native_offset;
      D.44414 = (sizetype) D.44411;
      D.44415 = D.31283 + D.44414;
      D.44416 = (long int) D.44415;
      code.211 = (long int) code;
      D.44417 = D.44416 - code.211;
      D.44418 = (unsigned int) D.44417;
      D.44419 = D.44418 + 4294967294;
      offset = (int) D.44419;
      offset.5122 = (unsigned int) offset;
      D.44421 = offset.5122 + 128;
      if (D.44421 <= 255) goto <D.44422>; else goto <D.44423>;
      <D.44422>:
      if (1 != 0) goto <D.44424>; else goto <D.44425>;
      <D.44424>:
      code.5123 = code;
      code = code.5123 + 1;
      D.44394 = 124;
      *code.5123 = D.44394;
      goto <D.44427>;
      <D.44425>:
      code.5124 = code;
      code = code.5124 + 1;
      D.44398 = 114;
      *code.5124 = D.44398;
      <D.44427>:
      D.44429 = (unsigned char) offset;
      *code = D.44429;
      code = code + 1;
      goto <D.44430>;
      <D.44423>:
      D.31283 = cfg->native_code;
      D.44409 = tins->data.op[1].many_blocks;
      D.44410 = *D.44409;
      D.44411 = D.44410->native_offset;
      D.44414 = (sizetype) D.44411;
      D.44415 = D.31283 + D.44414;
      D.44416 = (long int) D.44415;
      code.211 = (long int) code;
      D.44417 = D.44416 - code.211;
      D.44418 = (unsigned int) D.44417;
      D.44431 = D.44418 + 4294967290;
      offset = (int) D.44431;
      code.5125 = code;
      code = code.5125 + 1;
      *code.5125 = 15;
      if (1 != 0) goto <D.44433>; else goto <D.44434>;
      <D.44433>:
      code.5126 = code;
      code = code.5126 + 1;
      D.44394 = 124;
      D.44395 = D.44394 + 16;
      *code.5126 = D.44395;
      goto <D.44436>;
      <D.44434>:
      code.5127 = code;
      code = code.5127 + 1;
      D.44398 = 114;
      D.44399 = D.44398 + 16;
      *code.5127 = D.44399;
      <D.44436>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.5128 = code;
            code = code.5128 + 1;
            D.44439 = imb.b[0];
            *code.5128 = D.44439;
            code.5129 = code;
            code = code.5129 + 1;
            D.44441 = imb.b[1];
            *code.5129 = D.44441;
            code.5130 = code;
            code = code.5130 + 1;
            D.44443 = imb.b[2];
            *code.5130 = D.44443;
            code.5131 = code;
            code = code.5131 + 1;
            D.44445 = imb.b[3];
            *code.5131 = D.44445;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.44430>:
    }
    goto <D.44446>;
    <D.44413>:
    D.44409 = tins->data.op[1].many_blocks;
    D.44410 = *D.44409;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.44410);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.44449>; else goto <D.44447>;
    <D.44449>:
    D.44409 = tins->data.op[1].many_blocks;
    D.44410 = *D.44409;
    D.44450 = D.44410->max_offset;
    D.44451 = (unsigned int) D.44450;
    D.44452 = D.44451 - offset;
    D.44453 = (int) D.44452;
    if (D.44453 >= -128) goto <D.44454>; else goto <D.44447>;
    <D.44454>:
    D.44409 = tins->data.op[1].many_blocks;
    D.44410 = *D.44409;
    D.44450 = D.44410->max_offset;
    D.44451 = (unsigned int) D.44450;
    D.44452 = D.44451 - offset;
    D.44453 = (int) D.44452;
    if (D.44453 <= 127) goto <D.44455>; else goto <D.44447>;
    <D.44455>:
    if (1 != 0) goto <D.44456>; else goto <D.44457>;
    <D.44456>:
    code.5132 = code;
    code = code.5132 + 1;
    D.44394 = 124;
    *code.5132 = D.44394;
    goto <D.44459>;
    <D.44457>:
    code.5133 = code;
    code = code.5133 + 1;
    D.44398 = 114;
    *code.5133 = D.44398;
    <D.44459>:
    *code = 0;
    code = code + 1;
    goto <D.44448>;
    <D.44447>:
    code.5134 = code;
    code = code.5134 + 1;
    *code.5134 = 15;
    if (1 != 0) goto <D.44462>; else goto <D.44463>;
    <D.44462>:
    code.5135 = code;
    code = code.5135 + 1;
    D.44394 = 124;
    D.44395 = D.44394 + 16;
    *code.5135 = D.44395;
    goto <D.44465>;
    <D.44463>:
    code.5136 = code;
    code = code.5136 + 1;
    D.44398 = 114;
    D.44399 = D.44398 + 16;
    *code.5136 = D.44399;
    <D.44465>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5137 = code;
          code = code.5137 + 1;
          D.44468 = imb.b[0];
          *code.5137 = D.44468;
          code.5138 = code;
          code = code.5138 + 1;
          D.44470 = imb.b[1];
          *code.5138 = D.44470;
          code.5139 = code;
          code = code.5139 + 1;
          D.44472 = imb.b[2];
          *code.5139 = D.44472;
          code.5140 = code;
          code = code.5140 + 1;
          D.44474 = imb.b[3];
          *code.5140 = D.44474;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44448>:
    <D.44446>:
    <D.44408>:
  }
  if (0 != 0) goto <D.44475>; else goto <D.44476>;
  <D.44475>:
  code.5141 = code;
  code = code.5141 + 1;
  *code.5141 = 102;
  <D.44476>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44479>; else goto <D.44480>;
    <D.44479>:
    iftmp.5142 = 12;
    goto <D.44481>;
    <D.44480>:
    iftmp.5142 = 8;
    <D.44481>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.44482 = iftmp.5142 | D.33180;
    _amd64_rex_bits = (unsigned char) D.44482;
    if (_amd64_rex_bits != 0) goto <D.44483>; else goto <D.44484>;
    <D.44483>:
    code.5143 = code;
    code = code.5143 + 1;
    D.44486 = _amd64_rex_bits | 64;
    *code.5143 = D.44486;
    <D.44484>:
  }
  switch (8) <default: <D.26993>, case 1: <D.26988>, case 2: <D.26990>, case 4: <D.26991>, case 8: <D.26992>>
  <D.26988>:
  code.5144 = code;
  code = code.5144 + 1;
  *code.5144 = 138;
  goto <D.26989>;
  <D.26990>:
  <D.26991>:
  <D.26992>:
  code.5145 = code;
  code = code.5145 + 1;
  *code.5145 = 139;
  goto <D.26989>;
  <D.26993>:
  __assert_fail ("0", "mini-amd64.c", 5340, &__PRETTY_FUNCTION__);
  <D.26989>:
  code.5146 = code;
  code = code.5146 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.5146 = D.33727;
  goto <D.25197>;
  <D.26994>:
  if (0 != 0) goto <D.44490>; else goto <D.44491>;
  <D.44490>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.44493>; else goto <D.44494>;
    <D.44493>:
    iftmp.5147 = 9;
    goto <D.44495>;
    <D.44494>:
    iftmp.5147 = 8;
    <D.44495>:
    _amd64_rex_bits = iftmp.5147;
    if (_amd64_rex_bits != 0) goto <D.44496>; else goto <D.44497>;
    <D.44496>:
    code.5148 = code;
    code = code.5148 + 1;
    D.44499 = _amd64_rex_bits | 64;
    *code.5148 = D.44499;
    <D.44497>:
  }
  code.5149 = code;
  code = code.5149 + 1;
  *code.5149 = 131;
  code.5150 = code;
  code = code.5150 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.5150 = D.33839;
  *code = 255;
  code = code + 1;
  goto <D.44502>;
  <D.44491>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.44503>; else goto <D.44504>;
  <D.44503>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.44505>; else goto <D.44506>;
    <D.44505>:
    code.5151 = code;
    code = code.5151 + 1;
    D.44508 = _amd64_rex_bits | 64;
    *code.5151 = D.44508;
    <D.44506>:
  }
  code.5152 = code;
  code = code.5152 + 1;
  *code.5152 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2147483647;
        code.5153 = code;
        code = code.5153 + 1;
        D.44511 = imb.b[0];
        *code.5153 = D.44511;
        code.5154 = code;
        code = code.5154 + 1;
        D.44513 = imb.b[1];
        *code.5154 = D.44513;
        code.5155 = code;
        code = code.5155 + 1;
        D.44515 = imb.b[2];
        *code.5155 = D.44515;
        code.5156 = code;
        code = code.5156 + 1;
        D.44517 = imb.b[3];
        *code.5156 = D.44517;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.44518>;
  <D.44504>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.44520>; else goto <D.44521>;
    <D.44520>:
    iftmp.5157 = 9;
    goto <D.44522>;
    <D.44521>:
    iftmp.5157 = 8;
    <D.44522>:
    _amd64_rex_bits = iftmp.5157;
    if (_amd64_rex_bits != 0) goto <D.44523>; else goto <D.44524>;
    <D.44523>:
    code.5158 = code;
    code = code.5158 + 1;
    D.44526 = _amd64_rex_bits | 64;
    *code.5158 = D.44526;
    <D.44524>:
  }
  code.5159 = code;
  code = code.5159 + 1;
  *code.5159 = 129;
  code.5160 = code;
  code = code.5160 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.5160 = D.33839;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 2147483647;
        code.5161 = code;
        code = code.5161 + 1;
        D.44530 = imb.b[0];
        *code.5161 = D.44530;
        code.5162 = code;
        code = code.5162 + 1;
        D.44532 = imb.b[1];
        *code.5162 = D.44532;
        code.5163 = code;
        code = code.5163 + 1;
        D.44534 = imb.b[2];
        *code.5163 = D.44534;
        code.5164 = code;
        code = code.5164 + 1;
        D.44536 = imb.b[3];
        *code.5164 = D.44536;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44518>:
  <D.44502>:
  {
    struct MonoInst * tins;

    tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException");
    if (tins == 0B) goto <D.44537>; else goto <D.44538>;
    <D.44537>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, "OverflowException");
    code.5165 = code;
    code = code.5165 + 1;
    *code.5165 = 15;
    if (0 != 0) goto <D.44540>; else goto <D.44541>;
    <D.44540>:
    code.5166 = code;
    code = code.5166 + 1;
    D.44543 = 127;
    D.44544 = D.44543 + 16;
    *code.5166 = D.44544;
    goto <D.44545>;
    <D.44541>:
    code.5167 = code;
    code = code.5167 + 1;
    D.44547 = 119;
    D.44548 = D.44547 + 16;
    *code.5167 = D.44548;
    <D.44545>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5168 = code;
          code = code.5168 + 1;
          D.44550 = imb.b[0];
          *code.5168 = D.44550;
          code.5169 = code;
          code = code.5169 + 1;
          D.44552 = imb.b[1];
          *code.5169 = D.44552;
          code.5170 = code;
          code = code.5170 + 1;
          D.44554 = imb.b[2];
          *code.5170 = D.44554;
          code.5171 = code;
          code = code.5171 + 1;
          D.44556 = imb.b[3];
          *code.5171 = D.44556;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.44557>;
    <D.44538>:
    D.44558 = tins->data.op[1].many_blocks;
    D.44559 = *D.44558;
    D.44560 = D.44559->native_offset;
    if (D.44560 != 0) goto <D.44561>; else goto <D.44562>;
    <D.44561>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.44558 = tins->data.op[1].many_blocks;
      D.44559 = *D.44558;
      D.44560 = D.44559->native_offset;
      D.44563 = (sizetype) D.44560;
      D.44564 = D.31283 + D.44563;
      D.44565 = (long int) D.44564;
      code.211 = (long int) code;
      D.44566 = D.44565 - code.211;
      D.44567 = (unsigned int) D.44566;
      D.44568 = D.44567 + 4294967294;
      offset = (int) D.44568;
      offset.5172 = (unsigned int) offset;
      D.44570 = offset.5172 + 128;
      if (D.44570 <= 255) goto <D.44571>; else goto <D.44572>;
      <D.44571>:
      if (0 != 0) goto <D.44573>; else goto <D.44574>;
      <D.44573>:
      code.5173 = code;
      code = code.5173 + 1;
      D.44543 = 127;
      *code.5173 = D.44543;
      goto <D.44576>;
      <D.44574>:
      code.5174 = code;
      code = code.5174 + 1;
      D.44547 = 119;
      *code.5174 = D.44547;
      <D.44576>:
      D.44578 = (unsigned char) offset;
      *code = D.44578;
      code = code + 1;
      goto <D.44579>;
      <D.44572>:
      D.31283 = cfg->native_code;
      D.44558 = tins->data.op[1].many_blocks;
      D.44559 = *D.44558;
      D.44560 = D.44559->native_offset;
      D.44563 = (sizetype) D.44560;
      D.44564 = D.31283 + D.44563;
      D.44565 = (long int) D.44564;
      code.211 = (long int) code;
      D.44566 = D.44565 - code.211;
      D.44567 = (unsigned int) D.44566;
      D.44580 = D.44567 + 4294967290;
      offset = (int) D.44580;
      code.5175 = code;
      code = code.5175 + 1;
      *code.5175 = 15;
      if (0 != 0) goto <D.44582>; else goto <D.44583>;
      <D.44582>:
      code.5176 = code;
      code = code.5176 + 1;
      D.44543 = 127;
      D.44544 = D.44543 + 16;
      *code.5176 = D.44544;
      goto <D.44585>;
      <D.44583>:
      code.5177 = code;
      code = code.5177 + 1;
      D.44547 = 119;
      D.44548 = D.44547 + 16;
      *code.5177 = D.44548;
      <D.44585>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.5178 = code;
            code = code.5178 + 1;
            D.44588 = imb.b[0];
            *code.5178 = D.44588;
            code.5179 = code;
            code = code.5179 + 1;
            D.44590 = imb.b[1];
            *code.5179 = D.44590;
            code.5180 = code;
            code = code.5180 + 1;
            D.44592 = imb.b[2];
            *code.5180 = D.44592;
            code.5181 = code;
            code = code.5181 + 1;
            D.44594 = imb.b[3];
            *code.5181 = D.44594;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.44579>:
    }
    goto <D.44595>;
    <D.44562>:
    D.44558 = tins->data.op[1].many_blocks;
    D.44559 = *D.44558;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.44559);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.44598>; else goto <D.44596>;
    <D.44598>:
    D.44558 = tins->data.op[1].many_blocks;
    D.44559 = *D.44558;
    D.44599 = D.44559->max_offset;
    D.44600 = (unsigned int) D.44599;
    D.44601 = D.44600 - offset;
    D.44602 = (int) D.44601;
    if (D.44602 >= -128) goto <D.44603>; else goto <D.44596>;
    <D.44603>:
    D.44558 = tins->data.op[1].many_blocks;
    D.44559 = *D.44558;
    D.44599 = D.44559->max_offset;
    D.44600 = (unsigned int) D.44599;
    D.44601 = D.44600 - offset;
    D.44602 = (int) D.44601;
    if (D.44602 <= 127) goto <D.44604>; else goto <D.44596>;
    <D.44604>:
    if (0 != 0) goto <D.44605>; else goto <D.44606>;
    <D.44605>:
    code.5182 = code;
    code = code.5182 + 1;
    D.44543 = 127;
    *code.5182 = D.44543;
    goto <D.44608>;
    <D.44606>:
    code.5183 = code;
    code = code.5183 + 1;
    D.44547 = 119;
    *code.5183 = D.44547;
    <D.44608>:
    *code = 0;
    code = code + 1;
    goto <D.44597>;
    <D.44596>:
    code.5184 = code;
    code = code.5184 + 1;
    *code.5184 = 15;
    if (0 != 0) goto <D.44611>; else goto <D.44612>;
    <D.44611>:
    code.5185 = code;
    code = code.5185 + 1;
    D.44543 = 127;
    D.44544 = D.44543 + 16;
    *code.5185 = D.44544;
    goto <D.44614>;
    <D.44612>:
    code.5186 = code;
    code = code.5186 + 1;
    D.44547 = 119;
    D.44548 = D.44547 + 16;
    *code.5186 = D.44548;
    <D.44614>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5187 = code;
          code = code.5187 + 1;
          D.44617 = imb.b[0];
          *code.5187 = D.44617;
          code.5188 = code;
          code = code.5188 + 1;
          D.44619 = imb.b[1];
          *code.5188 = D.44619;
          code.5189 = code;
          code = code.5189 + 1;
          D.44621 = imb.b[2];
          *code.5189 = D.44621;
          code.5190 = code;
          code = code.5190 + 1;
          D.44623 = imb.b[3];
          *code.5190 = D.44623;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44597>:
    <D.44595>:
    <D.44557>:
  }
  if (0 != 0) goto <D.44624>; else goto <D.44625>;
  <D.44624>:
  code.5191 = code;
  code = code.5191 + 1;
  *code.5191 = 102;
  <D.44625>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44628>; else goto <D.44629>;
    <D.44628>:
    iftmp.5192 = 12;
    goto <D.44630>;
    <D.44629>:
    iftmp.5192 = 8;
    <D.44630>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.44631 = iftmp.5192 | D.33180;
    _amd64_rex_bits = (unsigned char) D.44631;
    if (_amd64_rex_bits != 0) goto <D.44632>; else goto <D.44633>;
    <D.44632>:
    code.5193 = code;
    code = code.5193 + 1;
    D.44635 = _amd64_rex_bits | 64;
    *code.5193 = D.44635;
    <D.44633>:
  }
  switch (8) <default: <D.27011>, case 1: <D.27006>, case 2: <D.27008>, case 4: <D.27009>, case 8: <D.27010>>
  <D.27006>:
  code.5194 = code;
  code = code.5194 + 1;
  *code.5194 = 138;
  goto <D.27007>;
  <D.27008>:
  <D.27009>:
  <D.27010>:
  code.5195 = code;
  code = code.5195 + 1;
  *code.5195 = 139;
  goto <D.27007>;
  <D.27011>:
  __assert_fail ("0", "mini-amd64.c", 5345, &__PRETTY_FUNCTION__);
  <D.27007>:
  code.5196 = code;
  code = code.5196 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.5196 = D.33727;
  goto <D.25197>;
  <D.27012>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  if (D.31589 != D.31516) goto <D.44639>; else goto <D.44640>;
  <D.44639>:
  code.5197 = code;
  code = code.5197 + 1;
  *code.5197 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44643>; else goto <D.44644>;
    <D.44643>:
    iftmp.5198 = 4;
    goto <D.44645>;
    <D.44644>:
    iftmp.5198 = 0;
    <D.44645>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.44646 = iftmp.5198 | D.33180;
    _amd64_rex_bits = (unsigned char) D.44646;
    if (_amd64_rex_bits != 0) goto <D.44647>; else goto <D.44648>;
    <D.44647>:
    code.5199 = code;
    code = code.5199 + 1;
    D.44650 = _amd64_rex_bits | 64;
    *code.5199 = D.44650;
    <D.44648>:
  }
  code.5200 = code;
  code = code.5200 + 1;
  *code.5200 = 15;
  code.5201 = code;
  code = code.5201 + 1;
  *code.5201 = 16;
  code.5202 = code;
  code = code.5202 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.5202 = D.33727;
  <D.44640>:
  goto <D.25197>;
  <D.27014>:
  code.5203 = code;
  code = code.5203 + 1;
  *code.5203 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44656>; else goto <D.44657>;
    <D.44656>:
    iftmp.5204 = 4;
    goto <D.44658>;
    <D.44657>:
    iftmp.5204 = 0;
    <D.44658>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.44659 = iftmp.5204 | D.33811;
    _amd64_rex_bits = (unsigned char) D.44659;
    if (_amd64_rex_bits != 0) goto <D.44660>; else goto <D.44661>;
    <D.44660>:
    code.5205 = code;
    code = code.5205 + 1;
    D.44663 = _amd64_rex_bits | 64;
    *code.5205 = D.44663;
    <D.44661>:
  }
  code.5206 = code;
  code = code.5206 + 1;
  *code.5206 = 15;
  code.5207 = code;
  code = code.5207 + 1;
  *code.5207 = 88;
  code.5208 = code;
  code = code.5208 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5208 = D.39958;
  goto <D.25197>;
  <D.27016>:
  code.5209 = code;
  code = code.5209 + 1;
  *code.5209 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44669>; else goto <D.44670>;
    <D.44669>:
    iftmp.5210 = 4;
    goto <D.44671>;
    <D.44670>:
    iftmp.5210 = 0;
    <D.44671>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.44672 = iftmp.5210 | D.33811;
    _amd64_rex_bits = (unsigned char) D.44672;
    if (_amd64_rex_bits != 0) goto <D.44673>; else goto <D.44674>;
    <D.44673>:
    code.5211 = code;
    code = code.5211 + 1;
    D.44676 = _amd64_rex_bits | 64;
    *code.5211 = D.44676;
    <D.44674>:
  }
  code.5212 = code;
  code = code.5212 + 1;
  *code.5212 = 15;
  code.5213 = code;
  code = code.5213 + 1;
  *code.5213 = 92;
  code.5214 = code;
  code = code.5214 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5214 = D.39958;
  goto <D.25197>;
  <D.27018>:
  code.5215 = code;
  code = code.5215 + 1;
  *code.5215 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44682>; else goto <D.44683>;
    <D.44682>:
    iftmp.5216 = 4;
    goto <D.44684>;
    <D.44683>:
    iftmp.5216 = 0;
    <D.44684>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.44685 = iftmp.5216 | D.33811;
    _amd64_rex_bits = (unsigned char) D.44685;
    if (_amd64_rex_bits != 0) goto <D.44686>; else goto <D.44687>;
    <D.44686>:
    code.5217 = code;
    code = code.5217 + 1;
    D.44689 = _amd64_rex_bits | 64;
    *code.5217 = D.44689;
    <D.44687>:
  }
  code.5218 = code;
  code = code.5218 + 1;
  *code.5218 = 15;
  code.5219 = code;
  code = code.5219 + 1;
  *code.5219 = 89;
  code.5220 = code;
  code = code.5220 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5220 = D.39958;
  goto <D.25197>;
  <D.27020>:
  code.5221 = code;
  code = code.5221 + 1;
  *code.5221 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44695>; else goto <D.44696>;
    <D.44695>:
    iftmp.5222 = 4;
    goto <D.44697>;
    <D.44696>:
    iftmp.5222 = 0;
    <D.44697>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.44698 = iftmp.5222 | D.33811;
    _amd64_rex_bits = (unsigned char) D.44698;
    if (_amd64_rex_bits != 0) goto <D.44699>; else goto <D.44700>;
    <D.44699>:
    code.5223 = code;
    code = code.5223 + 1;
    D.44702 = _amd64_rex_bits | 64;
    *code.5223 = D.44702;
    <D.44700>:
  }
  code.5224 = code;
  code = code.5224 + 1;
  *code.5224 = 15;
  code.5225 = code;
  code = code.5225 + 1;
  *code.5225 = 94;
  code.5226 = code;
  code = code.5226 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5226 = D.39958;
  goto <D.25197>;
  <D.27022>:
  {
    static double r8_0 = -0.0;

    D.31516 = ins->sreg1;
    D.31589 = ins->dreg;
    D.39926 = D.31516 != D.31589;
    D.39927 = (long int) D.39926;
    D.39928 = __builtin_expect (D.39927, 0);
    if (D.39928 != 0) goto <D.44706>; else goto <D.44707>;
    <D.44706>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5366, "ins->sreg1 == ins->dreg");
    <D.44707>:
    offset.3505 = (int) offset;
    mono_add_patch_info (cfg, offset.3505, 21, &r8_0);
    code.5227 = code;
    code = code.5227 + 1;
    *code.5227 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.44710>; else goto <D.44711>;
      <D.44710>:
      iftmp.5228 = 4;
      goto <D.44712>;
      <D.44711>:
      iftmp.5228 = 0;
      <D.44712>:
      _amd64_rex_bits = iftmp.5228;
      if (_amd64_rex_bits != 0) goto <D.44713>; else goto <D.44714>;
      <D.44713>:
      code.5229 = code;
      code = code.5229 + 1;
      D.44716 = _amd64_rex_bits | 64;
      *code.5229 = D.44716;
      <D.44714>:
    }
    code.5230 = code;
    code = code.5230 + 1;
    *code.5230 = 15;
    code.5231 = code;
    code = code.5231 + 1;
    *code.5231 = 87;
    if (1 != 0) goto <D.44719>; else goto <D.44720>;
    <D.44719>:
    code.5232 = code;
    code = code.5232 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32713 = D.32642 | 5;
    D.32714 = (unsigned char) D.32713;
    *code.5232 = D.32714;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5233 = code;
          code = code.5233 + 1;
          D.44723 = imb.b[0];
          *code.5233 = D.44723;
          code.5234 = code;
          code = code.5234 + 1;
          D.44725 = imb.b[1];
          *code.5234 = D.44725;
          code.5235 = code;
          code = code.5235 + 1;
          D.44727 = imb.b[2];
          *code.5235 = D.44727;
          code.5236 = code;
          code = code.5236 + 1;
          D.44729 = imb.b[3];
          *code.5236 = D.44729;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.44730>;
    <D.44720>:
    if (0 != 0) goto <D.44731>; else goto <D.44732>;
    <D.44731>:
    if (1 != 0) goto <D.44733>; else goto <D.44734>;
    <D.44733>:
    code.5237 = code;
    code = code.5237 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.5237 = D.32644;
    code.5238 = code;
    code = code.5238 + 1;
    *code.5238 = 36;
    goto <D.44737>;
    <D.44734>:
    if (1 != 0) goto <D.44738>; else goto <D.44739>;
    <D.44738>:
    code.5239 = code;
    code = code.5239 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.5239 = D.32735;
    code.5240 = code;
    code = code.5240 + 1;
    *code.5240 = 36;
    *code = 0;
    code = code + 1;
    goto <D.44742>;
    <D.44739>:
    code.5241 = code;
    code = code.5241 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.5241 = D.32740;
    code.5242 = code;
    code = code.5242 + 1;
    *code.5242 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5243 = code;
          code = code.5243 + 1;
          D.44746 = imb.b[0];
          *code.5243 = D.44746;
          code.5244 = code;
          code = code.5244 + 1;
          D.44748 = imb.b[1];
          *code.5244 = D.44748;
          code.5245 = code;
          code = code.5245 + 1;
          D.44750 = imb.b[2];
          *code.5245 = D.44750;
          code.5246 = code;
          code = code.5246 + 1;
          D.44752 = imb.b[3];
          *code.5246 = D.44752;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44742>:
    <D.44737>:
    goto <D.27027>;
    <D.44732>:
    if (1 != 0) goto <D.44753>; else goto <D.44754>;
    <D.44753>:
    code.5247 = code;
    code = code.5247 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.40107 = D.31627 << 3;
    *code.5247 = D.40107;
    goto <D.27027>;
    <D.44754>:
    if (1 != 0) goto <D.44756>; else goto <D.44757>;
    <D.44756>:
    code.5248 = code;
    code = code.5248 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.40111 = (unsigned char) D.32758;
    *code.5248 = D.40111;
    *code = 0;
    code = code + 1;
    goto <D.44759>;
    <D.44757>:
    code.5249 = code;
    code = code.5249 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.40114 = (unsigned char) D.32763;
    *code.5249 = D.40114;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5250 = code;
          code = code.5250 + 1;
          D.44762 = imb.b[0];
          *code.5250 = D.44762;
          code.5251 = code;
          code = code.5251 + 1;
          D.44764 = imb.b[1];
          *code.5251 = D.44764;
          code.5252 = code;
          code = code.5252 + 1;
          D.44766 = imb.b[2];
          *code.5252 = D.44766;
          code.5253 = code;
          code = code.5253 + 1;
          D.44768 = imb.b[3];
          *code.5253 = D.44768;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.44759>:
    <D.27027>:
    <D.44730>:
    goto <D.25197>;
  }
  <D.27029>:
  code.5254 = code;
  code = code.5254 + 1;
  *code.5254 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.44771>; else goto <D.44772>;
    <D.44771>:
    iftmp.5255 = 4;
    goto <D.44773>;
    <D.44772>:
    iftmp.5255 = 0;
    <D.44773>:
    _amd64_rex_bits = iftmp.5255;
    if (_amd64_rex_bits != 0) goto <D.44774>; else goto <D.44775>;
    <D.44774>:
    code.5256 = code;
    code = code.5256 + 1;
    D.44777 = _amd64_rex_bits | 64;
    *code.5256 = D.44777;
    <D.44775>:
  }
  code.5257 = code;
  code = code.5257 + 1;
  *code.5257 = 15;
  code.5258 = code;
  code = code.5258 + 1;
  *code.5258 = 17;
  if (1 != 0) goto <D.44780>; else goto <D.44781>;
  <D.44780>:
  if (0 != 0) goto <D.44782>; else goto <D.44783>;
  <D.44782>:
  code.5259 = code;
  code = code.5259 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.5259 = D.32056;
  code.5260 = code;
  code = code.5260 + 1;
  *code.5260 = 36;
  goto <D.44786>;
  <D.44783>:
  if (1 != 0) goto <D.44787>; else goto <D.44788>;
  <D.44787>:
  code.5261 = code;
  code = code.5261 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.5261 = D.32063;
  code.5262 = code;
  code = code.5262 + 1;
  *code.5262 = 36;
  *code = 248;
  code = code + 1;
  goto <D.44791>;
  <D.44788>:
  code.5263 = code;
  code = code.5263 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.5263 = D.32068;
  code.5264 = code;
  code = code.5264 + 1;
  *code.5264 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5265 = code;
        code = code.5265 + 1;
        D.44795 = imb.b[0];
        *code.5265 = D.44795;
        code.5266 = code;
        code = code.5266 + 1;
        D.44797 = imb.b[1];
        *code.5266 = D.44797;
        code.5267 = code;
        code = code.5267 + 1;
        D.44799 = imb.b[2];
        *code.5267 = D.44799;
        code.5268 = code;
        code = code.5268 + 1;
        D.44801 = imb.b[3];
        *code.5268 = D.44801;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44791>:
  <D.44786>:
  goto <D.27032>;
  <D.44781>:
  if (0 != 0) goto <D.44802>; else goto <D.44803>;
  <D.44802>:
  code.5269 = code;
  code = code.5269 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.5269 = D.32056;
  goto <D.27032>;
  <D.44803>:
  if (1 != 0) goto <D.44805>; else goto <D.44806>;
  <D.44805>:
  code.5270 = code;
  code = code.5270 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.5270 = D.32063;
  *code = 248;
  code = code + 1;
  goto <D.44808>;
  <D.44806>:
  code.5271 = code;
  code = code.5271 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.5271 = D.32068;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5272 = code;
        code = code.5272 + 1;
        D.44811 = imb.b[0];
        *code.5272 = D.44811;
        code.5273 = code;
        code = code.5273 + 1;
        D.44813 = imb.b[1];
        *code.5273 = D.44813;
        code.5274 = code;
        code = code.5274 + 1;
        D.44815 = imb.b[2];
        *code.5274 = D.44815;
        code.5275 = code;
        code = code.5275 + 1;
        D.44817 = imb.b[3];
        *code.5275 = D.44817;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44808>:
  <D.27032>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.44818>; else goto <D.44819>;
    <D.44818>:
    code.5276 = code;
    code = code.5276 + 1;
    D.44821 = _amd64_rex_bits | 64;
    *code.5276 = D.44821;
    <D.44819>:
  }
  code.5277 = code;
  code = code.5277 + 1;
  *code.5277 = 221;
  if (0 != 0) goto <D.44823>; else goto <D.44824>;
  <D.44823>:
  code.5278 = code;
  code = code.5278 + 1;
  *code.5278 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5279 = code;
        code = code.5279 + 1;
        D.44827 = imb.b[0];
        *code.5279 = D.44827;
        code.5280 = code;
        code = code.5280 + 1;
        D.44829 = imb.b[1];
        *code.5280 = D.44829;
        code.5281 = code;
        code = code.5281 + 1;
        D.44831 = imb.b[2];
        *code.5281 = D.44831;
        code.5282 = code;
        code = code.5282 + 1;
        D.44833 = imb.b[3];
        *code.5282 = D.44833;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.44834>;
  <D.44824>:
  if (1 != 0) goto <D.44835>; else goto <D.44836>;
  <D.44835>:
  if (0 != 0) goto <D.44837>; else goto <D.44838>;
  <D.44837>:
  code.5283 = code;
  code = code.5283 + 1;
  *code.5283 = 4;
  code.5284 = code;
  code = code.5284 + 1;
  *code.5284 = 36;
  goto <D.44841>;
  <D.44838>:
  if (1 != 0) goto <D.44842>; else goto <D.44843>;
  <D.44842>:
  code.5285 = code;
  code = code.5285 + 1;
  *code.5285 = 68;
  code.5286 = code;
  code = code.5286 + 1;
  *code.5286 = 36;
  *code = 248;
  code = code + 1;
  goto <D.44846>;
  <D.44843>:
  code.5287 = code;
  code = code.5287 + 1;
  *code.5287 = 132;
  code.5288 = code;
  code = code.5288 + 1;
  *code.5288 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5289 = code;
        code = code.5289 + 1;
        D.44850 = imb.b[0];
        *code.5289 = D.44850;
        code.5290 = code;
        code = code.5290 + 1;
        D.44852 = imb.b[1];
        *code.5290 = D.44852;
        code.5291 = code;
        code = code.5291 + 1;
        D.44854 = imb.b[2];
        *code.5291 = D.44854;
        code.5292 = code;
        code = code.5292 + 1;
        D.44856 = imb.b[3];
        *code.5292 = D.44856;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44846>:
  <D.44841>:
  goto <D.27037>;
  <D.44836>:
  if (0 != 0) goto <D.44857>; else goto <D.44858>;
  <D.44857>:
  code.5293 = code;
  code = code.5293 + 1;
  *code.5293 = 4;
  goto <D.27037>;
  <D.44858>:
  if (1 != 0) goto <D.44860>; else goto <D.44861>;
  <D.44860>:
  code.5294 = code;
  code = code.5294 + 1;
  *code.5294 = 68;
  *code = 248;
  code = code + 1;
  goto <D.44863>;
  <D.44861>:
  code.5295 = code;
  code = code.5295 + 1;
  *code.5295 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5296 = code;
        code = code.5296 + 1;
        D.44866 = imb.b[0];
        *code.5296 = D.44866;
        code.5297 = code;
        code = code.5297 + 1;
        D.44868 = imb.b[1];
        *code.5297 = D.44868;
        code.5298 = code;
        code = code.5298 + 1;
        D.44870 = imb.b[2];
        *code.5298 = D.44870;
        code.5299 = code;
        code = code.5299 + 1;
        D.44872 = imb.b[3];
        *code.5299 = D.44872;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44863>:
  <D.27037>:
  <D.44834>:
  code.5300 = code;
  code = code.5300 + 1;
  *code.5300 = 217;
  code.5301 = code;
  code = code.5301 + 1;
  *code.5301 = 254;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.44875>; else goto <D.44876>;
    <D.44875>:
    code.5302 = code;
    code = code.5302 + 1;
    D.44878 = _amd64_rex_bits | 64;
    *code.5302 = D.44878;
    <D.44876>:
  }
  code.5303 = code;
  code = code.5303 + 1;
  *code.5303 = 221;
  if (1 != 0) goto <D.44880>; else goto <D.44881>;
  <D.44880>:
  if (0 != 0) goto <D.44882>; else goto <D.44883>;
  <D.44882>:
  code.5304 = code;
  code = code.5304 + 1;
  *code.5304 = 28;
  code.5305 = code;
  code = code.5305 + 1;
  *code.5305 = 36;
  goto <D.44886>;
  <D.44883>:
  if (1 != 0) goto <D.44887>; else goto <D.44888>;
  <D.44887>:
  code.5306 = code;
  code = code.5306 + 1;
  *code.5306 = 92;
  code.5307 = code;
  code = code.5307 + 1;
  *code.5307 = 36;
  *code = 248;
  code = code + 1;
  goto <D.44891>;
  <D.44888>:
  code.5308 = code;
  code = code.5308 + 1;
  *code.5308 = 156;
  code.5309 = code;
  code = code.5309 + 1;
  *code.5309 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5310 = code;
        code = code.5310 + 1;
        D.44895 = imb.b[0];
        *code.5310 = D.44895;
        code.5311 = code;
        code = code.5311 + 1;
        D.44897 = imb.b[1];
        *code.5311 = D.44897;
        code.5312 = code;
        code = code.5312 + 1;
        D.44899 = imb.b[2];
        *code.5312 = D.44899;
        code.5313 = code;
        code = code.5313 + 1;
        D.44901 = imb.b[3];
        *code.5313 = D.44901;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44891>:
  <D.44886>:
  goto <D.27041>;
  <D.44881>:
  if (0 != 0) goto <D.44902>; else goto <D.44903>;
  <D.44902>:
  code.5314 = code;
  code = code.5314 + 1;
  *code.5314 = 28;
  goto <D.27041>;
  <D.44903>:
  if (1 != 0) goto <D.44905>; else goto <D.44906>;
  <D.44905>:
  code.5315 = code;
  code = code.5315 + 1;
  *code.5315 = 92;
  *code = 248;
  code = code + 1;
  goto <D.44908>;
  <D.44906>:
  code.5316 = code;
  code = code.5316 + 1;
  *code.5316 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5317 = code;
        code = code.5317 + 1;
        D.44911 = imb.b[0];
        *code.5317 = D.44911;
        code.5318 = code;
        code = code.5318 + 1;
        D.44913 = imb.b[1];
        *code.5318 = D.44913;
        code.5319 = code;
        code = code.5319 + 1;
        D.44915 = imb.b[2];
        *code.5319 = D.44915;
        code.5320 = code;
        code = code.5320 + 1;
        D.44917 = imb.b[3];
        *code.5320 = D.44917;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44908>:
  <D.27041>:
  code.5321 = code;
  code = code.5321 + 1;
  *code.5321 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.44920>; else goto <D.44921>;
    <D.44920>:
    iftmp.5322 = 4;
    goto <D.44922>;
    <D.44921>:
    iftmp.5322 = 0;
    <D.44922>:
    _amd64_rex_bits = iftmp.5322;
    if (_amd64_rex_bits != 0) goto <D.44923>; else goto <D.44924>;
    <D.44923>:
    code.5323 = code;
    code = code.5323 + 1;
    D.44926 = _amd64_rex_bits | 64;
    *code.5323 = D.44926;
    <D.44924>:
  }
  code.5324 = code;
  code = code.5324 + 1;
  *code.5324 = 15;
  code.5325 = code;
  code = code.5325 + 1;
  *code.5325 = 16;
  if (1 != 0) goto <D.44929>; else goto <D.44930>;
  <D.44929>:
  if (0 != 0) goto <D.44931>; else goto <D.44932>;
  <D.44931>:
  code.5326 = code;
  code = code.5326 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.5326 = D.32644;
  code.5327 = code;
  code = code.5327 + 1;
  *code.5327 = 36;
  goto <D.44935>;
  <D.44932>:
  if (1 != 0) goto <D.44936>; else goto <D.44937>;
  <D.44936>:
  code.5328 = code;
  code = code.5328 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.5328 = D.32735;
  code.5329 = code;
  code = code.5329 + 1;
  *code.5329 = 36;
  *code = 248;
  code = code + 1;
  goto <D.44940>;
  <D.44937>:
  code.5330 = code;
  code = code.5330 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.5330 = D.32740;
  code.5331 = code;
  code = code.5331 + 1;
  *code.5331 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5332 = code;
        code = code.5332 + 1;
        D.44944 = imb.b[0];
        *code.5332 = D.44944;
        code.5333 = code;
        code = code.5333 + 1;
        D.44946 = imb.b[1];
        *code.5333 = D.44946;
        code.5334 = code;
        code = code.5334 + 1;
        D.44948 = imb.b[2];
        *code.5334 = D.44948;
        code.5335 = code;
        code = code.5335 + 1;
        D.44950 = imb.b[3];
        *code.5335 = D.44950;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44940>:
  <D.44935>:
  goto <D.27045>;
  <D.44930>:
  if (0 != 0) goto <D.44951>; else goto <D.44952>;
  <D.44951>:
  code.5336 = code;
  code = code.5336 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.5336 = D.32644;
  goto <D.27045>;
  <D.44952>:
  if (1 != 0) goto <D.44954>; else goto <D.44955>;
  <D.44954>:
  code.5337 = code;
  code = code.5337 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.5337 = D.32735;
  *code = 248;
  code = code + 1;
  goto <D.44957>;
  <D.44955>:
  code.5338 = code;
  code = code.5338 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.5338 = D.32740;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5339 = code;
        code = code.5339 + 1;
        D.44960 = imb.b[0];
        *code.5339 = D.44960;
        code.5340 = code;
        code = code.5340 + 1;
        D.44962 = imb.b[1];
        *code.5340 = D.44962;
        code.5341 = code;
        code = code.5341 + 1;
        D.44964 = imb.b[2];
        *code.5341 = D.44964;
        code.5342 = code;
        code = code.5342 + 1;
        D.44966 = imb.b[3];
        *code.5342 = D.44966;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44957>:
  <D.27045>:
  goto <D.25197>;
  <D.27047>:
  code.5343 = code;
  code = code.5343 + 1;
  *code.5343 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.44969>; else goto <D.44970>;
    <D.44969>:
    iftmp.5344 = 4;
    goto <D.44971>;
    <D.44970>:
    iftmp.5344 = 0;
    <D.44971>:
    _amd64_rex_bits = iftmp.5344;
    if (_amd64_rex_bits != 0) goto <D.44972>; else goto <D.44973>;
    <D.44972>:
    code.5345 = code;
    code = code.5345 + 1;
    D.44975 = _amd64_rex_bits | 64;
    *code.5345 = D.44975;
    <D.44973>:
  }
  code.5346 = code;
  code = code.5346 + 1;
  *code.5346 = 15;
  code.5347 = code;
  code = code.5347 + 1;
  *code.5347 = 17;
  if (1 != 0) goto <D.44978>; else goto <D.44979>;
  <D.44978>:
  if (0 != 0) goto <D.44980>; else goto <D.44981>;
  <D.44980>:
  code.5348 = code;
  code = code.5348 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.5348 = D.32056;
  code.5349 = code;
  code = code.5349 + 1;
  *code.5349 = 36;
  goto <D.44984>;
  <D.44981>:
  if (1 != 0) goto <D.44985>; else goto <D.44986>;
  <D.44985>:
  code.5350 = code;
  code = code.5350 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.5350 = D.32063;
  code.5351 = code;
  code = code.5351 + 1;
  *code.5351 = 36;
  *code = 248;
  code = code + 1;
  goto <D.44989>;
  <D.44986>:
  code.5352 = code;
  code = code.5352 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.5352 = D.32068;
  code.5353 = code;
  code = code.5353 + 1;
  *code.5353 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5354 = code;
        code = code.5354 + 1;
        D.44993 = imb.b[0];
        *code.5354 = D.44993;
        code.5355 = code;
        code = code.5355 + 1;
        D.44995 = imb.b[1];
        *code.5355 = D.44995;
        code.5356 = code;
        code = code.5356 + 1;
        D.44997 = imb.b[2];
        *code.5356 = D.44997;
        code.5357 = code;
        code = code.5357 + 1;
        D.44999 = imb.b[3];
        *code.5357 = D.44999;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.44989>:
  <D.44984>:
  goto <D.27050>;
  <D.44979>:
  if (0 != 0) goto <D.45000>; else goto <D.45001>;
  <D.45000>:
  code.5358 = code;
  code = code.5358 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.5358 = D.32056;
  goto <D.27050>;
  <D.45001>:
  if (1 != 0) goto <D.45003>; else goto <D.45004>;
  <D.45003>:
  code.5359 = code;
  code = code.5359 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.5359 = D.32063;
  *code = 248;
  code = code + 1;
  goto <D.45006>;
  <D.45004>:
  code.5360 = code;
  code = code.5360 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.5360 = D.32068;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5361 = code;
        code = code.5361 + 1;
        D.45009 = imb.b[0];
        *code.5361 = D.45009;
        code.5362 = code;
        code = code.5362 + 1;
        D.45011 = imb.b[1];
        *code.5362 = D.45011;
        code.5363 = code;
        code = code.5363 + 1;
        D.45013 = imb.b[2];
        *code.5363 = D.45013;
        code.5364 = code;
        code = code.5364 + 1;
        D.45015 = imb.b[3];
        *code.5364 = D.45015;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45006>:
  <D.27050>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.45016>; else goto <D.45017>;
    <D.45016>:
    code.5365 = code;
    code = code.5365 + 1;
    D.45019 = _amd64_rex_bits | 64;
    *code.5365 = D.45019;
    <D.45017>:
  }
  code.5366 = code;
  code = code.5366 + 1;
  *code.5366 = 221;
  if (0 != 0) goto <D.45021>; else goto <D.45022>;
  <D.45021>:
  code.5367 = code;
  code = code.5367 + 1;
  *code.5367 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5368 = code;
        code = code.5368 + 1;
        D.45025 = imb.b[0];
        *code.5368 = D.45025;
        code.5369 = code;
        code = code.5369 + 1;
        D.45027 = imb.b[1];
        *code.5369 = D.45027;
        code.5370 = code;
        code = code.5370 + 1;
        D.45029 = imb.b[2];
        *code.5370 = D.45029;
        code.5371 = code;
        code = code.5371 + 1;
        D.45031 = imb.b[3];
        *code.5371 = D.45031;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.45032>;
  <D.45022>:
  if (1 != 0) goto <D.45033>; else goto <D.45034>;
  <D.45033>:
  if (0 != 0) goto <D.45035>; else goto <D.45036>;
  <D.45035>:
  code.5372 = code;
  code = code.5372 + 1;
  *code.5372 = 4;
  code.5373 = code;
  code = code.5373 + 1;
  *code.5373 = 36;
  goto <D.45039>;
  <D.45036>:
  if (1 != 0) goto <D.45040>; else goto <D.45041>;
  <D.45040>:
  code.5374 = code;
  code = code.5374 + 1;
  *code.5374 = 68;
  code.5375 = code;
  code = code.5375 + 1;
  *code.5375 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45044>;
  <D.45041>:
  code.5376 = code;
  code = code.5376 + 1;
  *code.5376 = 132;
  code.5377 = code;
  code = code.5377 + 1;
  *code.5377 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5378 = code;
        code = code.5378 + 1;
        D.45048 = imb.b[0];
        *code.5378 = D.45048;
        code.5379 = code;
        code = code.5379 + 1;
        D.45050 = imb.b[1];
        *code.5379 = D.45050;
        code.5380 = code;
        code = code.5380 + 1;
        D.45052 = imb.b[2];
        *code.5380 = D.45052;
        code.5381 = code;
        code = code.5381 + 1;
        D.45054 = imb.b[3];
        *code.5381 = D.45054;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45044>:
  <D.45039>:
  goto <D.27055>;
  <D.45034>:
  if (0 != 0) goto <D.45055>; else goto <D.45056>;
  <D.45055>:
  code.5382 = code;
  code = code.5382 + 1;
  *code.5382 = 4;
  goto <D.27055>;
  <D.45056>:
  if (1 != 0) goto <D.45058>; else goto <D.45059>;
  <D.45058>:
  code.5383 = code;
  code = code.5383 + 1;
  *code.5383 = 68;
  *code = 248;
  code = code + 1;
  goto <D.45061>;
  <D.45059>:
  code.5384 = code;
  code = code.5384 + 1;
  *code.5384 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5385 = code;
        code = code.5385 + 1;
        D.45064 = imb.b[0];
        *code.5385 = D.45064;
        code.5386 = code;
        code = code.5386 + 1;
        D.45066 = imb.b[1];
        *code.5386 = D.45066;
        code.5387 = code;
        code = code.5387 + 1;
        D.45068 = imb.b[2];
        *code.5387 = D.45068;
        code.5388 = code;
        code = code.5388 + 1;
        D.45070 = imb.b[3];
        *code.5388 = D.45070;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45061>:
  <D.27055>:
  <D.45032>:
  code.5389 = code;
  code = code.5389 + 1;
  *code.5389 = 217;
  code.5390 = code;
  code = code.5390 + 1;
  *code.5390 = 255;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.45073>; else goto <D.45074>;
    <D.45073>:
    code.5391 = code;
    code = code.5391 + 1;
    D.45076 = _amd64_rex_bits | 64;
    *code.5391 = D.45076;
    <D.45074>:
  }
  code.5392 = code;
  code = code.5392 + 1;
  *code.5392 = 221;
  if (1 != 0) goto <D.45078>; else goto <D.45079>;
  <D.45078>:
  if (0 != 0) goto <D.45080>; else goto <D.45081>;
  <D.45080>:
  code.5393 = code;
  code = code.5393 + 1;
  *code.5393 = 28;
  code.5394 = code;
  code = code.5394 + 1;
  *code.5394 = 36;
  goto <D.45084>;
  <D.45081>:
  if (1 != 0) goto <D.45085>; else goto <D.45086>;
  <D.45085>:
  code.5395 = code;
  code = code.5395 + 1;
  *code.5395 = 92;
  code.5396 = code;
  code = code.5396 + 1;
  *code.5396 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45089>;
  <D.45086>:
  code.5397 = code;
  code = code.5397 + 1;
  *code.5397 = 156;
  code.5398 = code;
  code = code.5398 + 1;
  *code.5398 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5399 = code;
        code = code.5399 + 1;
        D.45093 = imb.b[0];
        *code.5399 = D.45093;
        code.5400 = code;
        code = code.5400 + 1;
        D.45095 = imb.b[1];
        *code.5400 = D.45095;
        code.5401 = code;
        code = code.5401 + 1;
        D.45097 = imb.b[2];
        *code.5401 = D.45097;
        code.5402 = code;
        code = code.5402 + 1;
        D.45099 = imb.b[3];
        *code.5402 = D.45099;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45089>:
  <D.45084>:
  goto <D.27059>;
  <D.45079>:
  if (0 != 0) goto <D.45100>; else goto <D.45101>;
  <D.45100>:
  code.5403 = code;
  code = code.5403 + 1;
  *code.5403 = 28;
  goto <D.27059>;
  <D.45101>:
  if (1 != 0) goto <D.45103>; else goto <D.45104>;
  <D.45103>:
  code.5404 = code;
  code = code.5404 + 1;
  *code.5404 = 92;
  *code = 248;
  code = code + 1;
  goto <D.45106>;
  <D.45104>:
  code.5405 = code;
  code = code.5405 + 1;
  *code.5405 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5406 = code;
        code = code.5406 + 1;
        D.45109 = imb.b[0];
        *code.5406 = D.45109;
        code.5407 = code;
        code = code.5407 + 1;
        D.45111 = imb.b[1];
        *code.5407 = D.45111;
        code.5408 = code;
        code = code.5408 + 1;
        D.45113 = imb.b[2];
        *code.5408 = D.45113;
        code.5409 = code;
        code = code.5409 + 1;
        D.45115 = imb.b[3];
        *code.5409 = D.45115;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45106>:
  <D.27059>:
  code.5410 = code;
  code = code.5410 + 1;
  *code.5410 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45118>; else goto <D.45119>;
    <D.45118>:
    iftmp.5411 = 4;
    goto <D.45120>;
    <D.45119>:
    iftmp.5411 = 0;
    <D.45120>:
    _amd64_rex_bits = iftmp.5411;
    if (_amd64_rex_bits != 0) goto <D.45121>; else goto <D.45122>;
    <D.45121>:
    code.5412 = code;
    code = code.5412 + 1;
    D.45124 = _amd64_rex_bits | 64;
    *code.5412 = D.45124;
    <D.45122>:
  }
  code.5413 = code;
  code = code.5413 + 1;
  *code.5413 = 15;
  code.5414 = code;
  code = code.5414 + 1;
  *code.5414 = 16;
  if (1 != 0) goto <D.45127>; else goto <D.45128>;
  <D.45127>:
  if (0 != 0) goto <D.45129>; else goto <D.45130>;
  <D.45129>:
  code.5415 = code;
  code = code.5415 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.5415 = D.32644;
  code.5416 = code;
  code = code.5416 + 1;
  *code.5416 = 36;
  goto <D.45133>;
  <D.45130>:
  if (1 != 0) goto <D.45134>; else goto <D.45135>;
  <D.45134>:
  code.5417 = code;
  code = code.5417 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.5417 = D.32735;
  code.5418 = code;
  code = code.5418 + 1;
  *code.5418 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45138>;
  <D.45135>:
  code.5419 = code;
  code = code.5419 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.5419 = D.32740;
  code.5420 = code;
  code = code.5420 + 1;
  *code.5420 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5421 = code;
        code = code.5421 + 1;
        D.45142 = imb.b[0];
        *code.5421 = D.45142;
        code.5422 = code;
        code = code.5422 + 1;
        D.45144 = imb.b[1];
        *code.5422 = D.45144;
        code.5423 = code;
        code = code.5423 + 1;
        D.45146 = imb.b[2];
        *code.5423 = D.45146;
        code.5424 = code;
        code = code.5424 + 1;
        D.45148 = imb.b[3];
        *code.5424 = D.45148;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45138>:
  <D.45133>:
  goto <D.27063>;
  <D.45128>:
  if (0 != 0) goto <D.45149>; else goto <D.45150>;
  <D.45149>:
  code.5425 = code;
  code = code.5425 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.5425 = D.32644;
  goto <D.27063>;
  <D.45150>:
  if (1 != 0) goto <D.45152>; else goto <D.45153>;
  <D.45152>:
  code.5426 = code;
  code = code.5426 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.5426 = D.32735;
  *code = 248;
  code = code + 1;
  goto <D.45155>;
  <D.45153>:
  code.5427 = code;
  code = code.5427 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.5427 = D.32740;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5428 = code;
        code = code.5428 + 1;
        D.45158 = imb.b[0];
        *code.5428 = D.45158;
        code.5429 = code;
        code = code.5429 + 1;
        D.45160 = imb.b[1];
        *code.5429 = D.45160;
        code.5430 = code;
        code = code.5430 + 1;
        D.45162 = imb.b[2];
        *code.5430 = D.45162;
        code.5431 = code;
        code = code.5431 + 1;
        D.45164 = imb.b[3];
        *code.5431 = D.45164;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45155>:
  <D.27063>:
  goto <D.25197>;
  <D.27065>:
  {
    static guint64 d = 9223372036854775807;

    D.31516 = ins->sreg1;
    D.31589 = ins->dreg;
    D.39926 = D.31516 != D.31589;
    D.39927 = (long int) D.39926;
    D.39928 = __builtin_expect (D.39927, 0);
    if (D.39928 != 0) goto <D.45165>; else goto <D.45166>;
    <D.45165>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5381, "ins->sreg1 == ins->dreg");
    <D.45166>:
    offset.3505 = (int) offset;
    mono_add_patch_info (cfg, offset.3505, 21, &d);
    code.5432 = code;
    code = code.5432 + 1;
    *code.5432 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45169>; else goto <D.45170>;
      <D.45169>:
      iftmp.5433 = 4;
      goto <D.45171>;
      <D.45170>:
      iftmp.5433 = 0;
      <D.45171>:
      _amd64_rex_bits = iftmp.5433;
      if (_amd64_rex_bits != 0) goto <D.45172>; else goto <D.45173>;
      <D.45172>:
      code.5434 = code;
      code = code.5434 + 1;
      D.45175 = _amd64_rex_bits | 64;
      *code.5434 = D.45175;
      <D.45173>:
    }
    code.5435 = code;
    code = code.5435 + 1;
    *code.5435 = 15;
    code.5436 = code;
    code = code.5436 + 1;
    *code.5436 = 84;
    if (1 != 0) goto <D.45178>; else goto <D.45179>;
    <D.45178>:
    code.5437 = code;
    code = code.5437 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32713 = D.32642 | 5;
    D.32714 = (unsigned char) D.32713;
    *code.5437 = D.32714;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5438 = code;
          code = code.5438 + 1;
          D.45182 = imb.b[0];
          *code.5438 = D.45182;
          code.5439 = code;
          code = code.5439 + 1;
          D.45184 = imb.b[1];
          *code.5439 = D.45184;
          code.5440 = code;
          code = code.5440 + 1;
          D.45186 = imb.b[2];
          *code.5440 = D.45186;
          code.5441 = code;
          code = code.5441 + 1;
          D.45188 = imb.b[3];
          *code.5441 = D.45188;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.45189>;
    <D.45179>:
    if (0 != 0) goto <D.45190>; else goto <D.45191>;
    <D.45190>:
    if (1 != 0) goto <D.45192>; else goto <D.45193>;
    <D.45192>:
    code.5442 = code;
    code = code.5442 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32643 = D.32642 | 4;
    D.32644 = (unsigned char) D.32643;
    *code.5442 = D.32644;
    code.5443 = code;
    code = code.5443 + 1;
    *code.5443 = 36;
    goto <D.45196>;
    <D.45193>:
    if (1 != 0) goto <D.45197>; else goto <D.45198>;
    <D.45197>:
    code.5444 = code;
    code = code.5444 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32734 = D.32642 | 68;
    D.32735 = (unsigned char) D.32734;
    *code.5444 = D.32735;
    code.5445 = code;
    code = code.5445 + 1;
    *code.5445 = 36;
    *code = 0;
    code = code + 1;
    goto <D.45201>;
    <D.45198>:
    code.5446 = code;
    code = code.5446 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32739 = D.32642 | -124;
    D.32740 = (unsigned char) D.32739;
    *code.5446 = D.32740;
    code.5447 = code;
    code = code.5447 + 1;
    *code.5447 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5448 = code;
          code = code.5448 + 1;
          D.45205 = imb.b[0];
          *code.5448 = D.45205;
          code.5449 = code;
          code = code.5449 + 1;
          D.45207 = imb.b[1];
          *code.5449 = D.45207;
          code.5450 = code;
          code = code.5450 + 1;
          D.45209 = imb.b[2];
          *code.5450 = D.45209;
          code.5451 = code;
          code = code.5451 + 1;
          D.45211 = imb.b[3];
          *code.5451 = D.45211;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.45201>:
    <D.45196>:
    goto <D.27070>;
    <D.45191>:
    if (1 != 0) goto <D.45212>; else goto <D.45213>;
    <D.45212>:
    code.5452 = code;
    code = code.5452 + 1;
    D.31589 = ins->dreg;
    D.31626 = (unsigned char) D.31589;
    D.31627 = D.31626 & 7;
    D.40107 = D.31627 << 3;
    *code.5452 = D.40107;
    goto <D.27070>;
    <D.45213>:
    if (1 != 0) goto <D.45215>; else goto <D.45216>;
    <D.45215>:
    code.5453 = code;
    code = code.5453 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32758 = D.32642 | 64;
    D.40111 = (unsigned char) D.32758;
    *code.5453 = D.40111;
    *code = 0;
    code = code + 1;
    goto <D.45218>;
    <D.45216>:
    code.5454 = code;
    code = code.5454 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.32763 = D.32642 | -128;
    D.40114 = (unsigned char) D.32763;
    *code.5454 = D.40114;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5455 = code;
          code = code.5455 + 1;
          D.45221 = imb.b[0];
          *code.5455 = D.45221;
          code.5456 = code;
          code = code.5456 + 1;
          D.45223 = imb.b[1];
          *code.5456 = D.45223;
          code.5457 = code;
          code = code.5457 + 1;
          D.45225 = imb.b[2];
          *code.5457 = D.45225;
          code.5458 = code;
          code = code.5458 + 1;
          D.45227 = imb.b[3];
          *code.5458 = D.45227;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.45218>:
    <D.27070>:
    <D.45189>:
    goto <D.25197>;
  }
  <D.27072>:
  code.5459 = code;
  code = code.5459 + 1;
  *code.5459 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45230>; else goto <D.45231>;
    <D.45230>:
    iftmp.5460 = 4;
    goto <D.45232>;
    <D.45231>:
    iftmp.5460 = 0;
    <D.45232>:
    _amd64_rex_bits = iftmp.5460;
    if (_amd64_rex_bits != 0) goto <D.45233>; else goto <D.45234>;
    <D.45233>:
    code.5461 = code;
    code = code.5461 + 1;
    D.45236 = _amd64_rex_bits | 64;
    *code.5461 = D.45236;
    <D.45234>:
  }
  code.5462 = code;
  code = code.5462 + 1;
  *code.5462 = 15;
  code.5463 = code;
  code = code.5463 + 1;
  *code.5463 = 17;
  if (1 != 0) goto <D.45239>; else goto <D.45240>;
  <D.45239>:
  if (0 != 0) goto <D.45241>; else goto <D.45242>;
  <D.45241>:
  code.5464 = code;
  code = code.5464 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.5464 = D.32056;
  code.5465 = code;
  code = code.5465 + 1;
  *code.5465 = 36;
  goto <D.45245>;
  <D.45242>:
  if (1 != 0) goto <D.45246>; else goto <D.45247>;
  <D.45246>:
  code.5466 = code;
  code = code.5466 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.5466 = D.32063;
  code.5467 = code;
  code = code.5467 + 1;
  *code.5467 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45250>;
  <D.45247>:
  code.5468 = code;
  code = code.5468 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.5468 = D.32068;
  code.5469 = code;
  code = code.5469 + 1;
  *code.5469 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5470 = code;
        code = code.5470 + 1;
        D.45254 = imb.b[0];
        *code.5470 = D.45254;
        code.5471 = code;
        code = code.5471 + 1;
        D.45256 = imb.b[1];
        *code.5471 = D.45256;
        code.5472 = code;
        code = code.5472 + 1;
        D.45258 = imb.b[2];
        *code.5472 = D.45258;
        code.5473 = code;
        code = code.5473 + 1;
        D.45260 = imb.b[3];
        *code.5473 = D.45260;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45250>:
  <D.45245>:
  goto <D.27075>;
  <D.45240>:
  if (0 != 0) goto <D.45261>; else goto <D.45262>;
  <D.45261>:
  code.5474 = code;
  code = code.5474 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.5474 = D.32056;
  goto <D.27075>;
  <D.45262>:
  if (1 != 0) goto <D.45264>; else goto <D.45265>;
  <D.45264>:
  code.5475 = code;
  code = code.5475 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.5475 = D.32063;
  *code = 248;
  code = code + 1;
  goto <D.45267>;
  <D.45265>:
  code.5476 = code;
  code = code.5476 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.5476 = D.32068;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5477 = code;
        code = code.5477 + 1;
        D.45270 = imb.b[0];
        *code.5477 = D.45270;
        code.5478 = code;
        code = code.5478 + 1;
        D.45272 = imb.b[1];
        *code.5478 = D.45272;
        code.5479 = code;
        code = code.5479 + 1;
        D.45274 = imb.b[2];
        *code.5479 = D.45274;
        code.5480 = code;
        code = code.5480 + 1;
        D.45276 = imb.b[3];
        *code.5480 = D.45276;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45267>:
  <D.27075>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.45277>; else goto <D.45278>;
    <D.45277>:
    code.5481 = code;
    code = code.5481 + 1;
    D.45280 = _amd64_rex_bits | 64;
    *code.5481 = D.45280;
    <D.45278>:
  }
  code.5482 = code;
  code = code.5482 + 1;
  *code.5482 = 221;
  if (0 != 0) goto <D.45282>; else goto <D.45283>;
  <D.45282>:
  code.5483 = code;
  code = code.5483 + 1;
  *code.5483 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5484 = code;
        code = code.5484 + 1;
        D.45286 = imb.b[0];
        *code.5484 = D.45286;
        code.5485 = code;
        code = code.5485 + 1;
        D.45288 = imb.b[1];
        *code.5485 = D.45288;
        code.5486 = code;
        code = code.5486 + 1;
        D.45290 = imb.b[2];
        *code.5486 = D.45290;
        code.5487 = code;
        code = code.5487 + 1;
        D.45292 = imb.b[3];
        *code.5487 = D.45292;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.45293>;
  <D.45283>:
  if (1 != 0) goto <D.45294>; else goto <D.45295>;
  <D.45294>:
  if (0 != 0) goto <D.45296>; else goto <D.45297>;
  <D.45296>:
  code.5488 = code;
  code = code.5488 + 1;
  *code.5488 = 4;
  code.5489 = code;
  code = code.5489 + 1;
  *code.5489 = 36;
  goto <D.45300>;
  <D.45297>:
  if (1 != 0) goto <D.45301>; else goto <D.45302>;
  <D.45301>:
  code.5490 = code;
  code = code.5490 + 1;
  *code.5490 = 68;
  code.5491 = code;
  code = code.5491 + 1;
  *code.5491 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45305>;
  <D.45302>:
  code.5492 = code;
  code = code.5492 + 1;
  *code.5492 = 132;
  code.5493 = code;
  code = code.5493 + 1;
  *code.5493 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5494 = code;
        code = code.5494 + 1;
        D.45309 = imb.b[0];
        *code.5494 = D.45309;
        code.5495 = code;
        code = code.5495 + 1;
        D.45311 = imb.b[1];
        *code.5495 = D.45311;
        code.5496 = code;
        code = code.5496 + 1;
        D.45313 = imb.b[2];
        *code.5496 = D.45313;
        code.5497 = code;
        code = code.5497 + 1;
        D.45315 = imb.b[3];
        *code.5497 = D.45315;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45305>:
  <D.45300>:
  goto <D.27080>;
  <D.45295>:
  if (0 != 0) goto <D.45316>; else goto <D.45317>;
  <D.45316>:
  code.5498 = code;
  code = code.5498 + 1;
  *code.5498 = 4;
  goto <D.27080>;
  <D.45317>:
  if (1 != 0) goto <D.45319>; else goto <D.45320>;
  <D.45319>:
  code.5499 = code;
  code = code.5499 + 1;
  *code.5499 = 68;
  *code = 248;
  code = code + 1;
  goto <D.45322>;
  <D.45320>:
  code.5500 = code;
  code = code.5500 + 1;
  *code.5500 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5501 = code;
        code = code.5501 + 1;
        D.45325 = imb.b[0];
        *code.5501 = D.45325;
        code.5502 = code;
        code = code.5502 + 1;
        D.45327 = imb.b[1];
        *code.5502 = D.45327;
        code.5503 = code;
        code = code.5503 + 1;
        D.45329 = imb.b[2];
        *code.5503 = D.45329;
        code.5504 = code;
        code = code.5504 + 1;
        D.45331 = imb.b[3];
        *code.5504 = D.45331;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45322>:
  <D.27080>:
  <D.45293>:
  code.5505 = code;
  code = code.5505 + 1;
  *code.5505 = 217;
  code.5506 = code;
  code = code.5506 + 1;
  *code.5506 = 250;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.45334>; else goto <D.45335>;
    <D.45334>:
    code.5507 = code;
    code = code.5507 + 1;
    D.45337 = _amd64_rex_bits | 64;
    *code.5507 = D.45337;
    <D.45335>:
  }
  code.5508 = code;
  code = code.5508 + 1;
  *code.5508 = 221;
  if (1 != 0) goto <D.45339>; else goto <D.45340>;
  <D.45339>:
  if (0 != 0) goto <D.45341>; else goto <D.45342>;
  <D.45341>:
  code.5509 = code;
  code = code.5509 + 1;
  *code.5509 = 28;
  code.5510 = code;
  code = code.5510 + 1;
  *code.5510 = 36;
  goto <D.45345>;
  <D.45342>:
  if (1 != 0) goto <D.45346>; else goto <D.45347>;
  <D.45346>:
  code.5511 = code;
  code = code.5511 + 1;
  *code.5511 = 92;
  code.5512 = code;
  code = code.5512 + 1;
  *code.5512 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45350>;
  <D.45347>:
  code.5513 = code;
  code = code.5513 + 1;
  *code.5513 = 156;
  code.5514 = code;
  code = code.5514 + 1;
  *code.5514 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5515 = code;
        code = code.5515 + 1;
        D.45354 = imb.b[0];
        *code.5515 = D.45354;
        code.5516 = code;
        code = code.5516 + 1;
        D.45356 = imb.b[1];
        *code.5516 = D.45356;
        code.5517 = code;
        code = code.5517 + 1;
        D.45358 = imb.b[2];
        *code.5517 = D.45358;
        code.5518 = code;
        code = code.5518 + 1;
        D.45360 = imb.b[3];
        *code.5518 = D.45360;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45350>:
  <D.45345>:
  goto <D.27084>;
  <D.45340>:
  if (0 != 0) goto <D.45361>; else goto <D.45362>;
  <D.45361>:
  code.5519 = code;
  code = code.5519 + 1;
  *code.5519 = 28;
  goto <D.27084>;
  <D.45362>:
  if (1 != 0) goto <D.45364>; else goto <D.45365>;
  <D.45364>:
  code.5520 = code;
  code = code.5520 + 1;
  *code.5520 = 92;
  *code = 248;
  code = code + 1;
  goto <D.45367>;
  <D.45365>:
  code.5521 = code;
  code = code.5521 + 1;
  *code.5521 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5522 = code;
        code = code.5522 + 1;
        D.45370 = imb.b[0];
        *code.5522 = D.45370;
        code.5523 = code;
        code = code.5523 + 1;
        D.45372 = imb.b[1];
        *code.5523 = D.45372;
        code.5524 = code;
        code = code.5524 + 1;
        D.45374 = imb.b[2];
        *code.5524 = D.45374;
        code.5525 = code;
        code = code.5525 + 1;
        D.45376 = imb.b[3];
        *code.5525 = D.45376;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45367>:
  <D.27084>:
  code.5526 = code;
  code = code.5526 + 1;
  *code.5526 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45379>; else goto <D.45380>;
    <D.45379>:
    iftmp.5527 = 4;
    goto <D.45381>;
    <D.45380>:
    iftmp.5527 = 0;
    <D.45381>:
    _amd64_rex_bits = iftmp.5527;
    if (_amd64_rex_bits != 0) goto <D.45382>; else goto <D.45383>;
    <D.45382>:
    code.5528 = code;
    code = code.5528 + 1;
    D.45385 = _amd64_rex_bits | 64;
    *code.5528 = D.45385;
    <D.45383>:
  }
  code.5529 = code;
  code = code.5529 + 1;
  *code.5529 = 15;
  code.5530 = code;
  code = code.5530 + 1;
  *code.5530 = 16;
  if (1 != 0) goto <D.45388>; else goto <D.45389>;
  <D.45388>:
  if (0 != 0) goto <D.45390>; else goto <D.45391>;
  <D.45390>:
  code.5531 = code;
  code = code.5531 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.5531 = D.32644;
  code.5532 = code;
  code = code.5532 + 1;
  *code.5532 = 36;
  goto <D.45394>;
  <D.45391>:
  if (1 != 0) goto <D.45395>; else goto <D.45396>;
  <D.45395>:
  code.5533 = code;
  code = code.5533 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.5533 = D.32735;
  code.5534 = code;
  code = code.5534 + 1;
  *code.5534 = 36;
  *code = 248;
  code = code + 1;
  goto <D.45399>;
  <D.45396>:
  code.5535 = code;
  code = code.5535 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.5535 = D.32740;
  code.5536 = code;
  code = code.5536 + 1;
  *code.5536 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5537 = code;
        code = code.5537 + 1;
        D.45403 = imb.b[0];
        *code.5537 = D.45403;
        code.5538 = code;
        code = code.5538 + 1;
        D.45405 = imb.b[1];
        *code.5538 = D.45405;
        code.5539 = code;
        code = code.5539 + 1;
        D.45407 = imb.b[2];
        *code.5539 = D.45407;
        code.5540 = code;
        code = code.5540 + 1;
        D.45409 = imb.b[3];
        *code.5540 = D.45409;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45399>:
  <D.45394>:
  goto <D.27088>;
  <D.45389>:
  if (0 != 0) goto <D.45410>; else goto <D.45411>;
  <D.45410>:
  code.5541 = code;
  code = code.5541 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.5541 = D.32644;
  goto <D.27088>;
  <D.45411>:
  if (1 != 0) goto <D.45413>; else goto <D.45414>;
  <D.45413>:
  code.5542 = code;
  code = code.5542 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.5542 = D.32735;
  *code = 248;
  code = code + 1;
  goto <D.45416>;
  <D.45414>:
  code.5543 = code;
  code = code.5543 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.5543 = D.32740;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.5544 = code;
        code = code.5544 + 1;
        D.45419 = imb.b[0];
        *code.5544 = D.45419;
        code.5545 = code;
        code = code.5545 + 1;
        D.45421 = imb.b[1];
        *code.5545 = D.45421;
        code.5546 = code;
        code = code.5546 + 1;
        D.45423 = imb.b[2];
        *code.5546 = D.45423;
        code.5547 = code;
        code = code.5547 + 1;
        D.45425 = imb.b[3];
        *code.5547 = D.45425;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.45416>:
  <D.27088>:
  goto <D.25197>;
  <D.27090>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45430>; else goto <D.45431>;
  <D.45430>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5391, "cfg->opt & MONO_OPT_CMOV");
  <D.45431>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45432>; else goto <D.45433>;
  <D.45432>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5392, "ins->dreg == ins->sreg1");
  <D.45433>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45435>; else goto <D.45436>;
    <D.45435>:
    iftmp.5548 = 4;
    goto <D.45437>;
    <D.45436>:
    iftmp.5548 = 0;
    <D.45437>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45438 = iftmp.5548 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45438;
    if (_amd64_rex_bits != 0) goto <D.45439>; else goto <D.45440>;
    <D.45439>:
    code.5549 = code;
    code = code.5549 + 1;
    D.45442 = _amd64_rex_bits | 64;
    *code.5549 = D.45442;
    <D.45440>:
  }
  code.5550 = code;
  code = code.5550 + 1;
  *code.5550 = 59;
  code.5551 = code;
  code = code.5551 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5551 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45446>; else goto <D.45447>;
    <D.45446>:
    iftmp.5552 = 4;
    goto <D.45448>;
    <D.45447>:
    iftmp.5552 = 0;
    <D.45448>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45449 = iftmp.5552 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45449;
    if (_amd64_rex_bits != 0) goto <D.45450>; else goto <D.45451>;
    <D.45450>:
    code.5553 = code;
    code = code.5553 + 1;
    D.45453 = _amd64_rex_bits | 64;
    *code.5553 = D.45453;
    <D.45451>:
  }
  code.5554 = code;
  code = code.5554 + 1;
  *code.5554 = 15;
  if (1 != 0) goto <D.45455>; else goto <D.45456>;
  <D.45455>:
  code.5555 = code;
  code = code.5555 + 1;
  D.44543 = 127;
  D.45458 = D.44543 + 208;
  *code.5555 = D.45458;
  goto <D.45459>;
  <D.45456>:
  code.5556 = code;
  code = code.5556 + 1;
  D.44547 = 119;
  D.45461 = D.44547 + 208;
  *code.5556 = D.45461;
  <D.45459>:
  code.5557 = code;
  code = code.5557 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5557 = D.39958;
  goto <D.25197>;
  <D.27093>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45463>; else goto <D.45464>;
  <D.45463>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5397, "cfg->opt & MONO_OPT_CMOV");
  <D.45464>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45465>; else goto <D.45466>;
  <D.45465>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5398, "ins->dreg == ins->sreg1");
  <D.45466>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45468>; else goto <D.45469>;
    <D.45468>:
    iftmp.5558 = 4;
    goto <D.45470>;
    <D.45469>:
    iftmp.5558 = 0;
    <D.45470>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45471 = iftmp.5558 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45471;
    if (_amd64_rex_bits != 0) goto <D.45472>; else goto <D.45473>;
    <D.45472>:
    code.5559 = code;
    code = code.5559 + 1;
    D.45475 = _amd64_rex_bits | 64;
    *code.5559 = D.45475;
    <D.45473>:
  }
  code.5560 = code;
  code = code.5560 + 1;
  *code.5560 = 59;
  code.5561 = code;
  code = code.5561 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5561 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45479>; else goto <D.45480>;
    <D.45479>:
    iftmp.5562 = 4;
    goto <D.45481>;
    <D.45480>:
    iftmp.5562 = 0;
    <D.45481>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45482 = iftmp.5562 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45482;
    if (_amd64_rex_bits != 0) goto <D.45483>; else goto <D.45484>;
    <D.45483>:
    code.5563 = code;
    code = code.5563 + 1;
    D.45486 = _amd64_rex_bits | 64;
    *code.5563 = D.45486;
    <D.45484>:
  }
  code.5564 = code;
  code = code.5564 + 1;
  *code.5564 = 15;
  if (0 != 0) goto <D.45488>; else goto <D.45489>;
  <D.45488>:
  code.5565 = code;
  code = code.5565 + 1;
  D.44543 = 127;
  D.45458 = D.44543 + 208;
  *code.5565 = D.45458;
  goto <D.45491>;
  <D.45489>:
  code.5566 = code;
  code = code.5566 + 1;
  D.44547 = 119;
  D.45461 = D.44547 + 208;
  *code.5566 = D.45461;
  <D.45491>:
  code.5567 = code;
  code = code.5567 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5567 = D.39958;
  goto <D.25197>;
  <D.27096>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45494>; else goto <D.45495>;
  <D.45494>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5403, "cfg->opt & MONO_OPT_CMOV");
  <D.45495>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45496>; else goto <D.45497>;
  <D.45496>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5404, "ins->dreg == ins->sreg1");
  <D.45497>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45499>; else goto <D.45500>;
    <D.45499>:
    iftmp.5568 = 4;
    goto <D.45501>;
    <D.45500>:
    iftmp.5568 = 0;
    <D.45501>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45502 = iftmp.5568 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45502;
    if (_amd64_rex_bits != 0) goto <D.45503>; else goto <D.45504>;
    <D.45503>:
    code.5569 = code;
    code = code.5569 + 1;
    D.45506 = _amd64_rex_bits | 64;
    *code.5569 = D.45506;
    <D.45504>:
  }
  code.5570 = code;
  code = code.5570 + 1;
  *code.5570 = 59;
  code.5571 = code;
  code = code.5571 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5571 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45510>; else goto <D.45511>;
    <D.45510>:
    iftmp.5572 = 4;
    goto <D.45512>;
    <D.45511>:
    iftmp.5572 = 0;
    <D.45512>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45513 = iftmp.5572 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45513;
    if (_amd64_rex_bits != 0) goto <D.45514>; else goto <D.45515>;
    <D.45514>:
    code.5573 = code;
    code = code.5573 + 1;
    D.45517 = _amd64_rex_bits | 64;
    *code.5573 = D.45517;
    <D.45515>:
  }
  code.5574 = code;
  code = code.5574 + 1;
  *code.5574 = 15;
  if (1 != 0) goto <D.45519>; else goto <D.45520>;
  <D.45519>:
  code.5575 = code;
  code = code.5575 + 1;
  D.44394 = 124;
  D.45522 = D.44394 + 208;
  *code.5575 = D.45522;
  goto <D.45523>;
  <D.45520>:
  code.5576 = code;
  code = code.5576 + 1;
  D.44398 = 114;
  D.45525 = D.44398 + 208;
  *code.5576 = D.45525;
  <D.45523>:
  code.5577 = code;
  code = code.5577 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5577 = D.39958;
  goto <D.25197>;
  <D.27099>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45527>; else goto <D.45528>;
  <D.45527>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5409, "cfg->opt & MONO_OPT_CMOV");
  <D.45528>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45529>; else goto <D.45530>;
  <D.45529>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5410, "ins->dreg == ins->sreg1");
  <D.45530>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45532>; else goto <D.45533>;
    <D.45532>:
    iftmp.5578 = 4;
    goto <D.45534>;
    <D.45533>:
    iftmp.5578 = 0;
    <D.45534>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45535 = iftmp.5578 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45535;
    if (_amd64_rex_bits != 0) goto <D.45536>; else goto <D.45537>;
    <D.45536>:
    code.5579 = code;
    code = code.5579 + 1;
    D.45539 = _amd64_rex_bits | 64;
    *code.5579 = D.45539;
    <D.45537>:
  }
  code.5580 = code;
  code = code.5580 + 1;
  *code.5580 = 59;
  code.5581 = code;
  code = code.5581 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5581 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45543>; else goto <D.45544>;
    <D.45543>:
    iftmp.5582 = 4;
    goto <D.45545>;
    <D.45544>:
    iftmp.5582 = 0;
    <D.45545>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45546 = iftmp.5582 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45546;
    if (_amd64_rex_bits != 0) goto <D.45547>; else goto <D.45548>;
    <D.45547>:
    code.5583 = code;
    code = code.5583 + 1;
    D.45550 = _amd64_rex_bits | 64;
    *code.5583 = D.45550;
    <D.45548>:
  }
  code.5584 = code;
  code = code.5584 + 1;
  *code.5584 = 15;
  if (0 != 0) goto <D.45552>; else goto <D.45553>;
  <D.45552>:
  code.5585 = code;
  code = code.5585 + 1;
  D.44394 = 124;
  D.45522 = D.44394 + 208;
  *code.5585 = D.45522;
  goto <D.45555>;
  <D.45553>:
  code.5586 = code;
  code = code.5586 + 1;
  D.44398 = 114;
  D.45525 = D.44398 + 208;
  *code.5586 = D.45525;
  <D.45555>:
  code.5587 = code;
  code = code.5587 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5587 = D.39958;
  goto <D.25197>;
  <D.27102>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45558>; else goto <D.45559>;
  <D.45558>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5415, "cfg->opt & MONO_OPT_CMOV");
  <D.45559>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45560>; else goto <D.45561>;
  <D.45560>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5416, "ins->dreg == ins->sreg1");
  <D.45561>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45563>; else goto <D.45564>;
    <D.45563>:
    iftmp.5588 = 12;
    goto <D.45565>;
    <D.45564>:
    iftmp.5588 = 8;
    <D.45565>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45566 = iftmp.5588 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45566;
    if (_amd64_rex_bits != 0) goto <D.45567>; else goto <D.45568>;
    <D.45567>:
    code.5589 = code;
    code = code.5589 + 1;
    D.45570 = _amd64_rex_bits | 64;
    *code.5589 = D.45570;
    <D.45568>:
  }
  code.5590 = code;
  code = code.5590 + 1;
  *code.5590 = 59;
  code.5591 = code;
  code = code.5591 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5591 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45574>; else goto <D.45575>;
    <D.45574>:
    iftmp.5592 = 12;
    goto <D.45576>;
    <D.45575>:
    iftmp.5592 = 8;
    <D.45576>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45577 = iftmp.5592 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45577;
    if (_amd64_rex_bits != 0) goto <D.45578>; else goto <D.45579>;
    <D.45578>:
    code.5593 = code;
    code = code.5593 + 1;
    D.45581 = _amd64_rex_bits | 64;
    *code.5593 = D.45581;
    <D.45579>:
  }
  code.5594 = code;
  code = code.5594 + 1;
  *code.5594 = 15;
  if (1 != 0) goto <D.45583>; else goto <D.45584>;
  <D.45583>:
  code.5595 = code;
  code = code.5595 + 1;
  D.44543 = 127;
  D.45458 = D.44543 + 208;
  *code.5595 = D.45458;
  goto <D.45586>;
  <D.45584>:
  code.5596 = code;
  code = code.5596 + 1;
  D.44547 = 119;
  D.45461 = D.44547 + 208;
  *code.5596 = D.45461;
  <D.45586>:
  code.5597 = code;
  code = code.5597 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5597 = D.39958;
  goto <D.25197>;
  <D.27105>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45589>; else goto <D.45590>;
  <D.45589>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5421, "cfg->opt & MONO_OPT_CMOV");
  <D.45590>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45591>; else goto <D.45592>;
  <D.45591>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5422, "ins->dreg == ins->sreg1");
  <D.45592>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45594>; else goto <D.45595>;
    <D.45594>:
    iftmp.5598 = 12;
    goto <D.45596>;
    <D.45595>:
    iftmp.5598 = 8;
    <D.45596>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45597 = iftmp.5598 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45597;
    if (_amd64_rex_bits != 0) goto <D.45598>; else goto <D.45599>;
    <D.45598>:
    code.5599 = code;
    code = code.5599 + 1;
    D.45601 = _amd64_rex_bits | 64;
    *code.5599 = D.45601;
    <D.45599>:
  }
  code.5600 = code;
  code = code.5600 + 1;
  *code.5600 = 59;
  code.5601 = code;
  code = code.5601 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5601 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45605>; else goto <D.45606>;
    <D.45605>:
    iftmp.5602 = 12;
    goto <D.45607>;
    <D.45606>:
    iftmp.5602 = 8;
    <D.45607>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45608 = iftmp.5602 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45608;
    if (_amd64_rex_bits != 0) goto <D.45609>; else goto <D.45610>;
    <D.45609>:
    code.5603 = code;
    code = code.5603 + 1;
    D.45612 = _amd64_rex_bits | 64;
    *code.5603 = D.45612;
    <D.45610>:
  }
  code.5604 = code;
  code = code.5604 + 1;
  *code.5604 = 15;
  if (0 != 0) goto <D.45614>; else goto <D.45615>;
  <D.45614>:
  code.5605 = code;
  code = code.5605 + 1;
  D.44543 = 127;
  D.45458 = D.44543 + 208;
  *code.5605 = D.45458;
  goto <D.45617>;
  <D.45615>:
  code.5606 = code;
  code = code.5606 + 1;
  D.44547 = 119;
  D.45461 = D.44547 + 208;
  *code.5606 = D.45461;
  <D.45617>:
  code.5607 = code;
  code = code.5607 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5607 = D.39958;
  goto <D.25197>;
  <D.27108>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45620>; else goto <D.45621>;
  <D.45620>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5427, "cfg->opt & MONO_OPT_CMOV");
  <D.45621>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45622>; else goto <D.45623>;
  <D.45622>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5428, "ins->dreg == ins->sreg1");
  <D.45623>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45625>; else goto <D.45626>;
    <D.45625>:
    iftmp.5608 = 12;
    goto <D.45627>;
    <D.45626>:
    iftmp.5608 = 8;
    <D.45627>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45628 = iftmp.5608 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45628;
    if (_amd64_rex_bits != 0) goto <D.45629>; else goto <D.45630>;
    <D.45629>:
    code.5609 = code;
    code = code.5609 + 1;
    D.45632 = _amd64_rex_bits | 64;
    *code.5609 = D.45632;
    <D.45630>:
  }
  code.5610 = code;
  code = code.5610 + 1;
  *code.5610 = 59;
  code.5611 = code;
  code = code.5611 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5611 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45636>; else goto <D.45637>;
    <D.45636>:
    iftmp.5612 = 12;
    goto <D.45638>;
    <D.45637>:
    iftmp.5612 = 8;
    <D.45638>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45639 = iftmp.5612 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45639;
    if (_amd64_rex_bits != 0) goto <D.45640>; else goto <D.45641>;
    <D.45640>:
    code.5613 = code;
    code = code.5613 + 1;
    D.45643 = _amd64_rex_bits | 64;
    *code.5613 = D.45643;
    <D.45641>:
  }
  code.5614 = code;
  code = code.5614 + 1;
  *code.5614 = 15;
  if (1 != 0) goto <D.45645>; else goto <D.45646>;
  <D.45645>:
  code.5615 = code;
  code = code.5615 + 1;
  D.44394 = 124;
  D.45522 = D.44394 + 208;
  *code.5615 = D.45522;
  goto <D.45648>;
  <D.45646>:
  code.5616 = code;
  code = code.5616 + 1;
  D.44398 = 114;
  D.45525 = D.44398 + 208;
  *code.5616 = D.45525;
  <D.45648>:
  code.5617 = code;
  code = code.5617 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5617 = D.39958;
  goto <D.25197>;
  <D.27111>:
  D.31286 = cfg->opt;
  D.45426 = D.31286 & 256;
  D.45427 = D.45426 == 0;
  D.45428 = (long int) D.45427;
  D.45429 = __builtin_expect (D.45428, 0);
  if (D.45429 != 0) goto <D.45651>; else goto <D.45652>;
  <D.45651>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5433, "cfg->opt & MONO_OPT_CMOV");
  <D.45652>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  D.39926 = D.31589 != D.31516;
  D.39927 = (long int) D.39926;
  D.39928 = __builtin_expect (D.39927, 0);
  if (D.39928 != 0) goto <D.45653>; else goto <D.45654>;
  <D.45653>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5434, "ins->dreg == ins->sreg1");
  <D.45654>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.45656>; else goto <D.45657>;
    <D.45656>:
    iftmp.5618 = 12;
    goto <D.45658>;
    <D.45657>:
    iftmp.5618 = 8;
    <D.45658>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45659 = iftmp.5618 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45659;
    if (_amd64_rex_bits != 0) goto <D.45660>; else goto <D.45661>;
    <D.45660>:
    code.5619 = code;
    code = code.5619 + 1;
    D.45663 = _amd64_rex_bits | 64;
    *code.5619 = D.45663;
    <D.45661>:
  }
  code.5620 = code;
  code = code.5620 + 1;
  *code.5620 = 59;
  code.5621 = code;
  code = code.5621 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.5621 = D.33821;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45667>; else goto <D.45668>;
    <D.45667>:
    iftmp.5622 = 12;
    goto <D.45669>;
    <D.45668>:
    iftmp.5622 = 8;
    <D.45669>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.45670 = iftmp.5622 | D.33811;
    _amd64_rex_bits = (unsigned char) D.45670;
    if (_amd64_rex_bits != 0) goto <D.45671>; else goto <D.45672>;
    <D.45671>:
    code.5623 = code;
    code = code.5623 + 1;
    D.45674 = _amd64_rex_bits | 64;
    *code.5623 = D.45674;
    <D.45672>:
  }
  code.5624 = code;
  code = code.5624 + 1;
  *code.5624 = 15;
  if (0 != 0) goto <D.45676>; else goto <D.45677>;
  <D.45676>:
  code.5625 = code;
  code = code.5625 + 1;
  D.44394 = 124;
  D.45522 = D.44394 + 208;
  *code.5625 = D.45522;
  goto <D.45679>;
  <D.45677>:
  code.5626 = code;
  code = code.5626 + 1;
  D.44398 = 114;
  D.45525 = D.44398 + 208;
  *code.5626 = D.45525;
  <D.45679>:
  code.5627 = code;
  code = code.5627 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.5627 = D.39958;
  goto <D.25197>;
  <D.27114>:
  goto <D.25197>;
  <D.27115>:
  code.5628 = code;
  code = code.5628 + 1;
  *code.5628 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.45684>; else goto <D.45685>;
    <D.45684>:
    iftmp.5629 = 4;
    goto <D.45686>;
    <D.45685>:
    iftmp.5629 = 0;
    <D.45686>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.45687 = iftmp.5629 | D.33180;
    _amd64_rex_bits = (unsigned char) D.45687;
    if (_amd64_rex_bits != 0) goto <D.45688>; else goto <D.45689>;
    <D.45688>:
    code.5630 = code;
    code = code.5630 + 1;
    D.45691 = _amd64_rex_bits | 64;
    *code.5630 = D.45691;
    <D.45689>:
  }
  code.5631 = code;
  code = code.5631 + 1;
  *code.5631 = 15;
  code.5632 = code;
  code = code.5632 + 1;
  *code.5632 = 47;
  code.5633 = code;
  code = code.5633 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.42058 = D.33673 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.42059 = D.42058 | D.31571;
  D.42060 = (unsigned char) D.42059;
  *code.5633 = D.42060;
  goto <D.25197>;
  <D.27117>:
  <D.27118>:
  {
    guchar * unordered_check;

    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45696>; else goto <D.45697>;
      <D.45696>:
      iftmp.5634 = 12;
      goto <D.45698>;
      <D.45697>:
      iftmp.5634 = 8;
      <D.45698>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.45699 = iftmp.5634 | D.32040;
      _amd64_rex_bits = (unsigned char) D.45699;
      if (_amd64_rex_bits != 0) goto <D.45700>; else goto <D.45701>;
      <D.45700>:
      code.5635 = code;
      code = code.5635 + 1;
      D.45703 = _amd64_rex_bits | 64;
      *code.5635 = D.45703;
      <D.45701>:
    }
    code.5636 = code;
    code = code.5636 + 1;
    *code.5636 = 51;
    code.5637 = code;
    code = code.5637 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.5637 = D.37521;
    code.5638 = code;
    code = code.5638 + 1;
    *code.5638 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.45708>; else goto <D.45709>;
      <D.45708>:
      iftmp.5639 = 4;
      goto <D.45710>;
      <D.45709>:
      iftmp.5639 = 0;
      <D.45710>:
      D.31490 = ins->sreg2;
      D.33810 = D.31490 > 7;
      D.33811 = (signed char) D.33810;
      D.45711 = iftmp.5639 | D.33811;
      _amd64_rex_bits = (unsigned char) D.45711;
      if (_amd64_rex_bits != 0) goto <D.45712>; else goto <D.45713>;
      <D.45712>:
      code.5640 = code;
      code = code.5640 + 1;
      D.45715 = _amd64_rex_bits | 64;
      *code.5640 = D.45715;
      <D.45713>:
    }
    code.5641 = code;
    code = code.5641 + 1;
    *code.5641 = 15;
    code.5642 = code;
    code = code.5642 + 1;
    *code.5642 = 47;
    code.5643 = code;
    code = code.5643 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.33819 = D.32054 | -64;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.33820 = D.33819 | D.31501;
    D.33821 = (unsigned char) D.33820;
    *code.5643 = D.33821;
    unordered_check = code;
    if (0 != 0) goto <D.45719>; else goto <D.45720>;
    <D.45719>:
    code.5644 = code;
    code = code.5644 + 1;
    D.45722 = 122;
    *code.5644 = D.45722;
    goto <D.45723>;
    <D.45720>:
    code.5645 = code;
    code = code.5645 + 1;
    D.45725 = 122;
    *code.5645 = D.45725;
    <D.45723>:
    *code = 0;
    code = code + 1;
    D.31464 = ins->opcode;
    if (D.31464 == 718) goto <D.45726>; else goto <D.45727>;
    <D.45726>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.45728>; else goto <D.45729>;
      <D.45728>:
      code.5646 = code;
      code = code.5646 + 1;
      D.45731 = _amd64_rex_bits | 64;
      *code.5646 = D.45731;
      <D.45729>:
    }
    if (0 != 0) goto <D.45732>; else goto <D.45733>;
    <D.45732>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5459, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.45733>:
    code.5647 = code;
    code = code.5647 + 1;
    *code.5647 = 15;
    if (0 != 0) goto <D.45735>; else goto <D.45736>;
    <D.45735>:
    code.5648 = code;
    code = code.5648 + 1;
    D.31526 = 116;
    D.31527 = D.31526 + 32;
    *code.5648 = D.31527;
    goto <D.45738>;
    <D.45736>:
    code.5649 = code;
    code = code.5649 + 1;
    D.31530 = 116;
    D.31531 = D.31530 + 32;
    *code.5649 = D.31531;
    <D.45738>:
    code.5650 = code;
    code = code.5650 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5650 = D.35110;
    amd64_patch (unordered_check, code);
    goto <D.45741>;
    <D.45727>:
    {
      guchar * jump_to_end;

      {
        unsigned char _amd64_rex_bits;

        D.31589 = ins->dreg;
        D.31590 = D.31589 > 7;
        _amd64_rex_bits = (unsigned char) D.31590;
        if (1 != 0) goto <D.45742>; else goto <D.45743>;
        <D.45742>:
        code.5651 = code;
        code = code.5651 + 1;
        D.45745 = _amd64_rex_bits | 64;
        *code.5651 = D.45745;
        <D.45743>:
      }
      if (0 != 0) goto <D.45746>; else goto <D.45747>;
      <D.45746>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5463, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
      <D.45747>:
      code.5652 = code;
      code = code.5652 + 1;
      *code.5652 = 15;
      if (0 != 0) goto <D.45749>; else goto <D.45750>;
      <D.45749>:
      code.5653 = code;
      code = code.5653 + 1;
      D.45752 = 117;
      D.45753 = D.45752 + 32;
      *code.5653 = D.45753;
      goto <D.45754>;
      <D.45750>:
      code.5654 = code;
      code = code.5654 + 1;
      D.45756 = 117;
      D.45757 = D.45756 + 32;
      *code.5654 = D.45757;
      <D.45754>:
      code.5655 = code;
      code = code.5655 + 1;
      D.31589 = ins->dreg;
      D.31631 = (signed char) D.31589;
      D.31632 = D.31631 & 7;
      D.35109 = D.31632 | -64;
      D.35110 = (unsigned char) D.35109;
      *code.5655 = D.35110;
      jump_to_end = code;
      code.5656 = code;
      code = code.5656 + 1;
      *code.5656 = 235;
      *code = 0;
      code = code + 1;
      amd64_patch (unordered_check, code);
      {
        unsigned char _amd64_rex_bits;

        D.31589 = ins->dreg;
        if (D.31589 > 7) goto <D.45761>; else goto <D.45762>;
        <D.45761>:
        iftmp.5657 = 9;
        goto <D.45763>;
        <D.45762>:
        iftmp.5657 = 8;
        <D.45763>:
        _amd64_rex_bits = iftmp.5657;
        if (_amd64_rex_bits != 0) goto <D.45764>; else goto <D.45765>;
        <D.45764>:
        code.5658 = code;
        code = code.5658 + 1;
        D.45767 = _amd64_rex_bits | 64;
        *code.5658 = D.45767;
        <D.45765>:
      }
      code.5659 = code;
      code = code.5659 + 1;
      *code.5659 = 255;
      code.5660 = code;
      code = code.5660 + 1;
      D.31589 = ins->dreg;
      D.31631 = (signed char) D.31589;
      D.31632 = D.31631 & 7;
      D.35109 = D.31632 | -64;
      D.35110 = (unsigned char) D.35109;
      *code.5660 = D.35110;
      amd64_patch (jump_to_end, code);
    }
    <D.45741>:
    goto <D.25197>;
  }
  <D.27126>:
  <D.27127>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.45771>; else goto <D.45772>;
    <D.45771>:
    iftmp.5661 = 12;
    goto <D.45773>;
    <D.45772>:
    iftmp.5661 = 8;
    <D.45773>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.45774 = iftmp.5661 | D.32040;
    _amd64_rex_bits = (unsigned char) D.45774;
    if (_amd64_rex_bits != 0) goto <D.45775>; else goto <D.45776>;
    <D.45775>:
    code.5662 = code;
    code = code.5662 + 1;
    D.45778 = _amd64_rex_bits | 64;
    *code.5662 = D.45778;
    <D.45776>:
  }
  code.5663 = code;
  code = code.5663 + 1;
  *code.5663 = 51;
  code.5664 = code;
  code = code.5664 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.5664 = D.37521;
  code.5665 = code;
  code = code.5665 + 1;
  *code.5665 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.45783>; else goto <D.45784>;
    <D.45783>:
    iftmp.5666 = 4;
    goto <D.45785>;
    <D.45784>:
    iftmp.5666 = 0;
    <D.45785>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.45786 = iftmp.5666 | D.33180;
    _amd64_rex_bits = (unsigned char) D.45786;
    if (_amd64_rex_bits != 0) goto <D.45787>; else goto <D.45788>;
    <D.45787>:
    code.5667 = code;
    code = code.5667 + 1;
    D.45790 = _amd64_rex_bits | 64;
    *code.5667 = D.45790;
    <D.45788>:
  }
  code.5668 = code;
  code = code.5668 + 1;
  *code.5668 = 15;
  code.5669 = code;
  code = code.5669 + 1;
  *code.5669 = 47;
  code.5670 = code;
  code = code.5670 + 1;
  D.31490 = ins->sreg2;
  D.33671 = D.31490 & 7;
  D.33672 = D.33671 << 3;
  D.33673 = (signed char) D.33672;
  D.42058 = D.33673 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.42059 = D.42058 | D.31571;
  D.42060 = (unsigned char) D.42059;
  *code.5670 = D.42060;
  D.31464 = ins->opcode;
  if (D.31464 == 722) goto <D.45794>; else goto <D.45795>;
  <D.45794>:
  {
    guchar * unordered_check;
    guchar * jump_to_end;

    unordered_check = code;
    if (0 != 0) goto <D.45796>; else goto <D.45797>;
    <D.45796>:
    code.5671 = code;
    code = code.5671 + 1;
    D.45722 = 122;
    *code.5671 = D.45722;
    goto <D.45799>;
    <D.45797>:
    code.5672 = code;
    code = code.5672 + 1;
    D.45725 = 122;
    *code.5672 = D.45725;
    <D.45799>:
    *code = 0;
    code = code + 1;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.45801>; else goto <D.45802>;
      <D.45801>:
      code.5673 = code;
      code = code.5673 + 1;
      D.45804 = _amd64_rex_bits | 64;
      *code.5673 = D.45804;
      <D.45802>:
    }
    if (0 != 0) goto <D.45805>; else goto <D.45806>;
    <D.45805>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5483, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.45806>:
    code.5674 = code;
    code = code.5674 + 1;
    *code.5674 = 15;
    if (0 != 0) goto <D.45808>; else goto <D.45809>;
    <D.45808>:
    code.5675 = code;
    code = code.5675 + 1;
    D.44543 = 127;
    D.45811 = D.44543 + 32;
    *code.5675 = D.45811;
    goto <D.45812>;
    <D.45809>:
    code.5676 = code;
    code = code.5676 + 1;
    D.44547 = 119;
    D.45814 = D.44547 + 32;
    *code.5676 = D.45814;
    <D.45812>:
    code.5677 = code;
    code = code.5677 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5677 = D.35110;
    jump_to_end = code;
    code.5678 = code;
    code = code.5678 + 1;
    *code.5678 = 235;
    *code = 0;
    code = code + 1;
    amd64_patch (unordered_check, code);
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45818>; else goto <D.45819>;
      <D.45818>:
      iftmp.5679 = 9;
      goto <D.45820>;
      <D.45819>:
      iftmp.5679 = 8;
      <D.45820>:
      _amd64_rex_bits = iftmp.5679;
      if (_amd64_rex_bits != 0) goto <D.45821>; else goto <D.45822>;
      <D.45821>:
      code.5680 = code;
      code = code.5680 + 1;
      D.45824 = _amd64_rex_bits | 64;
      *code.5680 = D.45824;
      <D.45822>:
    }
    code.5681 = code;
    code = code.5681 + 1;
    *code.5681 = 255;
    code.5682 = code;
    code = code.5682 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5682 = D.35110;
    amd64_patch (jump_to_end, code);
  }
  goto <D.45827>;
  <D.45795>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (1 != 0) goto <D.45828>; else goto <D.45829>;
    <D.45828>:
    code.5683 = code;
    code = code.5683 + 1;
    D.45831 = _amd64_rex_bits | 64;
    *code.5683 = D.45831;
    <D.45829>:
  }
  if (0 != 0) goto <D.45832>; else goto <D.45833>;
  <D.45832>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5490, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
  <D.45833>:
  code.5684 = code;
  code = code.5684 + 1;
  *code.5684 = 15;
  if (0 != 0) goto <D.45835>; else goto <D.45836>;
  <D.45835>:
  code.5685 = code;
  code = code.5685 + 1;
  D.44543 = 127;
  D.45811 = D.44543 + 32;
  *code.5685 = D.45811;
  goto <D.45838>;
  <D.45836>:
  code.5686 = code;
  code = code.5686 + 1;
  D.44547 = 119;
  D.45814 = D.44547 + 32;
  *code.5686 = D.45814;
  <D.45838>:
  code.5687 = code;
  code = code.5687 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.35109 = D.31632 | -64;
  D.35110 = (unsigned char) D.35109;
  *code.5687 = D.35110;
  <D.45827>:
  goto <D.25197>;
  <D.27135>:
  {
    guchar * unordered_check;

    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45842>; else goto <D.45843>;
      <D.45842>:
      iftmp.5688 = 12;
      goto <D.45844>;
      <D.45843>:
      iftmp.5688 = 8;
      <D.45844>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.45845 = iftmp.5688 | D.32040;
      _amd64_rex_bits = (unsigned char) D.45845;
      if (_amd64_rex_bits != 0) goto <D.45846>; else goto <D.45847>;
      <D.45846>:
      code.5689 = code;
      code = code.5689 + 1;
      D.45849 = _amd64_rex_bits | 64;
      *code.5689 = D.45849;
      <D.45847>:
    }
    code.5690 = code;
    code = code.5690 + 1;
    *code.5690 = 51;
    code.5691 = code;
    code = code.5691 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.5691 = D.37521;
    code.5692 = code;
    code = code.5692 + 1;
    *code.5692 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31490 = ins->sreg2;
      if (D.31490 > 7) goto <D.45854>; else goto <D.45855>;
      <D.45854>:
      iftmp.5693 = 4;
      goto <D.45856>;
      <D.45855>:
      iftmp.5693 = 0;
      <D.45856>:
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.45857 = iftmp.5693 | D.33180;
      _amd64_rex_bits = (unsigned char) D.45857;
      if (_amd64_rex_bits != 0) goto <D.45858>; else goto <D.45859>;
      <D.45858>:
      code.5694 = code;
      code = code.5694 + 1;
      D.45861 = _amd64_rex_bits | 64;
      *code.5694 = D.45861;
      <D.45859>:
    }
    code.5695 = code;
    code = code.5695 + 1;
    *code.5695 = 15;
    code.5696 = code;
    code = code.5696 + 1;
    *code.5696 = 47;
    code.5697 = code;
    code = code.5697 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.42058 = D.33673 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.42059 = D.42058 | D.31571;
    D.42060 = (unsigned char) D.42059;
    *code.5697 = D.42060;
    unordered_check = code;
    if (0 != 0) goto <D.45865>; else goto <D.45866>;
    <D.45865>:
    code.5698 = code;
    code = code.5698 + 1;
    D.45722 = 122;
    *code.5698 = D.45722;
    goto <D.45868>;
    <D.45866>:
    code.5699 = code;
    code = code.5699 + 1;
    D.45725 = 122;
    *code.5699 = D.45725;
    <D.45868>:
    *code = 0;
    code = code + 1;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.45870>; else goto <D.45871>;
      <D.45870>:
      code.5700 = code;
      code = code.5700 + 1;
      D.45873 = _amd64_rex_bits | 64;
      *code.5700 = D.45873;
      <D.45871>:
    }
    if (0 != 0) goto <D.45874>; else goto <D.45875>;
    <D.45874>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5499, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.45875>:
    code.5701 = code;
    code = code.5701 + 1;
    *code.5701 = 15;
    if (0 != 0) goto <D.45877>; else goto <D.45878>;
    <D.45877>:
    code.5702 = code;
    code = code.5702 + 1;
    D.45880 = 125;
    D.45881 = D.45880 + 32;
    *code.5702 = D.45881;
    goto <D.45882>;
    <D.45878>:
    code.5703 = code;
    code = code.5703 + 1;
    D.45884 = 115;
    D.45885 = D.45884 + 32;
    *code.5703 = D.45885;
    <D.45882>:
    code.5704 = code;
    code = code.5704 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5704 = D.35110;
    amd64_patch (unordered_check, code);
    goto <D.25197>;
  }
  <D.27140>:
  <D.27141>:
  {
    guchar * unordered_check;

    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45888>; else goto <D.45889>;
      <D.45888>:
      iftmp.5705 = 12;
      goto <D.45890>;
      <D.45889>:
      iftmp.5705 = 8;
      <D.45890>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.45891 = iftmp.5705 | D.32040;
      _amd64_rex_bits = (unsigned char) D.45891;
      if (_amd64_rex_bits != 0) goto <D.45892>; else goto <D.45893>;
      <D.45892>:
      code.5706 = code;
      code = code.5706 + 1;
      D.45895 = _amd64_rex_bits | 64;
      *code.5706 = D.45895;
      <D.45893>:
    }
    code.5707 = code;
    code = code.5707 + 1;
    *code.5707 = 51;
    code.5708 = code;
    code = code.5708 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.5708 = D.37521;
    code.5709 = code;
    code = code.5709 + 1;
    *code.5709 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31490 = ins->sreg2;
      if (D.31490 > 7) goto <D.45900>; else goto <D.45901>;
      <D.45900>:
      iftmp.5710 = 4;
      goto <D.45902>;
      <D.45901>:
      iftmp.5710 = 0;
      <D.45902>:
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.45903 = iftmp.5710 | D.33180;
      _amd64_rex_bits = (unsigned char) D.45903;
      if (_amd64_rex_bits != 0) goto <D.45904>; else goto <D.45905>;
      <D.45904>:
      code.5711 = code;
      code = code.5711 + 1;
      D.45907 = _amd64_rex_bits | 64;
      *code.5711 = D.45907;
      <D.45905>:
    }
    code.5712 = code;
    code = code.5712 + 1;
    *code.5712 = 15;
    code.5713 = code;
    code = code.5713 + 1;
    *code.5713 = 47;
    code.5714 = code;
    code = code.5714 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.42058 = D.33673 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.42059 = D.42058 | D.31571;
    D.42060 = (unsigned char) D.42059;
    *code.5714 = D.42060;
    D.31464 = ins->opcode;
    if (D.31464 == 719) goto <D.45911>; else goto <D.45912>;
    <D.45911>:
    unordered_check = code;
    if (0 != 0) goto <D.45913>; else goto <D.45914>;
    <D.45913>:
    code.5715 = code;
    code = code.5715 + 1;
    D.45722 = 122;
    *code.5715 = D.45722;
    goto <D.45916>;
    <D.45914>:
    code.5716 = code;
    code = code.5716 + 1;
    D.45725 = 122;
    *code.5716 = D.45725;
    <D.45916>:
    *code = 0;
    code = code + 1;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.45918>; else goto <D.45919>;
      <D.45918>:
      code.5717 = code;
      code = code.5717 + 1;
      D.45921 = _amd64_rex_bits | 64;
      *code.5717 = D.45921;
      <D.45919>:
    }
    if (0 != 0) goto <D.45922>; else goto <D.45923>;
    <D.45922>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5514, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.45923>:
    code.5718 = code;
    code = code.5718 + 1;
    *code.5718 = 15;
    if (0 != 0) goto <D.45925>; else goto <D.45926>;
    <D.45925>:
    code.5719 = code;
    code = code.5719 + 1;
    D.44394 = 124;
    D.45928 = D.44394 + 32;
    *code.5719 = D.45928;
    goto <D.45929>;
    <D.45926>:
    code.5720 = code;
    code = code.5720 + 1;
    D.44398 = 114;
    D.45931 = D.44398 + 32;
    *code.5720 = D.45931;
    <D.45929>:
    code.5721 = code;
    code = code.5721 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5721 = D.35110;
    amd64_patch (unordered_check, code);
    goto <D.45933>;
    <D.45912>:
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.45934>; else goto <D.45935>;
      <D.45934>:
      code.5722 = code;
      code = code.5722 + 1;
      D.45937 = _amd64_rex_bits | 64;
      *code.5722 = D.45937;
      <D.45935>:
    }
    if (0 != 0) goto <D.45938>; else goto <D.45939>;
    <D.45938>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5517, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.45939>:
    code.5723 = code;
    code = code.5723 + 1;
    *code.5723 = 15;
    if (0 != 0) goto <D.45941>; else goto <D.45942>;
    <D.45941>:
    code.5724 = code;
    code = code.5724 + 1;
    D.44394 = 124;
    D.45928 = D.44394 + 32;
    *code.5724 = D.45928;
    goto <D.45944>;
    <D.45942>:
    code.5725 = code;
    code = code.5725 + 1;
    D.44398 = 114;
    D.45931 = D.44398 + 32;
    *code.5725 = D.45931;
    <D.45944>:
    code.5726 = code;
    code = code.5726 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5726 = D.35110;
    <D.45933>:
    goto <D.25197>;
  }
  <D.27147>:
  {
    guchar * unordered_check;

    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45948>; else goto <D.45949>;
      <D.45948>:
      iftmp.5727 = 12;
      goto <D.45950>;
      <D.45949>:
      iftmp.5727 = 8;
      <D.45950>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.45951 = iftmp.5727 | D.32040;
      _amd64_rex_bits = (unsigned char) D.45951;
      if (_amd64_rex_bits != 0) goto <D.45952>; else goto <D.45953>;
      <D.45952>:
      code.5728 = code;
      code = code.5728 + 1;
      D.45955 = _amd64_rex_bits | 64;
      *code.5728 = D.45955;
      <D.45953>:
    }
    code.5729 = code;
    code = code.5729 + 1;
    *code.5729 = 51;
    code.5730 = code;
    code = code.5730 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.5730 = D.37521;
    code.5731 = code;
    code = code.5731 + 1;
    *code.5731 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31490 = ins->sreg2;
      if (D.31490 > 7) goto <D.45960>; else goto <D.45961>;
      <D.45960>:
      iftmp.5732 = 4;
      goto <D.45962>;
      <D.45961>:
      iftmp.5732 = 0;
      <D.45962>:
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.45963 = iftmp.5732 | D.33180;
      _amd64_rex_bits = (unsigned char) D.45963;
      if (_amd64_rex_bits != 0) goto <D.45964>; else goto <D.45965>;
      <D.45964>:
      code.5733 = code;
      code = code.5733 + 1;
      D.45967 = _amd64_rex_bits | 64;
      *code.5733 = D.45967;
      <D.45965>:
    }
    code.5734 = code;
    code = code.5734 + 1;
    *code.5734 = 15;
    code.5735 = code;
    code = code.5735 + 1;
    *code.5735 = 47;
    code.5736 = code;
    code = code.5736 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.42058 = D.33673 | -64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.42059 = D.42058 | D.31571;
    D.42060 = (unsigned char) D.42059;
    *code.5736 = D.42060;
    unordered_check = code;
    if (0 != 0) goto <D.45971>; else goto <D.45972>;
    <D.45971>:
    code.5737 = code;
    code = code.5737 + 1;
    D.45722 = 122;
    *code.5737 = D.45722;
    goto <D.45974>;
    <D.45972>:
    code.5738 = code;
    code = code.5738 + 1;
    D.45725 = 122;
    *code.5738 = D.45725;
    <D.45974>:
    *code = 0;
    code = code + 1;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.45976>; else goto <D.45977>;
      <D.45976>:
      code.5739 = code;
      code = code.5739 + 1;
      D.45979 = _amd64_rex_bits | 64;
      *code.5739 = D.45979;
      <D.45977>:
    }
    if (0 != 0) goto <D.45980>; else goto <D.45981>;
    <D.45980>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5527, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.45981>:
    code.5740 = code;
    code = code.5740 + 1;
    *code.5740 = 15;
    if (0 != 0) goto <D.45983>; else goto <D.45984>;
    <D.45983>:
    code.5741 = code;
    code = code.5741 + 1;
    D.45986 = 126;
    D.45987 = D.45986 + 32;
    *code.5741 = D.45987;
    goto <D.45988>;
    <D.45984>:
    code.5742 = code;
    code = code.5742 + 1;
    D.45990 = 118;
    D.45991 = D.45990 + 32;
    *code.5742 = D.45991;
    <D.45988>:
    code.5743 = code;
    code = code.5743 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5743 = D.35110;
    amd64_patch (unordered_check, code);
    goto <D.25197>;
  }
  <D.27152>:
  <D.27153>:
  <D.27154>:
  <D.27155>:
  <D.27156>:
  {
    guchar * unordered_check;
    guchar * jump_to_end;
    int x86_cond;

    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.45994>; else goto <D.45995>;
      <D.45994>:
      iftmp.5744 = 12;
      goto <D.45996>;
      <D.45995>:
      iftmp.5744 = 8;
      <D.45996>:
      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      D.32040 = (signed char) D.31590;
      D.45997 = iftmp.5744 | D.32040;
      _amd64_rex_bits = (unsigned char) D.45997;
      if (_amd64_rex_bits != 0) goto <D.45998>; else goto <D.45999>;
      <D.45998>:
      code.5745 = code;
      code = code.5745 + 1;
      D.46001 = _amd64_rex_bits | 64;
      *code.5745 = D.46001;
      <D.45999>:
    }
    code.5746 = code;
    code = code.5746 + 1;
    *code.5746 = 51;
    code.5747 = code;
    code = code.5747 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.5747 = D.37521;
    code.5748 = code;
    code = code.5748 + 1;
    *code.5748 = 102;
    {
      unsigned char _amd64_rex_bits;

      D.31516 = ins->sreg1;
      if (D.31516 > 7) goto <D.46006>; else goto <D.46007>;
      <D.46006>:
      iftmp.5749 = 4;
      goto <D.46008>;
      <D.46007>:
      iftmp.5749 = 0;
      <D.46008>:
      D.46009 = ins->sreg2;
      D.46010 = D.46009 != 16;
      D.46011 = D.46009 > 7;
      D.46012 = D.46010 & D.46011;
      D.46013 = (int) D.46012;
      D.46014 = (signed char) D.46013;
      D.46015 = iftmp.5749 | D.46014;
      _amd64_rex_bits = (unsigned char) D.46015;
      if (_amd64_rex_bits != 0) goto <D.46016>; else goto <D.46017>;
      <D.46016>:
      code.5750 = code;
      code = code.5750 + 1;
      D.46019 = _amd64_rex_bits | 64;
      *code.5750 = D.46019;
      <D.46017>:
    }
    code.5751 = code;
    code = code.5751 + 1;
    *code.5751 = 15;
    code.5752 = code;
    code = code.5752 + 1;
    *code.5752 = 47;
    D.31490 = ins->sreg2;
    if (D.31490 == 16) goto <D.46022>; else goto <D.46023>;
    <D.46022>:
    code.5753 = code;
    code = code.5753 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.33888 = D.32054 | 5;
    D.33889 = (unsigned char) D.33888;
    *code.5753 = D.33889;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.5754 = code;
          code = code.5754 + 1;
          D.46026 = imb.b[0];
          *code.5754 = D.46026;
          code.5755 = code;
          code = code.5755 + 1;
          D.46028 = imb.b[1];
          *code.5755 = D.46028;
          code.5756 = code;
          code = code.5756 + 1;
          D.46030 = imb.b[2];
          *code.5756 = D.46030;
          code.5757 = code;
          code = code.5757 + 1;
          D.46032 = imb.b[3];
          *code.5757 = D.46032;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.46033>;
    <D.46023>:
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    if (D.33671 == 4) goto <D.46034>; else goto <D.46035>;
    <D.46034>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.46036>; else goto <D.46037>;
    <D.46036>:
    code.5758 = code;
    code = code.5758 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32055 = D.32054 | 4;
    D.32056 = (unsigned char) D.32055;
    *code.5758 = D.32056;
    code.5759 = code;
    code = code.5759 + 1;
    *code.5759 = 36;
    goto <D.46040>;
    <D.46037>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.46041>; else goto <D.46042>;
    <D.46041>:
    code.5760 = code;
    code = code.5760 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32062 = D.32054 | 68;
    D.32063 = (unsigned char) D.32062;
    *code.5760 = D.32063;
    code.5761 = code;
    code = code.5761 + 1;
    *code.5761 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.46045>;
    <D.46042>:
    code.5762 = code;
    code = code.5762 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32067 = D.32054 | -124;
    D.32068 = (unsigned char) D.32067;
    *code.5762 = D.32068;
    code.5763 = code;
    code = code.5763 + 1;
    *code.5763 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.5764 = code;
          code = code.5764 + 1;
          D.46049 = imb.b[0];
          *code.5764 = D.46049;
          code.5765 = code;
          code = code.5765 + 1;
          D.46051 = imb.b[1];
          *code.5765 = D.46051;
          code.5766 = code;
          code = code.5766 + 1;
          D.46053 = imb.b[2];
          *code.5766 = D.46053;
          code.5767 = code;
          code = code.5767 + 1;
          D.46055 = imb.b[3];
          *code.5767 = D.46055;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46045>:
    <D.46040>:
    goto <D.27164>;
    <D.46035>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.46056>; else goto <D.46057>;
    <D.46056>:
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    if (D.33671 != 5) goto <D.46058>; else goto <D.46059>;
    <D.46058>:
    code.5768 = code;
    code = code.5768 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.33926 = D.32054 | D.31501;
    D.33927 = (unsigned char) D.33926;
    *code.5768 = D.33927;
    goto <D.27164>;
    <D.46059>:
    <D.46057>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.46061>; else goto <D.46062>;
    <D.46061>:
    code.5769 = code;
    code = code.5769 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32088 = D.32054 | 64;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.33931 = D.32088 | D.31501;
    D.33932 = (unsigned char) D.33931;
    *code.5769 = D.33932;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.46064>;
    <D.46062>:
    code.5770 = code;
    code = code.5770 + 1;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    D.32053 = D.31532 << 3;
    D.32054 = (signed char) D.32053;
    D.32093 = D.32054 | -128;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.33935 = D.32093 | D.31501;
    D.33936 = (unsigned char) D.33935;
    *code.5770 = D.33936;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.5771 = code;
          code = code.5771 + 1;
          D.46067 = imb.b[0];
          *code.5771 = D.46067;
          code.5772 = code;
          code = code.5772 + 1;
          D.46069 = imb.b[1];
          *code.5772 = D.46069;
          code.5773 = code;
          code = code.5773 + 1;
          D.46071 = imb.b[2];
          *code.5773 = D.46071;
          code.5774 = code;
          code = code.5774 + 1;
          D.46073 = imb.b[3];
          *code.5774 = D.46073;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46064>:
    <D.27164>:
    <D.46033>:
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    switch (D.31465) <default: <D.27172>, case 726: <D.27166>, case 727: <D.27170>, case 728: <D.27171>, case 729: <D.27168>, case 730: <D.27169>>
    <D.27166>:
    x86_cond = 0;
    goto <D.27167>;
    <D.27168>:
    <D.27169>:
    x86_cond = 2;
    goto <D.27167>;
    <D.27170>:
    <D.27171>:
    x86_cond = 4;
    goto <D.27167>;
    <D.27172>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 5556);
    <D.27167>:
    unordered_check = code;
    if (0 != 0) goto <D.46074>; else goto <D.46075>;
    <D.46074>:
    code.5775 = code;
    code = code.5775 + 1;
    D.45722 = 122;
    *code.5775 = D.45722;
    goto <D.46077>;
    <D.46075>:
    code.5776 = code;
    code = code.5776 + 1;
    D.45725 = 122;
    *code.5776 = D.45725;
    <D.46077>:
    *code = 0;
    code = code + 1;
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      D.31590 = D.31589 > 7;
      _amd64_rex_bits = (unsigned char) D.31590;
      if (1 != 0) goto <D.46079>; else goto <D.46080>;
      <D.46079>:
      code.5777 = code;
      code = code.5777 + 1;
      D.46082 = _amd64_rex_bits | 64;
      *code.5777 = D.46082;
      <D.46080>:
    }
    if (0 != 0) goto <D.46083>; else goto <D.46084>;
    <D.46083>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5561, "X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.46084>:
    code.5778 = code;
    code = code.5778 + 1;
    *code.5778 = 15;
    if (0 != 0) goto <D.46086>; else goto <D.46087>;
    <D.46086>:
    code.5779 = code;
    code = code.5779 + 1;
    D.46089 = x86_cc_signed_map[x86_cond];
    D.46090 = D.46089 + 32;
    *code.5779 = D.46090;
    goto <D.46091>;
    <D.46087>:
    code.5780 = code;
    code = code.5780 + 1;
    D.46093 = x86_cc_unsigned_map[x86_cond];
    D.46094 = D.46093 + 32;
    *code.5780 = D.46094;
    <D.46091>:
    code.5781 = code;
    code = code.5781 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5781 = D.35110;
    D.31464 = ins->opcode;
    D.31465 = (int) D.31464;
    switch (D.31465) <default: <D.27181>, case 726: <D.27174>, case 727: <D.27176>, case 728: <D.27179>, case 729: <D.27175>, case 730: <D.27178>>
    <D.27174>:
    <D.27175>:
    <D.27176>:
    amd64_patch (unordered_check, code);
    goto <D.27177>;
    <D.27178>:
    <D.27179>:
    jump_to_end = code;
    code.5782 = code;
    code = code.5782 + 1;
    *code.5782 = 235;
    *code = 0;
    code = code + 1;
    amd64_patch (unordered_check, code);
    {
      unsigned char _amd64_rex_bits;

      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.46098>; else goto <D.46099>;
      <D.46098>:
      iftmp.5783 = 9;
      goto <D.46100>;
      <D.46099>:
      iftmp.5783 = 8;
      <D.46100>:
      _amd64_rex_bits = iftmp.5783;
      if (_amd64_rex_bits != 0) goto <D.46101>; else goto <D.46102>;
      <D.46101>:
      code.5784 = code;
      code = code.5784 + 1;
      D.46104 = _amd64_rex_bits | 64;
      *code.5784 = D.46104;
      <D.46102>:
    }
    code.5785 = code;
    code = code.5785 + 1;
    *code.5785 = 255;
    code.5786 = code;
    code = code.5786 + 1;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.35109 = D.31632 | -64;
    D.35110 = (unsigned char) D.35109;
    *code.5786 = D.35110;
    amd64_patch (jump_to_end, code);
    goto <D.27177>;
    <D.27181>:
    goto <D.27177>;
    <D.27177>:
    goto <D.25197>;
  }
  <D.27182>:
  {
    guchar * jump;

    jump = code;
    if (1 != 0) goto <D.46107>; else goto <D.46108>;
    <D.46107>:
    code.5787 = code;
    code = code.5787 + 1;
    D.45722 = 122;
    *code.5787 = D.45722;
    goto <D.46110>;
    <D.46108>:
    code.5788 = code;
    code = code.5788 + 1;
    D.45725 = 122;
    *code.5788 = D.45725;
    <D.46110>:
    *code = 0;
    code = code + 1;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    if (D.39826 != 0) goto <D.46112>; else goto <D.46113>;
    <D.46112>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39834 = D.39833 + 4294967294;
      offset = (int) D.39834;
      offset.5789 = (unsigned int) offset;
      D.46115 = offset.5789 + 128;
      if (D.46115 <= 255) goto <D.46116>; else goto <D.46117>;
      <D.46116>:
      if (0 != 0) goto <D.46118>; else goto <D.46119>;
      <D.46118>:
      code.5790 = code;
      code = code.5790 + 1;
      D.31526 = 116;
      *code.5790 = D.31526;
      goto <D.46121>;
      <D.46119>:
      code.5791 = code;
      code = code.5791 + 1;
      D.31530 = 116;
      *code.5791 = D.31530;
      <D.46121>:
      D.46123 = (unsigned char) offset;
      *code = D.46123;
      code = code + 1;
      goto <D.46124>;
      <D.46117>:
      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39854 = D.39833 + 4294967290;
      offset = (int) D.39854;
      code.5792 = code;
      code = code.5792 + 1;
      *code.5792 = 15;
      if (0 != 0) goto <D.46126>; else goto <D.46127>;
      <D.46126>:
      code.5793 = code;
      code = code.5793 + 1;
      D.31526 = 116;
      D.46129 = D.31526 + 16;
      *code.5793 = D.46129;
      goto <D.46130>;
      <D.46127>:
      code.5794 = code;
      code = code.5794 + 1;
      D.31530 = 116;
      D.46132 = D.31530 + 16;
      *code.5794 = D.46132;
      <D.46130>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.5795 = code;
            code = code.5795 + 1;
            D.46134 = imb.b[0];
            *code.5795 = D.46134;
            code.5796 = code;
            code = code.5796 + 1;
            D.46136 = imb.b[1];
            *code.5796 = D.46136;
            code.5797 = code;
            code = code.5797 + 1;
            D.46138 = imb.b[2];
            *code.5797 = D.46138;
            code.5798 = code;
            code = code.5798 + 1;
            D.46140 = imb.b[3];
            *code.5798 = D.46140;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.46124>:
    }
    goto <D.46141>;
    <D.46113>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.39825);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.46144>; else goto <D.46142>;
    <D.46144>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 >= -128) goto <D.46145>; else goto <D.46142>;
    <D.46145>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 <= 127) goto <D.46146>; else goto <D.46142>;
    <D.46146>:
    if (0 != 0) goto <D.46147>; else goto <D.46148>;
    <D.46147>:
    code.5799 = code;
    code = code.5799 + 1;
    D.31526 = 116;
    *code.5799 = D.31526;
    goto <D.46150>;
    <D.46148>:
    code.5800 = code;
    code = code.5800 + 1;
    D.31530 = 116;
    *code.5800 = D.31530;
    <D.46150>:
    *code = 0;
    code = code + 1;
    goto <D.46143>;
    <D.46142>:
    code.5801 = code;
    code = code.5801 + 1;
    *code.5801 = 15;
    if (0 != 0) goto <D.46153>; else goto <D.46154>;
    <D.46153>:
    code.5802 = code;
    code = code.5802 + 1;
    D.31526 = 116;
    D.46129 = D.31526 + 16;
    *code.5802 = D.46129;
    goto <D.46156>;
    <D.46154>:
    code.5803 = code;
    code = code.5803 + 1;
    D.31530 = 116;
    D.46132 = D.31530 + 16;
    *code.5803 = D.46132;
    <D.46156>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5804 = code;
          code = code.5804 + 1;
          D.46159 = imb.b[0];
          *code.5804 = D.46159;
          code.5805 = code;
          code = code.5805 + 1;
          D.46161 = imb.b[1];
          *code.5805 = D.46161;
          code.5806 = code;
          code = code.5806 + 1;
          D.46163 = imb.b[2];
          *code.5806 = D.46163;
          code.5807 = code;
          code = code.5807 + 1;
          D.46165 = imb.b[3];
          *code.5807 = D.46165;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46143>:
    <D.46141>:
    amd64_patch (jump, code);
    goto <D.25197>;
  }
  <D.27187>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46166>; else goto <D.46167>;
  <D.46166>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5808 = (unsigned int) offset;
    D.46169 = offset.5808 + 128;
    if (D.46169 <= 255) goto <D.46170>; else goto <D.46171>;
    <D.46170>:
    if (0 != 0) goto <D.46172>; else goto <D.46173>;
    <D.46172>:
    code.5809 = code;
    code = code.5809 + 1;
    D.45752 = 117;
    *code.5809 = D.45752;
    goto <D.46175>;
    <D.46173>:
    code.5810 = code;
    code = code.5810 + 1;
    D.45756 = 117;
    *code.5810 = D.45756;
    <D.46175>:
    D.46177 = (unsigned char) offset;
    *code = D.46177;
    code = code + 1;
    goto <D.46178>;
    <D.46171>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5811 = code;
    code = code.5811 + 1;
    *code.5811 = 15;
    if (0 != 0) goto <D.46180>; else goto <D.46181>;
    <D.46180>:
    code.5812 = code;
    code = code.5812 + 1;
    D.45752 = 117;
    D.46183 = D.45752 + 16;
    *code.5812 = D.46183;
    goto <D.46184>;
    <D.46181>:
    code.5813 = code;
    code = code.5813 + 1;
    D.45756 = 117;
    D.46186 = D.45756 + 16;
    *code.5813 = D.46186;
    <D.46184>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5814 = code;
          code = code.5814 + 1;
          D.46188 = imb.b[0];
          *code.5814 = D.46188;
          code.5815 = code;
          code = code.5815 + 1;
          D.46190 = imb.b[1];
          *code.5815 = D.46190;
          code.5816 = code;
          code = code.5816 + 1;
          D.46192 = imb.b[2];
          *code.5816 = D.46192;
          code.5817 = code;
          code = code.5817 + 1;
          D.46194 = imb.b[3];
          *code.5817 = D.46194;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46178>:
  }
  goto <D.46195>;
  <D.46167>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46198>; else goto <D.46196>;
  <D.46198>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46199>; else goto <D.46196>;
  <D.46199>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46200>; else goto <D.46196>;
  <D.46200>:
  if (0 != 0) goto <D.46201>; else goto <D.46202>;
  <D.46201>:
  code.5818 = code;
  code = code.5818 + 1;
  D.45752 = 117;
  *code.5818 = D.45752;
  goto <D.46204>;
  <D.46202>:
  code.5819 = code;
  code = code.5819 + 1;
  D.45756 = 117;
  *code.5819 = D.45756;
  <D.46204>:
  *code = 0;
  code = code + 1;
  goto <D.46197>;
  <D.46196>:
  code.5820 = code;
  code = code.5820 + 1;
  *code.5820 = 15;
  if (0 != 0) goto <D.46207>; else goto <D.46208>;
  <D.46207>:
  code.5821 = code;
  code = code.5821 + 1;
  D.45752 = 117;
  D.46183 = D.45752 + 16;
  *code.5821 = D.46183;
  goto <D.46210>;
  <D.46208>:
  code.5822 = code;
  code = code.5822 + 1;
  D.45756 = 117;
  D.46186 = D.45756 + 16;
  *code.5822 = D.46186;
  <D.46210>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5823 = code;
        code = code.5823 + 1;
        D.46213 = imb.b[0];
        *code.5823 = D.46213;
        code.5824 = code;
        code = code.5824 + 1;
        D.46215 = imb.b[1];
        *code.5824 = D.46215;
        code.5825 = code;
        code = code.5825 + 1;
        D.46217 = imb.b[2];
        *code.5825 = D.46217;
        code.5826 = code;
        code = code.5826 + 1;
        D.46219 = imb.b[3];
        *code.5826 = D.46219;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46197>:
  <D.46195>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46220>; else goto <D.46221>;
  <D.46220>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5827 = (unsigned int) offset;
    D.46223 = offset.5827 + 128;
    if (D.46223 <= 255) goto <D.46224>; else goto <D.46225>;
    <D.46224>:
    if (0 != 0) goto <D.46226>; else goto <D.46227>;
    <D.46226>:
    code.5828 = code;
    code = code.5828 + 1;
    D.45722 = 122;
    *code.5828 = D.45722;
    goto <D.46229>;
    <D.46227>:
    code.5829 = code;
    code = code.5829 + 1;
    D.45725 = 122;
    *code.5829 = D.45725;
    <D.46229>:
    D.46231 = (unsigned char) offset;
    *code = D.46231;
    code = code + 1;
    goto <D.46232>;
    <D.46225>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5830 = code;
    code = code.5830 + 1;
    *code.5830 = 15;
    if (0 != 0) goto <D.46234>; else goto <D.46235>;
    <D.46234>:
    code.5831 = code;
    code = code.5831 + 1;
    D.45722 = 122;
    D.46237 = D.45722 + 16;
    *code.5831 = D.46237;
    goto <D.46238>;
    <D.46235>:
    code.5832 = code;
    code = code.5832 + 1;
    D.45725 = 122;
    D.46240 = D.45725 + 16;
    *code.5832 = D.46240;
    <D.46238>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5833 = code;
          code = code.5833 + 1;
          D.46242 = imb.b[0];
          *code.5833 = D.46242;
          code.5834 = code;
          code = code.5834 + 1;
          D.46244 = imb.b[1];
          *code.5834 = D.46244;
          code.5835 = code;
          code = code.5835 + 1;
          D.46246 = imb.b[2];
          *code.5835 = D.46246;
          code.5836 = code;
          code = code.5836 + 1;
          D.46248 = imb.b[3];
          *code.5836 = D.46248;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46232>:
  }
  goto <D.46249>;
  <D.46221>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46252>; else goto <D.46250>;
  <D.46252>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46253>; else goto <D.46250>;
  <D.46253>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46254>; else goto <D.46250>;
  <D.46254>:
  if (0 != 0) goto <D.46255>; else goto <D.46256>;
  <D.46255>:
  code.5837 = code;
  code = code.5837 + 1;
  D.45722 = 122;
  *code.5837 = D.45722;
  goto <D.46258>;
  <D.46256>:
  code.5838 = code;
  code = code.5838 + 1;
  D.45725 = 122;
  *code.5838 = D.45725;
  <D.46258>:
  *code = 0;
  code = code + 1;
  goto <D.46251>;
  <D.46250>:
  code.5839 = code;
  code = code.5839 + 1;
  *code.5839 = 15;
  if (0 != 0) goto <D.46261>; else goto <D.46262>;
  <D.46261>:
  code.5840 = code;
  code = code.5840 + 1;
  D.45722 = 122;
  D.46237 = D.45722 + 16;
  *code.5840 = D.46237;
  goto <D.46264>;
  <D.46262>:
  code.5841 = code;
  code = code.5841 + 1;
  D.45725 = 122;
  D.46240 = D.45725 + 16;
  *code.5841 = D.46240;
  <D.46264>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5842 = code;
        code = code.5842 + 1;
        D.46267 = imb.b[0];
        *code.5842 = D.46267;
        code.5843 = code;
        code = code.5843 + 1;
        D.46269 = imb.b[1];
        *code.5843 = D.46269;
        code.5844 = code;
        code = code.5844 + 1;
        D.46271 = imb.b[2];
        *code.5844 = D.46271;
        code.5845 = code;
        code = code.5845 + 1;
        D.46273 = imb.b[3];
        *code.5845 = D.46273;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46251>:
  <D.46249>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46274>; else goto <D.46275>;
  <D.46274>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5846 = (unsigned int) offset;
    D.46277 = offset.5846 + 128;
    if (D.46277 <= 255) goto <D.46278>; else goto <D.46279>;
    <D.46278>:
    if (0 != 0) goto <D.46280>; else goto <D.46281>;
    <D.46280>:
    code.5847 = code;
    code = code.5847 + 1;
    D.44394 = 124;
    *code.5847 = D.44394;
    goto <D.46283>;
    <D.46281>:
    code.5848 = code;
    code = code.5848 + 1;
    D.44398 = 114;
    *code.5848 = D.44398;
    <D.46283>:
    D.46285 = (unsigned char) offset;
    *code = D.46285;
    code = code + 1;
    goto <D.46286>;
    <D.46279>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5849 = code;
    code = code.5849 + 1;
    *code.5849 = 15;
    if (0 != 0) goto <D.46288>; else goto <D.46289>;
    <D.46288>:
    code.5850 = code;
    code = code.5850 + 1;
    D.44394 = 124;
    D.44395 = D.44394 + 16;
    *code.5850 = D.44395;
    goto <D.46291>;
    <D.46289>:
    code.5851 = code;
    code = code.5851 + 1;
    D.44398 = 114;
    D.44399 = D.44398 + 16;
    *code.5851 = D.44399;
    <D.46291>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5852 = code;
          code = code.5852 + 1;
          D.46294 = imb.b[0];
          *code.5852 = D.46294;
          code.5853 = code;
          code = code.5853 + 1;
          D.46296 = imb.b[1];
          *code.5853 = D.46296;
          code.5854 = code;
          code = code.5854 + 1;
          D.46298 = imb.b[2];
          *code.5854 = D.46298;
          code.5855 = code;
          code = code.5855 + 1;
          D.46300 = imb.b[3];
          *code.5855 = D.46300;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46286>:
  }
  goto <D.46301>;
  <D.46275>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46304>; else goto <D.46302>;
  <D.46304>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46305>; else goto <D.46302>;
  <D.46305>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46306>; else goto <D.46302>;
  <D.46306>:
  if (0 != 0) goto <D.46307>; else goto <D.46308>;
  <D.46307>:
  code.5856 = code;
  code = code.5856 + 1;
  D.44394 = 124;
  *code.5856 = D.44394;
  goto <D.46310>;
  <D.46308>:
  code.5857 = code;
  code = code.5857 + 1;
  D.44398 = 114;
  *code.5857 = D.44398;
  <D.46310>:
  *code = 0;
  code = code + 1;
  goto <D.46303>;
  <D.46302>:
  code.5858 = code;
  code = code.5858 + 1;
  *code.5858 = 15;
  if (0 != 0) goto <D.46313>; else goto <D.46314>;
  <D.46313>:
  code.5859 = code;
  code = code.5859 + 1;
  D.44394 = 124;
  D.44395 = D.44394 + 16;
  *code.5859 = D.44395;
  goto <D.46316>;
  <D.46314>:
  code.5860 = code;
  code = code.5860 + 1;
  D.44398 = 114;
  D.44399 = D.44398 + 16;
  *code.5860 = D.44399;
  <D.46316>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5861 = code;
        code = code.5861 + 1;
        D.46319 = imb.b[0];
        *code.5861 = D.46319;
        code.5862 = code;
        code = code.5862 + 1;
        D.46321 = imb.b[1];
        *code.5862 = D.46321;
        code.5863 = code;
        code = code.5863 + 1;
        D.46323 = imb.b[2];
        *code.5863 = D.46323;
        code.5864 = code;
        code = code.5864 + 1;
        D.46325 = imb.b[3];
        *code.5864 = D.46325;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46303>:
  <D.46301>:
  goto <D.25197>;
  <D.27197>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46326>; else goto <D.46327>;
  <D.46326>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5865 = (unsigned int) offset;
    D.46329 = offset.5865 + 128;
    if (D.46329 <= 255) goto <D.46330>; else goto <D.46331>;
    <D.46330>:
    if (0 != 0) goto <D.46332>; else goto <D.46333>;
    <D.46332>:
    code.5866 = code;
    code = code.5866 + 1;
    D.44543 = 127;
    *code.5866 = D.44543;
    goto <D.46335>;
    <D.46333>:
    code.5867 = code;
    code = code.5867 + 1;
    D.44547 = 119;
    *code.5867 = D.44547;
    <D.46335>:
    D.46337 = (unsigned char) offset;
    *code = D.46337;
    code = code + 1;
    goto <D.46338>;
    <D.46331>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5868 = code;
    code = code.5868 + 1;
    *code.5868 = 15;
    if (0 != 0) goto <D.46340>; else goto <D.46341>;
    <D.46340>:
    code.5869 = code;
    code = code.5869 + 1;
    D.44543 = 127;
    D.44544 = D.44543 + 16;
    *code.5869 = D.44544;
    goto <D.46343>;
    <D.46341>:
    code.5870 = code;
    code = code.5870 + 1;
    D.44547 = 119;
    D.44548 = D.44547 + 16;
    *code.5870 = D.44548;
    <D.46343>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5871 = code;
          code = code.5871 + 1;
          D.46346 = imb.b[0];
          *code.5871 = D.46346;
          code.5872 = code;
          code = code.5872 + 1;
          D.46348 = imb.b[1];
          *code.5872 = D.46348;
          code.5873 = code;
          code = code.5873 + 1;
          D.46350 = imb.b[2];
          *code.5873 = D.46350;
          code.5874 = code;
          code = code.5874 + 1;
          D.46352 = imb.b[3];
          *code.5874 = D.46352;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46338>:
  }
  goto <D.46353>;
  <D.46327>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46356>; else goto <D.46354>;
  <D.46356>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46357>; else goto <D.46354>;
  <D.46357>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46358>; else goto <D.46354>;
  <D.46358>:
  if (0 != 0) goto <D.46359>; else goto <D.46360>;
  <D.46359>:
  code.5875 = code;
  code = code.5875 + 1;
  D.44543 = 127;
  *code.5875 = D.44543;
  goto <D.46362>;
  <D.46360>:
  code.5876 = code;
  code = code.5876 + 1;
  D.44547 = 119;
  *code.5876 = D.44547;
  <D.46362>:
  *code = 0;
  code = code + 1;
  goto <D.46355>;
  <D.46354>:
  code.5877 = code;
  code = code.5877 + 1;
  *code.5877 = 15;
  if (0 != 0) goto <D.46365>; else goto <D.46366>;
  <D.46365>:
  code.5878 = code;
  code = code.5878 + 1;
  D.44543 = 127;
  D.44544 = D.44543 + 16;
  *code.5878 = D.44544;
  goto <D.46368>;
  <D.46366>:
  code.5879 = code;
  code = code.5879 + 1;
  D.44547 = 119;
  D.44548 = D.44547 + 16;
  *code.5879 = D.44548;
  <D.46368>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5880 = code;
        code = code.5880 + 1;
        D.46371 = imb.b[0];
        *code.5880 = D.46371;
        code.5881 = code;
        code = code.5881 + 1;
        D.46373 = imb.b[1];
        *code.5881 = D.46373;
        code.5882 = code;
        code = code.5882 + 1;
        D.46375 = imb.b[2];
        *code.5882 = D.46375;
        code.5883 = code;
        code = code.5883 + 1;
        D.46377 = imb.b[3];
        *code.5883 = D.46377;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46355>:
  <D.46353>:
  goto <D.25197>;
  <D.27201>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46378>; else goto <D.46379>;
  <D.46378>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5884 = (unsigned int) offset;
    D.46381 = offset.5884 + 128;
    if (D.46381 <= 255) goto <D.46382>; else goto <D.46383>;
    <D.46382>:
    if (0 != 0) goto <D.46384>; else goto <D.46385>;
    <D.46384>:
    code.5885 = code;
    code = code.5885 + 1;
    D.45722 = 122;
    *code.5885 = D.45722;
    goto <D.46387>;
    <D.46385>:
    code.5886 = code;
    code = code.5886 + 1;
    D.45725 = 122;
    *code.5886 = D.45725;
    <D.46387>:
    D.46389 = (unsigned char) offset;
    *code = D.46389;
    code = code + 1;
    goto <D.46390>;
    <D.46383>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5887 = code;
    code = code.5887 + 1;
    *code.5887 = 15;
    if (0 != 0) goto <D.46392>; else goto <D.46393>;
    <D.46392>:
    code.5888 = code;
    code = code.5888 + 1;
    D.45722 = 122;
    D.46237 = D.45722 + 16;
    *code.5888 = D.46237;
    goto <D.46395>;
    <D.46393>:
    code.5889 = code;
    code = code.5889 + 1;
    D.45725 = 122;
    D.46240 = D.45725 + 16;
    *code.5889 = D.46240;
    <D.46395>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5890 = code;
          code = code.5890 + 1;
          D.46398 = imb.b[0];
          *code.5890 = D.46398;
          code.5891 = code;
          code = code.5891 + 1;
          D.46400 = imb.b[1];
          *code.5891 = D.46400;
          code.5892 = code;
          code = code.5892 + 1;
          D.46402 = imb.b[2];
          *code.5892 = D.46402;
          code.5893 = code;
          code = code.5893 + 1;
          D.46404 = imb.b[3];
          *code.5893 = D.46404;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46390>:
  }
  goto <D.46405>;
  <D.46379>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46408>; else goto <D.46406>;
  <D.46408>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46409>; else goto <D.46406>;
  <D.46409>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46410>; else goto <D.46406>;
  <D.46410>:
  if (0 != 0) goto <D.46411>; else goto <D.46412>;
  <D.46411>:
  code.5894 = code;
  code = code.5894 + 1;
  D.45722 = 122;
  *code.5894 = D.45722;
  goto <D.46414>;
  <D.46412>:
  code.5895 = code;
  code = code.5895 + 1;
  D.45725 = 122;
  *code.5895 = D.45725;
  <D.46414>:
  *code = 0;
  code = code + 1;
  goto <D.46407>;
  <D.46406>:
  code.5896 = code;
  code = code.5896 + 1;
  *code.5896 = 15;
  if (0 != 0) goto <D.46417>; else goto <D.46418>;
  <D.46417>:
  code.5897 = code;
  code = code.5897 + 1;
  D.45722 = 122;
  D.46237 = D.45722 + 16;
  *code.5897 = D.46237;
  goto <D.46420>;
  <D.46418>:
  code.5898 = code;
  code = code.5898 + 1;
  D.45725 = 122;
  D.46240 = D.45725 + 16;
  *code.5898 = D.46240;
  <D.46420>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5899 = code;
        code = code.5899 + 1;
        D.46423 = imb.b[0];
        *code.5899 = D.46423;
        code.5900 = code;
        code = code.5900 + 1;
        D.46425 = imb.b[1];
        *code.5900 = D.46425;
        code.5901 = code;
        code = code.5901 + 1;
        D.46427 = imb.b[2];
        *code.5901 = D.46427;
        code.5902 = code;
        code = code.5902 + 1;
        D.46429 = imb.b[3];
        *code.5902 = D.46429;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46407>:
  <D.46405>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46430>; else goto <D.46431>;
  <D.46430>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5903 = (unsigned int) offset;
    D.46433 = offset.5903 + 128;
    if (D.46433 <= 255) goto <D.46434>; else goto <D.46435>;
    <D.46434>:
    if (0 != 0) goto <D.46436>; else goto <D.46437>;
    <D.46436>:
    code.5904 = code;
    code = code.5904 + 1;
    D.44543 = 127;
    *code.5904 = D.44543;
    goto <D.46439>;
    <D.46437>:
    code.5905 = code;
    code = code.5905 + 1;
    D.44547 = 119;
    *code.5905 = D.44547;
    <D.46439>:
    D.46441 = (unsigned char) offset;
    *code = D.46441;
    code = code + 1;
    goto <D.46442>;
    <D.46435>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5906 = code;
    code = code.5906 + 1;
    *code.5906 = 15;
    if (0 != 0) goto <D.46444>; else goto <D.46445>;
    <D.46444>:
    code.5907 = code;
    code = code.5907 + 1;
    D.44543 = 127;
    D.44544 = D.44543 + 16;
    *code.5907 = D.44544;
    goto <D.46447>;
    <D.46445>:
    code.5908 = code;
    code = code.5908 + 1;
    D.44547 = 119;
    D.44548 = D.44547 + 16;
    *code.5908 = D.44548;
    <D.46447>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5909 = code;
          code = code.5909 + 1;
          D.46450 = imb.b[0];
          *code.5909 = D.46450;
          code.5910 = code;
          code = code.5910 + 1;
          D.46452 = imb.b[1];
          *code.5910 = D.46452;
          code.5911 = code;
          code = code.5911 + 1;
          D.46454 = imb.b[2];
          *code.5911 = D.46454;
          code.5912 = code;
          code = code.5912 + 1;
          D.46456 = imb.b[3];
          *code.5912 = D.46456;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46442>:
  }
  goto <D.46457>;
  <D.46431>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46460>; else goto <D.46458>;
  <D.46460>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46461>; else goto <D.46458>;
  <D.46461>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46462>; else goto <D.46458>;
  <D.46462>:
  if (0 != 0) goto <D.46463>; else goto <D.46464>;
  <D.46463>:
  code.5913 = code;
  code = code.5913 + 1;
  D.44543 = 127;
  *code.5913 = D.44543;
  goto <D.46466>;
  <D.46464>:
  code.5914 = code;
  code = code.5914 + 1;
  D.44547 = 119;
  *code.5914 = D.44547;
  <D.46466>:
  *code = 0;
  code = code + 1;
  goto <D.46459>;
  <D.46458>:
  code.5915 = code;
  code = code.5915 + 1;
  *code.5915 = 15;
  if (0 != 0) goto <D.46469>; else goto <D.46470>;
  <D.46469>:
  code.5916 = code;
  code = code.5916 + 1;
  D.44543 = 127;
  D.44544 = D.44543 + 16;
  *code.5916 = D.44544;
  goto <D.46472>;
  <D.46470>:
  code.5917 = code;
  code = code.5917 + 1;
  D.44547 = 119;
  D.44548 = D.44547 + 16;
  *code.5917 = D.44548;
  <D.46472>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5918 = code;
        code = code.5918 + 1;
        D.46475 = imb.b[0];
        *code.5918 = D.46475;
        code.5919 = code;
        code = code.5919 + 1;
        D.46477 = imb.b[1];
        *code.5919 = D.46477;
        code.5920 = code;
        code = code.5920 + 1;
        D.46479 = imb.b[2];
        *code.5920 = D.46479;
        code.5921 = code;
        code = code.5921 + 1;
        D.46481 = imb.b[3];
        *code.5921 = D.46481;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46459>:
  <D.46457>:
  goto <D.25197>;
  <D.27208>:
  <D.27209>:
  D.31464 = ins->opcode;
  if (D.31464 == 664) goto <D.46482>; else goto <D.46483>;
  <D.46482>:
  {
    guchar * br1;

    br1 = code;
    if (0 != 0) goto <D.46484>; else goto <D.46485>;
    <D.46484>:
    code.5922 = code;
    code = code.5922 + 1;
    D.45722 = 122;
    *code.5922 = D.45722;
    goto <D.46487>;
    <D.46485>:
    code.5923 = code;
    code = code.5923 + 1;
    D.45725 = 122;
    *code.5923 = D.45725;
    <D.46487>:
    *code = 0;
    code = code + 1;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    if (D.39826 != 0) goto <D.46489>; else goto <D.46490>;
    <D.46489>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39834 = D.39833 + 4294967294;
      offset = (int) D.39834;
      offset.5924 = (unsigned int) offset;
      D.46492 = offset.5924 + 128;
      if (D.46492 <= 255) goto <D.46493>; else goto <D.46494>;
      <D.46493>:
      if (0 != 0) goto <D.46495>; else goto <D.46496>;
      <D.46495>:
      code.5925 = code;
      code = code.5925 + 1;
      D.44394 = 124;
      *code.5925 = D.44394;
      goto <D.46498>;
      <D.46496>:
      code.5926 = code;
      code = code.5926 + 1;
      D.44398 = 114;
      *code.5926 = D.44398;
      <D.46498>:
      D.46500 = (unsigned char) offset;
      *code = D.46500;
      code = code + 1;
      goto <D.46501>;
      <D.46494>:
      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39854 = D.39833 + 4294967290;
      offset = (int) D.39854;
      code.5927 = code;
      code = code.5927 + 1;
      *code.5927 = 15;
      if (0 != 0) goto <D.46503>; else goto <D.46504>;
      <D.46503>:
      code.5928 = code;
      code = code.5928 + 1;
      D.44394 = 124;
      D.44395 = D.44394 + 16;
      *code.5928 = D.44395;
      goto <D.46506>;
      <D.46504>:
      code.5929 = code;
      code = code.5929 + 1;
      D.44398 = 114;
      D.44399 = D.44398 + 16;
      *code.5929 = D.44399;
      <D.46506>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.5930 = code;
            code = code.5930 + 1;
            D.46509 = imb.b[0];
            *code.5930 = D.46509;
            code.5931 = code;
            code = code.5931 + 1;
            D.46511 = imb.b[1];
            *code.5931 = D.46511;
            code.5932 = code;
            code = code.5932 + 1;
            D.46513 = imb.b[2];
            *code.5932 = D.46513;
            code.5933 = code;
            code = code.5933 + 1;
            D.46515 = imb.b[3];
            *code.5933 = D.46515;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.46501>:
    }
    goto <D.46516>;
    <D.46490>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.39825);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.46519>; else goto <D.46517>;
    <D.46519>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 >= -128) goto <D.46520>; else goto <D.46517>;
    <D.46520>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 <= 127) goto <D.46521>; else goto <D.46517>;
    <D.46521>:
    if (0 != 0) goto <D.46522>; else goto <D.46523>;
    <D.46522>:
    code.5934 = code;
    code = code.5934 + 1;
    D.44394 = 124;
    *code.5934 = D.44394;
    goto <D.46525>;
    <D.46523>:
    code.5935 = code;
    code = code.5935 + 1;
    D.44398 = 114;
    *code.5935 = D.44398;
    <D.46525>:
    *code = 0;
    code = code + 1;
    goto <D.46518>;
    <D.46517>:
    code.5936 = code;
    code = code.5936 + 1;
    *code.5936 = 15;
    if (0 != 0) goto <D.46528>; else goto <D.46529>;
    <D.46528>:
    code.5937 = code;
    code = code.5937 + 1;
    D.44394 = 124;
    D.44395 = D.44394 + 16;
    *code.5937 = D.44395;
    goto <D.46531>;
    <D.46529>:
    code.5938 = code;
    code = code.5938 + 1;
    D.44398 = 114;
    D.44399 = D.44398 + 16;
    *code.5938 = D.44399;
    <D.46531>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5939 = code;
          code = code.5939 + 1;
          D.46534 = imb.b[0];
          *code.5939 = D.46534;
          code.5940 = code;
          code = code.5940 + 1;
          D.46536 = imb.b[1];
          *code.5940 = D.46536;
          code.5941 = code;
          code = code.5941 + 1;
          D.46538 = imb.b[2];
          *code.5941 = D.46538;
          code.5942 = code;
          code = code.5942 + 1;
          D.46540 = imb.b[3];
          *code.5942 = D.46540;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46518>:
    <D.46516>:
    amd64_patch (br1, code);
    goto <D.25197>;
  }
  <D.46483>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46541>; else goto <D.46542>;
  <D.46541>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5943 = (unsigned int) offset;
    D.46544 = offset.5943 + 128;
    if (D.46544 <= 255) goto <D.46545>; else goto <D.46546>;
    <D.46545>:
    if (0 != 0) goto <D.46547>; else goto <D.46548>;
    <D.46547>:
    code.5944 = code;
    code = code.5944 + 1;
    D.44394 = 124;
    *code.5944 = D.44394;
    goto <D.46550>;
    <D.46548>:
    code.5945 = code;
    code = code.5945 + 1;
    D.44398 = 114;
    *code.5945 = D.44398;
    <D.46550>:
    D.46552 = (unsigned char) offset;
    *code = D.46552;
    code = code + 1;
    goto <D.46553>;
    <D.46546>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5946 = code;
    code = code.5946 + 1;
    *code.5946 = 15;
    if (0 != 0) goto <D.46555>; else goto <D.46556>;
    <D.46555>:
    code.5947 = code;
    code = code.5947 + 1;
    D.44394 = 124;
    D.44395 = D.44394 + 16;
    *code.5947 = D.44395;
    goto <D.46558>;
    <D.46556>:
    code.5948 = code;
    code = code.5948 + 1;
    D.44398 = 114;
    D.44399 = D.44398 + 16;
    *code.5948 = D.44399;
    <D.46558>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5949 = code;
          code = code.5949 + 1;
          D.46561 = imb.b[0];
          *code.5949 = D.46561;
          code.5950 = code;
          code = code.5950 + 1;
          D.46563 = imb.b[1];
          *code.5950 = D.46563;
          code.5951 = code;
          code = code.5951 + 1;
          D.46565 = imb.b[2];
          *code.5951 = D.46565;
          code.5952 = code;
          code = code.5952 + 1;
          D.46567 = imb.b[3];
          *code.5952 = D.46567;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46553>:
  }
  goto <D.46568>;
  <D.46542>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46571>; else goto <D.46569>;
  <D.46571>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46572>; else goto <D.46569>;
  <D.46572>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46573>; else goto <D.46569>;
  <D.46573>:
  if (0 != 0) goto <D.46574>; else goto <D.46575>;
  <D.46574>:
  code.5953 = code;
  code = code.5953 + 1;
  D.44394 = 124;
  *code.5953 = D.44394;
  goto <D.46577>;
  <D.46575>:
  code.5954 = code;
  code = code.5954 + 1;
  D.44398 = 114;
  *code.5954 = D.44398;
  <D.46577>:
  *code = 0;
  code = code + 1;
  goto <D.46570>;
  <D.46569>:
  code.5955 = code;
  code = code.5955 + 1;
  *code.5955 = 15;
  if (0 != 0) goto <D.46580>; else goto <D.46581>;
  <D.46580>:
  code.5956 = code;
  code = code.5956 + 1;
  D.44394 = 124;
  D.44395 = D.44394 + 16;
  *code.5956 = D.44395;
  goto <D.46583>;
  <D.46581>:
  code.5957 = code;
  code = code.5957 + 1;
  D.44398 = 114;
  D.44399 = D.44398 + 16;
  *code.5957 = D.44399;
  <D.46583>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5958 = code;
        code = code.5958 + 1;
        D.46586 = imb.b[0];
        *code.5958 = D.46586;
        code.5959 = code;
        code = code.5959 + 1;
        D.46588 = imb.b[1];
        *code.5959 = D.46588;
        code.5960 = code;
        code = code.5960 + 1;
        D.46590 = imb.b[2];
        *code.5960 = D.46590;
        code.5961 = code;
        code = code.5961 + 1;
        D.46592 = imb.b[3];
        *code.5961 = D.46592;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46570>:
  <D.46568>:
  goto <D.25197>;
  <D.27217>:
  {
    guchar * br1;

    br1 = code;
    if (0 != 0) goto <D.46593>; else goto <D.46594>;
    <D.46593>:
    code.5962 = code;
    code = code.5962 + 1;
    D.45722 = 122;
    *code.5962 = D.45722;
    goto <D.46596>;
    <D.46594>:
    code.5963 = code;
    code = code.5963 + 1;
    D.45725 = 122;
    *code.5963 = D.45725;
    <D.46596>:
    *code = 0;
    code = code + 1;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    if (D.39826 != 0) goto <D.46598>; else goto <D.46599>;
    <D.46598>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39834 = D.39833 + 4294967294;
      offset = (int) D.39834;
      offset.5964 = (unsigned int) offset;
      D.46601 = offset.5964 + 128;
      if (D.46601 <= 255) goto <D.46602>; else goto <D.46603>;
      <D.46602>:
      if (0 != 0) goto <D.46604>; else goto <D.46605>;
      <D.46604>:
      code.5965 = code;
      code = code.5965 + 1;
      D.45986 = 126;
      *code.5965 = D.45986;
      goto <D.46607>;
      <D.46605>:
      code.5966 = code;
      code = code.5966 + 1;
      D.45990 = 118;
      *code.5966 = D.45990;
      <D.46607>:
      D.46609 = (unsigned char) offset;
      *code = D.46609;
      code = code + 1;
      goto <D.46610>;
      <D.46603>:
      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39854 = D.39833 + 4294967290;
      offset = (int) D.39854;
      code.5967 = code;
      code = code.5967 + 1;
      *code.5967 = 15;
      if (0 != 0) goto <D.46612>; else goto <D.46613>;
      <D.46612>:
      code.5968 = code;
      code = code.5968 + 1;
      D.45986 = 126;
      D.46615 = D.45986 + 16;
      *code.5968 = D.46615;
      goto <D.46616>;
      <D.46613>:
      code.5969 = code;
      code = code.5969 + 1;
      D.45990 = 118;
      D.46618 = D.45990 + 16;
      *code.5969 = D.46618;
      <D.46616>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.5970 = code;
            code = code.5970 + 1;
            D.46620 = imb.b[0];
            *code.5970 = D.46620;
            code.5971 = code;
            code = code.5971 + 1;
            D.46622 = imb.b[1];
            *code.5971 = D.46622;
            code.5972 = code;
            code = code.5972 + 1;
            D.46624 = imb.b[2];
            *code.5972 = D.46624;
            code.5973 = code;
            code = code.5973 + 1;
            D.46626 = imb.b[3];
            *code.5973 = D.46626;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.46610>:
    }
    goto <D.46627>;
    <D.46599>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.39825);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.46630>; else goto <D.46628>;
    <D.46630>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 >= -128) goto <D.46631>; else goto <D.46628>;
    <D.46631>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 <= 127) goto <D.46632>; else goto <D.46628>;
    <D.46632>:
    if (0 != 0) goto <D.46633>; else goto <D.46634>;
    <D.46633>:
    code.5974 = code;
    code = code.5974 + 1;
    D.45986 = 126;
    *code.5974 = D.45986;
    goto <D.46636>;
    <D.46634>:
    code.5975 = code;
    code = code.5975 + 1;
    D.45990 = 118;
    *code.5975 = D.45990;
    <D.46636>:
    *code = 0;
    code = code + 1;
    goto <D.46629>;
    <D.46628>:
    code.5976 = code;
    code = code.5976 + 1;
    *code.5976 = 15;
    if (0 != 0) goto <D.46639>; else goto <D.46640>;
    <D.46639>:
    code.5977 = code;
    code = code.5977 + 1;
    D.45986 = 126;
    D.46615 = D.45986 + 16;
    *code.5977 = D.46615;
    goto <D.46642>;
    <D.46640>:
    code.5978 = code;
    code = code.5978 + 1;
    D.45990 = 118;
    D.46618 = D.45990 + 16;
    *code.5978 = D.46618;
    <D.46642>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.5979 = code;
          code = code.5979 + 1;
          D.46645 = imb.b[0];
          *code.5979 = D.46645;
          code.5980 = code;
          code = code.5980 + 1;
          D.46647 = imb.b[1];
          *code.5980 = D.46647;
          code.5981 = code;
          code = code.5981 + 1;
          D.46649 = imb.b[2];
          *code.5981 = D.46649;
          code.5982 = code;
          code = code.5982 + 1;
          D.46651 = imb.b[3];
          *code.5982 = D.46651;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46629>:
    <D.46627>:
    amd64_patch (br1, code);
    goto <D.25197>;
  }
  <D.27222>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46652>; else goto <D.46653>;
  <D.46652>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.5983 = (unsigned int) offset;
    D.46655 = offset.5983 + 128;
    if (D.46655 <= 255) goto <D.46656>; else goto <D.46657>;
    <D.46656>:
    if (0 != 0) goto <D.46658>; else goto <D.46659>;
    <D.46658>:
    code.5984 = code;
    code = code.5984 + 1;
    D.45986 = 126;
    *code.5984 = D.45986;
    goto <D.46661>;
    <D.46659>:
    code.5985 = code;
    code = code.5985 + 1;
    D.45990 = 118;
    *code.5985 = D.45990;
    <D.46661>:
    D.46663 = (unsigned char) offset;
    *code = D.46663;
    code = code + 1;
    goto <D.46664>;
    <D.46657>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.5986 = code;
    code = code.5986 + 1;
    *code.5986 = 15;
    if (0 != 0) goto <D.46666>; else goto <D.46667>;
    <D.46666>:
    code.5987 = code;
    code = code.5987 + 1;
    D.45986 = 126;
    D.46615 = D.45986 + 16;
    *code.5987 = D.46615;
    goto <D.46669>;
    <D.46667>:
    code.5988 = code;
    code = code.5988 + 1;
    D.45990 = 118;
    D.46618 = D.45990 + 16;
    *code.5988 = D.46618;
    <D.46669>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.5989 = code;
          code = code.5989 + 1;
          D.46672 = imb.b[0];
          *code.5989 = D.46672;
          code.5990 = code;
          code = code.5990 + 1;
          D.46674 = imb.b[1];
          *code.5990 = D.46674;
          code.5991 = code;
          code = code.5991 + 1;
          D.46676 = imb.b[2];
          *code.5991 = D.46676;
          code.5992 = code;
          code = code.5992 + 1;
          D.46678 = imb.b[3];
          *code.5992 = D.46678;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46664>:
  }
  goto <D.46679>;
  <D.46653>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46682>; else goto <D.46680>;
  <D.46682>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46683>; else goto <D.46680>;
  <D.46683>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46684>; else goto <D.46680>;
  <D.46684>:
  if (0 != 0) goto <D.46685>; else goto <D.46686>;
  <D.46685>:
  code.5993 = code;
  code = code.5993 + 1;
  D.45986 = 126;
  *code.5993 = D.45986;
  goto <D.46688>;
  <D.46686>:
  code.5994 = code;
  code = code.5994 + 1;
  D.45990 = 118;
  *code.5994 = D.45990;
  <D.46688>:
  *code = 0;
  code = code + 1;
  goto <D.46681>;
  <D.46680>:
  code.5995 = code;
  code = code.5995 + 1;
  *code.5995 = 15;
  if (0 != 0) goto <D.46691>; else goto <D.46692>;
  <D.46691>:
  code.5996 = code;
  code = code.5996 + 1;
  D.45986 = 126;
  D.46615 = D.45986 + 16;
  *code.5996 = D.46615;
  goto <D.46694>;
  <D.46692>:
  code.5997 = code;
  code = code.5997 + 1;
  D.45990 = 118;
  D.46618 = D.45990 + 16;
  *code.5997 = D.46618;
  <D.46694>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.5998 = code;
        code = code.5998 + 1;
        D.46697 = imb.b[0];
        *code.5998 = D.46697;
        code.5999 = code;
        code = code.5999 + 1;
        D.46699 = imb.b[1];
        *code.5999 = D.46699;
        code.6000 = code;
        code = code.6000 + 1;
        D.46701 = imb.b[2];
        *code.6000 = D.46701;
        code.6001 = code;
        code = code.6001 + 1;
        D.46703 = imb.b[3];
        *code.6001 = D.46703;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46681>:
  <D.46679>:
  goto <D.25197>;
  <D.27226>:
  {
    guchar * br1;

    br1 = code;
    if (0 != 0) goto <D.46704>; else goto <D.46705>;
    <D.46704>:
    code.6002 = code;
    code = code.6002 + 1;
    D.45722 = 122;
    *code.6002 = D.45722;
    goto <D.46707>;
    <D.46705>:
    code.6003 = code;
    code = code.6003 + 1;
    D.45725 = 122;
    *code.6003 = D.45725;
    <D.46707>:
    *code = 0;
    code = code + 1;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    if (D.39826 != 0) goto <D.46709>; else goto <D.46710>;
    <D.46709>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39834 = D.39833 + 4294967294;
      offset = (int) D.39834;
      offset.6004 = (unsigned int) offset;
      D.46712 = offset.6004 + 128;
      if (D.46712 <= 255) goto <D.46713>; else goto <D.46714>;
      <D.46713>:
      if (0 != 0) goto <D.46715>; else goto <D.46716>;
      <D.46715>:
      code.6005 = code;
      code = code.6005 + 1;
      D.45880 = 125;
      *code.6005 = D.45880;
      goto <D.46718>;
      <D.46716>:
      code.6006 = code;
      code = code.6006 + 1;
      D.45884 = 115;
      *code.6006 = D.45884;
      <D.46718>:
      D.46720 = (unsigned char) offset;
      *code = D.46720;
      code = code + 1;
      goto <D.46721>;
      <D.46714>:
      D.31283 = cfg->native_code;
      D.39824 = ins->data.op[1].many_blocks;
      D.39825 = *D.39824;
      D.39826 = D.39825->native_offset;
      D.39829 = (sizetype) D.39826;
      D.39830 = D.31283 + D.39829;
      D.39831 = (long int) D.39830;
      code.211 = (long int) code;
      D.39832 = D.39831 - code.211;
      D.39833 = (unsigned int) D.39832;
      D.39854 = D.39833 + 4294967290;
      offset = (int) D.39854;
      code.6007 = code;
      code = code.6007 + 1;
      *code.6007 = 15;
      if (0 != 0) goto <D.46723>; else goto <D.46724>;
      <D.46723>:
      code.6008 = code;
      code = code.6008 + 1;
      D.45880 = 125;
      D.46726 = D.45880 + 16;
      *code.6008 = D.46726;
      goto <D.46727>;
      <D.46724>:
      code.6009 = code;
      code = code.6009 + 1;
      D.45884 = 115;
      D.46729 = D.45884 + 16;
      *code.6009 = D.46729;
      <D.46727>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.6010 = code;
            code = code.6010 + 1;
            D.46731 = imb.b[0];
            *code.6010 = D.46731;
            code.6011 = code;
            code = code.6011 + 1;
            D.46733 = imb.b[1];
            *code.6011 = D.46733;
            code.6012 = code;
            code = code.6012 + 1;
            D.46735 = imb.b[2];
            *code.6012 = D.46735;
            code.6013 = code;
            code = code.6013 + 1;
            D.46737 = imb.b[3];
            *code.6013 = D.46737;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.46721>:
    }
    goto <D.46738>;
    <D.46710>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.39825);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.46741>; else goto <D.46739>;
    <D.46741>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 >= -128) goto <D.46742>; else goto <D.46739>;
    <D.46742>:
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39883 = D.39825->max_offset;
    D.39884 = (unsigned int) D.39883;
    D.39885 = D.39884 - offset;
    D.39886 = (int) D.39885;
    if (D.39886 <= 127) goto <D.46743>; else goto <D.46739>;
    <D.46743>:
    if (0 != 0) goto <D.46744>; else goto <D.46745>;
    <D.46744>:
    code.6014 = code;
    code = code.6014 + 1;
    D.45880 = 125;
    *code.6014 = D.45880;
    goto <D.46747>;
    <D.46745>:
    code.6015 = code;
    code = code.6015 + 1;
    D.45884 = 115;
    *code.6015 = D.45884;
    <D.46747>:
    *code = 0;
    code = code + 1;
    goto <D.46740>;
    <D.46739>:
    code.6016 = code;
    code = code.6016 + 1;
    *code.6016 = 15;
    if (0 != 0) goto <D.46750>; else goto <D.46751>;
    <D.46750>:
    code.6017 = code;
    code = code.6017 + 1;
    D.45880 = 125;
    D.46726 = D.45880 + 16;
    *code.6017 = D.46726;
    goto <D.46753>;
    <D.46751>:
    code.6018 = code;
    code = code.6018 + 1;
    D.45884 = 115;
    D.46729 = D.45884 + 16;
    *code.6018 = D.46729;
    <D.46753>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.6019 = code;
          code = code.6019 + 1;
          D.46756 = imb.b[0];
          *code.6019 = D.46756;
          code.6020 = code;
          code = code.6020 + 1;
          D.46758 = imb.b[1];
          *code.6020 = D.46758;
          code.6021 = code;
          code = code.6021 + 1;
          D.46760 = imb.b[2];
          *code.6021 = D.46760;
          code.6022 = code;
          code = code.6022 + 1;
          D.46762 = imb.b[3];
          *code.6022 = D.46762;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46740>:
    <D.46738>:
    amd64_patch (br1, code);
    goto <D.25197>;
  }
  <D.27231>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46763>; else goto <D.46764>;
  <D.46763>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.6023 = (unsigned int) offset;
    D.46766 = offset.6023 + 128;
    if (D.46766 <= 255) goto <D.46767>; else goto <D.46768>;
    <D.46767>:
    if (0 != 0) goto <D.46769>; else goto <D.46770>;
    <D.46769>:
    code.6024 = code;
    code = code.6024 + 1;
    D.45722 = 122;
    *code.6024 = D.45722;
    goto <D.46772>;
    <D.46770>:
    code.6025 = code;
    code = code.6025 + 1;
    D.45725 = 122;
    *code.6025 = D.45725;
    <D.46772>:
    D.46774 = (unsigned char) offset;
    *code = D.46774;
    code = code + 1;
    goto <D.46775>;
    <D.46768>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.6026 = code;
    code = code.6026 + 1;
    *code.6026 = 15;
    if (0 != 0) goto <D.46777>; else goto <D.46778>;
    <D.46777>:
    code.6027 = code;
    code = code.6027 + 1;
    D.45722 = 122;
    D.46237 = D.45722 + 16;
    *code.6027 = D.46237;
    goto <D.46780>;
    <D.46778>:
    code.6028 = code;
    code = code.6028 + 1;
    D.45725 = 122;
    D.46240 = D.45725 + 16;
    *code.6028 = D.46240;
    <D.46780>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.6029 = code;
          code = code.6029 + 1;
          D.46783 = imb.b[0];
          *code.6029 = D.46783;
          code.6030 = code;
          code = code.6030 + 1;
          D.46785 = imb.b[1];
          *code.6030 = D.46785;
          code.6031 = code;
          code = code.6031 + 1;
          D.46787 = imb.b[2];
          *code.6031 = D.46787;
          code.6032 = code;
          code = code.6032 + 1;
          D.46789 = imb.b[3];
          *code.6032 = D.46789;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46775>:
  }
  goto <D.46790>;
  <D.46764>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46793>; else goto <D.46791>;
  <D.46793>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46794>; else goto <D.46791>;
  <D.46794>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46795>; else goto <D.46791>;
  <D.46795>:
  if (0 != 0) goto <D.46796>; else goto <D.46797>;
  <D.46796>:
  code.6033 = code;
  code = code.6033 + 1;
  D.45722 = 122;
  *code.6033 = D.45722;
  goto <D.46799>;
  <D.46797>:
  code.6034 = code;
  code = code.6034 + 1;
  D.45725 = 122;
  *code.6034 = D.45725;
  <D.46799>:
  *code = 0;
  code = code + 1;
  goto <D.46792>;
  <D.46791>:
  code.6035 = code;
  code = code.6035 + 1;
  *code.6035 = 15;
  if (0 != 0) goto <D.46802>; else goto <D.46803>;
  <D.46802>:
  code.6036 = code;
  code = code.6036 + 1;
  D.45722 = 122;
  D.46237 = D.45722 + 16;
  *code.6036 = D.46237;
  goto <D.46805>;
  <D.46803>:
  code.6037 = code;
  code = code.6037 + 1;
  D.45725 = 122;
  D.46240 = D.45725 + 16;
  *code.6037 = D.46240;
  <D.46805>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6038 = code;
        code = code.6038 + 1;
        D.46808 = imb.b[0];
        *code.6038 = D.46808;
        code.6039 = code;
        code = code.6039 + 1;
        D.46810 = imb.b[1];
        *code.6039 = D.46810;
        code.6040 = code;
        code = code.6040 + 1;
        D.46812 = imb.b[2];
        *code.6040 = D.46812;
        code.6041 = code;
        code = code.6041 + 1;
        D.46814 = imb.b[3];
        *code.6041 = D.46814;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46792>:
  <D.46790>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39826 = D.39825->native_offset;
  if (D.39826 != 0) goto <D.46815>; else goto <D.46816>;
  <D.46815>:
  {
    int offset;

    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39834 = D.39833 + 4294967294;
    offset = (int) D.39834;
    offset.6042 = (unsigned int) offset;
    D.46818 = offset.6042 + 128;
    if (D.46818 <= 255) goto <D.46819>; else goto <D.46820>;
    <D.46819>:
    if (0 != 0) goto <D.46821>; else goto <D.46822>;
    <D.46821>:
    code.6043 = code;
    code = code.6043 + 1;
    D.45880 = 125;
    *code.6043 = D.45880;
    goto <D.46824>;
    <D.46822>:
    code.6044 = code;
    code = code.6044 + 1;
    D.45884 = 115;
    *code.6044 = D.45884;
    <D.46824>:
    D.46826 = (unsigned char) offset;
    *code = D.46826;
    code = code + 1;
    goto <D.46827>;
    <D.46820>:
    D.31283 = cfg->native_code;
    D.39824 = ins->data.op[1].many_blocks;
    D.39825 = *D.39824;
    D.39826 = D.39825->native_offset;
    D.39829 = (sizetype) D.39826;
    D.39830 = D.31283 + D.39829;
    D.39831 = (long int) D.39830;
    code.211 = (long int) code;
    D.39832 = D.39831 - code.211;
    D.39833 = (unsigned int) D.39832;
    D.39854 = D.39833 + 4294967290;
    offset = (int) D.39854;
    code.6045 = code;
    code = code.6045 + 1;
    *code.6045 = 15;
    if (0 != 0) goto <D.46829>; else goto <D.46830>;
    <D.46829>:
    code.6046 = code;
    code = code.6046 + 1;
    D.45880 = 125;
    D.46726 = D.45880 + 16;
    *code.6046 = D.46726;
    goto <D.46832>;
    <D.46830>:
    code.6047 = code;
    code = code.6047 + 1;
    D.45884 = 115;
    D.46729 = D.45884 + 16;
    *code.6047 = D.46729;
    <D.46832>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.6048 = code;
          code = code.6048 + 1;
          D.46835 = imb.b[0];
          *code.6048 = D.46835;
          code.6049 = code;
          code = code.6049 + 1;
          D.46837 = imb.b[1];
          *code.6049 = D.46837;
          code.6050 = code;
          code = code.6050 + 1;
          D.46839 = imb.b[2];
          *code.6050 = D.46839;
          code.6051 = code;
          code = code.6051 + 1;
          D.46841 = imb.b[3];
          *code.6051 = D.46841;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.46827>:
  }
  goto <D.46842>;
  <D.46816>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  mono_add_patch_info (cfg, D.36947, 0, D.39825);
  D.31286 = cfg->opt;
  D.31287 = D.31286 & 2;
  if (D.31287 != 0) goto <D.46845>; else goto <D.46843>;
  <D.46845>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 >= -128) goto <D.46846>; else goto <D.46843>;
  <D.46846>:
  D.39824 = ins->data.op[1].many_blocks;
  D.39825 = *D.39824;
  D.39883 = D.39825->max_offset;
  D.39884 = (unsigned int) D.39883;
  D.39885 = D.39884 - offset;
  D.39886 = (int) D.39885;
  if (D.39886 <= 127) goto <D.46847>; else goto <D.46843>;
  <D.46847>:
  if (0 != 0) goto <D.46848>; else goto <D.46849>;
  <D.46848>:
  code.6052 = code;
  code = code.6052 + 1;
  D.45880 = 125;
  *code.6052 = D.45880;
  goto <D.46851>;
  <D.46849>:
  code.6053 = code;
  code = code.6053 + 1;
  D.45884 = 115;
  *code.6053 = D.45884;
  <D.46851>:
  *code = 0;
  code = code + 1;
  goto <D.46844>;
  <D.46843>:
  code.6054 = code;
  code = code.6054 + 1;
  *code.6054 = 15;
  if (0 != 0) goto <D.46854>; else goto <D.46855>;
  <D.46854>:
  code.6055 = code;
  code = code.6055 + 1;
  D.45880 = 125;
  D.46726 = D.45880 + 16;
  *code.6055 = D.46726;
  goto <D.46857>;
  <D.46855>:
  code.6056 = code;
  code = code.6056 + 1;
  D.45884 = 115;
  D.46729 = D.45884 + 16;
  *code.6056 = D.46729;
  <D.46857>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6057 = code;
        code = code.6057 + 1;
        D.46860 = imb.b[0];
        *code.6057 = D.46860;
        code.6058 = code;
        code = code.6058 + 1;
        D.46862 = imb.b[1];
        *code.6058 = D.46862;
        code.6059 = code;
        code = code.6059 + 1;
        D.46864 = imb.b[2];
        *code.6059 = D.46864;
        code.6060 = code;
        code = code.6060 + 1;
        D.46866 = imb.b[3];
        *code.6060 = D.46866;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46844>:
  <D.46842>:
  goto <D.25197>;
  <D.27238>:
  if (1 != 0) goto <D.46867>; else goto <D.46868>;
  <D.46867>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.46869>; else goto <D.46870>;
    <D.46869>:
    code.6061 = code;
    code = code.6061 + 1;
    D.46872 = _amd64_rex_bits | 64;
    *code.6061 = D.46872;
    <D.46870>:
  }
  code.6062 = code;
  code = code.6062 + 1;
  *code.6062 = 131;
  code.6063 = code;
  code = code.6063 + 1;
  *code.6063 = 236;
  *code = 16;
  code = code + 1;
  goto <D.46875>;
  <D.46868>:
  if (0 != 0) goto <D.46876>; else goto <D.46877>;
  <D.46876>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.46878>; else goto <D.46879>;
    <D.46878>:
    code.6064 = code;
    code = code.6064 + 1;
    D.46881 = _amd64_rex_bits | 64;
    *code.6064 = D.46881;
    <D.46879>:
  }
  code.6065 = code;
  code = code.6065 + 1;
  *code.6065 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16;
        code.6066 = code;
        code = code.6066 + 1;
        D.46884 = imb.b[0];
        *code.6066 = D.46884;
        code.6067 = code;
        code = code.6067 + 1;
        D.46886 = imb.b[1];
        *code.6067 = D.46886;
        code.6068 = code;
        code = code.6068 + 1;
        D.46888 = imb.b[2];
        *code.6068 = D.46888;
        code.6069 = code;
        code = code.6069 + 1;
        D.46890 = imb.b[3];
        *code.6069 = D.46890;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.46891>;
  <D.46877>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.46892>; else goto <D.46893>;
    <D.46892>:
    code.6070 = code;
    code = code.6070 + 1;
    D.46895 = _amd64_rex_bits | 64;
    *code.6070 = D.46895;
    <D.46893>:
  }
  code.6071 = code;
  code = code.6071 + 1;
  *code.6071 = 129;
  code.6072 = code;
  code = code.6072 + 1;
  *code.6072 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16;
        code.6073 = code;
        code = code.6073 + 1;
        D.46899 = imb.b[0];
        *code.6073 = D.46899;
        code.6074 = code;
        code = code.6074 + 1;
        D.46901 = imb.b[1];
        *code.6074 = D.46901;
        code.6075 = code;
        code = code.6075 + 1;
        D.46903 = imb.b[2];
        *code.6075 = D.46903;
        code.6076 = code;
        code = code.6076 + 1;
        D.46905 = imb.b[3];
        *code.6076 = D.46905;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46891>:
  <D.46875>:
  code.6077 = code;
  code = code.6077 + 1;
  *code.6077 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.46908>; else goto <D.46909>;
    <D.46908>:
    iftmp.6078 = 4;
    goto <D.46910>;
    <D.46909>:
    iftmp.6078 = 0;
    <D.46910>:
    _amd64_rex_bits = iftmp.6078;
    if (_amd64_rex_bits != 0) goto <D.46911>; else goto <D.46912>;
    <D.46911>:
    code.6079 = code;
    code = code.6079 + 1;
    D.46914 = _amd64_rex_bits | 64;
    *code.6079 = D.46914;
    <D.46912>:
  }
  code.6080 = code;
  code = code.6080 + 1;
  *code.6080 = 15;
  code.6081 = code;
  code = code.6081 + 1;
  *code.6081 = 17;
  if (1 != 0) goto <D.46917>; else goto <D.46918>;
  <D.46917>:
  if (1 != 0) goto <D.46919>; else goto <D.46920>;
  <D.46919>:
  code.6082 = code;
  code = code.6082 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.6082 = D.32056;
  code.6083 = code;
  code = code.6083 + 1;
  *code.6083 = 36;
  goto <D.46923>;
  <D.46920>:
  if (1 != 0) goto <D.46924>; else goto <D.46925>;
  <D.46924>:
  code.6084 = code;
  code = code.6084 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.6084 = D.32063;
  code.6085 = code;
  code = code.6085 + 1;
  *code.6085 = 36;
  *code = 0;
  code = code + 1;
  goto <D.46928>;
  <D.46925>:
  code.6086 = code;
  code = code.6086 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.6086 = D.32068;
  code.6087 = code;
  code = code.6087 + 1;
  *code.6087 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6088 = code;
        code = code.6088 + 1;
        D.46932 = imb.b[0];
        *code.6088 = D.46932;
        code.6089 = code;
        code = code.6089 + 1;
        D.46934 = imb.b[1];
        *code.6089 = D.46934;
        code.6090 = code;
        code = code.6090 + 1;
        D.46936 = imb.b[2];
        *code.6090 = D.46936;
        code.6091 = code;
        code = code.6091 + 1;
        D.46938 = imb.b[3];
        *code.6091 = D.46938;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46928>:
  <D.46923>:
  goto <D.27246>;
  <D.46918>:
  if (1 != 0) goto <D.46939>; else goto <D.46940>;
  <D.46939>:
  code.6092 = code;
  code = code.6092 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.6092 = D.32056;
  goto <D.27246>;
  <D.46940>:
  if (1 != 0) goto <D.46942>; else goto <D.46943>;
  <D.46942>:
  code.6093 = code;
  code = code.6093 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.6093 = D.32063;
  *code = 0;
  code = code + 1;
  goto <D.46945>;
  <D.46943>:
  code.6094 = code;
  code = code.6094 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.6094 = D.32068;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6095 = code;
        code = code.6095 + 1;
        D.46948 = imb.b[0];
        *code.6095 = D.46948;
        code.6096 = code;
        code = code.6096 + 1;
        D.46950 = imb.b[1];
        *code.6096 = D.46950;
        code.6097 = code;
        code = code.6097 + 1;
        D.46952 = imb.b[2];
        *code.6097 = D.46952;
        code.6098 = code;
        code = code.6098 + 1;
        D.46954 = imb.b[3];
        *code.6098 = D.46954;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46945>:
  <D.27246>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.46955>; else goto <D.46956>;
    <D.46955>:
    code.6099 = code;
    code = code.6099 + 1;
    D.46958 = _amd64_rex_bits | 64;
    *code.6099 = D.46958;
    <D.46956>:
  }
  code.6100 = code;
  code = code.6100 + 1;
  *code.6100 = 221;
  if (0 != 0) goto <D.46960>; else goto <D.46961>;
  <D.46960>:
  code.6101 = code;
  code = code.6101 + 1;
  *code.6101 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6102 = code;
        code = code.6102 + 1;
        D.46964 = imb.b[0];
        *code.6102 = D.46964;
        code.6103 = code;
        code = code.6103 + 1;
        D.46966 = imb.b[1];
        *code.6103 = D.46966;
        code.6104 = code;
        code = code.6104 + 1;
        D.46968 = imb.b[2];
        *code.6104 = D.46968;
        code.6105 = code;
        code = code.6105 + 1;
        D.46970 = imb.b[3];
        *code.6105 = D.46970;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.46971>;
  <D.46961>:
  if (1 != 0) goto <D.46972>; else goto <D.46973>;
  <D.46972>:
  if (1 != 0) goto <D.46974>; else goto <D.46975>;
  <D.46974>:
  code.6106 = code;
  code = code.6106 + 1;
  *code.6106 = 4;
  code.6107 = code;
  code = code.6107 + 1;
  *code.6107 = 36;
  goto <D.46978>;
  <D.46975>:
  if (1 != 0) goto <D.46979>; else goto <D.46980>;
  <D.46979>:
  code.6108 = code;
  code = code.6108 + 1;
  *code.6108 = 68;
  code.6109 = code;
  code = code.6109 + 1;
  *code.6109 = 36;
  *code = 0;
  code = code + 1;
  goto <D.46983>;
  <D.46980>:
  code.6110 = code;
  code = code.6110 + 1;
  *code.6110 = 132;
  code.6111 = code;
  code = code.6111 + 1;
  *code.6111 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6112 = code;
        code = code.6112 + 1;
        D.46987 = imb.b[0];
        *code.6112 = D.46987;
        code.6113 = code;
        code = code.6113 + 1;
        D.46989 = imb.b[1];
        *code.6113 = D.46989;
        code.6114 = code;
        code = code.6114 + 1;
        D.46991 = imb.b[2];
        *code.6114 = D.46991;
        code.6115 = code;
        code = code.6115 + 1;
        D.46993 = imb.b[3];
        *code.6115 = D.46993;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.46983>:
  <D.46978>:
  goto <D.27251>;
  <D.46973>:
  if (1 != 0) goto <D.46994>; else goto <D.46995>;
  <D.46994>:
  code.6116 = code;
  code = code.6116 + 1;
  *code.6116 = 4;
  goto <D.27251>;
  <D.46995>:
  if (1 != 0) goto <D.46997>; else goto <D.46998>;
  <D.46997>:
  code.6117 = code;
  code = code.6117 + 1;
  *code.6117 = 68;
  *code = 0;
  code = code + 1;
  goto <D.47000>;
  <D.46998>:
  code.6118 = code;
  code = code.6118 + 1;
  *code.6118 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6119 = code;
        code = code.6119 + 1;
        D.47003 = imb.b[0];
        *code.6119 = D.47003;
        code.6120 = code;
        code = code.6120 + 1;
        D.47005 = imb.b[1];
        *code.6120 = D.47005;
        code.6121 = code;
        code = code.6121 + 1;
        D.47007 = imb.b[2];
        *code.6121 = D.47007;
        code.6122 = code;
        code = code.6122 + 1;
        D.47009 = imb.b[3];
        *code.6122 = D.47009;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47000>:
  <D.27251>:
  <D.46971>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.47010>; else goto <D.47011>;
    <D.47010>:
    code.6123 = code;
    code = code.6123 + 1;
    D.47013 = _amd64_rex_bits | 64;
    *code.6123 = D.47013;
    <D.47011>:
  }
  code.6124 = code;
  code = code.6124 + 1;
  *code.6124 = 80;
  code.6125 = code;
  code = code.6125 + 1;
  *code.6125 = 217;
  code.6126 = code;
  code = code.6126 + 1;
  *code.6126 = 229;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.47017>; else goto <D.47018>;
    <D.47017>:
    code.6127 = code;
    code = code.6127 + 1;
    D.47020 = _amd64_rex_bits | 64;
    *code.6127 = D.47020;
    <D.47018>:
  }
  code.6128 = code;
  code = code.6128 + 1;
  *code.6128 = 223;
  code.6129 = code;
  code = code.6129 + 1;
  *code.6129 = 224;
  if (0 != 0) goto <D.47023>; else goto <D.47024>;
  <D.47023>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47025>; else goto <D.47026>;
    <D.47025>:
    code.6130 = code;
    code = code.6130 + 1;
    D.47028 = _amd64_rex_bits | 64;
    *code.6130 = D.47028;
    <D.47026>:
  }
  code.6131 = code;
  code = code.6131 + 1;
  *code.6131 = 131;
  code.6132 = code;
  code = code.6132 + 1;
  *code.6132 = 224;
  *code = 0;
  code = code + 1;
  goto <D.47031>;
  <D.47024>:
  if (1 != 0) goto <D.47032>; else goto <D.47033>;
  <D.47032>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47034>; else goto <D.47035>;
    <D.47034>:
    code.6133 = code;
    code = code.6133 + 1;
    D.47037 = _amd64_rex_bits | 64;
    *code.6133 = D.47037;
    <D.47035>:
  }
  code.6134 = code;
  code = code.6134 + 1;
  *code.6134 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16640;
        code.6135 = code;
        code = code.6135 + 1;
        D.47040 = imb.b[0];
        *code.6135 = D.47040;
        code.6136 = code;
        code = code.6136 + 1;
        D.47042 = imb.b[1];
        *code.6136 = D.47042;
        code.6137 = code;
        code = code.6137 + 1;
        D.47044 = imb.b[2];
        *code.6137 = D.47044;
        code.6138 = code;
        code = code.6138 + 1;
        D.47046 = imb.b[3];
        *code.6138 = D.47046;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.47047>;
  <D.47033>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47048>; else goto <D.47049>;
    <D.47048>:
    code.6139 = code;
    code = code.6139 + 1;
    D.47051 = _amd64_rex_bits | 64;
    *code.6139 = D.47051;
    <D.47049>:
  }
  code.6140 = code;
  code = code.6140 + 1;
  *code.6140 = 129;
  code.6141 = code;
  code = code.6141 + 1;
  *code.6141 = 224;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16640;
        code.6142 = code;
        code = code.6142 + 1;
        D.47055 = imb.b[0];
        *code.6142 = D.47055;
        code.6143 = code;
        code = code.6143 + 1;
        D.47057 = imb.b[1];
        *code.6143 = D.47057;
        code.6144 = code;
        code = code.6144 + 1;
        D.47059 = imb.b[2];
        *code.6144 = D.47059;
        code.6145 = code;
        code = code.6145 + 1;
        D.47061 = imb.b[3];
        *code.6145 = D.47061;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47047>:
  <D.47031>:
  if (0 != 0) goto <D.47062>; else goto <D.47063>;
  <D.47062>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47064>; else goto <D.47065>;
    <D.47064>:
    code.6146 = code;
    code = code.6146 + 1;
    D.47067 = _amd64_rex_bits | 64;
    *code.6146 = D.47067;
    <D.47065>:
  }
  code.6147 = code;
  code = code.6147 + 1;
  *code.6147 = 131;
  code.6148 = code;
  code = code.6148 + 1;
  *code.6148 = 248;
  *code = 0;
  code = code + 1;
  goto <D.47070>;
  <D.47063>:
  if (1 != 0) goto <D.47071>; else goto <D.47072>;
  <D.47071>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47073>; else goto <D.47074>;
    <D.47073>:
    code.6149 = code;
    code = code.6149 + 1;
    D.47076 = _amd64_rex_bits | 64;
    *code.6149 = D.47076;
    <D.47074>:
  }
  code.6150 = code;
  code = code.6150 + 1;
  *code.6150 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.6151 = code;
        code = code.6151 + 1;
        D.47079 = imb.b[0];
        *code.6151 = D.47079;
        code.6152 = code;
        code = code.6152 + 1;
        D.47081 = imb.b[1];
        *code.6152 = D.47081;
        code.6153 = code;
        code = code.6153 + 1;
        D.47083 = imb.b[2];
        *code.6153 = D.47083;
        code.6154 = code;
        code = code.6154 + 1;
        D.47085 = imb.b[3];
        *code.6154 = D.47085;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.47086>;
  <D.47072>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47087>; else goto <D.47088>;
    <D.47087>:
    code.6155 = code;
    code = code.6155 + 1;
    D.47090 = _amd64_rex_bits | 64;
    *code.6155 = D.47090;
    <D.47088>:
  }
  code.6156 = code;
  code = code.6156 + 1;
  *code.6156 = 129;
  code.6157 = code;
  code = code.6157 + 1;
  *code.6157 = 248;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 256;
        code.6158 = code;
        code = code.6158 + 1;
        D.47094 = imb.b[0];
        *code.6158 = D.47094;
        code.6159 = code;
        code = code.6159 + 1;
        D.47096 = imb.b[1];
        *code.6159 = D.47096;
        code.6160 = code;
        code = code.6160 + 1;
        D.47098 = imb.b[2];
        *code.6160 = D.47098;
        code.6161 = code;
        code = code.6161 + 1;
        D.47100 = imb.b[3];
        *code.6161 = D.47100;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47086>:
  <D.47070>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.47101>; else goto <D.47102>;
    <D.47101>:
    code.6162 = code;
    code = code.6162 + 1;
    D.47104 = _amd64_rex_bits | 64;
    *code.6162 = D.47104;
    <D.47102>:
  }
  code.6163 = code;
  code = code.6163 + 1;
  *code.6163 = 88;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.47106>; else goto <D.47107>;
    <D.47106>:
    code.6164 = code;
    code = code.6164 + 1;
    D.47109 = _amd64_rex_bits | 64;
    *code.6164 = D.47109;
    <D.47107>:
  }
  code.6165 = code;
  code = code.6165 + 1;
  *code.6165 = 221;
  code.6166 = code;
  code = code.6166 + 1;
  *code.6166 = 216;
  {
    struct MonoInst * tins;

    tins = mono_branch_optimize_exception_target (cfg, bb, "ArithmeticException");
    if (tins == 0B) goto <D.47112>; else goto <D.47113>;
    <D.47112>:
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 9, "ArithmeticException");
    code.6167 = code;
    code = code.6167 + 1;
    *code.6167 = 15;
    if (0 != 0) goto <D.47115>; else goto <D.47116>;
    <D.47115>:
    code.6168 = code;
    code = code.6168 + 1;
    D.31526 = 116;
    D.46129 = D.31526 + 16;
    *code.6168 = D.46129;
    goto <D.47118>;
    <D.47116>:
    code.6169 = code;
    code = code.6169 + 1;
    D.31530 = 116;
    D.46132 = D.31530 + 16;
    *code.6169 = D.46132;
    <D.47118>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.6170 = code;
          code = code.6170 + 1;
          D.47121 = imb.b[0];
          *code.6170 = D.47121;
          code.6171 = code;
          code = code.6171 + 1;
          D.47123 = imb.b[1];
          *code.6171 = D.47123;
          code.6172 = code;
          code = code.6172 + 1;
          D.47125 = imb.b[2];
          *code.6172 = D.47125;
          code.6173 = code;
          code = code.6173 + 1;
          D.47127 = imb.b[3];
          *code.6173 = D.47127;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.47128>;
    <D.47113>:
    D.47129 = tins->data.op[1].many_blocks;
    D.47130 = *D.47129;
    D.47131 = D.47130->native_offset;
    if (D.47131 != 0) goto <D.47132>; else goto <D.47133>;
    <D.47132>:
    {
      int offset;

      D.31283 = cfg->native_code;
      D.47129 = tins->data.op[1].many_blocks;
      D.47130 = *D.47129;
      D.47131 = D.47130->native_offset;
      D.47134 = (sizetype) D.47131;
      D.47135 = D.31283 + D.47134;
      D.47136 = (long int) D.47135;
      code.211 = (long int) code;
      D.47137 = D.47136 - code.211;
      D.47138 = (unsigned int) D.47137;
      D.47139 = D.47138 + 4294967294;
      offset = (int) D.47139;
      offset.6174 = (unsigned int) offset;
      D.47141 = offset.6174 + 128;
      if (D.47141 <= 255) goto <D.47142>; else goto <D.47143>;
      <D.47142>:
      if (0 != 0) goto <D.47144>; else goto <D.47145>;
      <D.47144>:
      code.6175 = code;
      code = code.6175 + 1;
      D.31526 = 116;
      *code.6175 = D.31526;
      goto <D.47147>;
      <D.47145>:
      code.6176 = code;
      code = code.6176 + 1;
      D.31530 = 116;
      *code.6176 = D.31530;
      <D.47147>:
      D.47149 = (unsigned char) offset;
      *code = D.47149;
      code = code + 1;
      goto <D.47150>;
      <D.47143>:
      D.31283 = cfg->native_code;
      D.47129 = tins->data.op[1].many_blocks;
      D.47130 = *D.47129;
      D.47131 = D.47130->native_offset;
      D.47134 = (sizetype) D.47131;
      D.47135 = D.31283 + D.47134;
      D.47136 = (long int) D.47135;
      code.211 = (long int) code;
      D.47137 = D.47136 - code.211;
      D.47138 = (unsigned int) D.47137;
      D.47151 = D.47138 + 4294967290;
      offset = (int) D.47151;
      code.6177 = code;
      code = code.6177 + 1;
      *code.6177 = 15;
      if (0 != 0) goto <D.47153>; else goto <D.47154>;
      <D.47153>:
      code.6178 = code;
      code = code.6178 + 1;
      D.31526 = 116;
      D.46129 = D.31526 + 16;
      *code.6178 = D.46129;
      goto <D.47156>;
      <D.47154>:
      code.6179 = code;
      code = code.6179 + 1;
      D.31530 = 116;
      D.46132 = D.31530 + 16;
      *code.6179 = D.46132;
      <D.47156>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = offset;
            code.6180 = code;
            code = code.6180 + 1;
            D.47159 = imb.b[0];
            *code.6180 = D.47159;
            code.6181 = code;
            code = code.6181 + 1;
            D.47161 = imb.b[1];
            *code.6181 = D.47161;
            code.6182 = code;
            code = code.6182 + 1;
            D.47163 = imb.b[2];
            *code.6182 = D.47163;
            code.6183 = code;
            code = code.6183 + 1;
            D.47165 = imb.b[3];
            *code.6183 = D.47165;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.47150>:
    }
    goto <D.47166>;
    <D.47133>:
    D.47129 = tins->data.op[1].many_blocks;
    D.47130 = *D.47129;
    code.211 = (long int) code;
    D.31283 = cfg->native_code;
    D.31451 = (long int) D.31283;
    D.31452 = code.211 - D.31451;
    D.36947 = (int) D.31452;
    mono_add_patch_info (cfg, D.36947, 0, D.47130);
    D.31286 = cfg->opt;
    D.31287 = D.31286 & 2;
    if (D.31287 != 0) goto <D.47169>; else goto <D.47167>;
    <D.47169>:
    D.47129 = tins->data.op[1].many_blocks;
    D.47130 = *D.47129;
    D.47170 = D.47130->max_offset;
    D.47171 = (unsigned int) D.47170;
    D.47172 = D.47171 - offset;
    D.47173 = (int) D.47172;
    if (D.47173 >= -128) goto <D.47174>; else goto <D.47167>;
    <D.47174>:
    D.47129 = tins->data.op[1].many_blocks;
    D.47130 = *D.47129;
    D.47170 = D.47130->max_offset;
    D.47171 = (unsigned int) D.47170;
    D.47172 = D.47171 - offset;
    D.47173 = (int) D.47172;
    if (D.47173 <= 127) goto <D.47175>; else goto <D.47167>;
    <D.47175>:
    if (0 != 0) goto <D.47176>; else goto <D.47177>;
    <D.47176>:
    code.6184 = code;
    code = code.6184 + 1;
    D.31526 = 116;
    *code.6184 = D.31526;
    goto <D.47179>;
    <D.47177>:
    code.6185 = code;
    code = code.6185 + 1;
    D.31530 = 116;
    *code.6185 = D.31530;
    <D.47179>:
    *code = 0;
    code = code + 1;
    goto <D.47168>;
    <D.47167>:
    code.6186 = code;
    code = code.6186 + 1;
    *code.6186 = 15;
    if (0 != 0) goto <D.47182>; else goto <D.47183>;
    <D.47182>:
    code.6187 = code;
    code = code.6187 + 1;
    D.31526 = 116;
    D.46129 = D.31526 + 16;
    *code.6187 = D.46129;
    goto <D.47185>;
    <D.47183>:
    code.6188 = code;
    code = code.6188 + 1;
    D.31530 = 116;
    D.46132 = D.31530 + 16;
    *code.6188 = D.46132;
    <D.47185>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.6189 = code;
          code = code.6189 + 1;
          D.47188 = imb.b[0];
          *code.6189 = D.47188;
          code.6190 = code;
          code = code.6190 + 1;
          D.47190 = imb.b[1];
          *code.6190 = D.47190;
          code.6191 = code;
          code = code.6191 + 1;
          D.47192 = imb.b[2];
          *code.6191 = D.47192;
          code.6192 = code;
          code = code.6192 + 1;
          D.47194 = imb.b[3];
          *code.6192 = D.47194;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47168>:
    <D.47166>:
    <D.47128>:
  }
  if (1 != 0) goto <D.47195>; else goto <D.47196>;
  <D.47195>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47197>; else goto <D.47198>;
    <D.47197>:
    code.6193 = code;
    code = code.6193 + 1;
    D.47200 = _amd64_rex_bits | 64;
    *code.6193 = D.47200;
    <D.47198>:
  }
  code.6194 = code;
  code = code.6194 + 1;
  *code.6194 = 131;
  code.6195 = code;
  code = code.6195 + 1;
  *code.6195 = 196;
  *code = 16;
  code = code + 1;
  goto <D.47203>;
  <D.47196>:
  if (0 != 0) goto <D.47204>; else goto <D.47205>;
  <D.47204>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47206>; else goto <D.47207>;
    <D.47206>:
    code.6196 = code;
    code = code.6196 + 1;
    D.47209 = _amd64_rex_bits | 64;
    *code.6196 = D.47209;
    <D.47207>:
  }
  code.6197 = code;
  code = code.6197 + 1;
  *code.6197 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16;
        code.6198 = code;
        code = code.6198 + 1;
        D.47212 = imb.b[0];
        *code.6198 = D.47212;
        code.6199 = code;
        code = code.6199 + 1;
        D.47214 = imb.b[1];
        *code.6199 = D.47214;
        code.6200 = code;
        code = code.6200 + 1;
        D.47216 = imb.b[2];
        *code.6200 = D.47216;
        code.6201 = code;
        code = code.6201 + 1;
        D.47218 = imb.b[3];
        *code.6201 = D.47218;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.47219>;
  <D.47205>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47220>; else goto <D.47221>;
    <D.47220>:
    code.6202 = code;
    code = code.6202 + 1;
    D.47223 = _amd64_rex_bits | 64;
    *code.6202 = D.47223;
    <D.47221>:
  }
  code.6203 = code;
  code = code.6203 + 1;
  *code.6203 = 129;
  code.6204 = code;
  code = code.6204 + 1;
  *code.6204 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 16;
        code.6205 = code;
        code = code.6205 + 1;
        D.47227 = imb.b[0];
        *code.6205 = D.47227;
        code.6206 = code;
        code = code.6206 + 1;
        D.47229 = imb.b[1];
        *code.6206 = D.47229;
        code.6207 = code;
        code = code.6207 + 1;
        D.47231 = imb.b[2];
        *code.6207 = D.47231;
        code.6208 = code;
        code = code.6208 + 1;
        D.47233 = imb.b[3];
        *code.6208 = D.47233;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47219>:
  <D.47203>:
  goto <D.25197>;
  <D.27277>:
  D.31535 = ins->data.op[0].const_val;
  D.31551 = (int) D.31535;
  D.31589 = ins->dreg;
  code = mono_amd64_emit_tls_get (code, D.31589, D.31551);
  goto <D.25197>;
  <D.27278>:
  D.31516 = ins->sreg1;
  D.31589 = ins->dreg;
  code = emit_tls_get_reg (code, D.31589, D.31516);
  goto <D.25197>;
  <D.27279>:
  D.31535 = ins->data.op[0].const_val;
  D.31551 = (int) D.31535;
  D.31516 = ins->sreg1;
  code = amd64_emit_tls_set (code, D.31516, D.31551);
  goto <D.25197>;
  <D.27280>:
  D.31490 = ins->sreg2;
  D.31516 = ins->sreg1;
  code = amd64_emit_tls_set_reg (code, D.31516, D.31490);
  goto <D.25197>;
  <D.27281>:
  D.47234 = ins->backend.memory_barrier_kind;
  switch (D.47234) <default: <D.47329>, case 2: <D.27282>, case 4: <D.27283>>
  <D.27282>:
  <D.27283>:
  code.6209 = code;
  code = code.6209 + 1;
  *code.6209 = 240;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.47236>; else goto <D.47237>;
    <D.47236>:
    code.6210 = code;
    code = code.6210 + 1;
    D.47239 = _amd64_rex_bits | 64;
    *code.6210 = D.47239;
    <D.47237>:
  }
  if (1 != 0) goto <D.47240>; else goto <D.47241>;
  <D.47240>:
  code.6211 = code;
  code = code.6211 + 1;
  *code.6211 = 131;
  if (1 != 0) goto <D.47243>; else goto <D.47244>;
  <D.47243>:
  if (1 != 0) goto <D.47245>; else goto <D.47246>;
  <D.47245>:
  code.6212 = code;
  code = code.6212 + 1;
  *code.6212 = 4;
  code.6213 = code;
  code = code.6213 + 1;
  *code.6213 = 36;
  goto <D.47249>;
  <D.47246>:
  if (1 != 0) goto <D.47250>; else goto <D.47251>;
  <D.47250>:
  code.6214 = code;
  code = code.6214 + 1;
  *code.6214 = 68;
  code.6215 = code;
  code = code.6215 + 1;
  *code.6215 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47254>;
  <D.47251>:
  code.6216 = code;
  code = code.6216 + 1;
  *code.6216 = 132;
  code.6217 = code;
  code = code.6217 + 1;
  *code.6217 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6218 = code;
        code = code.6218 + 1;
        D.47258 = imb.b[0];
        *code.6218 = D.47258;
        code.6219 = code;
        code = code.6219 + 1;
        D.47260 = imb.b[1];
        *code.6219 = D.47260;
        code.6220 = code;
        code = code.6220 + 1;
        D.47262 = imb.b[2];
        *code.6220 = D.47262;
        code.6221 = code;
        code = code.6221 + 1;
        D.47264 = imb.b[3];
        *code.6221 = D.47264;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47254>:
  <D.47249>:
  goto <D.27286>;
  <D.47244>:
  if (1 != 0) goto <D.47265>; else goto <D.47266>;
  <D.47265>:
  code.6222 = code;
  code = code.6222 + 1;
  *code.6222 = 4;
  goto <D.27286>;
  <D.47266>:
  if (1 != 0) goto <D.47268>; else goto <D.47269>;
  <D.47268>:
  code.6223 = code;
  code = code.6223 + 1;
  *code.6223 = 68;
  *code = 0;
  code = code + 1;
  goto <D.47271>;
  <D.47269>:
  code.6224 = code;
  code = code.6224 + 1;
  *code.6224 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6225 = code;
        code = code.6225 + 1;
        D.47274 = imb.b[0];
        *code.6225 = D.47274;
        code.6226 = code;
        code = code.6226 + 1;
        D.47276 = imb.b[1];
        *code.6226 = D.47276;
        code.6227 = code;
        code = code.6227 + 1;
        D.47278 = imb.b[2];
        *code.6227 = D.47278;
        code.6228 = code;
        code = code.6228 + 1;
        D.47280 = imb.b[3];
        *code.6228 = D.47280;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47271>:
  <D.27286>:
  *code = 0;
  code = code + 1;
  goto <D.47281>;
  <D.47241>:
  code.6229 = code;
  code = code.6229 + 1;
  *code.6229 = 129;
  if (1 != 0) goto <D.47283>; else goto <D.47284>;
  <D.47283>:
  if (1 != 0) goto <D.47285>; else goto <D.47286>;
  <D.47285>:
  code.6230 = code;
  code = code.6230 + 1;
  *code.6230 = 4;
  code.6231 = code;
  code = code.6231 + 1;
  *code.6231 = 36;
  goto <D.47289>;
  <D.47286>:
  if (1 != 0) goto <D.47290>; else goto <D.47291>;
  <D.47290>:
  code.6232 = code;
  code = code.6232 + 1;
  *code.6232 = 68;
  code.6233 = code;
  code = code.6233 + 1;
  *code.6233 = 36;
  *code = 0;
  code = code + 1;
  goto <D.47294>;
  <D.47291>:
  code.6234 = code;
  code = code.6234 + 1;
  *code.6234 = 132;
  code.6235 = code;
  code = code.6235 + 1;
  *code.6235 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6236 = code;
        code = code.6236 + 1;
        D.47298 = imb.b[0];
        *code.6236 = D.47298;
        code.6237 = code;
        code = code.6237 + 1;
        D.47300 = imb.b[1];
        *code.6237 = D.47300;
        code.6238 = code;
        code = code.6238 + 1;
        D.47302 = imb.b[2];
        *code.6238 = D.47302;
        code.6239 = code;
        code = code.6239 + 1;
        D.47304 = imb.b[3];
        *code.6239 = D.47304;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47294>:
  <D.47289>:
  goto <D.27289>;
  <D.47284>:
  if (1 != 0) goto <D.47305>; else goto <D.47306>;
  <D.47305>:
  code.6240 = code;
  code = code.6240 + 1;
  *code.6240 = 4;
  goto <D.27289>;
  <D.47306>:
  if (1 != 0) goto <D.47308>; else goto <D.47309>;
  <D.47308>:
  code.6241 = code;
  code = code.6241 + 1;
  *code.6241 = 68;
  *code = 0;
  code = code + 1;
  goto <D.47311>;
  <D.47309>:
  code.6242 = code;
  code = code.6242 + 1;
  *code.6242 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6243 = code;
        code = code.6243 + 1;
        D.47314 = imb.b[0];
        *code.6243 = D.47314;
        code.6244 = code;
        code = code.6244 + 1;
        D.47316 = imb.b[1];
        *code.6244 = D.47316;
        code.6245 = code;
        code = code.6245 + 1;
        D.47318 = imb.b[2];
        *code.6245 = D.47318;
        code.6246 = code;
        code = code.6246 + 1;
        D.47320 = imb.b[3];
        *code.6246 = D.47320;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47311>:
  <D.27289>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.6247 = code;
        code = code.6247 + 1;
        D.47322 = imb.b[0];
        *code.6247 = D.47322;
        code.6248 = code;
        code = code.6248 + 1;
        D.47324 = imb.b[1];
        *code.6248 = D.47324;
        code.6249 = code;
        code = code.6249 + 1;
        D.47326 = imb.b[2];
        *code.6249 = D.47326;
        code.6250 = code;
        code = code.6250 + 1;
        D.47328 = imb.b[3];
        *code.6250 = D.47328;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.47281>:
  goto <D.27292>;
  <D.47329>:
  <D.27292>:
  goto <D.25197>;
  <D.27293>:
  <D.27294>:
  {
    int dreg;
    guint32 size;

    dreg = ins->dreg;
    D.31464 = ins->opcode;
    if (D.31464 == 965) goto <D.47331>; else goto <D.47332>;
    <D.47331>:
    iftmp.6251 = 4;
    goto <D.47333>;
    <D.47332>:
    iftmp.6251 = 8;
    <D.47333>:
    size = iftmp.6251;
    D.31516 = ins->sreg1;
    if (D.31516 == dreg) goto <D.47334>; else goto <D.47335>;
    <D.47334>:
    dreg = 11;
    <D.47335>:
    D.31490 = ins->sreg2;
    if (D.31490 != dreg) goto <D.47336>; else goto <D.47337>;
    <D.47336>:
    if (size == 2) goto <D.47338>; else goto <D.47339>;
    <D.47338>:
    code.6252 = code;
    code = code.6252 + 1;
    *code.6252 = 102;
    <D.47339>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47342>; else goto <D.47343>;
      <D.47342>:
      iftmp.6253 = 8;
      goto <D.47344>;
      <D.47343>:
      iftmp.6253 = 0;
      <D.47344>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.47346>; else goto <D.47347>;
      <D.47346>:
      iftmp.6254 = 4;
      goto <D.47348>;
      <D.47347>:
      iftmp.6254 = 0;
      <D.47348>:
      D.47349 = iftmp.6253 | iftmp.6254;
      D.31490 = ins->sreg2;
      D.33810 = D.31490 > 7;
      D.33811 = (signed char) D.33810;
      D.47350 = D.47349 | D.33811;
      _amd64_rex_bits = (unsigned char) D.47350;
      D.47351 = _amd64_rex_bits != 0;
      D.47352 = size == 1;
      D.47353 = D.47351 | D.47352;
      if (D.47353 != 0) goto <D.47354>; else goto <D.47355>;
      <D.47354>:
      code.6255 = code;
      code = code.6255 + 1;
      D.47357 = _amd64_rex_bits | 64;
      *code.6255 = D.47357;
      <D.47355>:
    }
    switch (size) <default: <D.27303>, case 1: <D.27298>, case 2: <D.27300>, case 4: <D.27301>, case 8: <D.27302>>
    <D.27298>:
    code.6256 = code;
    code = code.6256 + 1;
    *code.6256 = 138;
    goto <D.27299>;
    <D.27300>:
    <D.27301>:
    <D.27302>:
    code.6257 = code;
    code = code.6257 + 1;
    *code.6257 = 139;
    goto <D.27299>;
    <D.27303>:
    __assert_fail ("0", "mini-amd64.c", 5703, &__PRETTY_FUNCTION__);
    <D.27299>:
    code.6258 = code;
    code = code.6258 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.39957 = D.33725 | D.31501;
    D.39958 = (unsigned char) D.39957;
    *code.6258 = D.39958;
    <D.47337>:
    code.6259 = code;
    code = code.6259 + 1;
    *code.6259 = 240;
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47363>; else goto <D.47364>;
      <D.47363>:
      iftmp.6260 = 8;
      goto <D.47365>;
      <D.47364>:
      iftmp.6260 = 0;
      <D.47365>:
      if (dreg > 7) goto <D.47367>; else goto <D.47368>;
      <D.47367>:
      iftmp.6261 = 4;
      goto <D.47369>;
      <D.47368>:
      iftmp.6261 = 0;
      <D.47369>:
      D.47370 = iftmp.6260 | iftmp.6261;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.47371 = D.47370 | D.33180;
      _amd64_rex_bits = (unsigned char) D.47371;
      D.47372 = _amd64_rex_bits != 0;
      D.47352 = size == 1;
      D.47373 = D.47372 | D.47352;
      if (D.47373 != 0) goto <D.47374>; else goto <D.47375>;
      <D.47374>:
      code.6262 = code;
      code = code.6262 + 1;
      D.47377 = _amd64_rex_bits | 64;
      *code.6262 = D.47377;
      <D.47375>:
    }
    code.6263 = code;
    code = code.6263 + 1;
    *code.6263 = 15;
    if (size == 1) goto <D.47379>; else goto <D.47380>;
    <D.47379>:
    code.6264 = code;
    code = code.6264 + 1;
    *code.6264 = 192;
    goto <D.47382>;
    <D.47380>:
    code.6265 = code;
    code = code.6265 + 1;
    *code.6265 = 193;
    <D.47382>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.47384>; else goto <D.47385>;
    <D.47384>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.47386>; else goto <D.47387>;
    <D.47386>:
    code.6266 = code;
    code = code.6266 + 1;
    D.47389 = dreg & 7;
    D.47390 = D.47389 << 3;
    D.47391 = (signed char) D.47390;
    D.47392 = D.47391 | 4;
    D.47393 = (unsigned char) D.47392;
    *code.6266 = D.47393;
    code.6267 = code;
    code = code.6267 + 1;
    *code.6267 = 36;
    goto <D.47395>;
    <D.47387>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.47396>; else goto <D.47397>;
    <D.47396>:
    code.6268 = code;
    code = code.6268 + 1;
    D.47389 = dreg & 7;
    D.47390 = D.47389 << 3;
    D.47391 = (signed char) D.47390;
    D.47399 = D.47391 | 68;
    D.47400 = (unsigned char) D.47399;
    *code.6268 = D.47400;
    code.6269 = code;
    code = code.6269 + 1;
    *code.6269 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.47402>;
    <D.47397>:
    code.6270 = code;
    code = code.6270 + 1;
    D.47389 = dreg & 7;
    D.47390 = D.47389 << 3;
    D.47391 = (signed char) D.47390;
    D.47404 = D.47391 | -124;
    D.47405 = (unsigned char) D.47404;
    *code.6270 = D.47405;
    code.6271 = code;
    code = code.6271 + 1;
    *code.6271 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.6272 = code;
          code = code.6272 + 1;
          D.47408 = imb.b[0];
          *code.6272 = D.47408;
          code.6273 = code;
          code = code.6273 + 1;
          D.47410 = imb.b[1];
          *code.6273 = D.47410;
          code.6274 = code;
          code = code.6274 + 1;
          D.47412 = imb.b[2];
          *code.6274 = D.47412;
          code.6275 = code;
          code = code.6275 + 1;
          D.47414 = imb.b[3];
          *code.6275 = D.47414;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47402>:
    <D.47395>:
    goto <D.27306>;
    <D.47385>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.47415>; else goto <D.47416>;
    <D.47415>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.47417>; else goto <D.47418>;
    <D.47417>:
    code.6276 = code;
    code = code.6276 + 1;
    D.47389 = dreg & 7;
    D.47390 = D.47389 << 3;
    D.47391 = (signed char) D.47390;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.47420 = D.47391 | D.31571;
    D.47421 = (unsigned char) D.47420;
    *code.6276 = D.47421;
    goto <D.27306>;
    <D.47418>:
    <D.47416>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.47422>; else goto <D.47423>;
    <D.47422>:
    code.6277 = code;
    code = code.6277 + 1;
    D.47389 = dreg & 7;
    D.47390 = D.47389 << 3;
    D.47391 = (signed char) D.47390;
    D.47425 = D.47391 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.47426 = D.47425 | D.31571;
    D.47427 = (unsigned char) D.47426;
    *code.6277 = D.47427;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.47428>;
    <D.47423>:
    code.6278 = code;
    code = code.6278 + 1;
    D.47389 = dreg & 7;
    D.47390 = D.47389 << 3;
    D.47391 = (signed char) D.47390;
    D.47430 = D.47391 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.47431 = D.47430 | D.31571;
    D.47432 = (unsigned char) D.47431;
    *code.6278 = D.47432;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.6279 = code;
          code = code.6279 + 1;
          D.47434 = imb.b[0];
          *code.6279 = D.47434;
          code.6280 = code;
          code = code.6280 + 1;
          D.47436 = imb.b[1];
          *code.6280 = D.47436;
          code.6281 = code;
          code = code.6281 + 1;
          D.47438 = imb.b[2];
          *code.6281 = D.47438;
          code.6282 = code;
          code = code.6282 + 1;
          D.47440 = imb.b[3];
          *code.6282 = D.47440;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47428>:
    <D.27306>:
    D.31589 = ins->dreg;
    if (D.31589 != dreg) goto <D.47441>; else goto <D.47442>;
    <D.47441>:
    if (size == 2) goto <D.47443>; else goto <D.47444>;
    <D.47443>:
    code.6283 = code;
    code = code.6283 + 1;
    *code.6283 = 102;
    <D.47444>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47447>; else goto <D.47448>;
      <D.47447>:
      iftmp.6284 = 8;
      goto <D.47449>;
      <D.47448>:
      iftmp.6284 = 0;
      <D.47449>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.47451>; else goto <D.47452>;
      <D.47451>:
      iftmp.6285 = 4;
      goto <D.47453>;
      <D.47452>:
      iftmp.6285 = 0;
      <D.47453>:
      D.47454 = iftmp.6284 | iftmp.6285;
      D.47455 = dreg > 7;
      D.47456 = (signed char) D.47455;
      D.47457 = D.47454 | D.47456;
      _amd64_rex_bits = (unsigned char) D.47457;
      D.47458 = _amd64_rex_bits != 0;
      D.47352 = size == 1;
      D.47459 = D.47458 | D.47352;
      if (D.47459 != 0) goto <D.47460>; else goto <D.47461>;
      <D.47460>:
      code.6286 = code;
      code = code.6286 + 1;
      D.47463 = _amd64_rex_bits | 64;
      *code.6286 = D.47463;
      <D.47461>:
    }
    switch (size) <default: <D.27314>, case 1: <D.27309>, case 2: <D.27311>, case 4: <D.27312>, case 8: <D.27313>>
    <D.27309>:
    code.6287 = code;
    code = code.6287 + 1;
    *code.6287 = 138;
    goto <D.27310>;
    <D.27311>:
    <D.27312>:
    <D.27313>:
    code.6288 = code;
    code = code.6288 + 1;
    *code.6288 = 139;
    goto <D.27310>;
    <D.27314>:
    __assert_fail ("0", "mini-amd64.c", 5709, &__PRETTY_FUNCTION__);
    <D.27310>:
    code.6289 = code;
    code = code.6289 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.47467 = (signed char) dreg;
    D.47468 = D.47467 & 7;
    D.47469 = D.33725 | D.47468;
    D.47470 = (unsigned char) D.47469;
    *code.6289 = D.47470;
    <D.47442>:
    goto <D.25197>;
  }
  <D.27315>:
  <D.27316>:
  {
    int dreg;
    guint32 size;

    dreg = ins->dreg;
    D.31464 = ins->opcode;
    if (D.31464 == 966) goto <D.47472>; else goto <D.47473>;
    <D.47472>:
    iftmp.6290 = 4;
    goto <D.47474>;
    <D.47473>:
    iftmp.6290 = 8;
    <D.47474>:
    size = iftmp.6290;
    D.31490 = ins->sreg2;
    if (D.31490 == dreg) goto <D.47475>; else goto <D.47477>;
    <D.47477>:
    D.31516 = ins->sreg1;
    if (D.31516 == dreg) goto <D.47475>; else goto <D.47476>;
    <D.47475>:
    dreg = 11;
    <D.47476>:
    if (size == 2) goto <D.47478>; else goto <D.47479>;
    <D.47478>:
    code.6291 = code;
    code = code.6291 + 1;
    *code.6291 = 102;
    <D.47479>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47482>; else goto <D.47483>;
      <D.47482>:
      iftmp.6292 = 8;
      goto <D.47484>;
      <D.47483>:
      iftmp.6292 = 0;
      <D.47484>:
      if (dreg > 7) goto <D.47486>; else goto <D.47487>;
      <D.47486>:
      iftmp.6293 = 4;
      goto <D.47488>;
      <D.47487>:
      iftmp.6293 = 0;
      <D.47488>:
      D.47489 = iftmp.6292 | iftmp.6293;
      D.31490 = ins->sreg2;
      D.33810 = D.31490 > 7;
      D.33811 = (signed char) D.33810;
      D.47490 = D.47489 | D.33811;
      _amd64_rex_bits = (unsigned char) D.47490;
      D.47491 = _amd64_rex_bits != 0;
      D.47492 = size == 1;
      D.47493 = D.47491 | D.47492;
      if (D.47493 != 0) goto <D.47494>; else goto <D.47495>;
      <D.47494>:
      code.6294 = code;
      code = code.6294 + 1;
      D.47497 = _amd64_rex_bits | 64;
      *code.6294 = D.47497;
      <D.47495>:
    }
    switch (size) <default: <D.27325>, case 1: <D.27320>, case 2: <D.27322>, case 4: <D.27323>, case 8: <D.27324>>
    <D.27320>:
    code.6295 = code;
    code = code.6295 + 1;
    *code.6295 = 138;
    goto <D.27321>;
    <D.27322>:
    <D.27323>:
    <D.27324>:
    code.6296 = code;
    code = code.6296 + 1;
    *code.6296 = 139;
    goto <D.27321>;
    <D.27325>:
    __assert_fail ("0", "mini-amd64.c", 5721, &__PRETTY_FUNCTION__);
    <D.27321>:
    code.6297 = code;
    code = code.6297 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47504 = D.47503 | -64;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.47505 = D.47504 | D.31501;
    D.47506 = (unsigned char) D.47505;
    *code.6297 = D.47506;
    code.6298 = code;
    code = code.6298 + 1;
    *code.6298 = 240;
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47509>; else goto <D.47510>;
      <D.47509>:
      iftmp.6299 = 8;
      goto <D.47511>;
      <D.47510>:
      iftmp.6299 = 0;
      <D.47511>:
      if (dreg > 7) goto <D.47513>; else goto <D.47514>;
      <D.47513>:
      iftmp.6300 = 4;
      goto <D.47515>;
      <D.47514>:
      iftmp.6300 = 0;
      <D.47515>:
      D.47516 = iftmp.6299 | iftmp.6300;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.47517 = D.47516 | D.33180;
      _amd64_rex_bits = (unsigned char) D.47517;
      D.47518 = _amd64_rex_bits != 0;
      D.47492 = size == 1;
      D.47519 = D.47518 | D.47492;
      if (D.47519 != 0) goto <D.47520>; else goto <D.47521>;
      <D.47520>:
      code.6301 = code;
      code = code.6301 + 1;
      D.47523 = _amd64_rex_bits | 64;
      *code.6301 = D.47523;
      <D.47521>:
    }
    code.6302 = code;
    code = code.6302 + 1;
    *code.6302 = 15;
    if (size == 1) goto <D.47525>; else goto <D.47526>;
    <D.47525>:
    code.6303 = code;
    code = code.6303 + 1;
    *code.6303 = 192;
    goto <D.47528>;
    <D.47526>:
    code.6304 = code;
    code = code.6304 + 1;
    *code.6304 = 193;
    <D.47528>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.47530>; else goto <D.47531>;
    <D.47530>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.47532>; else goto <D.47533>;
    <D.47532>:
    code.6305 = code;
    code = code.6305 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47535 = D.47503 | 4;
    D.47536 = (unsigned char) D.47535;
    *code.6305 = D.47536;
    code.6306 = code;
    code = code.6306 + 1;
    *code.6306 = 36;
    goto <D.47538>;
    <D.47533>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.47539>; else goto <D.47540>;
    <D.47539>:
    code.6307 = code;
    code = code.6307 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47542 = D.47503 | 68;
    D.47543 = (unsigned char) D.47542;
    *code.6307 = D.47543;
    code.6308 = code;
    code = code.6308 + 1;
    *code.6308 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.47545>;
    <D.47540>:
    code.6309 = code;
    code = code.6309 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47547 = D.47503 | -124;
    D.47548 = (unsigned char) D.47547;
    *code.6309 = D.47548;
    code.6310 = code;
    code = code.6310 + 1;
    *code.6310 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.6311 = code;
          code = code.6311 + 1;
          D.47551 = imb.b[0];
          *code.6311 = D.47551;
          code.6312 = code;
          code = code.6312 + 1;
          D.47553 = imb.b[1];
          *code.6312 = D.47553;
          code.6313 = code;
          code = code.6313 + 1;
          D.47555 = imb.b[2];
          *code.6313 = D.47555;
          code.6314 = code;
          code = code.6314 + 1;
          D.47557 = imb.b[3];
          *code.6314 = D.47557;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47545>:
    <D.47538>:
    goto <D.27328>;
    <D.47531>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.47558>; else goto <D.47559>;
    <D.47558>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.47560>; else goto <D.47561>;
    <D.47560>:
    code.6315 = code;
    code = code.6315 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.47563 = D.47503 | D.31571;
    D.47564 = (unsigned char) D.47563;
    *code.6315 = D.47564;
    goto <D.27328>;
    <D.47561>:
    <D.47559>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.47565>; else goto <D.47566>;
    <D.47565>:
    code.6316 = code;
    code = code.6316 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47568 = D.47503 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.47569 = D.47568 | D.31571;
    D.47570 = (unsigned char) D.47569;
    *code.6316 = D.47570;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.47571>;
    <D.47566>:
    code.6317 = code;
    code = code.6317 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47573 = D.47503 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.47574 = D.47573 | D.31571;
    D.47575 = (unsigned char) D.47574;
    *code.6317 = D.47575;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.6318 = code;
          code = code.6318 + 1;
          D.47577 = imb.b[0];
          *code.6318 = D.47577;
          code.6319 = code;
          code = code.6319 + 1;
          D.47579 = imb.b[1];
          *code.6319 = D.47579;
          code.6320 = code;
          code = code.6320 + 1;
          D.47581 = imb.b[2];
          *code.6320 = D.47581;
          code.6321 = code;
          code = code.6321 + 1;
          D.47583 = imb.b[3];
          *code.6321 = D.47583;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47571>:
    <D.27328>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47585>; else goto <D.47586>;
      <D.47585>:
      iftmp.6322 = 8;
      goto <D.47587>;
      <D.47586>:
      iftmp.6322 = 0;
      <D.47587>:
      if (dreg > 7) goto <D.47589>; else goto <D.47590>;
      <D.47589>:
      iftmp.6323 = 4;
      goto <D.47591>;
      <D.47590>:
      iftmp.6323 = 0;
      <D.47591>:
      D.47592 = iftmp.6322 | iftmp.6323;
      D.31490 = ins->sreg2;
      D.33810 = D.31490 > 7;
      D.33811 = (signed char) D.33810;
      D.47593 = D.47592 | D.33811;
      _amd64_rex_bits = (unsigned char) D.47593;
      D.47594 = _amd64_rex_bits != 0;
      D.47492 = size == 1;
      D.47595 = D.47594 | D.47492;
      if (D.47595 != 0) goto <D.47596>; else goto <D.47597>;
      <D.47596>:
      code.6324 = code;
      code = code.6324 + 1;
      D.47599 = _amd64_rex_bits | 64;
      *code.6324 = D.47599;
      <D.47597>:
    }
    code.6325 = code;
    code = code.6325 + 1;
    *code.6325 = 3;
    code.6326 = code;
    code = code.6326 + 1;
    D.47501 = dreg & 7;
    D.47502 = D.47501 << 3;
    D.47503 = (signed char) D.47502;
    D.47504 = D.47503 | -64;
    D.31490 = ins->sreg2;
    D.31500 = (signed char) D.31490;
    D.31501 = D.31500 & 7;
    D.47505 = D.47504 | D.31501;
    D.47506 = (unsigned char) D.47505;
    *code.6326 = D.47506;
    D.31589 = ins->dreg;
    if (D.31589 != dreg) goto <D.47602>; else goto <D.47603>;
    <D.47602>:
    if (size == 2) goto <D.47604>; else goto <D.47605>;
    <D.47604>:
    code.6327 = code;
    code = code.6327 + 1;
    *code.6327 = 102;
    <D.47605>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47608>; else goto <D.47609>;
      <D.47608>:
      iftmp.6328 = 8;
      goto <D.47610>;
      <D.47609>:
      iftmp.6328 = 0;
      <D.47610>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.47612>; else goto <D.47613>;
      <D.47612>:
      iftmp.6329 = 4;
      goto <D.47614>;
      <D.47613>:
      iftmp.6329 = 0;
      <D.47614>:
      D.47615 = iftmp.6328 | iftmp.6329;
      D.47616 = dreg > 7;
      D.47617 = (signed char) D.47616;
      D.47618 = D.47615 | D.47617;
      _amd64_rex_bits = (unsigned char) D.47618;
      D.47619 = _amd64_rex_bits != 0;
      D.47492 = size == 1;
      D.47620 = D.47619 | D.47492;
      if (D.47620 != 0) goto <D.47621>; else goto <D.47622>;
      <D.47621>:
      code.6330 = code;
      code = code.6330 + 1;
      D.47624 = _amd64_rex_bits | 64;
      *code.6330 = D.47624;
      <D.47622>:
    }
    switch (size) <default: <D.27337>, case 1: <D.27332>, case 2: <D.27334>, case 4: <D.27335>, case 8: <D.27336>>
    <D.27332>:
    code.6331 = code;
    code = code.6331 + 1;
    *code.6331 = 138;
    goto <D.27333>;
    <D.27334>:
    <D.27335>:
    <D.27336>:
    code.6332 = code;
    code = code.6332 + 1;
    *code.6332 = 139;
    goto <D.27333>;
    <D.27337>:
    __assert_fail ("0", "mini-amd64.c", 5728, &__PRETTY_FUNCTION__);
    <D.27333>:
    code.6333 = code;
    code = code.6333 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.47628 = (signed char) dreg;
    D.47629 = D.47628 & 7;
    D.47630 = D.33725 | D.47629;
    D.47631 = (unsigned char) D.47630;
    *code.6333 = D.47631;
    <D.47603>:
    goto <D.25197>;
  }
  <D.27338>:
  <D.27339>:
  {
    guchar * br[2];
    int sreg2;
    int breg;
    guint32 size;
    gboolean need_push;
    gboolean rdx_pushed;

    try
      {
        sreg2 = ins->sreg2;
        breg = ins->sreg1;
        need_push = 0;
        rdx_pushed = 0;
        D.31464 = ins->opcode;
        if (D.31464 == 974) goto <D.47632>; else goto <D.47633>;
        <D.47632>:
        size = 8;
        goto <D.47634>;
        <D.47633>:
        size = 4;
        <D.47634>:
        D.31589 = ins->dreg;
        D.38557 = D.31589 != 0;
        D.38558 = (long int) D.38557;
        D.38559 = __builtin_expect (D.38558, 0);
        if (D.38559 != 0) goto <D.47635>; else goto <D.47636>;
        <D.47635>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5754, "ins->dreg == AMD64_RAX");
        <D.47636>:
        if (breg == 0) goto <D.47637>; else goto <D.47638>;
        <D.47637>:
        D.31490 = ins->sreg2;
        if (D.31490 == 0) goto <D.47639>; else goto <D.47640>;
        <D.47639>:
        need_push = 1;
        <D.47640>:
        <D.47638>:
        D.47641 = breg == 0;
        D.47642 = need_push != 0;
        D.47643 = D.47641 | D.47642;
        if (D.47643 != 0) goto <D.47644>; else goto <D.47645>;
        <D.47644>:
        if (0 != 0) goto <D.47646>; else goto <D.47647>;
        <D.47646>:
        code.6334 = code;
        code = code.6334 + 1;
        *code.6334 = 102;
        <D.47647>:
        {
          unsigned char _amd64_rex_bits;

          if (breg > 7) goto <D.47650>; else goto <D.47651>;
          <D.47650>:
          iftmp.6335 = 13;
          goto <D.47652>;
          <D.47651>:
          iftmp.6335 = 12;
          <D.47652>:
          _amd64_rex_bits = iftmp.6335;
          if (_amd64_rex_bits != 0) goto <D.47653>; else goto <D.47654>;
          <D.47653>:
          code.6336 = code;
          code = code.6336 + 1;
          D.47656 = _amd64_rex_bits | 64;
          *code.6336 = D.47656;
          <D.47654>:
        }
        switch (8) <default: <D.27352>, case 1: <D.27347>, case 2: <D.27349>, case 4: <D.27350>, case 8: <D.27351>>
        <D.27347>:
        code.6337 = code;
        code = code.6337 + 1;
        *code.6337 = 138;
        goto <D.27348>;
        <D.27349>:
        <D.27350>:
        <D.27351>:
        code.6338 = code;
        code = code.6338 + 1;
        *code.6338 = 139;
        goto <D.27348>;
        <D.27352>:
        __assert_fail ("0", "mini-amd64.c", 5762, &__PRETTY_FUNCTION__);
        <D.27348>:
        code.6339 = code;
        code = code.6339 + 1;
        D.47660 = (signed char) breg;
        D.47661 = D.47660 & 7;
        D.47662 = D.47661 | -40;
        D.47663 = (unsigned char) D.47662;
        *code.6339 = D.47663;
        breg = 11;
        <D.47645>:
        D.31490 = ins->sreg2;
        if (D.31490 == 0) goto <D.47664>; else goto <D.47665>;
        <D.47664>:
        if (breg != 11) goto <D.47666>; else goto <D.47667>;
        <D.47666>:
        if (0 != 0) goto <D.47668>; else goto <D.47669>;
        <D.47668>:
        code.6340 = code;
        code = code.6340 + 1;
        *code.6340 = 102;
        <D.47669>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 12;
          if (_amd64_rex_bits != 0) goto <D.47671>; else goto <D.47672>;
          <D.47671>:
          code.6341 = code;
          code = code.6341 + 1;
          D.47674 = _amd64_rex_bits | 64;
          *code.6341 = D.47674;
          <D.47672>:
        }
        switch (8) <default: <D.27359>, case 1: <D.27354>, case 2: <D.27356>, case 4: <D.27357>, case 8: <D.27358>>
        <D.27354>:
        code.6342 = code;
        code = code.6342 + 1;
        *code.6342 = 138;
        goto <D.27355>;
        <D.27356>:
        <D.27357>:
        <D.27358>:
        code.6343 = code;
        code = code.6343 + 1;
        *code.6343 = 139;
        goto <D.27355>;
        <D.27359>:
        __assert_fail ("0", "mini-amd64.c", 5769, &__PRETTY_FUNCTION__);
        <D.27355>:
        code.6344 = code;
        code = code.6344 + 1;
        *code.6344 = 216;
        sreg2 = 11;
        goto <D.47678>;
        <D.47667>:
        D.47679 = need_push == 0;
        D.47680 = (long int) D.47679;
        D.47681 = __builtin_expect (D.47680, 0);
        if (D.47681 != 0) goto <D.47682>; else goto <D.47683>;
        <D.47682>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5772, "need_push");
        <D.47683>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 0;
          if (_amd64_rex_bits != 0) goto <D.47684>; else goto <D.47685>;
          <D.47684>:
          code.6345 = code;
          code = code.6345 + 1;
          D.47687 = _amd64_rex_bits | 64;
          *code.6345 = D.47687;
          <D.47685>:
        }
        code.6346 = code;
        code = code.6346 + 1;
        *code.6346 = 82;
        if (size == 2) goto <D.47689>; else goto <D.47690>;
        <D.47689>:
        code.6347 = code;
        code = code.6347 + 1;
        *code.6347 = 102;
        <D.47690>:
        {
          unsigned char _amd64_rex_bits;

          if (size > 4) goto <D.47693>; else goto <D.47694>;
          <D.47693>:
          iftmp.6348 = 8;
          goto <D.47695>;
          <D.47694>:
          iftmp.6348 = 0;
          <D.47695>:
          _amd64_rex_bits = iftmp.6348;
          D.47696 = _amd64_rex_bits != 0;
          D.47697 = size == 1;
          D.47698 = D.47696 | D.47697;
          if (D.47698 != 0) goto <D.47699>; else goto <D.47700>;
          <D.47699>:
          code.6349 = code;
          code = code.6349 + 1;
          D.47702 = _amd64_rex_bits | 64;
          *code.6349 = D.47702;
          <D.47700>:
        }
        switch (size) <default: <D.27367>, case 1: <D.27362>, case 2: <D.27364>, case 4: <D.27365>, case 8: <D.27366>>
        <D.27362>:
        code.6350 = code;
        code = code.6350 + 1;
        *code.6350 = 138;
        goto <D.27363>;
        <D.27364>:
        <D.27365>:
        <D.27366>:
        code.6351 = code;
        code = code.6351 + 1;
        *code.6351 = 139;
        goto <D.27363>;
        <D.27367>:
        __assert_fail ("0", "mini-amd64.c", 5774, &__PRETTY_FUNCTION__);
        <D.27363>:
        code.6352 = code;
        code = code.6352 + 1;
        *code.6352 = 208;
        sreg2 = 2;
        rdx_pushed = 1;
        <D.47678>:
        <D.47665>:
        if (size == 2) goto <D.47706>; else goto <D.47707>;
        <D.47706>:
        code.6353 = code;
        code = code.6353 + 1;
        *code.6353 = 102;
        <D.47707>:
        {
          unsigned char _amd64_rex_bits;

          if (size > 4) goto <D.47710>; else goto <D.47711>;
          <D.47710>:
          iftmp.6354 = 8;
          goto <D.47712>;
          <D.47711>:
          iftmp.6354 = 0;
          <D.47712>:
          D.47713 = breg > 7;
          D.47714 = (signed char) D.47713;
          D.47715 = iftmp.6354 | D.47714;
          _amd64_rex_bits = (unsigned char) D.47715;
          D.47716 = _amd64_rex_bits != 0;
          D.47697 = size == 1;
          D.47717 = D.47716 | D.47697;
          if (D.47717 != 0) goto <D.47718>; else goto <D.47719>;
          <D.47718>:
          code.6355 = code;
          code = code.6355 + 1;
          D.47721 = _amd64_rex_bits | 64;
          *code.6355 = D.47721;
          <D.47719>:
        }
        switch (size) <default: <D.27374>, case 1: <D.27369>, case 2: <D.27371>, case 4: <D.27372>, case 8: <D.27373>>
        <D.27369>:
        code.6356 = code;
        code = code.6356 + 1;
        *code.6356 = 138;
        goto <D.27370>;
        <D.27371>:
        <D.27372>:
        <D.27373>:
        code.6357 = code;
        code = code.6357 + 1;
        *code.6357 = 139;
        goto <D.27370>;
        <D.27374>:
        __assert_fail ("0", "mini-amd64.c", 5780, &__PRETTY_FUNCTION__);
        <D.27370>:
        if (breg == 16) goto <D.47724>; else goto <D.47725>;
        <D.47724>:
        code.6358 = code;
        code = code.6358 + 1;
        *code.6358 = 5;
        {
          union x86_imm_buf imb;

          try
            {
              D.31535 = ins->data.op[0].const_val;
              D.31551 = (int) D.31535;
              imb.val = D.31551;
              code.6359 = code;
              code = code.6359 + 1;
              D.47728 = imb.b[0];
              *code.6359 = D.47728;
              code.6360 = code;
              code = code.6360 + 1;
              D.47730 = imb.b[1];
              *code.6360 = D.47730;
              code.6361 = code;
              code = code.6361 + 1;
              D.47732 = imb.b[2];
              *code.6361 = D.47732;
              code.6362 = code;
              code = code.6362 + 1;
              D.47734 = imb.b[3];
              *code.6362 = D.47734;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.47735>;
        <D.47725>:
        D.47736 = breg & 7;
        if (D.47736 == 4) goto <D.47737>; else goto <D.47738>;
        <D.47737>:
        D.31535 = ins->data.op[0].const_val;
        if (D.31535 == 0) goto <D.47739>; else goto <D.47740>;
        <D.47739>:
        code.6363 = code;
        code = code.6363 + 1;
        *code.6363 = 4;
        code.6364 = code;
        code = code.6364 + 1;
        *code.6364 = 36;
        goto <D.47743>;
        <D.47740>:
        D.31535 = ins->data.op[0].const_val;
        D.31541 = (unsigned int) D.31535;
        D.31542 = D.31541 + 128;
        if (D.31542 <= 255) goto <D.47744>; else goto <D.47745>;
        <D.47744>:
        code.6365 = code;
        code = code.6365 + 1;
        *code.6365 = 68;
        code.6366 = code;
        code = code.6366 + 1;
        *code.6366 = 36;
        D.31535 = ins->data.op[0].const_val;
        D.31547 = (unsigned char) D.31535;
        *code = D.31547;
        code = code + 1;
        goto <D.47748>;
        <D.47745>:
        code.6367 = code;
        code = code.6367 + 1;
        *code.6367 = 132;
        code.6368 = code;
        code = code.6368 + 1;
        *code.6368 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              D.31535 = ins->data.op[0].const_val;
              D.31551 = (int) D.31535;
              imb.val = D.31551;
              code.6369 = code;
              code = code.6369 + 1;
              D.47752 = imb.b[0];
              *code.6369 = D.47752;
              code.6370 = code;
              code = code.6370 + 1;
              D.47754 = imb.b[1];
              *code.6370 = D.47754;
              code.6371 = code;
              code = code.6371 + 1;
              D.47756 = imb.b[2];
              *code.6371 = D.47756;
              code.6372 = code;
              code = code.6372 + 1;
              D.47758 = imb.b[3];
              *code.6372 = D.47758;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.47748>:
        <D.47743>:
        goto <D.27377>;
        <D.47738>:
        D.31535 = ins->data.op[0].const_val;
        if (D.31535 == 0) goto <D.47759>; else goto <D.47760>;
        <D.47759>:
        D.47736 = breg & 7;
        if (D.47736 != 5) goto <D.47761>; else goto <D.47762>;
        <D.47761>:
        code.6373 = code;
        code = code.6373 + 1;
        D.47764 = (unsigned char) breg;
        D.47765 = D.47764 & 7;
        *code.6373 = D.47765;
        goto <D.27377>;
        <D.47762>:
        <D.47760>:
        D.31535 = ins->data.op[0].const_val;
        D.31541 = (unsigned int) D.31535;
        D.31542 = D.31541 + 128;
        if (D.31542 <= 255) goto <D.47766>; else goto <D.47767>;
        <D.47766>:
        code.6374 = code;
        code = code.6374 + 1;
        D.47660 = (signed char) breg;
        D.47661 = D.47660 & 7;
        D.47769 = D.47661 | 64;
        D.47770 = (unsigned char) D.47769;
        *code.6374 = D.47770;
        D.31535 = ins->data.op[0].const_val;
        D.31547 = (unsigned char) D.31535;
        *code = D.31547;
        code = code + 1;
        goto <D.47771>;
        <D.47767>:
        code.6375 = code;
        code = code.6375 + 1;
        D.47660 = (signed char) breg;
        D.47661 = D.47660 & 7;
        D.47773 = D.47661 | -128;
        D.47774 = (unsigned char) D.47773;
        *code.6375 = D.47774;
        {
          union x86_imm_buf imb;

          try
            {
              D.31535 = ins->data.op[0].const_val;
              D.31551 = (int) D.31535;
              imb.val = D.31551;
              code.6376 = code;
              code = code.6376 + 1;
              D.47776 = imb.b[0];
              *code.6376 = D.47776;
              code.6377 = code;
              code = code.6377 + 1;
              D.47778 = imb.b[1];
              *code.6377 = D.47778;
              code.6378 = code;
              code = code.6378 + 1;
              D.47780 = imb.b[2];
              *code.6378 = D.47780;
              code.6379 = code;
              code = code.6379 + 1;
              D.47782 = imb.b[3];
              *code.6379 = D.47782;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.47771>:
        <D.27377>:
        <D.47735>:
        br[0] = code;
        code.6380 = code;
        code = code.6380 + 1;
        *code.6380 = 240;
        {
          unsigned char _amd64_rex_bits;

          if (size > 4) goto <D.47785>; else goto <D.47786>;
          <D.47785>:
          iftmp.6381 = 8;
          goto <D.47787>;
          <D.47786>:
          iftmp.6381 = 0;
          <D.47787>:
          if (sreg2 > 7) goto <D.47789>; else goto <D.47790>;
          <D.47789>:
          iftmp.6382 = 4;
          goto <D.47791>;
          <D.47790>:
          iftmp.6382 = 0;
          <D.47791>:
          D.47792 = iftmp.6381 | iftmp.6382;
          D.47713 = breg > 7;
          D.47714 = (signed char) D.47713;
          D.47793 = D.47792 | D.47714;
          _amd64_rex_bits = (unsigned char) D.47793;
          D.47794 = _amd64_rex_bits != 0;
          D.47697 = size == 1;
          D.47795 = D.47794 | D.47697;
          if (D.47795 != 0) goto <D.47796>; else goto <D.47797>;
          <D.47796>:
          code.6383 = code;
          code = code.6383 + 1;
          D.47799 = _amd64_rex_bits | 64;
          *code.6383 = D.47799;
          <D.47797>:
        }
        code.6384 = code;
        code = code.6384 + 1;
        *code.6384 = 15;
        code.6385 = code;
        code = code.6385 + 1;
        *code.6385 = 177;
        D.47736 = breg & 7;
        if (D.47736 == 4) goto <D.47802>; else goto <D.47803>;
        <D.47802>:
        D.31535 = ins->data.op[0].const_val;
        if (D.31535 == 0) goto <D.47804>; else goto <D.47805>;
        <D.47804>:
        code.6386 = code;
        code = code.6386 + 1;
        D.47807 = sreg2 & 7;
        D.47808 = D.47807 << 3;
        D.47809 = (signed char) D.47808;
        D.47810 = D.47809 | 4;
        D.47811 = (unsigned char) D.47810;
        *code.6386 = D.47811;
        code.6387 = code;
        code = code.6387 + 1;
        *code.6387 = 36;
        goto <D.47813>;
        <D.47805>:
        D.31535 = ins->data.op[0].const_val;
        D.31541 = (unsigned int) D.31535;
        D.31542 = D.31541 + 128;
        if (D.31542 <= 255) goto <D.47814>; else goto <D.47815>;
        <D.47814>:
        code.6388 = code;
        code = code.6388 + 1;
        D.47807 = sreg2 & 7;
        D.47808 = D.47807 << 3;
        D.47809 = (signed char) D.47808;
        D.47817 = D.47809 | 68;
        D.47818 = (unsigned char) D.47817;
        *code.6388 = D.47818;
        code.6389 = code;
        code = code.6389 + 1;
        *code.6389 = 36;
        D.31535 = ins->data.op[0].const_val;
        D.31547 = (unsigned char) D.31535;
        *code = D.31547;
        code = code + 1;
        goto <D.47820>;
        <D.47815>:
        code.6390 = code;
        code = code.6390 + 1;
        D.47807 = sreg2 & 7;
        D.47808 = D.47807 << 3;
        D.47809 = (signed char) D.47808;
        D.47822 = D.47809 | -124;
        D.47823 = (unsigned char) D.47822;
        *code.6390 = D.47823;
        code.6391 = code;
        code = code.6391 + 1;
        *code.6391 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              D.31535 = ins->data.op[0].const_val;
              D.31551 = (int) D.31535;
              imb.val = D.31551;
              code.6392 = code;
              code = code.6392 + 1;
              D.47826 = imb.b[0];
              *code.6392 = D.47826;
              code.6393 = code;
              code = code.6393 + 1;
              D.47828 = imb.b[1];
              *code.6393 = D.47828;
              code.6394 = code;
              code = code.6394 + 1;
              D.47830 = imb.b[2];
              *code.6394 = D.47830;
              code.6395 = code;
              code = code.6395 + 1;
              D.47832 = imb.b[3];
              *code.6395 = D.47832;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.47820>:
        <D.47813>:
        goto <D.27381>;
        <D.47803>:
        D.31535 = ins->data.op[0].const_val;
        if (D.31535 == 0) goto <D.47833>; else goto <D.47834>;
        <D.47833>:
        D.47736 = breg & 7;
        if (D.47736 != 5) goto <D.47835>; else goto <D.47836>;
        <D.47835>:
        code.6396 = code;
        code = code.6396 + 1;
        D.47807 = sreg2 & 7;
        D.47808 = D.47807 << 3;
        D.47809 = (signed char) D.47808;
        D.47660 = (signed char) breg;
        D.47661 = D.47660 & 7;
        D.47838 = D.47809 | D.47661;
        D.47839 = (unsigned char) D.47838;
        *code.6396 = D.47839;
        goto <D.27381>;
        <D.47836>:
        <D.47834>:
        D.31535 = ins->data.op[0].const_val;
        D.31541 = (unsigned int) D.31535;
        D.31542 = D.31541 + 128;
        if (D.31542 <= 255) goto <D.47840>; else goto <D.47841>;
        <D.47840>:
        code.6397 = code;
        code = code.6397 + 1;
        D.47807 = sreg2 & 7;
        D.47808 = D.47807 << 3;
        D.47809 = (signed char) D.47808;
        D.47843 = D.47809 | 64;
        D.47660 = (signed char) breg;
        D.47661 = D.47660 & 7;
        D.47844 = D.47843 | D.47661;
        D.47845 = (unsigned char) D.47844;
        *code.6397 = D.47845;
        D.31535 = ins->data.op[0].const_val;
        D.31547 = (unsigned char) D.31535;
        *code = D.31547;
        code = code + 1;
        goto <D.47846>;
        <D.47841>:
        code.6398 = code;
        code = code.6398 + 1;
        D.47807 = sreg2 & 7;
        D.47808 = D.47807 << 3;
        D.47809 = (signed char) D.47808;
        D.47848 = D.47809 | -128;
        D.47660 = (signed char) breg;
        D.47661 = D.47660 & 7;
        D.47849 = D.47848 | D.47661;
        D.47850 = (unsigned char) D.47849;
        *code.6398 = D.47850;
        {
          union x86_imm_buf imb;

          try
            {
              D.31535 = ins->data.op[0].const_val;
              D.31551 = (int) D.31535;
              imb.val = D.31551;
              code.6399 = code;
              code = code.6399 + 1;
              D.47852 = imb.b[0];
              *code.6399 = D.47852;
              code.6400 = code;
              code = code.6400 + 1;
              D.47854 = imb.b[1];
              *code.6400 = D.47854;
              code.6401 = code;
              code = code.6401 + 1;
              D.47856 = imb.b[2];
              *code.6401 = D.47856;
              code.6402 = code;
              code = code.6402 + 1;
              D.47858 = imb.b[3];
              *code.6402 = D.47858;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.47846>:
        <D.27381>:
        br[1] = code;
        if (0 != 0) goto <D.47859>; else goto <D.47860>;
        <D.47859>:
        code.6403 = code;
        code = code.6403 + 1;
        D.45752 = 117;
        *code.6403 = D.45752;
        goto <D.47862>;
        <D.47860>:
        code.6404 = code;
        code = code.6404 + 1;
        D.45756 = 117;
        *code.6404 = D.45756;
        <D.47862>:
        *code = 255;
        code = code + 1;
        D.47864 = br[0];
        D.47865 = br[1];
        amd64_patch (D.47865, D.47864);
        if (rdx_pushed != 0) goto <D.47866>; else goto <D.47867>;
        <D.47866>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 0;
          if (_amd64_rex_bits != 0) goto <D.47868>; else goto <D.47869>;
          <D.47868>:
          code.6405 = code;
          code = code.6405 + 1;
          D.47871 = _amd64_rex_bits | 64;
          *code.6405 = D.47871;
          <D.47869>:
        }
        code.6406 = code;
        code = code.6406 + 1;
        *code.6406 = 90;
        <D.47867>:
        goto <D.25197>;
      }
    finally
      {
        br = {CLOBBER};
      }
  }
  <D.27384>:
  <D.27385>:
  {
    guint32 size;

    D.31464 = ins->opcode;
    if (D.31464 == 977) goto <D.47873>; else goto <D.47874>;
    <D.47873>:
    size = 8;
    goto <D.47875>;
    <D.47874>:
    size = 4;
    <D.47875>:
    D.47876 = ins->sreg3;
    D.47877 = D.47876 != 0;
    D.47878 = (long int) D.47877;
    D.47879 = __builtin_expect (D.47878, 0);
    if (D.47879 != 0) goto <D.47880>; else goto <D.47881>;
    <D.47880>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5805, "ins->sreg3 == AMD64_RAX");
    <D.47881>:
    D.31516 = ins->sreg1;
    D.47882 = D.31516 == 0;
    D.47883 = (long int) D.47882;
    D.47884 = __builtin_expect (D.47883, 0);
    if (D.47884 != 0) goto <D.47885>; else goto <D.47886>;
    <D.47885>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5806, "ins->sreg1 != AMD64_RAX");
    <D.47886>:
    D.31516 = ins->sreg1;
    D.31490 = ins->sreg2;
    D.47887 = D.31516 == D.31490;
    D.47888 = (long int) D.47887;
    D.47889 = __builtin_expect (D.47888, 0);
    if (D.47889 != 0) goto <D.47890>; else goto <D.47891>;
    <D.47890>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5807, "ins->sreg1 != ins->sreg2");
    <D.47891>:
    code.6407 = code;
    code = code.6407 + 1;
    *code.6407 = 240;
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47894>; else goto <D.47895>;
      <D.47894>:
      iftmp.6408 = 8;
      goto <D.47896>;
      <D.47895>:
      iftmp.6408 = 0;
      <D.47896>:
      D.31490 = ins->sreg2;
      if (D.31490 > 7) goto <D.47898>; else goto <D.47899>;
      <D.47898>:
      iftmp.6409 = 4;
      goto <D.47900>;
      <D.47899>:
      iftmp.6409 = 0;
      <D.47900>:
      D.47901 = iftmp.6408 | iftmp.6409;
      D.31516 = ins->sreg1;
      D.31517 = D.31516 > 7;
      D.33180 = (signed char) D.31517;
      D.47902 = D.47901 | D.33180;
      _amd64_rex_bits = (unsigned char) D.47902;
      D.47903 = _amd64_rex_bits != 0;
      D.47904 = size == 1;
      D.47905 = D.47903 | D.47904;
      if (D.47905 != 0) goto <D.47906>; else goto <D.47907>;
      <D.47906>:
      code.6410 = code;
      code = code.6410 + 1;
      D.47909 = _amd64_rex_bits | 64;
      *code.6410 = D.47909;
      <D.47907>:
    }
    code.6411 = code;
    code = code.6411 + 1;
    *code.6411 = 15;
    code.6412 = code;
    code = code.6412 + 1;
    *code.6412 = 177;
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 == 4) goto <D.47912>; else goto <D.47913>;
    <D.47912>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.47914>; else goto <D.47915>;
    <D.47914>:
    code.6413 = code;
    code = code.6413 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.34811 = D.33673 | 4;
    D.34812 = (unsigned char) D.34811;
    *code.6413 = D.34812;
    code.6414 = code;
    code = code.6414 + 1;
    *code.6414 = 36;
    goto <D.47918>;
    <D.47915>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.47919>; else goto <D.47920>;
    <D.47919>:
    code.6415 = code;
    code = code.6415 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.34818 = D.33673 | 68;
    D.34819 = (unsigned char) D.34818;
    *code.6415 = D.34819;
    code.6416 = code;
    code = code.6416 + 1;
    *code.6416 = 36;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.47923>;
    <D.47920>:
    code.6417 = code;
    code = code.6417 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.34823 = D.33673 | -124;
    D.34824 = (unsigned char) D.34823;
    *code.6417 = D.34824;
    code.6418 = code;
    code = code.6418 + 1;
    *code.6418 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.6419 = code;
          code = code.6419 + 1;
          D.47927 = imb.b[0];
          *code.6419 = D.47927;
          code.6420 = code;
          code = code.6420 + 1;
          D.47929 = imb.b[1];
          *code.6420 = D.47929;
          code.6421 = code;
          code = code.6421 + 1;
          D.47931 = imb.b[2];
          *code.6421 = D.47931;
          code.6422 = code;
          code = code.6422 + 1;
          D.47933 = imb.b[3];
          *code.6422 = D.47933;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47923>:
    <D.47918>:
    goto <D.27389>;
    <D.47913>:
    D.31535 = ins->data.op[0].const_val;
    if (D.31535 == 0) goto <D.47934>; else goto <D.47935>;
    <D.47934>:
    D.31516 = ins->sreg1;
    D.31532 = D.31516 & 7;
    if (D.31532 != 5) goto <D.47936>; else goto <D.47937>;
    <D.47936>:
    code.6423 = code;
    code = code.6423 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.33689 = D.33673 | D.31571;
    D.33690 = (unsigned char) D.33689;
    *code.6423 = D.33690;
    goto <D.27389>;
    <D.47937>:
    <D.47935>:
    D.31535 = ins->data.op[0].const_val;
    D.31541 = (unsigned int) D.31535;
    D.31542 = D.31541 + 128;
    if (D.31542 <= 255) goto <D.47939>; else goto <D.47940>;
    <D.47939>:
    code.6424 = code;
    code = code.6424 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.34842 = D.33673 | 64;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.34843 = D.34842 | D.31571;
    D.34844 = (unsigned char) D.34843;
    *code.6424 = D.34844;
    D.31535 = ins->data.op[0].const_val;
    D.31547 = (unsigned char) D.31535;
    *code = D.31547;
    code = code + 1;
    goto <D.47942>;
    <D.47940>:
    code.6425 = code;
    code = code.6425 + 1;
    D.31490 = ins->sreg2;
    D.33671 = D.31490 & 7;
    D.33672 = D.33671 << 3;
    D.33673 = (signed char) D.33672;
    D.34847 = D.33673 | -128;
    D.31516 = ins->sreg1;
    D.31570 = (signed char) D.31516;
    D.31571 = D.31570 & 7;
    D.34848 = D.34847 | D.31571;
    D.34849 = (unsigned char) D.34848;
    *code.6425 = D.34849;
    {
      union x86_imm_buf imb;

      try
        {
          D.31535 = ins->data.op[0].const_val;
          D.31551 = (int) D.31535;
          imb.val = D.31551;
          code.6426 = code;
          code = code.6426 + 1;
          D.47945 = imb.b[0];
          *code.6426 = D.47945;
          code.6427 = code;
          code = code.6427 + 1;
          D.47947 = imb.b[1];
          *code.6427 = D.47947;
          code.6428 = code;
          code = code.6428 + 1;
          D.47949 = imb.b[2];
          *code.6428 = D.47949;
          code.6429 = code;
          code = code.6429 + 1;
          D.47951 = imb.b[3];
          *code.6429 = D.47951;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.47942>:
    <D.27389>:
    D.31589 = ins->dreg;
    if (D.31589 != 0) goto <D.47952>; else goto <D.47953>;
    <D.47952>:
    if (size == 2) goto <D.47954>; else goto <D.47955>;
    <D.47954>:
    code.6430 = code;
    code = code.6430 + 1;
    *code.6430 = 102;
    <D.47955>:
    {
      unsigned char _amd64_rex_bits;

      if (size > 4) goto <D.47958>; else goto <D.47959>;
      <D.47958>:
      iftmp.6431 = 8;
      goto <D.47960>;
      <D.47959>:
      iftmp.6431 = 0;
      <D.47960>:
      D.31589 = ins->dreg;
      if (D.31589 > 7) goto <D.47962>; else goto <D.47963>;
      <D.47962>:
      iftmp.6432 = 4;
      goto <D.47964>;
      <D.47963>:
      iftmp.6432 = 0;
      <D.47964>:
      D.47965 = iftmp.6431 | iftmp.6432;
      _amd64_rex_bits = (unsigned char) D.47965;
      D.47966 = _amd64_rex_bits != 0;
      D.47904 = size == 1;
      D.47967 = D.47966 | D.47904;
      if (D.47967 != 0) goto <D.47968>; else goto <D.47969>;
      <D.47968>:
      code.6433 = code;
      code = code.6433 + 1;
      D.47971 = _amd64_rex_bits | 64;
      *code.6433 = D.47971;
      <D.47969>:
    }
    switch (size) <default: <D.27397>, case 1: <D.27392>, case 2: <D.27394>, case 4: <D.27395>, case 8: <D.27396>>
    <D.27392>:
    code.6434 = code;
    code = code.6434 + 1;
    *code.6434 = 138;
    goto <D.27393>;
    <D.27394>:
    <D.27395>:
    <D.27396>:
    code.6435 = code;
    code = code.6435 + 1;
    *code.6435 = 139;
    goto <D.27393>;
    <D.27397>:
    __assert_fail ("0", "mini-amd64.c", 5813, &__PRETTY_FUNCTION__);
    <D.27393>:
    code.6436 = code;
    code = code.6436 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.39676 = (unsigned char) D.33725;
    *code.6436 = D.39676;
    <D.47953>:
    goto <D.25197>;
  }
  <D.27398>:
  {
    int ptr;
    int value;
    guchar * br;
    int nursery_shift;
    int card_table_shift;
    void * card_table_mask;
    size_t nursery_size;
    void * card_table;
    guint64 nursery_start;
    guint64 shifted_nursery_start;

    try
      {
        ptr = ins->sreg1;
        value = ins->sreg2;
        br = 0B;
        card_table = mono_gc_get_card_table (&card_table_shift, &card_table_mask);
        D.47975 = mono_gc_get_nursery (&nursery_shift, &nursery_size);
        nursery_start = (guint64) D.47975;
        nursery_shift.6437 = nursery_shift;
        shifted_nursery_start = nursery_start >> nursery_shift.6437;
        D.31516 = ins->sreg1;
        if (D.31516 == 4) goto <D.47977>; else goto <D.47979>;
        <D.47979>:
        D.31490 = ins->sreg2;
        if (D.31490 == 4) goto <D.47977>; else goto <D.47978>;
        <D.47977>:
        // predicted unlikely by continue predictor.
        goto <D.27409>;
        <D.47978>:
        D.31516 = ins->sreg1;
        D.38552 = D.31516 != 0;
        D.38553 = (long int) D.38552;
        D.38554 = __builtin_expect (D.38553, 0);
        if (D.38554 != 0) goto <D.47980>; else goto <D.47981>;
        <D.47980>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5840, "ins->sreg1 == AMD64_RAX");
        <D.47981>:
        D.47982 = mono_gc_card_table_nursery_check ();
        if (D.47982 != 0) goto <D.47983>; else goto <D.47984>;
        <D.47983>:
        if (value != 2) goto <D.47985>; else goto <D.47986>;
        <D.47985>:
        if (0 != 0) goto <D.47987>; else goto <D.47988>;
        <D.47987>:
        code.6438 = code;
        code = code.6438 + 1;
        *code.6438 = 102;
        <D.47988>:
        {
          unsigned char _amd64_rex_bits;

          if (value > 7) goto <D.47991>; else goto <D.47992>;
          <D.47991>:
          iftmp.6439 = 9;
          goto <D.47993>;
          <D.47992>:
          iftmp.6439 = 8;
          <D.47993>:
          _amd64_rex_bits = iftmp.6439;
          if (_amd64_rex_bits != 0) goto <D.47994>; else goto <D.47995>;
          <D.47994>:
          code.6440 = code;
          code = code.6440 + 1;
          D.47997 = _amd64_rex_bits | 64;
          *code.6440 = D.47997;
          <D.47995>:
        }
        switch (8) <default: <D.27416>, case 1: <D.27411>, case 2: <D.27413>, case 4: <D.27414>, case 8: <D.27415>>
        <D.27411>:
        code.6441 = code;
        code = code.6441 + 1;
        *code.6441 = 138;
        goto <D.27412>;
        <D.27413>:
        <D.27414>:
        <D.27415>:
        code.6442 = code;
        code = code.6442 + 1;
        *code.6442 = 139;
        goto <D.27412>;
        <D.27416>:
        __assert_fail ("0", "mini-amd64.c", 5858, &__PRETTY_FUNCTION__);
        <D.27412>:
        code.6443 = code;
        code = code.6443 + 1;
        D.48001 = (signed char) value;
        D.48002 = D.48001 & 7;
        D.48003 = D.48002 | -48;
        D.48004 = (unsigned char) D.48003;
        *code.6443 = D.48004;
        <D.47986>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48005>; else goto <D.48006>;
          <D.48005>:
          code.6444 = code;
          code = code.6444 + 1;
          D.48008 = _amd64_rex_bits | 64;
          *code.6444 = D.48008;
          <D.48006>:
        }
        nursery_shift.6437 = nursery_shift;
        if (nursery_shift.6437 == 1) goto <D.48009>; else goto <D.48010>;
        <D.48009>:
        code.6445 = code;
        code = code.6445 + 1;
        *code.6445 = 209;
        code.6446 = code;
        code = code.6446 + 1;
        *code.6446 = 234;
        goto <D.48013>;
        <D.48010>:
        code.6447 = code;
        code = code.6447 + 1;
        *code.6447 = 193;
        code.6448 = code;
        code = code.6448 + 1;
        *code.6448 = 234;
        nursery_shift.6437 = nursery_shift;
        D.48016 = (unsigned char) nursery_shift.6437;
        *code = D.48016;
        code = code + 1;
        <D.48013>:
        D.48017 = shifted_nursery_start >> 31;
        if (D.48017 != 0) goto <D.48018>; else goto <D.48019>;
        <D.48018>:
        if (0 != 0) goto <D.48020>; else goto <D.48021>;
        <D.48020>:
        code.6449 = code;
        code = code.6449 + 1;
        *code.6449 = 102;
        <D.48021>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48023>; else goto <D.48024>;
          <D.48023>:
          code.6450 = code;
          code = code.6450 + 1;
          D.48026 = _amd64_rex_bits | 64;
          *code.6450 = D.48026;
          <D.48024>:
        }
        switch (8) <default: <D.27424>, case 1: <D.27419>, case 2: <D.27421>, case 4: <D.27422>, case 8: <D.27423>>
        <D.27419>:
        code.6451 = code;
        code = code.6451 + 1;
        *code.6451 = 136;
        goto <D.27420>;
        <D.27421>:
        <D.27422>:
        <D.27423>:
        code.6452 = code;
        code = code.6452 + 1;
        *code.6452 = 137;
        goto <D.27420>;
        <D.27424>:
        __assert_fail ("0", "mini-amd64.c", 5866, &__PRETTY_FUNCTION__);
        <D.27420>:
        if (1 != 0) goto <D.48029>; else goto <D.48030>;
        <D.48029>:
        if (0 != 0) goto <D.48031>; else goto <D.48032>;
        <D.48031>:
        code.6453 = code;
        code = code.6453 + 1;
        *code.6453 = 28;
        code.6454 = code;
        code = code.6454 + 1;
        *code.6454 = 36;
        goto <D.48035>;
        <D.48032>:
        if (1 != 0) goto <D.48036>; else goto <D.48037>;
        <D.48036>:
        code.6455 = code;
        code = code.6455 + 1;
        *code.6455 = 92;
        code.6456 = code;
        code = code.6456 + 1;
        *code.6456 = 36;
        *code = 248;
        code = code + 1;
        goto <D.48040>;
        <D.48037>:
        code.6457 = code;
        code = code.6457 + 1;
        *code.6457 = 156;
        code.6458 = code;
        code = code.6458 + 1;
        *code.6458 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.6459 = code;
              code = code.6459 + 1;
              D.48044 = imb.b[0];
              *code.6459 = D.48044;
              code.6460 = code;
              code = code.6460 + 1;
              D.48046 = imb.b[1];
              *code.6460 = D.48046;
              code.6461 = code;
              code = code.6461 + 1;
              D.48048 = imb.b[2];
              *code.6461 = D.48048;
              code.6462 = code;
              code = code.6462 + 1;
              D.48050 = imb.b[3];
              *code.6462 = D.48050;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48040>:
        <D.48035>:
        goto <D.27426>;
        <D.48030>:
        if (0 != 0) goto <D.48051>; else goto <D.48052>;
        <D.48051>:
        code.6463 = code;
        code = code.6463 + 1;
        *code.6463 = 28;
        goto <D.27426>;
        <D.48052>:
        if (1 != 0) goto <D.48054>; else goto <D.48055>;
        <D.48054>:
        code.6464 = code;
        code = code.6464 + 1;
        *code.6464 = 92;
        *code = 248;
        code = code + 1;
        goto <D.48057>;
        <D.48055>:
        code.6465 = code;
        code = code.6465 + 1;
        *code.6465 = 156;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.6466 = code;
              code = code.6466 + 1;
              D.48060 = imb.b[0];
              *code.6466 = D.48060;
              code.6467 = code;
              code = code.6467 + 1;
              D.48062 = imb.b[1];
              *code.6467 = D.48062;
              code.6468 = code;
              code = code.6468 + 1;
              D.48064 = imb.b[2];
              *code.6468 = D.48064;
              code.6469 = code;
              code = code.6469 + 1;
              D.48066 = imb.b[3];
              *code.6469 = D.48066;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48057>:
        <D.27426>:
        {
          int _amd64_width_temp;

          D.48067 = (int) shifted_nursery_start;
          D.48068 = (long unsigned int) D.48067;
          D.48069 = D.48068 == shifted_nursery_start;
          _amd64_width_temp = (int) D.48069;
          {
            unsigned char _amd64_rex_bits;

            if (_amd64_width_temp == 0) goto <D.48071>; else goto <D.48072>;
            <D.48071>:
            iftmp.6470 = 8;
            goto <D.48073>;
            <D.48072>:
            iftmp.6470 = 0;
            <D.48073>:
            _amd64_rex_bits = iftmp.6470;
            if (_amd64_rex_bits != 0) goto <D.48074>; else goto <D.48075>;
            <D.48074>:
            code.6471 = code;
            code = code.6471 + 1;
            D.48077 = _amd64_rex_bits | 64;
            *code.6471 = D.48077;
            <D.48075>:
          }
          code.6472 = code;
          code = code.6472 + 1;
          *code.6472 = 187;
          if (_amd64_width_temp == 0) goto <D.48079>; else goto <D.48080>;
          <D.48079>:
          {
            union amd64_imm_buf imb;

            try
              {
                imb.val = shifted_nursery_start;
                code.6473 = code;
                code = code.6473 + 1;
                D.48082 = imb.b[0];
                *code.6473 = D.48082;
                code.6474 = code;
                code = code.6474 + 1;
                D.48084 = imb.b[1];
                *code.6474 = D.48084;
                code.6475 = code;
                code = code.6475 + 1;
                D.48086 = imb.b[2];
                *code.6475 = D.48086;
                code.6476 = code;
                code = code.6476 + 1;
                D.48088 = imb.b[3];
                *code.6476 = D.48088;
                code.6477 = code;
                code = code.6477 + 1;
                D.48090 = imb.b[4];
                *code.6477 = D.48090;
                code.6478 = code;
                code = code.6478 + 1;
                D.48092 = imb.b[5];
                *code.6478 = D.48092;
                code.6479 = code;
                code = code.6479 + 1;
                D.48094 = imb.b[6];
                *code.6479 = D.48094;
                code.6480 = code;
                code = code.6480 + 1;
                D.48096 = imb.b[7];
                *code.6480 = D.48096;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.48097>;
          <D.48080>:
          {
            union x86_imm_buf imb;

            try
              {
                D.48067 = (int) shifted_nursery_start;
                imb.val = D.48067;
                code.6481 = code;
                code = code.6481 + 1;
                D.48099 = imb.b[0];
                *code.6481 = D.48099;
                code.6482 = code;
                code = code.6482 + 1;
                D.48101 = imb.b[1];
                *code.6482 = D.48101;
                code.6483 = code;
                code = code.6483 + 1;
                D.48103 = imb.b[2];
                *code.6483 = D.48103;
                code.6484 = code;
                code = code.6484 + 1;
                D.48105 = imb.b[3];
                *code.6484 = D.48105;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.48097>:
        }
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48106>; else goto <D.48107>;
          <D.48106>:
          code.6485 = code;
          code = code.6485 + 1;
          D.48109 = _amd64_rex_bits | 64;
          *code.6485 = D.48109;
          <D.48107>:
        }
        code.6486 = code;
        code = code.6486 + 1;
        *code.6486 = 59;
        code.6487 = code;
        code = code.6487 + 1;
        *code.6487 = 211;
        if (0 != 0) goto <D.48112>; else goto <D.48113>;
        <D.48112>:
        code.6488 = code;
        code = code.6488 + 1;
        *code.6488 = 102;
        <D.48113>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48115>; else goto <D.48116>;
          <D.48115>:
          code.6489 = code;
          code = code.6489 + 1;
          D.48118 = _amd64_rex_bits | 64;
          *code.6489 = D.48118;
          <D.48116>:
        }
        switch (8) <default: <D.27439>, case 1: <D.27434>, case 2: <D.27436>, case 4: <D.27437>, case 8: <D.27438>>
        <D.27434>:
        code.6490 = code;
        code = code.6490 + 1;
        *code.6490 = 138;
        goto <D.27435>;
        <D.27436>:
        <D.27437>:
        <D.27438>:
        code.6491 = code;
        code = code.6491 + 1;
        *code.6491 = 139;
        goto <D.27435>;
        <D.27439>:
        __assert_fail ("0", "mini-amd64.c", 5869, &__PRETTY_FUNCTION__);
        <D.27435>:
        if (0 != 0) goto <D.48121>; else goto <D.48122>;
        <D.48121>:
        code.6492 = code;
        code = code.6492 + 1;
        *code.6492 = 29;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.6493 = code;
              code = code.6493 + 1;
              D.48125 = imb.b[0];
              *code.6493 = D.48125;
              code.6494 = code;
              code = code.6494 + 1;
              D.48127 = imb.b[1];
              *code.6494 = D.48127;
              code.6495 = code;
              code = code.6495 + 1;
              D.48129 = imb.b[2];
              *code.6495 = D.48129;
              code.6496 = code;
              code = code.6496 + 1;
              D.48131 = imb.b[3];
              *code.6496 = D.48131;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.48132>;
        <D.48122>:
        if (1 != 0) goto <D.48133>; else goto <D.48134>;
        <D.48133>:
        if (0 != 0) goto <D.48135>; else goto <D.48136>;
        <D.48135>:
        code.6497 = code;
        code = code.6497 + 1;
        *code.6497 = 28;
        code.6498 = code;
        code = code.6498 + 1;
        *code.6498 = 36;
        goto <D.48139>;
        <D.48136>:
        if (1 != 0) goto <D.48140>; else goto <D.48141>;
        <D.48140>:
        code.6499 = code;
        code = code.6499 + 1;
        *code.6499 = 92;
        code.6500 = code;
        code = code.6500 + 1;
        *code.6500 = 36;
        *code = 248;
        code = code + 1;
        goto <D.48144>;
        <D.48141>:
        code.6501 = code;
        code = code.6501 + 1;
        *code.6501 = 156;
        code.6502 = code;
        code = code.6502 + 1;
        *code.6502 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.6503 = code;
              code = code.6503 + 1;
              D.48148 = imb.b[0];
              *code.6503 = D.48148;
              code.6504 = code;
              code = code.6504 + 1;
              D.48150 = imb.b[1];
              *code.6504 = D.48150;
              code.6505 = code;
              code = code.6505 + 1;
              D.48152 = imb.b[2];
              *code.6505 = D.48152;
              code.6506 = code;
              code = code.6506 + 1;
              D.48154 = imb.b[3];
              *code.6506 = D.48154;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48144>:
        <D.48139>:
        goto <D.27442>;
        <D.48134>:
        if (0 != 0) goto <D.48155>; else goto <D.48156>;
        <D.48155>:
        code.6507 = code;
        code = code.6507 + 1;
        *code.6507 = 28;
        goto <D.27442>;
        <D.48156>:
        if (1 != 0) goto <D.48158>; else goto <D.48159>;
        <D.48158>:
        code.6508 = code;
        code = code.6508 + 1;
        *code.6508 = 92;
        *code = 248;
        code = code + 1;
        goto <D.48161>;
        <D.48159>:
        code.6509 = code;
        code = code.6509 + 1;
        *code.6509 = 156;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -8;
              code.6510 = code;
              code = code.6510 + 1;
              D.48164 = imb.b[0];
              *code.6510 = D.48164;
              code.6511 = code;
              code = code.6511 + 1;
              D.48166 = imb.b[1];
              *code.6511 = D.48166;
              code.6512 = code;
              code = code.6512 + 1;
              D.48168 = imb.b[2];
              *code.6512 = D.48168;
              code.6513 = code;
              code = code.6513 + 1;
              D.48170 = imb.b[3];
              *code.6513 = D.48170;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48161>:
        <D.27442>:
        <D.48132>:
        goto <D.48171>;
        <D.48019>:
        D.48172 = (unsigned int) shifted_nursery_start;
        D.48173 = D.48172 + 128;
        if (D.48173 <= 255) goto <D.48174>; else goto <D.48175>;
        <D.48174>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48176>; else goto <D.48177>;
          <D.48176>:
          code.6514 = code;
          code = code.6514 + 1;
          D.48179 = _amd64_rex_bits | 64;
          *code.6514 = D.48179;
          <D.48177>:
        }
        code.6515 = code;
        code = code.6515 + 1;
        *code.6515 = 131;
        code.6516 = code;
        code = code.6516 + 1;
        *code.6516 = 250;
        D.48182 = (unsigned char) shifted_nursery_start;
        *code = D.48182;
        code = code + 1;
        goto <D.48183>;
        <D.48175>:
        if (0 != 0) goto <D.48184>; else goto <D.48185>;
        <D.48184>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48186>; else goto <D.48187>;
          <D.48186>:
          code.6517 = code;
          code = code.6517 + 1;
          D.48189 = _amd64_rex_bits | 64;
          *code.6517 = D.48189;
          <D.48187>:
        }
        code.6518 = code;
        code = code.6518 + 1;
        *code.6518 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              D.48067 = (int) shifted_nursery_start;
              imb.val = D.48067;
              code.6519 = code;
              code = code.6519 + 1;
              D.48192 = imb.b[0];
              *code.6519 = D.48192;
              code.6520 = code;
              code = code.6520 + 1;
              D.48194 = imb.b[1];
              *code.6520 = D.48194;
              code.6521 = code;
              code = code.6521 + 1;
              D.48196 = imb.b[2];
              *code.6521 = D.48196;
              code.6522 = code;
              code = code.6522 + 1;
              D.48198 = imb.b[3];
              *code.6522 = D.48198;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.48199>;
        <D.48185>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48200>; else goto <D.48201>;
          <D.48200>:
          code.6523 = code;
          code = code.6523 + 1;
          D.48203 = _amd64_rex_bits | 64;
          *code.6523 = D.48203;
          <D.48201>:
        }
        code.6524 = code;
        code = code.6524 + 1;
        *code.6524 = 129;
        code.6525 = code;
        code = code.6525 + 1;
        *code.6525 = 250;
        {
          union x86_imm_buf imb;

          try
            {
              D.48067 = (int) shifted_nursery_start;
              imb.val = D.48067;
              code.6526 = code;
              code = code.6526 + 1;
              D.48207 = imb.b[0];
              *code.6526 = D.48207;
              code.6527 = code;
              code = code.6527 + 1;
              D.48209 = imb.b[1];
              *code.6527 = D.48209;
              code.6528 = code;
              code = code.6528 + 1;
              D.48211 = imb.b[2];
              *code.6528 = D.48211;
              code.6529 = code;
              code = code.6529 + 1;
              D.48213 = imb.b[3];
              *code.6529 = D.48213;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48199>:
        <D.48183>:
        <D.48171>:
        br = code;
        if (0 != 0) goto <D.48214>; else goto <D.48215>;
        <D.48214>:
        code.6530 = code;
        code = code.6530 + 1;
        D.45752 = 117;
        *code.6530 = D.45752;
        goto <D.48217>;
        <D.48215>:
        code.6531 = code;
        code = code.6531 + 1;
        D.45756 = 117;
        *code.6531 = D.45756;
        <D.48217>:
        *code = 255;
        code = code + 1;
        <D.47984>:
        if (0 != 0) goto <D.48219>; else goto <D.48220>;
        <D.48219>:
        code.6532 = code;
        code = code.6532 + 1;
        *code.6532 = 102;
        <D.48220>:
        {
          unsigned char _amd64_rex_bits;

          if (ptr > 7) goto <D.48223>; else goto <D.48224>;
          <D.48223>:
          iftmp.6533 = 9;
          goto <D.48225>;
          <D.48224>:
          iftmp.6533 = 8;
          <D.48225>:
          _amd64_rex_bits = iftmp.6533;
          if (_amd64_rex_bits != 0) goto <D.48226>; else goto <D.48227>;
          <D.48226>:
          code.6534 = code;
          code = code.6534 + 1;
          D.48229 = _amd64_rex_bits | 64;
          *code.6534 = D.48229;
          <D.48227>:
        }
        switch (8) <default: <D.27455>, case 1: <D.27450>, case 2: <D.27452>, case 4: <D.27453>, case 8: <D.27454>>
        <D.27450>:
        code.6535 = code;
        code = code.6535 + 1;
        *code.6535 = 138;
        goto <D.27451>;
        <D.27452>:
        <D.27453>:
        <D.27454>:
        code.6536 = code;
        code = code.6536 + 1;
        *code.6536 = 139;
        goto <D.27451>;
        <D.27455>:
        __assert_fail ("0", "mini-amd64.c", 5875, &__PRETTY_FUNCTION__);
        <D.27451>:
        code.6537 = code;
        code = code.6537 + 1;
        D.48233 = (signed char) ptr;
        D.48234 = D.48233 & 7;
        D.48235 = D.48234 | -48;
        D.48236 = (unsigned char) D.48235;
        *code.6537 = D.48236;
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48237>; else goto <D.48238>;
          <D.48237>:
          code.6538 = code;
          code = code.6538 + 1;
          D.48240 = _amd64_rex_bits | 64;
          *code.6538 = D.48240;
          <D.48238>:
        }
        card_table_shift.6539 = card_table_shift;
        if (card_table_shift.6539 == 1) goto <D.48242>; else goto <D.48243>;
        <D.48242>:
        code.6540 = code;
        code = code.6540 + 1;
        *code.6540 = 209;
        code.6541 = code;
        code = code.6541 + 1;
        *code.6541 = 234;
        goto <D.48246>;
        <D.48243>:
        code.6542 = code;
        code = code.6542 + 1;
        *code.6542 = 193;
        code.6543 = code;
        code = code.6543 + 1;
        *code.6543 = 234;
        card_table_shift.6539 = card_table_shift;
        D.48249 = (unsigned char) card_table_shift.6539;
        *code = D.48249;
        code = code + 1;
        <D.48246>:
        card_table_mask.6544 = card_table_mask;
        if (card_table_mask.6544 != 0B) goto <D.48251>; else goto <D.48252>;
        <D.48251>:
        card_table_mask.6544 = card_table_mask;
        card_table_mask.6545 = (long int) card_table_mask.6544;
        D.48254 = (unsigned int) card_table_mask.6545;
        D.48255 = D.48254 + 128;
        if (D.48255 <= 255) goto <D.48256>; else goto <D.48257>;
        <D.48256>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48258>; else goto <D.48259>;
          <D.48258>:
          code.6546 = code;
          code = code.6546 + 1;
          D.48261 = _amd64_rex_bits | 64;
          *code.6546 = D.48261;
          <D.48259>:
        }
        code.6547 = code;
        code = code.6547 + 1;
        *code.6547 = 131;
        code.6548 = code;
        code = code.6548 + 1;
        *code.6548 = 226;
        card_table_mask.6544 = card_table_mask;
        card_table_mask.6545 = (long int) card_table_mask.6544;
        D.48264 = (unsigned char) card_table_mask.6545;
        *code = D.48264;
        code = code + 1;
        goto <D.48265>;
        <D.48257>:
        if (0 != 0) goto <D.48266>; else goto <D.48267>;
        <D.48266>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48268>; else goto <D.48269>;
          <D.48268>:
          code.6549 = code;
          code = code.6549 + 1;
          D.48271 = _amd64_rex_bits | 64;
          *code.6549 = D.48271;
          <D.48269>:
        }
        code.6550 = code;
        code = code.6550 + 1;
        *code.6550 = 37;
        {
          union x86_imm_buf imb;

          try
            {
              card_table_mask.6544 = card_table_mask;
              card_table_mask.6545 = (long int) card_table_mask.6544;
              D.48273 = (int) card_table_mask.6545;
              imb.val = D.48273;
              code.6551 = code;
              code = code.6551 + 1;
              D.48275 = imb.b[0];
              *code.6551 = D.48275;
              code.6552 = code;
              code = code.6552 + 1;
              D.48277 = imb.b[1];
              *code.6552 = D.48277;
              code.6553 = code;
              code = code.6553 + 1;
              D.48279 = imb.b[2];
              *code.6553 = D.48279;
              code.6554 = code;
              code = code.6554 + 1;
              D.48281 = imb.b[3];
              *code.6554 = D.48281;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.48282>;
        <D.48267>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.48283>; else goto <D.48284>;
          <D.48283>:
          code.6555 = code;
          code = code.6555 + 1;
          D.48286 = _amd64_rex_bits | 64;
          *code.6555 = D.48286;
          <D.48284>:
        }
        code.6556 = code;
        code = code.6556 + 1;
        *code.6556 = 129;
        code.6557 = code;
        code = code.6557 + 1;
        *code.6557 = 226;
        {
          union x86_imm_buf imb;

          try
            {
              card_table_mask.6544 = card_table_mask;
              card_table_mask.6545 = (long int) card_table_mask.6544;
              D.48273 = (int) card_table_mask.6545;
              imb.val = D.48273;
              code.6558 = code;
              code = code.6558 + 1;
              D.48290 = imb.b[0];
              *code.6558 = D.48290;
              code.6559 = code;
              code = code.6559 + 1;
              D.48292 = imb.b[1];
              *code.6559 = D.48292;
              code.6560 = code;
              code = code.6560 + 1;
              D.48294 = imb.b[2];
              *code.6560 = D.48294;
              code.6561 = code;
              code = code.6561 + 1;
              D.48296 = imb.b[3];
              *code.6561 = D.48296;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48282>:
        <D.48265>:
        <D.48252>:
        code.211 = (long int) code;
        D.31283 = cfg->native_code;
        D.31451 = (long int) D.31283;
        D.31452 = code.211 - D.31451;
        D.36947 = (int) D.31452;
        mono_add_patch_info (cfg, D.36947, 42, card_table);
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 9;
          if (_amd64_rex_bits != 0) goto <D.48297>; else goto <D.48298>;
          <D.48297>:
          code.6562 = code;
          code = code.6562 + 1;
          D.48300 = _amd64_rex_bits | 64;
          *code.6562 = D.48300;
          <D.48298>:
        }
        code.6563 = code;
        code = code.6563 + 1;
        *code.6563 = 3;
        if (1 != 0) goto <D.48302>; else goto <D.48303>;
        <D.48302>:
        code.6564 = code;
        code = code.6564 + 1;
        *code.6564 = 21;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6565 = code;
              code = code.6565 + 1;
              D.48306 = imb.b[0];
              *code.6565 = D.48306;
              code.6566 = code;
              code = code.6566 + 1;
              D.48308 = imb.b[1];
              *code.6566 = D.48308;
              code.6567 = code;
              code = code.6567 + 1;
              D.48310 = imb.b[2];
              *code.6567 = D.48310;
              code.6568 = code;
              code = code.6568 + 1;
              D.48312 = imb.b[3];
              *code.6568 = D.48312;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.48313>;
        <D.48303>:
        if (0 != 0) goto <D.48314>; else goto <D.48315>;
        <D.48314>:
        if (1 != 0) goto <D.48316>; else goto <D.48317>;
        <D.48316>:
        code.6569 = code;
        code = code.6569 + 1;
        *code.6569 = 20;
        code.6570 = code;
        code = code.6570 + 1;
        *code.6570 = 36;
        goto <D.48320>;
        <D.48317>:
        if (1 != 0) goto <D.48321>; else goto <D.48322>;
        <D.48321>:
        code.6571 = code;
        code = code.6571 + 1;
        *code.6571 = 84;
        code.6572 = code;
        code = code.6572 + 1;
        *code.6572 = 36;
        *code = 0;
        code = code + 1;
        goto <D.48325>;
        <D.48322>:
        code.6573 = code;
        code = code.6573 + 1;
        *code.6573 = 148;
        code.6574 = code;
        code = code.6574 + 1;
        *code.6574 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6575 = code;
              code = code.6575 + 1;
              D.48329 = imb.b[0];
              *code.6575 = D.48329;
              code.6576 = code;
              code = code.6576 + 1;
              D.48331 = imb.b[1];
              *code.6576 = D.48331;
              code.6577 = code;
              code = code.6577 + 1;
              D.48333 = imb.b[2];
              *code.6577 = D.48333;
              code.6578 = code;
              code = code.6578 + 1;
              D.48335 = imb.b[3];
              *code.6578 = D.48335;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48325>:
        <D.48320>:
        goto <D.27465>;
        <D.48315>:
        if (1 != 0) goto <D.48336>; else goto <D.48337>;
        <D.48336>:
        code.6579 = code;
        code = code.6579 + 1;
        *code.6579 = 16;
        goto <D.27465>;
        <D.48337>:
        if (1 != 0) goto <D.48339>; else goto <D.48340>;
        <D.48339>:
        code.6580 = code;
        code = code.6580 + 1;
        *code.6580 = 80;
        *code = 0;
        code = code + 1;
        goto <D.48342>;
        <D.48340>:
        code.6581 = code;
        code = code.6581 + 1;
        *code.6581 = 144;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6582 = code;
              code = code.6582 + 1;
              D.48345 = imb.b[0];
              *code.6582 = D.48345;
              code.6583 = code;
              code = code.6583 + 1;
              D.48347 = imb.b[1];
              *code.6583 = D.48347;
              code.6584 = code;
              code = code.6584 + 1;
              D.48349 = imb.b[2];
              *code.6584 = D.48349;
              code.6585 = code;
              code = code.6585 + 1;
              D.48351 = imb.b[3];
              *code.6585 = D.48351;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48342>:
        <D.27465>:
        <D.48313>:
        if (0 != 0) goto <D.48352>; else goto <D.48353>;
        <D.48352>:
        code.6586 = code;
        code = code.6586 + 1;
        *code.6586 = 102;
        <D.48353>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 0;
          if (_amd64_rex_bits != 0) goto <D.48355>; else goto <D.48356>;
          <D.48355>:
          code.6587 = code;
          code = code.6587 + 1;
          D.48358 = _amd64_rex_bits | 64;
          *code.6587 = D.48358;
          <D.48356>:
        }
        if (1 != 0) goto <D.48359>; else goto <D.48360>;
        <D.48359>:
        code.6588 = code;
        code = code.6588 + 1;
        *code.6588 = 198;
        if (0 != 0) goto <D.48362>; else goto <D.48363>;
        <D.48362>:
        if (1 != 0) goto <D.48364>; else goto <D.48365>;
        <D.48364>:
        code.6589 = code;
        code = code.6589 + 1;
        *code.6589 = 4;
        code.6590 = code;
        code = code.6590 + 1;
        *code.6590 = 36;
        goto <D.48368>;
        <D.48365>:
        if (1 != 0) goto <D.48369>; else goto <D.48370>;
        <D.48369>:
        code.6591 = code;
        code = code.6591 + 1;
        *code.6591 = 68;
        code.6592 = code;
        code = code.6592 + 1;
        *code.6592 = 36;
        *code = 0;
        code = code + 1;
        goto <D.48373>;
        <D.48370>:
        code.6593 = code;
        code = code.6593 + 1;
        *code.6593 = 132;
        code.6594 = code;
        code = code.6594 + 1;
        *code.6594 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6595 = code;
              code = code.6595 + 1;
              D.48377 = imb.b[0];
              *code.6595 = D.48377;
              code.6596 = code;
              code = code.6596 + 1;
              D.48379 = imb.b[1];
              *code.6596 = D.48379;
              code.6597 = code;
              code = code.6597 + 1;
              D.48381 = imb.b[2];
              *code.6597 = D.48381;
              code.6598 = code;
              code = code.6598 + 1;
              D.48383 = imb.b[3];
              *code.6598 = D.48383;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48373>:
        <D.48368>:
        goto <D.27469>;
        <D.48363>:
        if (1 != 0) goto <D.48384>; else goto <D.48385>;
        <D.48384>:
        code.6599 = code;
        code = code.6599 + 1;
        *code.6599 = 2;
        goto <D.27469>;
        <D.48385>:
        if (1 != 0) goto <D.48387>; else goto <D.48388>;
        <D.48387>:
        code.6600 = code;
        code = code.6600 + 1;
        *code.6600 = 66;
        *code = 0;
        code = code + 1;
        goto <D.48390>;
        <D.48388>:
        code.6601 = code;
        code = code.6601 + 1;
        *code.6601 = 130;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6602 = code;
              code = code.6602 + 1;
              D.48393 = imb.b[0];
              *code.6602 = D.48393;
              code.6603 = code;
              code = code.6603 + 1;
              D.48395 = imb.b[1];
              *code.6603 = D.48395;
              code.6604 = code;
              code = code.6604 + 1;
              D.48397 = imb.b[2];
              *code.6604 = D.48397;
              code.6605 = code;
              code = code.6605 + 1;
              D.48399 = imb.b[3];
              *code.6605 = D.48399;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48390>:
        <D.27469>:
        *code = 1;
        code = code + 1;
        goto <D.48400>;
        <D.48360>:
        if (0 != 0) goto <D.48401>; else goto <D.48402>;
        <D.48401>:
        code.6606 = code;
        code = code.6606 + 1;
        *code.6606 = 199;
        if (0 != 0) goto <D.48404>; else goto <D.48405>;
        <D.48404>:
        if (1 != 0) goto <D.48406>; else goto <D.48407>;
        <D.48406>:
        code.6607 = code;
        code = code.6607 + 1;
        *code.6607 = 4;
        code.6608 = code;
        code = code.6608 + 1;
        *code.6608 = 36;
        goto <D.48410>;
        <D.48407>:
        if (1 != 0) goto <D.48411>; else goto <D.48412>;
        <D.48411>:
        code.6609 = code;
        code = code.6609 + 1;
        *code.6609 = 68;
        code.6610 = code;
        code = code.6610 + 1;
        *code.6610 = 36;
        *code = 0;
        code = code + 1;
        goto <D.48415>;
        <D.48412>:
        code.6611 = code;
        code = code.6611 + 1;
        *code.6611 = 132;
        code.6612 = code;
        code = code.6612 + 1;
        *code.6612 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6613 = code;
              code = code.6613 + 1;
              D.48419 = imb.b[0];
              *code.6613 = D.48419;
              code.6614 = code;
              code = code.6614 + 1;
              D.48421 = imb.b[1];
              *code.6614 = D.48421;
              code.6615 = code;
              code = code.6615 + 1;
              D.48423 = imb.b[2];
              *code.6615 = D.48423;
              code.6616 = code;
              code = code.6616 + 1;
              D.48425 = imb.b[3];
              *code.6616 = D.48425;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48415>:
        <D.48410>:
        goto <D.27472>;
        <D.48405>:
        if (1 != 0) goto <D.48426>; else goto <D.48427>;
        <D.48426>:
        code.6617 = code;
        code = code.6617 + 1;
        *code.6617 = 2;
        goto <D.27472>;
        <D.48427>:
        if (1 != 0) goto <D.48429>; else goto <D.48430>;
        <D.48429>:
        code.6618 = code;
        code = code.6618 + 1;
        *code.6618 = 66;
        *code = 0;
        code = code + 1;
        goto <D.48432>;
        <D.48430>:
        code.6619 = code;
        code = code.6619 + 1;
        *code.6619 = 130;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6620 = code;
              code = code.6620 + 1;
              D.48435 = imb.b[0];
              *code.6620 = D.48435;
              code.6621 = code;
              code = code.6621 + 1;
              D.48437 = imb.b[1];
              *code.6621 = D.48437;
              code.6622 = code;
              code = code.6622 + 1;
              D.48439 = imb.b[2];
              *code.6622 = D.48439;
              code.6623 = code;
              code = code.6623 + 1;
              D.48441 = imb.b[3];
              *code.6623 = D.48441;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48432>:
        <D.27472>:
        MEM[(short int *)code] = 1;
        code = code + 2;
        goto <D.48442>;
        <D.48402>:
        code.6624 = code;
        code = code.6624 + 1;
        *code.6624 = 199;
        if (0 != 0) goto <D.48444>; else goto <D.48445>;
        <D.48444>:
        if (1 != 0) goto <D.48446>; else goto <D.48447>;
        <D.48446>:
        code.6625 = code;
        code = code.6625 + 1;
        *code.6625 = 4;
        code.6626 = code;
        code = code.6626 + 1;
        *code.6626 = 36;
        goto <D.48450>;
        <D.48447>:
        if (1 != 0) goto <D.48451>; else goto <D.48452>;
        <D.48451>:
        code.6627 = code;
        code = code.6627 + 1;
        *code.6627 = 68;
        code.6628 = code;
        code = code.6628 + 1;
        *code.6628 = 36;
        *code = 0;
        code = code + 1;
        goto <D.48455>;
        <D.48452>:
        code.6629 = code;
        code = code.6629 + 1;
        *code.6629 = 132;
        code.6630 = code;
        code = code.6630 + 1;
        *code.6630 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6631 = code;
              code = code.6631 + 1;
              D.48459 = imb.b[0];
              *code.6631 = D.48459;
              code.6632 = code;
              code = code.6632 + 1;
              D.48461 = imb.b[1];
              *code.6632 = D.48461;
              code.6633 = code;
              code = code.6633 + 1;
              D.48463 = imb.b[2];
              *code.6633 = D.48463;
              code.6634 = code;
              code = code.6634 + 1;
              D.48465 = imb.b[3];
              *code.6634 = D.48465;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48455>:
        <D.48450>:
        goto <D.27475>;
        <D.48445>:
        if (1 != 0) goto <D.48466>; else goto <D.48467>;
        <D.48466>:
        code.6635 = code;
        code = code.6635 + 1;
        *code.6635 = 2;
        goto <D.27475>;
        <D.48467>:
        if (1 != 0) goto <D.48469>; else goto <D.48470>;
        <D.48469>:
        code.6636 = code;
        code = code.6636 + 1;
        *code.6636 = 66;
        *code = 0;
        code = code + 1;
        goto <D.48472>;
        <D.48470>:
        code.6637 = code;
        code = code.6637 + 1;
        *code.6637 = 130;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.6638 = code;
              code = code.6638 + 1;
              D.48475 = imb.b[0];
              *code.6638 = D.48475;
              code.6639 = code;
              code = code.6639 + 1;
              D.48477 = imb.b[1];
              *code.6639 = D.48477;
              code.6640 = code;
              code = code.6640 + 1;
              D.48479 = imb.b[2];
              *code.6640 = D.48479;
              code.6641 = code;
              code = code.6641 + 1;
              D.48481 = imb.b[3];
              *code.6641 = D.48481;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48472>:
        <D.27475>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 1;
              code.6642 = code;
              code = code.6642 + 1;
              D.48483 = imb.b[0];
              *code.6642 = D.48483;
              code.6643 = code;
              code = code.6643 + 1;
              D.48485 = imb.b[1];
              *code.6643 = D.48485;
              code.6644 = code;
              code = code.6644 + 1;
              D.48487 = imb.b[2];
              *code.6644 = D.48487;
              code.6645 = code;
              code = code.6645 + 1;
              D.48489 = imb.b[3];
              *code.6645 = D.48489;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.48442>:
        <D.48400>:
        D.48490 = mono_gc_card_table_nursery_check ();
        if (D.48490 != 0) goto <D.48491>; else goto <D.48492>;
        <D.48491>:
        {
          unsigned char * pos;
          int disp;
          int size;

          pos = br + 1;
          size = 0;
          D.48493 = MEM[(unsigned char *)br];
          D.48494 = (int) D.48493;
          switch (D.48494) <default: <D.27505>, case 15: <D.27484>, case 112: <D.27489>, case 113: <D.27490>, case 114: <D.27491>, case 115: <D.27492>, case 116: <D.27493>, case 117: <D.27494>, case 118: <D.27495>, case 119: <D.27496>, case 120: <D.27497>, case 121: <D.27498>, case 122: <D.27499>, case 123: <D.27500>, case 124: <D.27501>, case 125: <D.27502>, case 126: <D.27503>, case 127: <D.27504>, case 224: <D.27485>, case 225: <D.27486>, case 226: <D.27487>, case 232: <D.27481>, case 233: <D.27482>, case 235: <D.27488>>
          <D.27481>:
          <D.27482>:
          size = size + 1;
          goto <D.27483>;
          <D.27484>:
          D.48495 = *pos;
          D.48496 = D.48495 + 144;
          if (D.48496 > 31) goto <D.48497>; else goto <D.48498>;
          <D.48497>:
          __assert_fail ("0", "mini-amd64.c", 5886, &__PRETTY_FUNCTION__);
          <D.48498>:
          size = size + 1;
          pos = pos + 1;
          goto <D.27483>;
          <D.27485>:
          <D.27486>:
          <D.27487>:
          <D.27488>:
          <D.27489>:
          <D.27490>:
          <D.27491>:
          <D.27492>:
          <D.27493>:
          <D.27494>:
          <D.27495>:
          <D.27496>:
          <D.27497>:
          <D.27498>:
          <D.27499>:
          <D.27500>:
          <D.27501>:
          <D.27502>:
          <D.27503>:
          <D.27504>:
          goto <D.27483>;
          <D.27505>:
          __assert_fail ("0", "mini-amd64.c", 5886, &__PRETTY_FUNCTION__);
          <D.27483>:
          code.211 = (long int) code;
          pos.6646 = (long int) pos;
          D.48500 = code.211 - pos.6646;
          disp = (int) D.48500;
          if (size != 0) goto <D.48501>; else goto <D.48502>;
          <D.48501>:
          {
            union x86_imm_buf imb;

            try
              {
                D.48503 = disp + -4;
                imb.val = D.48503;
                pos.6647 = pos;
                pos = pos.6647 + 1;
                D.48505 = imb.b[0];
                *pos.6647 = D.48505;
                pos.6648 = pos;
                pos = pos.6648 + 1;
                D.48507 = imb.b[1];
                *pos.6648 = D.48507;
                pos.6649 = pos;
                pos = pos.6649 + 1;
                D.48509 = imb.b[2];
                *pos.6649 = D.48509;
                pos.6650 = pos;
                pos = pos.6650 + 1;
                D.48511 = imb.b[3];
                *pos.6650 = D.48511;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.48512>;
          <D.48502>:
          disp.6651 = (unsigned int) disp;
          D.48514 = disp.6651 + 127;
          if (D.48514 <= 255) goto <D.48515>; else goto <D.48516>;
          <D.48515>:
          D.48517 = (unsigned char) disp;
          D.48518 = D.48517 + 255;
          *pos = D.48518;
          pos = pos + 1;
          goto <D.48519>;
          <D.48516>:
          __assert_fail ("0", "mini-amd64.c", 5886, &__PRETTY_FUNCTION__);
          <D.48519>:
          <D.48512>:
        }
        <D.48492>:
        goto <D.25197>;
      }
    finally
      {
        nursery_shift = {CLOBBER};
        card_table_shift = {CLOBBER};
        card_table_mask = {CLOBBER};
        nursery_size = {CLOBBER};
      }
  }
  <D.27507>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48521>; else goto <D.48522>;
    <D.48521>:
    iftmp.6652 = 4;
    goto <D.48523>;
    <D.48522>:
    iftmp.6652 = 0;
    <D.48523>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48524 = iftmp.6652 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48524;
    if (_amd64_rex_bits != 0) goto <D.48525>; else goto <D.48526>;
    <D.48525>:
    code.6653 = code;
    code = code.6653 + 1;
    D.48528 = _amd64_rex_bits | 64;
    *code.6653 = D.48528;
    <D.48526>:
  }
  code.6654 = code;
  code = code.6654 + 1;
  *code.6654 = 15;
  code.6655 = code;
  code = code.6655 + 1;
  *code.6655 = 88;
  code.6656 = code;
  code = code.6656 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6656 = D.33821;
  goto <D.25197>;
  <D.27509>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48533>; else goto <D.48534>;
    <D.48533>:
    iftmp.6657 = 4;
    goto <D.48535>;
    <D.48534>:
    iftmp.6657 = 0;
    <D.48535>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48536 = iftmp.6657 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48536;
    if (_amd64_rex_bits != 0) goto <D.48537>; else goto <D.48538>;
    <D.48537>:
    code.6658 = code;
    code = code.6658 + 1;
    D.48540 = _amd64_rex_bits | 64;
    *code.6658 = D.48540;
    <D.48538>:
  }
  code.6659 = code;
  code = code.6659 + 1;
  *code.6659 = 15;
  code.6660 = code;
  code = code.6660 + 1;
  *code.6660 = 94;
  code.6661 = code;
  code = code.6661 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6661 = D.33821;
  goto <D.25197>;
  <D.27511>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48545>; else goto <D.48546>;
    <D.48545>:
    iftmp.6662 = 4;
    goto <D.48547>;
    <D.48546>:
    iftmp.6662 = 0;
    <D.48547>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48548 = iftmp.6662 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48548;
    if (_amd64_rex_bits != 0) goto <D.48549>; else goto <D.48550>;
    <D.48549>:
    code.6663 = code;
    code = code.6663 + 1;
    D.48552 = _amd64_rex_bits | 64;
    *code.6663 = D.48552;
    <D.48550>:
  }
  code.6664 = code;
  code = code.6664 + 1;
  *code.6664 = 15;
  code.6665 = code;
  code = code.6665 + 1;
  *code.6665 = 89;
  code.6666 = code;
  code = code.6666 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6666 = D.33821;
  goto <D.25197>;
  <D.27513>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48557>; else goto <D.48558>;
    <D.48557>:
    iftmp.6667 = 4;
    goto <D.48559>;
    <D.48558>:
    iftmp.6667 = 0;
    <D.48559>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48560 = iftmp.6667 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48560;
    if (_amd64_rex_bits != 0) goto <D.48561>; else goto <D.48562>;
    <D.48561>:
    code.6668 = code;
    code = code.6668 + 1;
    D.48564 = _amd64_rex_bits | 64;
    *code.6668 = D.48564;
    <D.48562>:
  }
  code.6669 = code;
  code = code.6669 + 1;
  *code.6669 = 15;
  code.6670 = code;
  code = code.6670 + 1;
  *code.6670 = 92;
  code.6671 = code;
  code = code.6671 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6671 = D.33821;
  goto <D.25197>;
  <D.27515>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48569>; else goto <D.48570>;
    <D.48569>:
    iftmp.6672 = 4;
    goto <D.48571>;
    <D.48570>:
    iftmp.6672 = 0;
    <D.48571>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48572 = iftmp.6672 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48572;
    if (_amd64_rex_bits != 0) goto <D.48573>; else goto <D.48574>;
    <D.48573>:
    code.6673 = code;
    code = code.6673 + 1;
    D.48576 = _amd64_rex_bits | 64;
    *code.6673 = D.48576;
    <D.48574>:
  }
  code.6674 = code;
  code = code.6674 + 1;
  *code.6674 = 15;
  code.6675 = code;
  code = code.6675 + 1;
  *code.6675 = 95;
  code.6676 = code;
  code = code.6676 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6676 = D.33821;
  goto <D.25197>;
  <D.27517>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48581>; else goto <D.48582>;
    <D.48581>:
    iftmp.6677 = 4;
    goto <D.48583>;
    <D.48582>:
    iftmp.6677 = 0;
    <D.48583>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48584 = iftmp.6677 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48584;
    if (_amd64_rex_bits != 0) goto <D.48585>; else goto <D.48586>;
    <D.48585>:
    code.6678 = code;
    code = code.6678 + 1;
    D.48588 = _amd64_rex_bits | 64;
    *code.6678 = D.48588;
    <D.48586>:
  }
  code.6679 = code;
  code = code.6679 + 1;
  *code.6679 = 15;
  code.6680 = code;
  code = code.6680 + 1;
  *code.6680 = 93;
  code.6681 = code;
  code = code.6681 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6681 = D.33821;
  goto <D.25197>;
  <D.27519>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48592 = D.33166 > 7;
  D.48593 = (long int) D.48592;
  D.48594 = __builtin_expect (D.48593, 0);
  if (D.48594 != 0) goto <D.48595>; else goto <D.48596>;
  <D.48595>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5910, "ins->inst_c0 >= 0 && ins->inst_c0 <= 7");
  <D.48596>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48598>; else goto <D.48599>;
    <D.48598>:
    iftmp.6682 = 4;
    goto <D.48600>;
    <D.48599>:
    iftmp.6682 = 0;
    <D.48600>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48601 = iftmp.6682 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48601;
    if (_amd64_rex_bits != 0) goto <D.48602>; else goto <D.48603>;
    <D.48602>:
    code.6683 = code;
    code = code.6683 + 1;
    D.48605 = _amd64_rex_bits | 64;
    *code.6683 = D.48605;
    <D.48603>:
  }
  code.6684 = code;
  code = code.6684 + 1;
  *code.6684 = 15;
  code.6685 = code;
  code = code.6685 + 1;
  *code.6685 = 194;
  code.6686 = code;
  code = code.6686 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6686 = D.33821;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27521>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48610>; else goto <D.48611>;
    <D.48610>:
    iftmp.6687 = 4;
    goto <D.48612>;
    <D.48611>:
    iftmp.6687 = 0;
    <D.48612>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48613 = iftmp.6687 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48613;
    if (_amd64_rex_bits != 0) goto <D.48614>; else goto <D.48615>;
    <D.48614>:
    code.6688 = code;
    code = code.6688 + 1;
    D.48617 = _amd64_rex_bits | 64;
    *code.6688 = D.48617;
    <D.48615>:
  }
  code.6689 = code;
  code = code.6689 + 1;
  *code.6689 = 15;
  code.6690 = code;
  code = code.6690 + 1;
  *code.6690 = 84;
  code.6691 = code;
  code = code.6691 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6691 = D.33821;
  goto <D.25197>;
  <D.27523>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48622>; else goto <D.48623>;
    <D.48622>:
    iftmp.6692 = 4;
    goto <D.48624>;
    <D.48623>:
    iftmp.6692 = 0;
    <D.48624>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48625 = iftmp.6692 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48625;
    if (_amd64_rex_bits != 0) goto <D.48626>; else goto <D.48627>;
    <D.48626>:
    code.6693 = code;
    code = code.6693 + 1;
    D.48629 = _amd64_rex_bits | 64;
    *code.6693 = D.48629;
    <D.48627>:
  }
  code.6694 = code;
  code = code.6694 + 1;
  *code.6694 = 15;
  code.6695 = code;
  code = code.6695 + 1;
  *code.6695 = 85;
  code.6696 = code;
  code = code.6696 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6696 = D.33821;
  goto <D.25197>;
  <D.27525>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48634>; else goto <D.48635>;
    <D.48634>:
    iftmp.6697 = 4;
    goto <D.48636>;
    <D.48635>:
    iftmp.6697 = 0;
    <D.48636>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48637 = iftmp.6697 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48637;
    if (_amd64_rex_bits != 0) goto <D.48638>; else goto <D.48639>;
    <D.48638>:
    code.6698 = code;
    code = code.6698 + 1;
    D.48641 = _amd64_rex_bits | 64;
    *code.6698 = D.48641;
    <D.48639>:
  }
  code.6699 = code;
  code = code.6699 + 1;
  *code.6699 = 15;
  code.6700 = code;
  code = code.6700 + 1;
  *code.6700 = 86;
  code.6701 = code;
  code = code.6701 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6701 = D.33821;
  goto <D.25197>;
  <D.27527>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48646>; else goto <D.48647>;
    <D.48646>:
    iftmp.6702 = 4;
    goto <D.48648>;
    <D.48647>:
    iftmp.6702 = 0;
    <D.48648>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48649 = iftmp.6702 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48649;
    if (_amd64_rex_bits != 0) goto <D.48650>; else goto <D.48651>;
    <D.48650>:
    code.6703 = code;
    code = code.6703 + 1;
    D.48653 = _amd64_rex_bits | 64;
    *code.6703 = D.48653;
    <D.48651>:
  }
  code.6704 = code;
  code = code.6704 + 1;
  *code.6704 = 15;
  code.6705 = code;
  code = code.6705 + 1;
  *code.6705 = 87;
  code.6706 = code;
  code = code.6706 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6706 = D.33821;
  goto <D.25197>;
  <D.27529>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48658>; else goto <D.48659>;
    <D.48658>:
    iftmp.6707 = 4;
    goto <D.48660>;
    <D.48659>:
    iftmp.6707 = 0;
    <D.48660>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48661 = iftmp.6707 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48661;
    if (_amd64_rex_bits != 0) goto <D.48662>; else goto <D.48663>;
    <D.48662>:
    code.6708 = code;
    code = code.6708 + 1;
    D.48665 = _amd64_rex_bits | 64;
    *code.6708 = D.48665;
    <D.48663>:
  }
  code.6709 = code;
  code = code.6709 + 1;
  *code.6709 = 15;
  code.6710 = code;
  code = code.6710 + 1;
  *code.6710 = 81;
  code.6711 = code;
  code = code.6711 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6711 = D.33727;
  goto <D.25197>;
  <D.27531>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48670>; else goto <D.48671>;
    <D.48670>:
    iftmp.6712 = 4;
    goto <D.48672>;
    <D.48671>:
    iftmp.6712 = 0;
    <D.48672>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48673 = iftmp.6712 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48673;
    if (_amd64_rex_bits != 0) goto <D.48674>; else goto <D.48675>;
    <D.48674>:
    code.6713 = code;
    code = code.6713 + 1;
    D.48677 = _amd64_rex_bits | 64;
    *code.6713 = D.48677;
    <D.48675>:
  }
  code.6714 = code;
  code = code.6714 + 1;
  *code.6714 = 15;
  code.6715 = code;
  code = code.6715 + 1;
  *code.6715 = 82;
  code.6716 = code;
  code = code.6716 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6716 = D.33727;
  goto <D.25197>;
  <D.27533>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48682>; else goto <D.48683>;
    <D.48682>:
    iftmp.6717 = 4;
    goto <D.48684>;
    <D.48683>:
    iftmp.6717 = 0;
    <D.48684>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48685 = iftmp.6717 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48685;
    if (_amd64_rex_bits != 0) goto <D.48686>; else goto <D.48687>;
    <D.48686>:
    code.6718 = code;
    code = code.6718 + 1;
    D.48689 = _amd64_rex_bits | 64;
    *code.6718 = D.48689;
    <D.48687>:
  }
  code.6719 = code;
  code = code.6719 + 1;
  *code.6719 = 15;
  code.6720 = code;
  code = code.6720 + 1;
  *code.6720 = 83;
  code.6721 = code;
  code = code.6721 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6721 = D.33727;
  goto <D.25197>;
  <D.27535>:
  code.6722 = code;
  code = code.6722 + 1;
  *code.6722 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48695>; else goto <D.48696>;
    <D.48695>:
    iftmp.6723 = 4;
    goto <D.48697>;
    <D.48696>:
    iftmp.6723 = 0;
    <D.48697>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48698 = iftmp.6723 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48698;
    if (_amd64_rex_bits != 0) goto <D.48699>; else goto <D.48700>;
    <D.48699>:
    code.6724 = code;
    code = code.6724 + 1;
    D.48702 = _amd64_rex_bits | 64;
    *code.6724 = D.48702;
    <D.48700>:
  }
  code.6725 = code;
  code = code.6725 + 1;
  *code.6725 = 15;
  code.6726 = code;
  code = code.6726 + 1;
  *code.6726 = 208;
  code.6727 = code;
  code = code.6727 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6727 = D.33821;
  goto <D.25197>;
  <D.27537>:
  code.6728 = code;
  code = code.6728 + 1;
  *code.6728 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48708>; else goto <D.48709>;
    <D.48708>:
    iftmp.6729 = 4;
    goto <D.48710>;
    <D.48709>:
    iftmp.6729 = 0;
    <D.48710>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48711 = iftmp.6729 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48711;
    if (_amd64_rex_bits != 0) goto <D.48712>; else goto <D.48713>;
    <D.48712>:
    code.6730 = code;
    code = code.6730 + 1;
    D.48715 = _amd64_rex_bits | 64;
    *code.6730 = D.48715;
    <D.48713>:
  }
  code.6731 = code;
  code = code.6731 + 1;
  *code.6731 = 15;
  code.6732 = code;
  code = code.6732 + 1;
  *code.6732 = 124;
  code.6733 = code;
  code = code.6733 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6733 = D.33821;
  goto <D.25197>;
  <D.27539>:
  code.6734 = code;
  code = code.6734 + 1;
  *code.6734 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48721>; else goto <D.48722>;
    <D.48721>:
    iftmp.6735 = 4;
    goto <D.48723>;
    <D.48722>:
    iftmp.6735 = 0;
    <D.48723>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48724 = iftmp.6735 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48724;
    if (_amd64_rex_bits != 0) goto <D.48725>; else goto <D.48726>;
    <D.48725>:
    code.6736 = code;
    code = code.6736 + 1;
    D.48728 = _amd64_rex_bits | 64;
    *code.6736 = D.48728;
    <D.48726>:
  }
  code.6737 = code;
  code = code.6737 + 1;
  *code.6737 = 15;
  code.6738 = code;
  code = code.6738 + 1;
  *code.6738 = 125;
  code.6739 = code;
  code = code.6739 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6739 = D.33821;
  goto <D.25197>;
  <D.27541>:
  code.6740 = code;
  code = code.6740 + 1;
  *code.6740 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48734>; else goto <D.48735>;
    <D.48734>:
    iftmp.6741 = 4;
    goto <D.48736>;
    <D.48735>:
    iftmp.6741 = 0;
    <D.48736>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48737 = iftmp.6741 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48737;
    if (_amd64_rex_bits != 0) goto <D.48738>; else goto <D.48739>;
    <D.48738>:
    code.6742 = code;
    code = code.6742 + 1;
    D.48741 = _amd64_rex_bits | 64;
    *code.6742 = D.48741;
    <D.48739>:
  }
  code.6743 = code;
  code = code.6743 + 1;
  *code.6743 = 15;
  code.6744 = code;
  code = code.6744 + 1;
  *code.6744 = 22;
  code.6745 = code;
  code = code.6745 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6745 = D.33727;
  goto <D.25197>;
  <D.27543>:
  code.6746 = code;
  code = code.6746 + 1;
  *code.6746 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48747>; else goto <D.48748>;
    <D.48747>:
    iftmp.6747 = 4;
    goto <D.48749>;
    <D.48748>:
    iftmp.6747 = 0;
    <D.48749>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48750 = iftmp.6747 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48750;
    if (_amd64_rex_bits != 0) goto <D.48751>; else goto <D.48752>;
    <D.48751>:
    code.6748 = code;
    code = code.6748 + 1;
    D.48754 = _amd64_rex_bits | 64;
    *code.6748 = D.48754;
    <D.48752>:
  }
  code.6749 = code;
  code = code.6749 + 1;
  *code.6749 = 15;
  code.6750 = code;
  code = code.6750 + 1;
  *code.6750 = 18;
  code.6751 = code;
  code = code.6751 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6751 = D.33727;
  goto <D.25197>;
  <D.27545>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48758 = D.33166 > 255;
  D.48759 = (long int) D.48758;
  D.48760 = __builtin_expect (D.48759, 0);
  if (D.48760 != 0) goto <D.48761>; else goto <D.48762>;
  <D.48761>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5951, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.48762>:
  code.6752 = code;
  code = code.6752 + 1;
  *code.6752 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48765>; else goto <D.48766>;
    <D.48765>:
    iftmp.6753 = 4;
    goto <D.48767>;
    <D.48766>:
    iftmp.6753 = 0;
    <D.48767>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48768 = iftmp.6753 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48768;
    if (_amd64_rex_bits != 0) goto <D.48769>; else goto <D.48770>;
    <D.48769>:
    code.6754 = code;
    code = code.6754 + 1;
    D.48772 = _amd64_rex_bits | 64;
    *code.6754 = D.48772;
    <D.48770>:
  }
  code.6755 = code;
  code = code.6755 + 1;
  *code.6755 = 15;
  code.6756 = code;
  code = code.6756 + 1;
  *code.6756 = 112;
  code.6757 = code;
  code = code.6757 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6757 = D.33727;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27547>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48758 = D.33166 > 255;
  D.48759 = (long int) D.48758;
  D.48760 = __builtin_expect (D.48759, 0);
  if (D.48760 != 0) goto <D.48776>; else goto <D.48777>;
  <D.48776>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5955, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.48777>:
  code.6758 = code;
  code = code.6758 + 1;
  *code.6758 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48780>; else goto <D.48781>;
    <D.48780>:
    iftmp.6759 = 4;
    goto <D.48782>;
    <D.48781>:
    iftmp.6759 = 0;
    <D.48782>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48783 = iftmp.6759 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48783;
    if (_amd64_rex_bits != 0) goto <D.48784>; else goto <D.48785>;
    <D.48784>:
    code.6760 = code;
    code = code.6760 + 1;
    D.48787 = _amd64_rex_bits | 64;
    *code.6760 = D.48787;
    <D.48785>:
  }
  code.6761 = code;
  code = code.6761 + 1;
  *code.6761 = 15;
  code.6762 = code;
  code = code.6762 + 1;
  *code.6762 = 112;
  code.6763 = code;
  code = code.6763 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6763 = D.33727;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27549>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48758 = D.33166 > 255;
  D.48759 = (long int) D.48758;
  D.48760 = __builtin_expect (D.48759, 0);
  if (D.48760 != 0) goto <D.48791>; else goto <D.48792>;
  <D.48791>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5959, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.48792>:
  code.6764 = code;
  code = code.6764 + 1;
  *code.6764 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48795>; else goto <D.48796>;
    <D.48795>:
    iftmp.6765 = 4;
    goto <D.48797>;
    <D.48796>:
    iftmp.6765 = 0;
    <D.48797>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48798 = iftmp.6765 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48798;
    if (_amd64_rex_bits != 0) goto <D.48799>; else goto <D.48800>;
    <D.48799>:
    code.6766 = code;
    code = code.6766 + 1;
    D.48802 = _amd64_rex_bits | 64;
    *code.6766 = D.48802;
    <D.48800>:
  }
  code.6767 = code;
  code = code.6767 + 1;
  *code.6767 = 15;
  code.6768 = code;
  code = code.6768 + 1;
  *code.6768 = 112;
  code.6769 = code;
  code = code.6769 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6769 = D.33727;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27551>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48758 = D.33166 > 255;
  D.48759 = (long int) D.48758;
  D.48760 = __builtin_expect (D.48759, 0);
  if (D.48760 != 0) goto <D.48806>; else goto <D.48807>;
  <D.48806>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5963, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF");
  <D.48807>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48809>; else goto <D.48810>;
    <D.48809>:
    iftmp.6770 = 4;
    goto <D.48811>;
    <D.48810>:
    iftmp.6770 = 0;
    <D.48811>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48812 = iftmp.6770 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48812;
    if (_amd64_rex_bits != 0) goto <D.48813>; else goto <D.48814>;
    <D.48813>:
    code.6771 = code;
    code = code.6771 + 1;
    D.48816 = _amd64_rex_bits | 64;
    *code.6771 = D.48816;
    <D.48814>:
  }
  code.6772 = code;
  code = code.6772 + 1;
  *code.6772 = 15;
  code.6773 = code;
  code = code.6773 + 1;
  *code.6773 = 198;
  code.6774 = code;
  code = code.6774 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6774 = D.33821;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27553>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48820 = D.33166 > 3;
  D.48821 = (long int) D.48820;
  D.48822 = __builtin_expect (D.48821, 0);
  if (D.48822 != 0) goto <D.48823>; else goto <D.48824>;
  <D.48823>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5967, "ins->inst_c0 >= 0 && ins->inst_c0 <= 0x3");
  <D.48824>:
  code.6775 = code;
  code = code.6775 + 1;
  *code.6775 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48827>; else goto <D.48828>;
    <D.48827>:
    iftmp.6776 = 4;
    goto <D.48829>;
    <D.48828>:
    iftmp.6776 = 0;
    <D.48829>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48830 = iftmp.6776 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48830;
    if (_amd64_rex_bits != 0) goto <D.48831>; else goto <D.48832>;
    <D.48831>:
    code.6777 = code;
    code = code.6777 + 1;
    D.48834 = _amd64_rex_bits | 64;
    *code.6777 = D.48834;
    <D.48832>:
  }
  code.6778 = code;
  code = code.6778 + 1;
  *code.6778 = 15;
  code.6779 = code;
  code = code.6779 + 1;
  *code.6779 = 198;
  code.6780 = code;
  code = code.6780 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6780 = D.33821;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27555>:
  code.6781 = code;
  code = code.6781 + 1;
  *code.6781 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48840>; else goto <D.48841>;
    <D.48840>:
    iftmp.6782 = 4;
    goto <D.48842>;
    <D.48841>:
    iftmp.6782 = 0;
    <D.48842>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48843 = iftmp.6782 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48843;
    if (_amd64_rex_bits != 0) goto <D.48844>; else goto <D.48845>;
    <D.48844>:
    code.6783 = code;
    code = code.6783 + 1;
    D.48847 = _amd64_rex_bits | 64;
    *code.6783 = D.48847;
    <D.48845>:
  }
  code.6784 = code;
  code = code.6784 + 1;
  *code.6784 = 15;
  code.6785 = code;
  code = code.6785 + 1;
  *code.6785 = 88;
  code.6786 = code;
  code = code.6786 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6786 = D.33821;
  goto <D.25197>;
  <D.27557>:
  code.6787 = code;
  code = code.6787 + 1;
  *code.6787 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48853>; else goto <D.48854>;
    <D.48853>:
    iftmp.6788 = 4;
    goto <D.48855>;
    <D.48854>:
    iftmp.6788 = 0;
    <D.48855>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48856 = iftmp.6788 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48856;
    if (_amd64_rex_bits != 0) goto <D.48857>; else goto <D.48858>;
    <D.48857>:
    code.6789 = code;
    code = code.6789 + 1;
    D.48860 = _amd64_rex_bits | 64;
    *code.6789 = D.48860;
    <D.48858>:
  }
  code.6790 = code;
  code = code.6790 + 1;
  *code.6790 = 15;
  code.6791 = code;
  code = code.6791 + 1;
  *code.6791 = 94;
  code.6792 = code;
  code = code.6792 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6792 = D.33821;
  goto <D.25197>;
  <D.27559>:
  code.6793 = code;
  code = code.6793 + 1;
  *code.6793 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48866>; else goto <D.48867>;
    <D.48866>:
    iftmp.6794 = 4;
    goto <D.48868>;
    <D.48867>:
    iftmp.6794 = 0;
    <D.48868>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48869 = iftmp.6794 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48869;
    if (_amd64_rex_bits != 0) goto <D.48870>; else goto <D.48871>;
    <D.48870>:
    code.6795 = code;
    code = code.6795 + 1;
    D.48873 = _amd64_rex_bits | 64;
    *code.6795 = D.48873;
    <D.48871>:
  }
  code.6796 = code;
  code = code.6796 + 1;
  *code.6796 = 15;
  code.6797 = code;
  code = code.6797 + 1;
  *code.6797 = 89;
  code.6798 = code;
  code = code.6798 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6798 = D.33821;
  goto <D.25197>;
  <D.27561>:
  code.6799 = code;
  code = code.6799 + 1;
  *code.6799 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48879>; else goto <D.48880>;
    <D.48879>:
    iftmp.6800 = 4;
    goto <D.48881>;
    <D.48880>:
    iftmp.6800 = 0;
    <D.48881>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48882 = iftmp.6800 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48882;
    if (_amd64_rex_bits != 0) goto <D.48883>; else goto <D.48884>;
    <D.48883>:
    code.6801 = code;
    code = code.6801 + 1;
    D.48886 = _amd64_rex_bits | 64;
    *code.6801 = D.48886;
    <D.48884>:
  }
  code.6802 = code;
  code = code.6802 + 1;
  *code.6802 = 15;
  code.6803 = code;
  code = code.6803 + 1;
  *code.6803 = 92;
  code.6804 = code;
  code = code.6804 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6804 = D.33821;
  goto <D.25197>;
  <D.27563>:
  code.6805 = code;
  code = code.6805 + 1;
  *code.6805 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48892>; else goto <D.48893>;
    <D.48892>:
    iftmp.6806 = 4;
    goto <D.48894>;
    <D.48893>:
    iftmp.6806 = 0;
    <D.48894>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48895 = iftmp.6806 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48895;
    if (_amd64_rex_bits != 0) goto <D.48896>; else goto <D.48897>;
    <D.48896>:
    code.6807 = code;
    code = code.6807 + 1;
    D.48899 = _amd64_rex_bits | 64;
    *code.6807 = D.48899;
    <D.48897>:
  }
  code.6808 = code;
  code = code.6808 + 1;
  *code.6808 = 15;
  code.6809 = code;
  code = code.6809 + 1;
  *code.6809 = 95;
  code.6810 = code;
  code = code.6810 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6810 = D.33821;
  goto <D.25197>;
  <D.27565>:
  code.6811 = code;
  code = code.6811 + 1;
  *code.6811 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48905>; else goto <D.48906>;
    <D.48905>:
    iftmp.6812 = 4;
    goto <D.48907>;
    <D.48906>:
    iftmp.6812 = 0;
    <D.48907>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48908 = iftmp.6812 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48908;
    if (_amd64_rex_bits != 0) goto <D.48909>; else goto <D.48910>;
    <D.48909>:
    code.6813 = code;
    code = code.6813 + 1;
    D.48912 = _amd64_rex_bits | 64;
    *code.6813 = D.48912;
    <D.48910>:
  }
  code.6814 = code;
  code = code.6814 + 1;
  *code.6814 = 15;
  code.6815 = code;
  code = code.6815 + 1;
  *code.6815 = 93;
  code.6816 = code;
  code = code.6816 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6816 = D.33821;
  goto <D.25197>;
  <D.27567>:
  D.31535 = ins->data.op[0].const_val;
  D.33166 = (unsigned long) D.31535;
  D.48592 = D.33166 > 7;
  D.48593 = (long int) D.48592;
  D.48594 = __builtin_expect (D.48593, 0);
  if (D.48594 != 0) goto <D.48916>; else goto <D.48917>;
  <D.48916>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 5990, "ins->inst_c0 >= 0 && ins->inst_c0 <= 7");
  <D.48917>:
  code.6817 = code;
  code = code.6817 + 1;
  *code.6817 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48920>; else goto <D.48921>;
    <D.48920>:
    iftmp.6818 = 4;
    goto <D.48922>;
    <D.48921>:
    iftmp.6818 = 0;
    <D.48922>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48923 = iftmp.6818 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48923;
    if (_amd64_rex_bits != 0) goto <D.48924>; else goto <D.48925>;
    <D.48924>:
    code.6819 = code;
    code = code.6819 + 1;
    D.48927 = _amd64_rex_bits | 64;
    *code.6819 = D.48927;
    <D.48925>:
  }
  code.6820 = code;
  code = code.6820 + 1;
  *code.6820 = 15;
  code.6821 = code;
  code = code.6821 + 1;
  *code.6821 = 194;
  code.6822 = code;
  code = code.6822 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6822 = D.33821;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27569>:
  code.6823 = code;
  code = code.6823 + 1;
  *code.6823 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48933>; else goto <D.48934>;
    <D.48933>:
    iftmp.6824 = 4;
    goto <D.48935>;
    <D.48934>:
    iftmp.6824 = 0;
    <D.48935>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48936 = iftmp.6824 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48936;
    if (_amd64_rex_bits != 0) goto <D.48937>; else goto <D.48938>;
    <D.48937>:
    code.6825 = code;
    code = code.6825 + 1;
    D.48940 = _amd64_rex_bits | 64;
    *code.6825 = D.48940;
    <D.48938>:
  }
  code.6826 = code;
  code = code.6826 + 1;
  *code.6826 = 15;
  code.6827 = code;
  code = code.6827 + 1;
  *code.6827 = 84;
  code.6828 = code;
  code = code.6828 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6828 = D.33821;
  goto <D.25197>;
  <D.27571>:
  code.6829 = code;
  code = code.6829 + 1;
  *code.6829 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48946>; else goto <D.48947>;
    <D.48946>:
    iftmp.6830 = 4;
    goto <D.48948>;
    <D.48947>:
    iftmp.6830 = 0;
    <D.48948>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48949 = iftmp.6830 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48949;
    if (_amd64_rex_bits != 0) goto <D.48950>; else goto <D.48951>;
    <D.48950>:
    code.6831 = code;
    code = code.6831 + 1;
    D.48953 = _amd64_rex_bits | 64;
    *code.6831 = D.48953;
    <D.48951>:
  }
  code.6832 = code;
  code = code.6832 + 1;
  *code.6832 = 15;
  code.6833 = code;
  code = code.6833 + 1;
  *code.6833 = 85;
  code.6834 = code;
  code = code.6834 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6834 = D.33821;
  goto <D.25197>;
  <D.27573>:
  code.6835 = code;
  code = code.6835 + 1;
  *code.6835 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48959>; else goto <D.48960>;
    <D.48959>:
    iftmp.6836 = 4;
    goto <D.48961>;
    <D.48960>:
    iftmp.6836 = 0;
    <D.48961>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48962 = iftmp.6836 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48962;
    if (_amd64_rex_bits != 0) goto <D.48963>; else goto <D.48964>;
    <D.48963>:
    code.6837 = code;
    code = code.6837 + 1;
    D.48966 = _amd64_rex_bits | 64;
    *code.6837 = D.48966;
    <D.48964>:
  }
  code.6838 = code;
  code = code.6838 + 1;
  *code.6838 = 15;
  code.6839 = code;
  code = code.6839 + 1;
  *code.6839 = 86;
  code.6840 = code;
  code = code.6840 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6840 = D.33821;
  goto <D.25197>;
  <D.27575>:
  code.6841 = code;
  code = code.6841 + 1;
  *code.6841 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48972>; else goto <D.48973>;
    <D.48972>:
    iftmp.6842 = 4;
    goto <D.48974>;
    <D.48973>:
    iftmp.6842 = 0;
    <D.48974>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.48975 = iftmp.6842 | D.33811;
    _amd64_rex_bits = (unsigned char) D.48975;
    if (_amd64_rex_bits != 0) goto <D.48976>; else goto <D.48977>;
    <D.48976>:
    code.6843 = code;
    code = code.6843 + 1;
    D.48979 = _amd64_rex_bits | 64;
    *code.6843 = D.48979;
    <D.48977>:
  }
  code.6844 = code;
  code = code.6844 + 1;
  *code.6844 = 15;
  code.6845 = code;
  code = code.6845 + 1;
  *code.6845 = 87;
  code.6846 = code;
  code = code.6846 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6846 = D.33821;
  goto <D.25197>;
  <D.27577>:
  code.6847 = code;
  code = code.6847 + 1;
  *code.6847 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.48985>; else goto <D.48986>;
    <D.48985>:
    iftmp.6848 = 4;
    goto <D.48987>;
    <D.48986>:
    iftmp.6848 = 0;
    <D.48987>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.48988 = iftmp.6848 | D.33180;
    _amd64_rex_bits = (unsigned char) D.48988;
    if (_amd64_rex_bits != 0) goto <D.48989>; else goto <D.48990>;
    <D.48989>:
    code.6849 = code;
    code = code.6849 + 1;
    D.48992 = _amd64_rex_bits | 64;
    *code.6849 = D.48992;
    <D.48990>:
  }
  code.6850 = code;
  code = code.6850 + 1;
  *code.6850 = 15;
  code.6851 = code;
  code = code.6851 + 1;
  *code.6851 = 81;
  code.6852 = code;
  code = code.6852 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6852 = D.33727;
  goto <D.25197>;
  <D.27579>:
  code.6853 = code;
  code = code.6853 + 1;
  *code.6853 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.48998>; else goto <D.48999>;
    <D.48998>:
    iftmp.6854 = 4;
    goto <D.49000>;
    <D.48999>:
    iftmp.6854 = 0;
    <D.49000>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49001 = iftmp.6854 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49001;
    if (_amd64_rex_bits != 0) goto <D.49002>; else goto <D.49003>;
    <D.49002>:
    code.6855 = code;
    code = code.6855 + 1;
    D.49005 = _amd64_rex_bits | 64;
    *code.6855 = D.49005;
    <D.49003>:
  }
  code.6856 = code;
  code = code.6856 + 1;
  *code.6856 = 15;
  code.6857 = code;
  code = code.6857 + 1;
  *code.6857 = 208;
  code.6858 = code;
  code = code.6858 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6858 = D.33821;
  goto <D.25197>;
  <D.27581>:
  code.6859 = code;
  code = code.6859 + 1;
  *code.6859 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49011>; else goto <D.49012>;
    <D.49011>:
    iftmp.6860 = 4;
    goto <D.49013>;
    <D.49012>:
    iftmp.6860 = 0;
    <D.49013>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49014 = iftmp.6860 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49014;
    if (_amd64_rex_bits != 0) goto <D.49015>; else goto <D.49016>;
    <D.49015>:
    code.6861 = code;
    code = code.6861 + 1;
    D.49018 = _amd64_rex_bits | 64;
    *code.6861 = D.49018;
    <D.49016>:
  }
  code.6862 = code;
  code = code.6862 + 1;
  *code.6862 = 15;
  code.6863 = code;
  code = code.6863 + 1;
  *code.6863 = 124;
  code.6864 = code;
  code = code.6864 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6864 = D.33821;
  goto <D.25197>;
  <D.27583>:
  code.6865 = code;
  code = code.6865 + 1;
  *code.6865 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49024>; else goto <D.49025>;
    <D.49024>:
    iftmp.6866 = 4;
    goto <D.49026>;
    <D.49025>:
    iftmp.6866 = 0;
    <D.49026>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49027 = iftmp.6866 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49027;
    if (_amd64_rex_bits != 0) goto <D.49028>; else goto <D.49029>;
    <D.49028>:
    code.6867 = code;
    code = code.6867 + 1;
    D.49031 = _amd64_rex_bits | 64;
    *code.6867 = D.49031;
    <D.49029>:
  }
  code.6868 = code;
  code = code.6868 + 1;
  *code.6868 = 15;
  code.6869 = code;
  code = code.6869 + 1;
  *code.6869 = 125;
  code.6870 = code;
  code = code.6870 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6870 = D.33821;
  goto <D.25197>;
  <D.27585>:
  code.6871 = code;
  code = code.6871 + 1;
  *code.6871 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49037>; else goto <D.49038>;
    <D.49037>:
    iftmp.6872 = 4;
    goto <D.49039>;
    <D.49038>:
    iftmp.6872 = 0;
    <D.49039>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.49040 = iftmp.6872 | D.33180;
    _amd64_rex_bits = (unsigned char) D.49040;
    if (_amd64_rex_bits != 0) goto <D.49041>; else goto <D.49042>;
    <D.49041>:
    code.6873 = code;
    code = code.6873 + 1;
    D.49044 = _amd64_rex_bits | 64;
    *code.6873 = D.49044;
    <D.49042>:
  }
  code.6874 = code;
  code = code.6874 + 1;
  *code.6874 = 15;
  code.6875 = code;
  code = code.6875 + 1;
  *code.6875 = 18;
  code.6876 = code;
  code = code.6876 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6876 = D.33727;
  goto <D.25197>;
  <D.27587>:
  code.6877 = code;
  code = code.6877 + 1;
  *code.6877 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49050>; else goto <D.49051>;
    <D.49050>:
    iftmp.6878 = 4;
    goto <D.49052>;
    <D.49051>:
    iftmp.6878 = 0;
    <D.49052>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.49053 = iftmp.6878 | D.33180;
    _amd64_rex_bits = (unsigned char) D.49053;
    if (_amd64_rex_bits != 0) goto <D.49054>; else goto <D.49055>;
    <D.49054>:
    code.6879 = code;
    code = code.6879 + 1;
    D.49057 = _amd64_rex_bits | 64;
    *code.6879 = D.49057;
    <D.49055>:
  }
  code.6880 = code;
  code = code.6880 + 1;
  *code.6880 = 15;
  code.6881 = code;
  code = code.6881 + 1;
  *code.6881 = 215;
  code.6882 = code;
  code = code.6882 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.6882 = D.33727;
  goto <D.25197>;
  <D.27589>:
  code.6883 = code;
  code = code.6883 + 1;
  *code.6883 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49063>; else goto <D.49064>;
    <D.49063>:
    iftmp.6884 = 4;
    goto <D.49065>;
    <D.49064>:
    iftmp.6884 = 0;
    <D.49065>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49066 = iftmp.6884 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49066;
    if (_amd64_rex_bits != 0) goto <D.49067>; else goto <D.49068>;
    <D.49067>:
    code.6885 = code;
    code = code.6885 + 1;
    D.49070 = _amd64_rex_bits | 64;
    *code.6885 = D.49070;
    <D.49068>:
  }
  code.6886 = code;
  code = code.6886 + 1;
  *code.6886 = 15;
  code.6887 = code;
  code = code.6887 + 1;
  *code.6887 = 219;
  code.6888 = code;
  code = code.6888 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6888 = D.33821;
  goto <D.25197>;
  <D.27591>:
  code.6889 = code;
  code = code.6889 + 1;
  *code.6889 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49076>; else goto <D.49077>;
    <D.49076>:
    iftmp.6890 = 4;
    goto <D.49078>;
    <D.49077>:
    iftmp.6890 = 0;
    <D.49078>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49079 = iftmp.6890 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49079;
    if (_amd64_rex_bits != 0) goto <D.49080>; else goto <D.49081>;
    <D.49080>:
    code.6891 = code;
    code = code.6891 + 1;
    D.49083 = _amd64_rex_bits | 64;
    *code.6891 = D.49083;
    <D.49081>:
  }
  code.6892 = code;
  code = code.6892 + 1;
  *code.6892 = 15;
  code.6893 = code;
  code = code.6893 + 1;
  *code.6893 = 235;
  code.6894 = code;
  code = code.6894 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6894 = D.33821;
  goto <D.25197>;
  <D.27593>:
  code.6895 = code;
  code = code.6895 + 1;
  *code.6895 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49089>; else goto <D.49090>;
    <D.49089>:
    iftmp.6896 = 4;
    goto <D.49091>;
    <D.49090>:
    iftmp.6896 = 0;
    <D.49091>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49092 = iftmp.6896 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49092;
    if (_amd64_rex_bits != 0) goto <D.49093>; else goto <D.49094>;
    <D.49093>:
    code.6897 = code;
    code = code.6897 + 1;
    D.49096 = _amd64_rex_bits | 64;
    *code.6897 = D.49096;
    <D.49094>:
  }
  code.6898 = code;
  code = code.6898 + 1;
  *code.6898 = 15;
  code.6899 = code;
  code = code.6899 + 1;
  *code.6899 = 239;
  code.6900 = code;
  code = code.6900 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6900 = D.33821;
  goto <D.25197>;
  <D.27595>:
  code.6901 = code;
  code = code.6901 + 1;
  *code.6901 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49102>; else goto <D.49103>;
    <D.49102>:
    iftmp.6902 = 4;
    goto <D.49104>;
    <D.49103>:
    iftmp.6902 = 0;
    <D.49104>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49105 = iftmp.6902 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49105;
    if (_amd64_rex_bits != 0) goto <D.49106>; else goto <D.49107>;
    <D.49106>:
    code.6903 = code;
    code = code.6903 + 1;
    D.49109 = _amd64_rex_bits | 64;
    *code.6903 = D.49109;
    <D.49107>:
  }
  code.6904 = code;
  code = code.6904 + 1;
  *code.6904 = 15;
  code.6905 = code;
  code = code.6905 + 1;
  *code.6905 = 252;
  code.6906 = code;
  code = code.6906 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6906 = D.33821;
  goto <D.25197>;
  <D.27597>:
  code.6907 = code;
  code = code.6907 + 1;
  *code.6907 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49115>; else goto <D.49116>;
    <D.49115>:
    iftmp.6908 = 4;
    goto <D.49117>;
    <D.49116>:
    iftmp.6908 = 0;
    <D.49117>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49118 = iftmp.6908 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49118;
    if (_amd64_rex_bits != 0) goto <D.49119>; else goto <D.49120>;
    <D.49119>:
    code.6909 = code;
    code = code.6909 + 1;
    D.49122 = _amd64_rex_bits | 64;
    *code.6909 = D.49122;
    <D.49120>:
  }
  code.6910 = code;
  code = code.6910 + 1;
  *code.6910 = 15;
  code.6911 = code;
  code = code.6911 + 1;
  *code.6911 = 253;
  code.6912 = code;
  code = code.6912 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6912 = D.33821;
  goto <D.25197>;
  <D.27599>:
  code.6913 = code;
  code = code.6913 + 1;
  *code.6913 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49128>; else goto <D.49129>;
    <D.49128>:
    iftmp.6914 = 4;
    goto <D.49130>;
    <D.49129>:
    iftmp.6914 = 0;
    <D.49130>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49131 = iftmp.6914 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49131;
    if (_amd64_rex_bits != 0) goto <D.49132>; else goto <D.49133>;
    <D.49132>:
    code.6915 = code;
    code = code.6915 + 1;
    D.49135 = _amd64_rex_bits | 64;
    *code.6915 = D.49135;
    <D.49133>:
  }
  code.6916 = code;
  code = code.6916 + 1;
  *code.6916 = 15;
  code.6917 = code;
  code = code.6917 + 1;
  *code.6917 = 254;
  code.6918 = code;
  code = code.6918 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6918 = D.33821;
  goto <D.25197>;
  <D.27601>:
  code.6919 = code;
  code = code.6919 + 1;
  *code.6919 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49141>; else goto <D.49142>;
    <D.49141>:
    iftmp.6920 = 4;
    goto <D.49143>;
    <D.49142>:
    iftmp.6920 = 0;
    <D.49143>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49144 = iftmp.6920 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49144;
    if (_amd64_rex_bits != 0) goto <D.49145>; else goto <D.49146>;
    <D.49145>:
    code.6921 = code;
    code = code.6921 + 1;
    D.49148 = _amd64_rex_bits | 64;
    *code.6921 = D.49148;
    <D.49146>:
  }
  code.6922 = code;
  code = code.6922 + 1;
  *code.6922 = 15;
  code.6923 = code;
  code = code.6923 + 1;
  *code.6923 = 212;
  code.6924 = code;
  code = code.6924 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6924 = D.33821;
  goto <D.25197>;
  <D.27603>:
  code.6925 = code;
  code = code.6925 + 1;
  *code.6925 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49154>; else goto <D.49155>;
    <D.49154>:
    iftmp.6926 = 4;
    goto <D.49156>;
    <D.49155>:
    iftmp.6926 = 0;
    <D.49156>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49157 = iftmp.6926 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49157;
    if (_amd64_rex_bits != 0) goto <D.49158>; else goto <D.49159>;
    <D.49158>:
    code.6927 = code;
    code = code.6927 + 1;
    D.49161 = _amd64_rex_bits | 64;
    *code.6927 = D.49161;
    <D.49159>:
  }
  code.6928 = code;
  code = code.6928 + 1;
  *code.6928 = 15;
  code.6929 = code;
  code = code.6929 + 1;
  *code.6929 = 248;
  code.6930 = code;
  code = code.6930 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6930 = D.33821;
  goto <D.25197>;
  <D.27605>:
  code.6931 = code;
  code = code.6931 + 1;
  *code.6931 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49167>; else goto <D.49168>;
    <D.49167>:
    iftmp.6932 = 4;
    goto <D.49169>;
    <D.49168>:
    iftmp.6932 = 0;
    <D.49169>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49170 = iftmp.6932 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49170;
    if (_amd64_rex_bits != 0) goto <D.49171>; else goto <D.49172>;
    <D.49171>:
    code.6933 = code;
    code = code.6933 + 1;
    D.49174 = _amd64_rex_bits | 64;
    *code.6933 = D.49174;
    <D.49172>:
  }
  code.6934 = code;
  code = code.6934 + 1;
  *code.6934 = 15;
  code.6935 = code;
  code = code.6935 + 1;
  *code.6935 = 249;
  code.6936 = code;
  code = code.6936 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6936 = D.33821;
  goto <D.25197>;
  <D.27607>:
  code.6937 = code;
  code = code.6937 + 1;
  *code.6937 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49180>; else goto <D.49181>;
    <D.49180>:
    iftmp.6938 = 4;
    goto <D.49182>;
    <D.49181>:
    iftmp.6938 = 0;
    <D.49182>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49183 = iftmp.6938 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49183;
    if (_amd64_rex_bits != 0) goto <D.49184>; else goto <D.49185>;
    <D.49184>:
    code.6939 = code;
    code = code.6939 + 1;
    D.49187 = _amd64_rex_bits | 64;
    *code.6939 = D.49187;
    <D.49185>:
  }
  code.6940 = code;
  code = code.6940 + 1;
  *code.6940 = 15;
  code.6941 = code;
  code = code.6941 + 1;
  *code.6941 = 250;
  code.6942 = code;
  code = code.6942 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6942 = D.33821;
  goto <D.25197>;
  <D.27609>:
  code.6943 = code;
  code = code.6943 + 1;
  *code.6943 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49193>; else goto <D.49194>;
    <D.49193>:
    iftmp.6944 = 4;
    goto <D.49195>;
    <D.49194>:
    iftmp.6944 = 0;
    <D.49195>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49196 = iftmp.6944 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49196;
    if (_amd64_rex_bits != 0) goto <D.49197>; else goto <D.49198>;
    <D.49197>:
    code.6945 = code;
    code = code.6945 + 1;
    D.49200 = _amd64_rex_bits | 64;
    *code.6945 = D.49200;
    <D.49198>:
  }
  code.6946 = code;
  code = code.6946 + 1;
  *code.6946 = 15;
  code.6947 = code;
  code = code.6947 + 1;
  *code.6947 = 251;
  code.6948 = code;
  code = code.6948 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6948 = D.33821;
  goto <D.25197>;
  <D.27611>:
  code.6949 = code;
  code = code.6949 + 1;
  *code.6949 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49206>; else goto <D.49207>;
    <D.49206>:
    iftmp.6950 = 4;
    goto <D.49208>;
    <D.49207>:
    iftmp.6950 = 0;
    <D.49208>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49209 = iftmp.6950 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49209;
    if (_amd64_rex_bits != 0) goto <D.49210>; else goto <D.49211>;
    <D.49210>:
    code.6951 = code;
    code = code.6951 + 1;
    D.49213 = _amd64_rex_bits | 64;
    *code.6951 = D.49213;
    <D.49211>:
  }
  code.6952 = code;
  code = code.6952 + 1;
  *code.6952 = 15;
  code.6953 = code;
  code = code.6953 + 1;
  *code.6953 = 222;
  code.6954 = code;
  code = code.6954 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6954 = D.33821;
  goto <D.25197>;
  <D.27613>:
  code.6955 = code;
  code = code.6955 + 1;
  *code.6955 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49219>; else goto <D.49220>;
    <D.49219>:
    iftmp.6956 = 4;
    goto <D.49221>;
    <D.49220>:
    iftmp.6956 = 0;
    <D.49221>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49222 = iftmp.6956 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49222;
    if (_amd64_rex_bits != 0) goto <D.49223>; else goto <D.49224>;
    <D.49223>:
    code.6957 = code;
    code = code.6957 + 1;
    D.49226 = _amd64_rex_bits | 64;
    *code.6957 = D.49226;
    <D.49224>:
  }
  code.6958 = code;
  code = code.6958 + 1;
  *code.6958 = 15;
  code.6959 = code;
  code = code.6959 + 1;
  *code.6959 = 56;
  code.6960 = code;
  code = code.6960 + 1;
  *code.6960 = 62;
  code.6961 = code;
  code = code.6961 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6961 = D.33821;
  goto <D.25197>;
  <D.27615>:
  code.6962 = code;
  code = code.6962 + 1;
  *code.6962 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49233>; else goto <D.49234>;
    <D.49233>:
    iftmp.6963 = 4;
    goto <D.49235>;
    <D.49234>:
    iftmp.6963 = 0;
    <D.49235>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49236 = iftmp.6963 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49236;
    if (_amd64_rex_bits != 0) goto <D.49237>; else goto <D.49238>;
    <D.49237>:
    code.6964 = code;
    code = code.6964 + 1;
    D.49240 = _amd64_rex_bits | 64;
    *code.6964 = D.49240;
    <D.49238>:
  }
  code.6965 = code;
  code = code.6965 + 1;
  *code.6965 = 15;
  code.6966 = code;
  code = code.6966 + 1;
  *code.6966 = 56;
  code.6967 = code;
  code = code.6967 + 1;
  *code.6967 = 63;
  code.6968 = code;
  code = code.6968 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6968 = D.33821;
  goto <D.25197>;
  <D.27617>:
  code.6969 = code;
  code = code.6969 + 1;
  *code.6969 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49247>; else goto <D.49248>;
    <D.49247>:
    iftmp.6970 = 4;
    goto <D.49249>;
    <D.49248>:
    iftmp.6970 = 0;
    <D.49249>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49250 = iftmp.6970 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49250;
    if (_amd64_rex_bits != 0) goto <D.49251>; else goto <D.49252>;
    <D.49251>:
    code.6971 = code;
    code = code.6971 + 1;
    D.49254 = _amd64_rex_bits | 64;
    *code.6971 = D.49254;
    <D.49252>:
  }
  code.6972 = code;
  code = code.6972 + 1;
  *code.6972 = 15;
  code.6973 = code;
  code = code.6973 + 1;
  *code.6973 = 56;
  code.6974 = code;
  code = code.6974 + 1;
  *code.6974 = 60;
  code.6975 = code;
  code = code.6975 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6975 = D.33821;
  goto <D.25197>;
  <D.27619>:
  code.6976 = code;
  code = code.6976 + 1;
  *code.6976 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49261>; else goto <D.49262>;
    <D.49261>:
    iftmp.6977 = 4;
    goto <D.49263>;
    <D.49262>:
    iftmp.6977 = 0;
    <D.49263>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49264 = iftmp.6977 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49264;
    if (_amd64_rex_bits != 0) goto <D.49265>; else goto <D.49266>;
    <D.49265>:
    code.6978 = code;
    code = code.6978 + 1;
    D.49268 = _amd64_rex_bits | 64;
    *code.6978 = D.49268;
    <D.49266>:
  }
  code.6979 = code;
  code = code.6979 + 1;
  *code.6979 = 15;
  code.6980 = code;
  code = code.6980 + 1;
  *code.6980 = 238;
  code.6981 = code;
  code = code.6981 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6981 = D.33821;
  goto <D.25197>;
  <D.27621>:
  code.6982 = code;
  code = code.6982 + 1;
  *code.6982 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49274>; else goto <D.49275>;
    <D.49274>:
    iftmp.6983 = 4;
    goto <D.49276>;
    <D.49275>:
    iftmp.6983 = 0;
    <D.49276>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49277 = iftmp.6983 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49277;
    if (_amd64_rex_bits != 0) goto <D.49278>; else goto <D.49279>;
    <D.49278>:
    code.6984 = code;
    code = code.6984 + 1;
    D.49281 = _amd64_rex_bits | 64;
    *code.6984 = D.49281;
    <D.49279>:
  }
  code.6985 = code;
  code = code.6985 + 1;
  *code.6985 = 15;
  code.6986 = code;
  code = code.6986 + 1;
  *code.6986 = 56;
  code.6987 = code;
  code = code.6987 + 1;
  *code.6987 = 61;
  code.6988 = code;
  code = code.6988 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6988 = D.33821;
  goto <D.25197>;
  <D.27623>:
  code.6989 = code;
  code = code.6989 + 1;
  *code.6989 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49288>; else goto <D.49289>;
    <D.49288>:
    iftmp.6990 = 4;
    goto <D.49290>;
    <D.49289>:
    iftmp.6990 = 0;
    <D.49290>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49291 = iftmp.6990 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49291;
    if (_amd64_rex_bits != 0) goto <D.49292>; else goto <D.49293>;
    <D.49292>:
    code.6991 = code;
    code = code.6991 + 1;
    D.49295 = _amd64_rex_bits | 64;
    *code.6991 = D.49295;
    <D.49293>:
  }
  code.6992 = code;
  code = code.6992 + 1;
  *code.6992 = 15;
  code.6993 = code;
  code = code.6993 + 1;
  *code.6993 = 224;
  code.6994 = code;
  code = code.6994 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.6994 = D.33821;
  goto <D.25197>;
  <D.27625>:
  code.6995 = code;
  code = code.6995 + 1;
  *code.6995 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49301>; else goto <D.49302>;
    <D.49301>:
    iftmp.6996 = 4;
    goto <D.49303>;
    <D.49302>:
    iftmp.6996 = 0;
    <D.49303>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49304 = iftmp.6996 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49304;
    if (_amd64_rex_bits != 0) goto <D.49305>; else goto <D.49306>;
    <D.49305>:
    code.6997 = code;
    code = code.6997 + 1;
    D.49308 = _amd64_rex_bits | 64;
    *code.6997 = D.49308;
    <D.49306>:
  }
  code.6998 = code;
  code = code.6998 + 1;
  *code.6998 = 15;
  code.6999 = code;
  code = code.6999 + 1;
  *code.6999 = 227;
  code.7000 = code;
  code = code.7000 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7000 = D.33821;
  goto <D.25197>;
  <D.27627>:
  code.7001 = code;
  code = code.7001 + 1;
  *code.7001 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49314>; else goto <D.49315>;
    <D.49314>:
    iftmp.7002 = 4;
    goto <D.49316>;
    <D.49315>:
    iftmp.7002 = 0;
    <D.49316>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49317 = iftmp.7002 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49317;
    if (_amd64_rex_bits != 0) goto <D.49318>; else goto <D.49319>;
    <D.49318>:
    code.7003 = code;
    code = code.7003 + 1;
    D.49321 = _amd64_rex_bits | 64;
    *code.7003 = D.49321;
    <D.49319>:
  }
  code.7004 = code;
  code = code.7004 + 1;
  *code.7004 = 15;
  code.7005 = code;
  code = code.7005 + 1;
  *code.7005 = 218;
  code.7006 = code;
  code = code.7006 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7006 = D.33821;
  goto <D.25197>;
  <D.27629>:
  code.7007 = code;
  code = code.7007 + 1;
  *code.7007 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49327>; else goto <D.49328>;
    <D.49327>:
    iftmp.7008 = 4;
    goto <D.49329>;
    <D.49328>:
    iftmp.7008 = 0;
    <D.49329>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49330 = iftmp.7008 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49330;
    if (_amd64_rex_bits != 0) goto <D.49331>; else goto <D.49332>;
    <D.49331>:
    code.7009 = code;
    code = code.7009 + 1;
    D.49334 = _amd64_rex_bits | 64;
    *code.7009 = D.49334;
    <D.49332>:
  }
  code.7010 = code;
  code = code.7010 + 1;
  *code.7010 = 15;
  code.7011 = code;
  code = code.7011 + 1;
  *code.7011 = 56;
  code.7012 = code;
  code = code.7012 + 1;
  *code.7012 = 58;
  code.7013 = code;
  code = code.7013 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7013 = D.33821;
  goto <D.25197>;
  <D.27631>:
  code.7014 = code;
  code = code.7014 + 1;
  *code.7014 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49341>; else goto <D.49342>;
    <D.49341>:
    iftmp.7015 = 4;
    goto <D.49343>;
    <D.49342>:
    iftmp.7015 = 0;
    <D.49343>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49344 = iftmp.7015 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49344;
    if (_amd64_rex_bits != 0) goto <D.49345>; else goto <D.49346>;
    <D.49345>:
    code.7016 = code;
    code = code.7016 + 1;
    D.49348 = _amd64_rex_bits | 64;
    *code.7016 = D.49348;
    <D.49346>:
  }
  code.7017 = code;
  code = code.7017 + 1;
  *code.7017 = 15;
  code.7018 = code;
  code = code.7018 + 1;
  *code.7018 = 56;
  code.7019 = code;
  code = code.7019 + 1;
  *code.7019 = 59;
  code.7020 = code;
  code = code.7020 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7020 = D.33821;
  goto <D.25197>;
  <D.27633>:
  code.7021 = code;
  code = code.7021 + 1;
  *code.7021 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49355>; else goto <D.49356>;
    <D.49355>:
    iftmp.7022 = 4;
    goto <D.49357>;
    <D.49356>:
    iftmp.7022 = 0;
    <D.49357>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49358 = iftmp.7022 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49358;
    if (_amd64_rex_bits != 0) goto <D.49359>; else goto <D.49360>;
    <D.49359>:
    code.7023 = code;
    code = code.7023 + 1;
    D.49362 = _amd64_rex_bits | 64;
    *code.7023 = D.49362;
    <D.49360>:
  }
  code.7024 = code;
  code = code.7024 + 1;
  *code.7024 = 15;
  code.7025 = code;
  code = code.7025 + 1;
  *code.7025 = 56;
  code.7026 = code;
  code = code.7026 + 1;
  *code.7026 = 56;
  code.7027 = code;
  code = code.7027 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7027 = D.33821;
  goto <D.25197>;
  <D.27635>:
  code.7028 = code;
  code = code.7028 + 1;
  *code.7028 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49369>; else goto <D.49370>;
    <D.49369>:
    iftmp.7029 = 4;
    goto <D.49371>;
    <D.49370>:
    iftmp.7029 = 0;
    <D.49371>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49372 = iftmp.7029 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49372;
    if (_amd64_rex_bits != 0) goto <D.49373>; else goto <D.49374>;
    <D.49373>:
    code.7030 = code;
    code = code.7030 + 1;
    D.49376 = _amd64_rex_bits | 64;
    *code.7030 = D.49376;
    <D.49374>:
  }
  code.7031 = code;
  code = code.7031 + 1;
  *code.7031 = 15;
  code.7032 = code;
  code = code.7032 + 1;
  *code.7032 = 234;
  code.7033 = code;
  code = code.7033 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7033 = D.33821;
  goto <D.25197>;
  <D.27637>:
  code.7034 = code;
  code = code.7034 + 1;
  *code.7034 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49382>; else goto <D.49383>;
    <D.49382>:
    iftmp.7035 = 4;
    goto <D.49384>;
    <D.49383>:
    iftmp.7035 = 0;
    <D.49384>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49385 = iftmp.7035 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49385;
    if (_amd64_rex_bits != 0) goto <D.49386>; else goto <D.49387>;
    <D.49386>:
    code.7036 = code;
    code = code.7036 + 1;
    D.49389 = _amd64_rex_bits | 64;
    *code.7036 = D.49389;
    <D.49387>:
  }
  code.7037 = code;
  code = code.7037 + 1;
  *code.7037 = 15;
  code.7038 = code;
  code = code.7038 + 1;
  *code.7038 = 56;
  code.7039 = code;
  code = code.7039 + 1;
  *code.7039 = 57;
  code.7040 = code;
  code = code.7040 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7040 = D.33821;
  goto <D.25197>;
  <D.27639>:
  code.7041 = code;
  code = code.7041 + 1;
  *code.7041 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49396>; else goto <D.49397>;
    <D.49396>:
    iftmp.7042 = 4;
    goto <D.49398>;
    <D.49397>:
    iftmp.7042 = 0;
    <D.49398>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49399 = iftmp.7042 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49399;
    if (_amd64_rex_bits != 0) goto <D.49400>; else goto <D.49401>;
    <D.49400>:
    code.7043 = code;
    code = code.7043 + 1;
    D.49403 = _amd64_rex_bits | 64;
    *code.7043 = D.49403;
    <D.49401>:
  }
  code.7044 = code;
  code = code.7044 + 1;
  *code.7044 = 15;
  code.7045 = code;
  code = code.7045 + 1;
  *code.7045 = 116;
  code.7046 = code;
  code = code.7046 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7046 = D.33821;
  goto <D.25197>;
  <D.27641>:
  code.7047 = code;
  code = code.7047 + 1;
  *code.7047 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49409>; else goto <D.49410>;
    <D.49409>:
    iftmp.7048 = 4;
    goto <D.49411>;
    <D.49410>:
    iftmp.7048 = 0;
    <D.49411>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49412 = iftmp.7048 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49412;
    if (_amd64_rex_bits != 0) goto <D.49413>; else goto <D.49414>;
    <D.49413>:
    code.7049 = code;
    code = code.7049 + 1;
    D.49416 = _amd64_rex_bits | 64;
    *code.7049 = D.49416;
    <D.49414>:
  }
  code.7050 = code;
  code = code.7050 + 1;
  *code.7050 = 15;
  code.7051 = code;
  code = code.7051 + 1;
  *code.7051 = 117;
  code.7052 = code;
  code = code.7052 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7052 = D.33821;
  goto <D.25197>;
  <D.27643>:
  code.7053 = code;
  code = code.7053 + 1;
  *code.7053 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49422>; else goto <D.49423>;
    <D.49422>:
    iftmp.7054 = 4;
    goto <D.49424>;
    <D.49423>:
    iftmp.7054 = 0;
    <D.49424>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49425 = iftmp.7054 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49425;
    if (_amd64_rex_bits != 0) goto <D.49426>; else goto <D.49427>;
    <D.49426>:
    code.7055 = code;
    code = code.7055 + 1;
    D.49429 = _amd64_rex_bits | 64;
    *code.7055 = D.49429;
    <D.49427>:
  }
  code.7056 = code;
  code = code.7056 + 1;
  *code.7056 = 15;
  code.7057 = code;
  code = code.7057 + 1;
  *code.7057 = 118;
  code.7058 = code;
  code = code.7058 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7058 = D.33821;
  goto <D.25197>;
  <D.27645>:
  code.7059 = code;
  code = code.7059 + 1;
  *code.7059 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49435>; else goto <D.49436>;
    <D.49435>:
    iftmp.7060 = 4;
    goto <D.49437>;
    <D.49436>:
    iftmp.7060 = 0;
    <D.49437>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49438 = iftmp.7060 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49438;
    if (_amd64_rex_bits != 0) goto <D.49439>; else goto <D.49440>;
    <D.49439>:
    code.7061 = code;
    code = code.7061 + 1;
    D.49442 = _amd64_rex_bits | 64;
    *code.7061 = D.49442;
    <D.49440>:
  }
  code.7062 = code;
  code = code.7062 + 1;
  *code.7062 = 15;
  code.7063 = code;
  code = code.7063 + 1;
  *code.7063 = 56;
  code.7064 = code;
  code = code.7064 + 1;
  *code.7064 = 41;
  code.7065 = code;
  code = code.7065 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7065 = D.33821;
  goto <D.25197>;
  <D.27647>:
  code.7066 = code;
  code = code.7066 + 1;
  *code.7066 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49449>; else goto <D.49450>;
    <D.49449>:
    iftmp.7067 = 4;
    goto <D.49451>;
    <D.49450>:
    iftmp.7067 = 0;
    <D.49451>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49452 = iftmp.7067 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49452;
    if (_amd64_rex_bits != 0) goto <D.49453>; else goto <D.49454>;
    <D.49453>:
    code.7068 = code;
    code = code.7068 + 1;
    D.49456 = _amd64_rex_bits | 64;
    *code.7068 = D.49456;
    <D.49454>:
  }
  code.7069 = code;
  code = code.7069 + 1;
  *code.7069 = 15;
  code.7070 = code;
  code = code.7070 + 1;
  *code.7070 = 100;
  code.7071 = code;
  code = code.7071 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7071 = D.33821;
  goto <D.25197>;
  <D.27649>:
  code.7072 = code;
  code = code.7072 + 1;
  *code.7072 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49462>; else goto <D.49463>;
    <D.49462>:
    iftmp.7073 = 4;
    goto <D.49464>;
    <D.49463>:
    iftmp.7073 = 0;
    <D.49464>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49465 = iftmp.7073 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49465;
    if (_amd64_rex_bits != 0) goto <D.49466>; else goto <D.49467>;
    <D.49466>:
    code.7074 = code;
    code = code.7074 + 1;
    D.49469 = _amd64_rex_bits | 64;
    *code.7074 = D.49469;
    <D.49467>:
  }
  code.7075 = code;
  code = code.7075 + 1;
  *code.7075 = 15;
  code.7076 = code;
  code = code.7076 + 1;
  *code.7076 = 101;
  code.7077 = code;
  code = code.7077 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7077 = D.33821;
  goto <D.25197>;
  <D.27651>:
  code.7078 = code;
  code = code.7078 + 1;
  *code.7078 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49475>; else goto <D.49476>;
    <D.49475>:
    iftmp.7079 = 4;
    goto <D.49477>;
    <D.49476>:
    iftmp.7079 = 0;
    <D.49477>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49478 = iftmp.7079 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49478;
    if (_amd64_rex_bits != 0) goto <D.49479>; else goto <D.49480>;
    <D.49479>:
    code.7080 = code;
    code = code.7080 + 1;
    D.49482 = _amd64_rex_bits | 64;
    *code.7080 = D.49482;
    <D.49480>:
  }
  code.7081 = code;
  code = code.7081 + 1;
  *code.7081 = 15;
  code.7082 = code;
  code = code.7082 + 1;
  *code.7082 = 102;
  code.7083 = code;
  code = code.7083 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7083 = D.33821;
  goto <D.25197>;
  <D.27653>:
  code.7084 = code;
  code = code.7084 + 1;
  *code.7084 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49488>; else goto <D.49489>;
    <D.49488>:
    iftmp.7085 = 4;
    goto <D.49490>;
    <D.49489>:
    iftmp.7085 = 0;
    <D.49490>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49491 = iftmp.7085 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49491;
    if (_amd64_rex_bits != 0) goto <D.49492>; else goto <D.49493>;
    <D.49492>:
    code.7086 = code;
    code = code.7086 + 1;
    D.49495 = _amd64_rex_bits | 64;
    *code.7086 = D.49495;
    <D.49493>:
  }
  code.7087 = code;
  code = code.7087 + 1;
  *code.7087 = 15;
  code.7088 = code;
  code = code.7088 + 1;
  *code.7088 = 56;
  code.7089 = code;
  code = code.7089 + 1;
  *code.7089 = 55;
  code.7090 = code;
  code = code.7090 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7090 = D.33821;
  goto <D.25197>;
  <D.27655>:
  code.7091 = code;
  code = code.7091 + 1;
  *code.7091 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49502>; else goto <D.49503>;
    <D.49502>:
    iftmp.7092 = 4;
    goto <D.49504>;
    <D.49503>:
    iftmp.7092 = 0;
    <D.49504>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49505 = iftmp.7092 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49505;
    if (_amd64_rex_bits != 0) goto <D.49506>; else goto <D.49507>;
    <D.49506>:
    code.7093 = code;
    code = code.7093 + 1;
    D.49509 = _amd64_rex_bits | 64;
    *code.7093 = D.49509;
    <D.49507>:
  }
  code.7094 = code;
  code = code.7094 + 1;
  *code.7094 = 15;
  code.7095 = code;
  code = code.7095 + 1;
  *code.7095 = 246;
  code.7096 = code;
  code = code.7096 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7096 = D.33821;
  goto <D.25197>;
  <D.27657>:
  code.7097 = code;
  code = code.7097 + 1;
  *code.7097 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49515>; else goto <D.49516>;
    <D.49515>:
    iftmp.7098 = 4;
    goto <D.49517>;
    <D.49516>:
    iftmp.7098 = 0;
    <D.49517>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49518 = iftmp.7098 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49518;
    if (_amd64_rex_bits != 0) goto <D.49519>; else goto <D.49520>;
    <D.49519>:
    code.7099 = code;
    code = code.7099 + 1;
    D.49522 = _amd64_rex_bits | 64;
    *code.7099 = D.49522;
    <D.49520>:
  }
  code.7100 = code;
  code = code.7100 + 1;
  *code.7100 = 15;
  code.7101 = code;
  code = code.7101 + 1;
  *code.7101 = 96;
  code.7102 = code;
  code = code.7102 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7102 = D.33821;
  goto <D.25197>;
  <D.27659>:
  code.7103 = code;
  code = code.7103 + 1;
  *code.7103 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49528>; else goto <D.49529>;
    <D.49528>:
    iftmp.7104 = 4;
    goto <D.49530>;
    <D.49529>:
    iftmp.7104 = 0;
    <D.49530>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49531 = iftmp.7104 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49531;
    if (_amd64_rex_bits != 0) goto <D.49532>; else goto <D.49533>;
    <D.49532>:
    code.7105 = code;
    code = code.7105 + 1;
    D.49535 = _amd64_rex_bits | 64;
    *code.7105 = D.49535;
    <D.49533>:
  }
  code.7106 = code;
  code = code.7106 + 1;
  *code.7106 = 15;
  code.7107 = code;
  code = code.7107 + 1;
  *code.7107 = 97;
  code.7108 = code;
  code = code.7108 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7108 = D.33821;
  goto <D.25197>;
  <D.27661>:
  code.7109 = code;
  code = code.7109 + 1;
  *code.7109 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49541>; else goto <D.49542>;
    <D.49541>:
    iftmp.7110 = 4;
    goto <D.49543>;
    <D.49542>:
    iftmp.7110 = 0;
    <D.49543>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49544 = iftmp.7110 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49544;
    if (_amd64_rex_bits != 0) goto <D.49545>; else goto <D.49546>;
    <D.49545>:
    code.7111 = code;
    code = code.7111 + 1;
    D.49548 = _amd64_rex_bits | 64;
    *code.7111 = D.49548;
    <D.49546>:
  }
  code.7112 = code;
  code = code.7112 + 1;
  *code.7112 = 15;
  code.7113 = code;
  code = code.7113 + 1;
  *code.7113 = 98;
  code.7114 = code;
  code = code.7114 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7114 = D.33821;
  goto <D.25197>;
  <D.27663>:
  code.7115 = code;
  code = code.7115 + 1;
  *code.7115 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49554>; else goto <D.49555>;
    <D.49554>:
    iftmp.7116 = 4;
    goto <D.49556>;
    <D.49555>:
    iftmp.7116 = 0;
    <D.49556>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49557 = iftmp.7116 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49557;
    if (_amd64_rex_bits != 0) goto <D.49558>; else goto <D.49559>;
    <D.49558>:
    code.7117 = code;
    code = code.7117 + 1;
    D.49561 = _amd64_rex_bits | 64;
    *code.7117 = D.49561;
    <D.49559>:
  }
  code.7118 = code;
  code = code.7118 + 1;
  *code.7118 = 15;
  code.7119 = code;
  code = code.7119 + 1;
  *code.7119 = 108;
  code.7120 = code;
  code = code.7120 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7120 = D.33821;
  goto <D.25197>;
  <D.27665>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49566>; else goto <D.49567>;
    <D.49566>:
    iftmp.7121 = 4;
    goto <D.49568>;
    <D.49567>:
    iftmp.7121 = 0;
    <D.49568>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49569 = iftmp.7121 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49569;
    if (_amd64_rex_bits != 0) goto <D.49570>; else goto <D.49571>;
    <D.49570>:
    code.7122 = code;
    code = code.7122 + 1;
    D.49573 = _amd64_rex_bits | 64;
    *code.7122 = D.49573;
    <D.49571>:
  }
  code.7123 = code;
  code = code.7123 + 1;
  *code.7123 = 15;
  code.7124 = code;
  code = code.7124 + 1;
  *code.7124 = 20;
  code.7125 = code;
  code = code.7125 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7125 = D.33821;
  goto <D.25197>;
  <D.27667>:
  code.7126 = code;
  code = code.7126 + 1;
  *code.7126 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49579>; else goto <D.49580>;
    <D.49579>:
    iftmp.7127 = 4;
    goto <D.49581>;
    <D.49580>:
    iftmp.7127 = 0;
    <D.49581>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49582 = iftmp.7127 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49582;
    if (_amd64_rex_bits != 0) goto <D.49583>; else goto <D.49584>;
    <D.49583>:
    code.7128 = code;
    code = code.7128 + 1;
    D.49586 = _amd64_rex_bits | 64;
    *code.7128 = D.49586;
    <D.49584>:
  }
  code.7129 = code;
  code = code.7129 + 1;
  *code.7129 = 15;
  code.7130 = code;
  code = code.7130 + 1;
  *code.7130 = 20;
  code.7131 = code;
  code = code.7131 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7131 = D.33821;
  goto <D.25197>;
  <D.27669>:
  code.7132 = code;
  code = code.7132 + 1;
  *code.7132 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49592>; else goto <D.49593>;
    <D.49592>:
    iftmp.7133 = 4;
    goto <D.49594>;
    <D.49593>:
    iftmp.7133 = 0;
    <D.49594>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49595 = iftmp.7133 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49595;
    if (_amd64_rex_bits != 0) goto <D.49596>; else goto <D.49597>;
    <D.49596>:
    code.7134 = code;
    code = code.7134 + 1;
    D.49599 = _amd64_rex_bits | 64;
    *code.7134 = D.49599;
    <D.49597>:
  }
  code.7135 = code;
  code = code.7135 + 1;
  *code.7135 = 15;
  code.7136 = code;
  code = code.7136 + 1;
  *code.7136 = 104;
  code.7137 = code;
  code = code.7137 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7137 = D.33821;
  goto <D.25197>;
  <D.27671>:
  code.7138 = code;
  code = code.7138 + 1;
  *code.7138 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49605>; else goto <D.49606>;
    <D.49605>:
    iftmp.7139 = 4;
    goto <D.49607>;
    <D.49606>:
    iftmp.7139 = 0;
    <D.49607>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49608 = iftmp.7139 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49608;
    if (_amd64_rex_bits != 0) goto <D.49609>; else goto <D.49610>;
    <D.49609>:
    code.7140 = code;
    code = code.7140 + 1;
    D.49612 = _amd64_rex_bits | 64;
    *code.7140 = D.49612;
    <D.49610>:
  }
  code.7141 = code;
  code = code.7141 + 1;
  *code.7141 = 15;
  code.7142 = code;
  code = code.7142 + 1;
  *code.7142 = 105;
  code.7143 = code;
  code = code.7143 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7143 = D.33821;
  goto <D.25197>;
  <D.27673>:
  code.7144 = code;
  code = code.7144 + 1;
  *code.7144 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49618>; else goto <D.49619>;
    <D.49618>:
    iftmp.7145 = 4;
    goto <D.49620>;
    <D.49619>:
    iftmp.7145 = 0;
    <D.49620>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49621 = iftmp.7145 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49621;
    if (_amd64_rex_bits != 0) goto <D.49622>; else goto <D.49623>;
    <D.49622>:
    code.7146 = code;
    code = code.7146 + 1;
    D.49625 = _amd64_rex_bits | 64;
    *code.7146 = D.49625;
    <D.49623>:
  }
  code.7147 = code;
  code = code.7147 + 1;
  *code.7147 = 15;
  code.7148 = code;
  code = code.7148 + 1;
  *code.7148 = 106;
  code.7149 = code;
  code = code.7149 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7149 = D.33821;
  goto <D.25197>;
  <D.27675>:
  code.7150 = code;
  code = code.7150 + 1;
  *code.7150 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49631>; else goto <D.49632>;
    <D.49631>:
    iftmp.7151 = 4;
    goto <D.49633>;
    <D.49632>:
    iftmp.7151 = 0;
    <D.49633>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49634 = iftmp.7151 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49634;
    if (_amd64_rex_bits != 0) goto <D.49635>; else goto <D.49636>;
    <D.49635>:
    code.7152 = code;
    code = code.7152 + 1;
    D.49638 = _amd64_rex_bits | 64;
    *code.7152 = D.49638;
    <D.49636>:
  }
  code.7153 = code;
  code = code.7153 + 1;
  *code.7153 = 15;
  code.7154 = code;
  code = code.7154 + 1;
  *code.7154 = 109;
  code.7155 = code;
  code = code.7155 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7155 = D.33821;
  goto <D.25197>;
  <D.27677>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49643>; else goto <D.49644>;
    <D.49643>:
    iftmp.7156 = 4;
    goto <D.49645>;
    <D.49644>:
    iftmp.7156 = 0;
    <D.49645>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49646 = iftmp.7156 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49646;
    if (_amd64_rex_bits != 0) goto <D.49647>; else goto <D.49648>;
    <D.49647>:
    code.7157 = code;
    code = code.7157 + 1;
    D.49650 = _amd64_rex_bits | 64;
    *code.7157 = D.49650;
    <D.49648>:
  }
  code.7158 = code;
  code = code.7158 + 1;
  *code.7158 = 15;
  code.7159 = code;
  code = code.7159 + 1;
  *code.7159 = 21;
  code.7160 = code;
  code = code.7160 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7160 = D.33821;
  goto <D.25197>;
  <D.27679>:
  code.7161 = code;
  code = code.7161 + 1;
  *code.7161 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49656>; else goto <D.49657>;
    <D.49656>:
    iftmp.7162 = 4;
    goto <D.49658>;
    <D.49657>:
    iftmp.7162 = 0;
    <D.49658>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49659 = iftmp.7162 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49659;
    if (_amd64_rex_bits != 0) goto <D.49660>; else goto <D.49661>;
    <D.49660>:
    code.7163 = code;
    code = code.7163 + 1;
    D.49663 = _amd64_rex_bits | 64;
    *code.7163 = D.49663;
    <D.49661>:
  }
  code.7164 = code;
  code = code.7164 + 1;
  *code.7164 = 15;
  code.7165 = code;
  code = code.7165 + 1;
  *code.7165 = 21;
  code.7166 = code;
  code = code.7166 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7166 = D.33821;
  goto <D.25197>;
  <D.27681>:
  code.7167 = code;
  code = code.7167 + 1;
  *code.7167 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49669>; else goto <D.49670>;
    <D.49669>:
    iftmp.7168 = 4;
    goto <D.49671>;
    <D.49670>:
    iftmp.7168 = 0;
    <D.49671>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49672 = iftmp.7168 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49672;
    if (_amd64_rex_bits != 0) goto <D.49673>; else goto <D.49674>;
    <D.49673>:
    code.7169 = code;
    code = code.7169 + 1;
    D.49676 = _amd64_rex_bits | 64;
    *code.7169 = D.49676;
    <D.49674>:
  }
  code.7170 = code;
  code = code.7170 + 1;
  *code.7170 = 15;
  code.7171 = code;
  code = code.7171 + 1;
  *code.7171 = 99;
  code.7172 = code;
  code = code.7172 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7172 = D.33821;
  goto <D.25197>;
  <D.27683>:
  code.7173 = code;
  code = code.7173 + 1;
  *code.7173 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49682>; else goto <D.49683>;
    <D.49682>:
    iftmp.7174 = 4;
    goto <D.49684>;
    <D.49683>:
    iftmp.7174 = 0;
    <D.49684>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49685 = iftmp.7174 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49685;
    if (_amd64_rex_bits != 0) goto <D.49686>; else goto <D.49687>;
    <D.49686>:
    code.7175 = code;
    code = code.7175 + 1;
    D.49689 = _amd64_rex_bits | 64;
    *code.7175 = D.49689;
    <D.49687>:
  }
  code.7176 = code;
  code = code.7176 + 1;
  *code.7176 = 15;
  code.7177 = code;
  code = code.7177 + 1;
  *code.7177 = 107;
  code.7178 = code;
  code = code.7178 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7178 = D.33821;
  goto <D.25197>;
  <D.27685>:
  code.7179 = code;
  code = code.7179 + 1;
  *code.7179 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49695>; else goto <D.49696>;
    <D.49695>:
    iftmp.7180 = 4;
    goto <D.49697>;
    <D.49696>:
    iftmp.7180 = 0;
    <D.49697>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49698 = iftmp.7180 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49698;
    if (_amd64_rex_bits != 0) goto <D.49699>; else goto <D.49700>;
    <D.49699>:
    code.7181 = code;
    code = code.7181 + 1;
    D.49702 = _amd64_rex_bits | 64;
    *code.7181 = D.49702;
    <D.49700>:
  }
  code.7182 = code;
  code = code.7182 + 1;
  *code.7182 = 15;
  code.7183 = code;
  code = code.7183 + 1;
  *code.7183 = 103;
  code.7184 = code;
  code = code.7184 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7184 = D.33821;
  goto <D.25197>;
  <D.27687>:
  code.7185 = code;
  code = code.7185 + 1;
  *code.7185 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49708>; else goto <D.49709>;
    <D.49708>:
    iftmp.7186 = 4;
    goto <D.49710>;
    <D.49709>:
    iftmp.7186 = 0;
    <D.49710>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49711 = iftmp.7186 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49711;
    if (_amd64_rex_bits != 0) goto <D.49712>; else goto <D.49713>;
    <D.49712>:
    code.7187 = code;
    code = code.7187 + 1;
    D.49715 = _amd64_rex_bits | 64;
    *code.7187 = D.49715;
    <D.49713>:
  }
  code.7188 = code;
  code = code.7188 + 1;
  *code.7188 = 15;
  code.7189 = code;
  code = code.7189 + 1;
  *code.7189 = 56;
  code.7190 = code;
  code = code.7190 + 1;
  *code.7190 = 43;
  code.7191 = code;
  code = code.7191 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7191 = D.33821;
  goto <D.25197>;
  <D.27689>:
  code.7192 = code;
  code = code.7192 + 1;
  *code.7192 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49722>; else goto <D.49723>;
    <D.49722>:
    iftmp.7193 = 4;
    goto <D.49724>;
    <D.49723>:
    iftmp.7193 = 0;
    <D.49724>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49725 = iftmp.7193 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49725;
    if (_amd64_rex_bits != 0) goto <D.49726>; else goto <D.49727>;
    <D.49726>:
    code.7194 = code;
    code = code.7194 + 1;
    D.49729 = _amd64_rex_bits | 64;
    *code.7194 = D.49729;
    <D.49727>:
  }
  code.7195 = code;
  code = code.7195 + 1;
  *code.7195 = 15;
  code.7196 = code;
  code = code.7196 + 1;
  *code.7196 = 220;
  code.7197 = code;
  code = code.7197 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7197 = D.33821;
  goto <D.25197>;
  <D.27691>:
  code.7198 = code;
  code = code.7198 + 1;
  *code.7198 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49735>; else goto <D.49736>;
    <D.49735>:
    iftmp.7199 = 4;
    goto <D.49737>;
    <D.49736>:
    iftmp.7199 = 0;
    <D.49737>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49738 = iftmp.7199 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49738;
    if (_amd64_rex_bits != 0) goto <D.49739>; else goto <D.49740>;
    <D.49739>:
    code.7200 = code;
    code = code.7200 + 1;
    D.49742 = _amd64_rex_bits | 64;
    *code.7200 = D.49742;
    <D.49740>:
  }
  code.7201 = code;
  code = code.7201 + 1;
  *code.7201 = 15;
  code.7202 = code;
  code = code.7202 + 1;
  *code.7202 = 216;
  code.7203 = code;
  code = code.7203 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7203 = D.33821;
  goto <D.25197>;
  <D.27693>:
  code.7204 = code;
  code = code.7204 + 1;
  *code.7204 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49748>; else goto <D.49749>;
    <D.49748>:
    iftmp.7205 = 4;
    goto <D.49750>;
    <D.49749>:
    iftmp.7205 = 0;
    <D.49750>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49751 = iftmp.7205 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49751;
    if (_amd64_rex_bits != 0) goto <D.49752>; else goto <D.49753>;
    <D.49752>:
    code.7206 = code;
    code = code.7206 + 1;
    D.49755 = _amd64_rex_bits | 64;
    *code.7206 = D.49755;
    <D.49753>:
  }
  code.7207 = code;
  code = code.7207 + 1;
  *code.7207 = 15;
  code.7208 = code;
  code = code.7208 + 1;
  *code.7208 = 221;
  code.7209 = code;
  code = code.7209 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7209 = D.33821;
  goto <D.25197>;
  <D.27695>:
  code.7210 = code;
  code = code.7210 + 1;
  *code.7210 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49761>; else goto <D.49762>;
    <D.49761>:
    iftmp.7211 = 4;
    goto <D.49763>;
    <D.49762>:
    iftmp.7211 = 0;
    <D.49763>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49764 = iftmp.7211 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49764;
    if (_amd64_rex_bits != 0) goto <D.49765>; else goto <D.49766>;
    <D.49765>:
    code.7212 = code;
    code = code.7212 + 1;
    D.49768 = _amd64_rex_bits | 64;
    *code.7212 = D.49768;
    <D.49766>:
  }
  code.7213 = code;
  code = code.7213 + 1;
  *code.7213 = 15;
  code.7214 = code;
  code = code.7214 + 1;
  *code.7214 = 216;
  code.7215 = code;
  code = code.7215 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7215 = D.33821;
  goto <D.25197>;
  <D.27697>:
  code.7216 = code;
  code = code.7216 + 1;
  *code.7216 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49774>; else goto <D.49775>;
    <D.49774>:
    iftmp.7217 = 4;
    goto <D.49776>;
    <D.49775>:
    iftmp.7217 = 0;
    <D.49776>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49777 = iftmp.7217 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49777;
    if (_amd64_rex_bits != 0) goto <D.49778>; else goto <D.49779>;
    <D.49778>:
    code.7218 = code;
    code = code.7218 + 1;
    D.49781 = _amd64_rex_bits | 64;
    *code.7218 = D.49781;
    <D.49779>:
  }
  code.7219 = code;
  code = code.7219 + 1;
  *code.7219 = 15;
  code.7220 = code;
  code = code.7220 + 1;
  *code.7220 = 236;
  code.7221 = code;
  code = code.7221 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7221 = D.33821;
  goto <D.25197>;
  <D.27699>:
  code.7222 = code;
  code = code.7222 + 1;
  *code.7222 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49787>; else goto <D.49788>;
    <D.49787>:
    iftmp.7223 = 4;
    goto <D.49789>;
    <D.49788>:
    iftmp.7223 = 0;
    <D.49789>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49790 = iftmp.7223 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49790;
    if (_amd64_rex_bits != 0) goto <D.49791>; else goto <D.49792>;
    <D.49791>:
    code.7224 = code;
    code = code.7224 + 1;
    D.49794 = _amd64_rex_bits | 64;
    *code.7224 = D.49794;
    <D.49792>:
  }
  code.7225 = code;
  code = code.7225 + 1;
  *code.7225 = 15;
  code.7226 = code;
  code = code.7226 + 1;
  *code.7226 = 232;
  code.7227 = code;
  code = code.7227 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7227 = D.33821;
  goto <D.25197>;
  <D.27701>:
  code.7228 = code;
  code = code.7228 + 1;
  *code.7228 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49800>; else goto <D.49801>;
    <D.49800>:
    iftmp.7229 = 4;
    goto <D.49802>;
    <D.49801>:
    iftmp.7229 = 0;
    <D.49802>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49803 = iftmp.7229 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49803;
    if (_amd64_rex_bits != 0) goto <D.49804>; else goto <D.49805>;
    <D.49804>:
    code.7230 = code;
    code = code.7230 + 1;
    D.49807 = _amd64_rex_bits | 64;
    *code.7230 = D.49807;
    <D.49805>:
  }
  code.7231 = code;
  code = code.7231 + 1;
  *code.7231 = 15;
  code.7232 = code;
  code = code.7232 + 1;
  *code.7232 = 237;
  code.7233 = code;
  code = code.7233 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7233 = D.33821;
  goto <D.25197>;
  <D.27703>:
  code.7234 = code;
  code = code.7234 + 1;
  *code.7234 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49813>; else goto <D.49814>;
    <D.49813>:
    iftmp.7235 = 4;
    goto <D.49815>;
    <D.49814>:
    iftmp.7235 = 0;
    <D.49815>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49816 = iftmp.7235 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49816;
    if (_amd64_rex_bits != 0) goto <D.49817>; else goto <D.49818>;
    <D.49817>:
    code.7236 = code;
    code = code.7236 + 1;
    D.49820 = _amd64_rex_bits | 64;
    *code.7236 = D.49820;
    <D.49818>:
  }
  code.7237 = code;
  code = code.7237 + 1;
  *code.7237 = 15;
  code.7238 = code;
  code = code.7238 + 1;
  *code.7238 = 233;
  code.7239 = code;
  code = code.7239 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7239 = D.33821;
  goto <D.25197>;
  <D.27705>:
  code.7240 = code;
  code = code.7240 + 1;
  *code.7240 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49826>; else goto <D.49827>;
    <D.49826>:
    iftmp.7241 = 4;
    goto <D.49828>;
    <D.49827>:
    iftmp.7241 = 0;
    <D.49828>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49829 = iftmp.7241 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49829;
    if (_amd64_rex_bits != 0) goto <D.49830>; else goto <D.49831>;
    <D.49830>:
    code.7242 = code;
    code = code.7242 + 1;
    D.49833 = _amd64_rex_bits | 64;
    *code.7242 = D.49833;
    <D.49831>:
  }
  code.7243 = code;
  code = code.7243 + 1;
  *code.7243 = 15;
  code.7244 = code;
  code = code.7244 + 1;
  *code.7244 = 213;
  code.7245 = code;
  code = code.7245 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7245 = D.33821;
  goto <D.25197>;
  <D.27707>:
  code.7246 = code;
  code = code.7246 + 1;
  *code.7246 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49839>; else goto <D.49840>;
    <D.49839>:
    iftmp.7247 = 4;
    goto <D.49841>;
    <D.49840>:
    iftmp.7247 = 0;
    <D.49841>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49842 = iftmp.7247 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49842;
    if (_amd64_rex_bits != 0) goto <D.49843>; else goto <D.49844>;
    <D.49843>:
    code.7248 = code;
    code = code.7248 + 1;
    D.49846 = _amd64_rex_bits | 64;
    *code.7248 = D.49846;
    <D.49844>:
  }
  code.7249 = code;
  code = code.7249 + 1;
  *code.7249 = 15;
  code.7250 = code;
  code = code.7250 + 1;
  *code.7250 = 56;
  code.7251 = code;
  code = code.7251 + 1;
  *code.7251 = 64;
  code.7252 = code;
  code = code.7252 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7252 = D.33821;
  goto <D.25197>;
  <D.27709>:
  code.7253 = code;
  code = code.7253 + 1;
  *code.7253 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49853>; else goto <D.49854>;
    <D.49853>:
    iftmp.7254 = 4;
    goto <D.49855>;
    <D.49854>:
    iftmp.7254 = 0;
    <D.49855>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49856 = iftmp.7254 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49856;
    if (_amd64_rex_bits != 0) goto <D.49857>; else goto <D.49858>;
    <D.49857>:
    code.7255 = code;
    code = code.7255 + 1;
    D.49860 = _amd64_rex_bits | 64;
    *code.7255 = D.49860;
    <D.49858>:
  }
  code.7256 = code;
  code = code.7256 + 1;
  *code.7256 = 15;
  code.7257 = code;
  code = code.7257 + 1;
  *code.7257 = 244;
  code.7258 = code;
  code = code.7258 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7258 = D.33821;
  goto <D.25197>;
  <D.27711>:
  code.7259 = code;
  code = code.7259 + 1;
  *code.7259 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49866>; else goto <D.49867>;
    <D.49866>:
    iftmp.7260 = 4;
    goto <D.49868>;
    <D.49867>:
    iftmp.7260 = 0;
    <D.49868>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49869 = iftmp.7260 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49869;
    if (_amd64_rex_bits != 0) goto <D.49870>; else goto <D.49871>;
    <D.49870>:
    code.7261 = code;
    code = code.7261 + 1;
    D.49873 = _amd64_rex_bits | 64;
    *code.7261 = D.49873;
    <D.49871>:
  }
  code.7262 = code;
  code = code.7262 + 1;
  *code.7262 = 15;
  code.7263 = code;
  code = code.7263 + 1;
  *code.7263 = 228;
  code.7264 = code;
  code = code.7264 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7264 = D.33821;
  goto <D.25197>;
  <D.27713>:
  code.7265 = code;
  code = code.7265 + 1;
  *code.7265 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.49879>; else goto <D.49880>;
    <D.49879>:
    iftmp.7266 = 4;
    goto <D.49881>;
    <D.49880>:
    iftmp.7266 = 0;
    <D.49881>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49882 = iftmp.7266 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49882;
    if (_amd64_rex_bits != 0) goto <D.49883>; else goto <D.49884>;
    <D.49883>:
    code.7267 = code;
    code = code.7267 + 1;
    D.49886 = _amd64_rex_bits | 64;
    *code.7267 = D.49886;
    <D.49884>:
  }
  code.7268 = code;
  code = code.7268 + 1;
  *code.7268 = 15;
  code.7269 = code;
  code = code.7269 + 1;
  *code.7269 = 229;
  code.7270 = code;
  code = code.7270 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7270 = D.33821;
  goto <D.25197>;
  <D.27715>:
  code.7271 = code;
  code = code.7271 + 1;
  *code.7271 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.49891>; else goto <D.49892>;
    <D.49891>:
    code.7272 = code;
    code = code.7272 + 1;
    D.49894 = _amd64_rex_bits | 64;
    *code.7272 = D.49894;
    <D.49892>:
  }
  code.7273 = code;
  code = code.7273 + 1;
  *code.7273 = 15;
  code.7274 = code;
  code = code.7274 + 1;
  *code.7274 = 113;
  code.7275 = code;
  code = code.7275 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.7275 = D.37246;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27717>:
  code.7276 = code;
  code = code.7276 + 1;
  *code.7276 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49900>; else goto <D.49901>;
    <D.49900>:
    iftmp.7277 = 4;
    goto <D.49902>;
    <D.49901>:
    iftmp.7277 = 0;
    <D.49902>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49903 = iftmp.7277 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49903;
    if (_amd64_rex_bits != 0) goto <D.49904>; else goto <D.49905>;
    <D.49904>:
    code.7278 = code;
    code = code.7278 + 1;
    D.49907 = _amd64_rex_bits | 64;
    *code.7278 = D.49907;
    <D.49905>:
  }
  code.7279 = code;
  code = code.7279 + 1;
  *code.7279 = 15;
  code.7280 = code;
  code = code.7280 + 1;
  *code.7280 = 209;
  code.7281 = code;
  code = code.7281 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7281 = D.39958;
  goto <D.25197>;
  <D.27719>:
  code.7282 = code;
  code = code.7282 + 1;
  *code.7282 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.49912>; else goto <D.49913>;
    <D.49912>:
    code.7283 = code;
    code = code.7283 + 1;
    D.49915 = _amd64_rex_bits | 64;
    *code.7283 = D.49915;
    <D.49913>:
  }
  code.7284 = code;
  code = code.7284 + 1;
  *code.7284 = 15;
  code.7285 = code;
  code = code.7285 + 1;
  *code.7285 = 113;
  code.7286 = code;
  code = code.7286 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.7286 = D.37855;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27721>:
  code.7287 = code;
  code = code.7287 + 1;
  *code.7287 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49921>; else goto <D.49922>;
    <D.49921>:
    iftmp.7288 = 4;
    goto <D.49923>;
    <D.49922>:
    iftmp.7288 = 0;
    <D.49923>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49924 = iftmp.7288 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49924;
    if (_amd64_rex_bits != 0) goto <D.49925>; else goto <D.49926>;
    <D.49925>:
    code.7289 = code;
    code = code.7289 + 1;
    D.49928 = _amd64_rex_bits | 64;
    *code.7289 = D.49928;
    <D.49926>:
  }
  code.7290 = code;
  code = code.7290 + 1;
  *code.7290 = 15;
  code.7291 = code;
  code = code.7291 + 1;
  *code.7291 = 225;
  code.7292 = code;
  code = code.7292 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7292 = D.39958;
  goto <D.25197>;
  <D.27723>:
  code.7293 = code;
  code = code.7293 + 1;
  *code.7293 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.49933>; else goto <D.49934>;
    <D.49933>:
    code.7294 = code;
    code = code.7294 + 1;
    D.49936 = _amd64_rex_bits | 64;
    *code.7294 = D.49936;
    <D.49934>:
  }
  code.7295 = code;
  code = code.7295 + 1;
  *code.7295 = 15;
  code.7296 = code;
  code = code.7296 + 1;
  *code.7296 = 113;
  code.7297 = code;
  code = code.7297 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.49940 = D.31632 | -16;
  D.49941 = (unsigned char) D.49940;
  *code.7297 = D.49941;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27725>:
  code.7298 = code;
  code = code.7298 + 1;
  *code.7298 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49944>; else goto <D.49945>;
    <D.49944>:
    iftmp.7299 = 4;
    goto <D.49946>;
    <D.49945>:
    iftmp.7299 = 0;
    <D.49946>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49947 = iftmp.7299 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49947;
    if (_amd64_rex_bits != 0) goto <D.49948>; else goto <D.49949>;
    <D.49948>:
    code.7300 = code;
    code = code.7300 + 1;
    D.49951 = _amd64_rex_bits | 64;
    *code.7300 = D.49951;
    <D.49949>:
  }
  code.7301 = code;
  code = code.7301 + 1;
  *code.7301 = 15;
  code.7302 = code;
  code = code.7302 + 1;
  *code.7302 = 241;
  code.7303 = code;
  code = code.7303 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7303 = D.39958;
  goto <D.25197>;
  <D.27727>:
  code.7304 = code;
  code = code.7304 + 1;
  *code.7304 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.49956>; else goto <D.49957>;
    <D.49956>:
    code.7305 = code;
    code = code.7305 + 1;
    D.49959 = _amd64_rex_bits | 64;
    *code.7305 = D.49959;
    <D.49957>:
  }
  code.7306 = code;
  code = code.7306 + 1;
  *code.7306 = 15;
  code.7307 = code;
  code = code.7307 + 1;
  *code.7307 = 114;
  code.7308 = code;
  code = code.7308 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.7308 = D.37246;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27729>:
  code.7309 = code;
  code = code.7309 + 1;
  *code.7309 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49965>; else goto <D.49966>;
    <D.49965>:
    iftmp.7310 = 4;
    goto <D.49967>;
    <D.49966>:
    iftmp.7310 = 0;
    <D.49967>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49968 = iftmp.7310 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49968;
    if (_amd64_rex_bits != 0) goto <D.49969>; else goto <D.49970>;
    <D.49969>:
    code.7311 = code;
    code = code.7311 + 1;
    D.49972 = _amd64_rex_bits | 64;
    *code.7311 = D.49972;
    <D.49970>:
  }
  code.7312 = code;
  code = code.7312 + 1;
  *code.7312 = 15;
  code.7313 = code;
  code = code.7313 + 1;
  *code.7313 = 210;
  code.7314 = code;
  code = code.7314 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7314 = D.39958;
  goto <D.25197>;
  <D.27731>:
  code.7315 = code;
  code = code.7315 + 1;
  *code.7315 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.49977>; else goto <D.49978>;
    <D.49977>:
    code.7316 = code;
    code = code.7316 + 1;
    D.49980 = _amd64_rex_bits | 64;
    *code.7316 = D.49980;
    <D.49978>:
  }
  code.7317 = code;
  code = code.7317 + 1;
  *code.7317 = 15;
  code.7318 = code;
  code = code.7318 + 1;
  *code.7318 = 114;
  code.7319 = code;
  code = code.7319 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37854 = D.31632 | -32;
  D.37855 = (unsigned char) D.37854;
  *code.7319 = D.37855;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27733>:
  code.7320 = code;
  code = code.7320 + 1;
  *code.7320 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.49986>; else goto <D.49987>;
    <D.49986>:
    iftmp.7321 = 4;
    goto <D.49988>;
    <D.49987>:
    iftmp.7321 = 0;
    <D.49988>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.49989 = iftmp.7321 | D.33811;
    _amd64_rex_bits = (unsigned char) D.49989;
    if (_amd64_rex_bits != 0) goto <D.49990>; else goto <D.49991>;
    <D.49990>:
    code.7322 = code;
    code = code.7322 + 1;
    D.49993 = _amd64_rex_bits | 64;
    *code.7322 = D.49993;
    <D.49991>:
  }
  code.7323 = code;
  code = code.7323 + 1;
  *code.7323 = 15;
  code.7324 = code;
  code = code.7324 + 1;
  *code.7324 = 226;
  code.7325 = code;
  code = code.7325 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7325 = D.39958;
  goto <D.25197>;
  <D.27735>:
  code.7326 = code;
  code = code.7326 + 1;
  *code.7326 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.49998>; else goto <D.49999>;
    <D.49998>:
    code.7327 = code;
    code = code.7327 + 1;
    D.50001 = _amd64_rex_bits | 64;
    *code.7327 = D.50001;
    <D.49999>:
  }
  code.7328 = code;
  code = code.7328 + 1;
  *code.7328 = 15;
  code.7329 = code;
  code = code.7329 + 1;
  *code.7329 = 114;
  code.7330 = code;
  code = code.7330 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.49940 = D.31632 | -16;
  D.49941 = (unsigned char) D.49940;
  *code.7330 = D.49941;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27737>:
  code.7331 = code;
  code = code.7331 + 1;
  *code.7331 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50007>; else goto <D.50008>;
    <D.50007>:
    iftmp.7332 = 4;
    goto <D.50009>;
    <D.50008>:
    iftmp.7332 = 0;
    <D.50009>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50010 = iftmp.7332 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50010;
    if (_amd64_rex_bits != 0) goto <D.50011>; else goto <D.50012>;
    <D.50011>:
    code.7333 = code;
    code = code.7333 + 1;
    D.50014 = _amd64_rex_bits | 64;
    *code.7333 = D.50014;
    <D.50012>:
  }
  code.7334 = code;
  code = code.7334 + 1;
  *code.7334 = 15;
  code.7335 = code;
  code = code.7335 + 1;
  *code.7335 = 242;
  code.7336 = code;
  code = code.7336 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7336 = D.39958;
  goto <D.25197>;
  <D.27739>:
  code.7337 = code;
  code = code.7337 + 1;
  *code.7337 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.50019>; else goto <D.50020>;
    <D.50019>:
    code.7338 = code;
    code = code.7338 + 1;
    D.50022 = _amd64_rex_bits | 64;
    *code.7338 = D.50022;
    <D.50020>:
  }
  code.7339 = code;
  code = code.7339 + 1;
  *code.7339 = 15;
  code.7340 = code;
  code = code.7340 + 1;
  *code.7340 = 115;
  code.7341 = code;
  code = code.7341 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37245 = D.31632 | -48;
  D.37246 = (unsigned char) D.37245;
  *code.7341 = D.37246;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27741>:
  code.7342 = code;
  code = code.7342 + 1;
  *code.7342 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50028>; else goto <D.50029>;
    <D.50028>:
    iftmp.7343 = 4;
    goto <D.50030>;
    <D.50029>:
    iftmp.7343 = 0;
    <D.50030>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50031 = iftmp.7343 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50031;
    if (_amd64_rex_bits != 0) goto <D.50032>; else goto <D.50033>;
    <D.50032>:
    code.7344 = code;
    code = code.7344 + 1;
    D.50035 = _amd64_rex_bits | 64;
    *code.7344 = D.50035;
    <D.50033>:
  }
  code.7345 = code;
  code = code.7345 + 1;
  *code.7345 = 15;
  code.7346 = code;
  code = code.7346 + 1;
  *code.7346 = 211;
  code.7347 = code;
  code = code.7347 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7347 = D.39958;
  goto <D.25197>;
  <D.27743>:
  code.7348 = code;
  code = code.7348 + 1;
  *code.7348 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    _amd64_rex_bits = (unsigned char) D.31590;
    if (_amd64_rex_bits != 0) goto <D.50040>; else goto <D.50041>;
    <D.50040>:
    code.7349 = code;
    code = code.7349 + 1;
    D.50043 = _amd64_rex_bits | 64;
    *code.7349 = D.50043;
    <D.50041>:
  }
  code.7350 = code;
  code = code.7350 + 1;
  *code.7350 = 15;
  code.7351 = code;
  code = code.7351 + 1;
  *code.7351 = 115;
  code.7352 = code;
  code = code.7352 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.49940 = D.31632 | -16;
  D.49941 = (unsigned char) D.49940;
  *code.7352 = D.49941;
  D.31647 = ins->data.op[1].const_val;
  D.31648 = (unsigned char) D.31647;
  *code = D.31648;
  code = code + 1;
  goto <D.25197>;
  <D.27745>:
  code.7353 = code;
  code = code.7353 + 1;
  *code.7353 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50049>; else goto <D.50050>;
    <D.50049>:
    iftmp.7354 = 4;
    goto <D.50051>;
    <D.50050>:
    iftmp.7354 = 0;
    <D.50051>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50052 = iftmp.7354 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50052;
    if (_amd64_rex_bits != 0) goto <D.50053>; else goto <D.50054>;
    <D.50053>:
    code.7355 = code;
    code = code.7355 + 1;
    D.50056 = _amd64_rex_bits | 64;
    *code.7355 = D.50056;
    <D.50054>:
  }
  code.7356 = code;
  code = code.7356 + 1;
  *code.7356 = 15;
  code.7357 = code;
  code = code.7357 + 1;
  *code.7357 = 243;
  code.7358 = code;
  code = code.7358 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7358 = D.39958;
  goto <D.25197>;
  <D.27747>:
  code.7359 = code;
  code = code.7359 + 1;
  *code.7359 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50062>; else goto <D.50063>;
    <D.50062>:
    iftmp.7360 = 4;
    goto <D.50064>;
    <D.50063>:
    iftmp.7360 = 0;
    <D.50064>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50065 = iftmp.7360 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50065;
    if (_amd64_rex_bits != 0) goto <D.50066>; else goto <D.50067>;
    <D.50066>:
    code.7361 = code;
    code = code.7361 + 1;
    D.50069 = _amd64_rex_bits | 64;
    *code.7361 = D.50069;
    <D.50067>:
  }
  code.7362 = code;
  code = code.7362 + 1;
  *code.7362 = 15;
  code.7363 = code;
  code = code.7363 + 1;
  *code.7363 = 230;
  code.7364 = code;
  code = code.7364 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7364 = D.33727;
  goto <D.25197>;
  <D.27749>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50074>; else goto <D.50075>;
    <D.50074>:
    iftmp.7365 = 4;
    goto <D.50076>;
    <D.50075>:
    iftmp.7365 = 0;
    <D.50076>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50077 = iftmp.7365 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50077;
    if (_amd64_rex_bits != 0) goto <D.50078>; else goto <D.50079>;
    <D.50078>:
    code.7366 = code;
    code = code.7366 + 1;
    D.50081 = _amd64_rex_bits | 64;
    *code.7366 = D.50081;
    <D.50079>:
  }
  code.7367 = code;
  code = code.7367 + 1;
  *code.7367 = 15;
  code.7368 = code;
  code = code.7368 + 1;
  *code.7368 = 91;
  code.7369 = code;
  code = code.7369 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7369 = D.33727;
  goto <D.25197>;
  <D.27751>:
  code.7370 = code;
  code = code.7370 + 1;
  *code.7370 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50087>; else goto <D.50088>;
    <D.50087>:
    iftmp.7371 = 4;
    goto <D.50089>;
    <D.50088>:
    iftmp.7371 = 0;
    <D.50089>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50090 = iftmp.7371 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50090;
    if (_amd64_rex_bits != 0) goto <D.50091>; else goto <D.50092>;
    <D.50091>:
    code.7372 = code;
    code = code.7372 + 1;
    D.50094 = _amd64_rex_bits | 64;
    *code.7372 = D.50094;
    <D.50092>:
  }
  code.7373 = code;
  code = code.7373 + 1;
  *code.7373 = 15;
  code.7374 = code;
  code = code.7374 + 1;
  *code.7374 = 230;
  code.7375 = code;
  code = code.7375 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7375 = D.33727;
  goto <D.25197>;
  <D.27753>:
  code.7376 = code;
  code = code.7376 + 1;
  *code.7376 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50100>; else goto <D.50101>;
    <D.50100>:
    iftmp.7377 = 4;
    goto <D.50102>;
    <D.50101>:
    iftmp.7377 = 0;
    <D.50102>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50103 = iftmp.7377 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50103;
    if (_amd64_rex_bits != 0) goto <D.50104>; else goto <D.50105>;
    <D.50104>:
    code.7378 = code;
    code = code.7378 + 1;
    D.50107 = _amd64_rex_bits | 64;
    *code.7378 = D.50107;
    <D.50105>:
  }
  code.7379 = code;
  code = code.7379 + 1;
  *code.7379 = 15;
  code.7380 = code;
  code = code.7380 + 1;
  *code.7380 = 90;
  code.7381 = code;
  code = code.7381 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7381 = D.33727;
  goto <D.25197>;
  <D.27755>:
  code.7382 = code;
  code = code.7382 + 1;
  *code.7382 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50113>; else goto <D.50114>;
    <D.50113>:
    iftmp.7383 = 4;
    goto <D.50115>;
    <D.50114>:
    iftmp.7383 = 0;
    <D.50115>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50116 = iftmp.7383 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50116;
    if (_amd64_rex_bits != 0) goto <D.50117>; else goto <D.50118>;
    <D.50117>:
    code.7384 = code;
    code = code.7384 + 1;
    D.50120 = _amd64_rex_bits | 64;
    *code.7384 = D.50120;
    <D.50118>:
  }
  code.7385 = code;
  code = code.7385 + 1;
  *code.7385 = 15;
  code.7386 = code;
  code = code.7386 + 1;
  *code.7386 = 91;
  code.7387 = code;
  code = code.7387 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7387 = D.33727;
  goto <D.25197>;
  <D.27757>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50125>; else goto <D.50126>;
    <D.50125>:
    iftmp.7388 = 4;
    goto <D.50127>;
    <D.50126>:
    iftmp.7388 = 0;
    <D.50127>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50128 = iftmp.7388 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50128;
    if (_amd64_rex_bits != 0) goto <D.50129>; else goto <D.50130>;
    <D.50129>:
    code.7389 = code;
    code = code.7389 + 1;
    D.50132 = _amd64_rex_bits | 64;
    *code.7389 = D.50132;
    <D.50130>:
  }
  code.7390 = code;
  code = code.7390 + 1;
  *code.7390 = 15;
  code.7391 = code;
  code = code.7391 + 1;
  *code.7391 = 90;
  code.7392 = code;
  code = code.7392 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7392 = D.33727;
  goto <D.25197>;
  <D.27759>:
  code.7393 = code;
  code = code.7393 + 1;
  *code.7393 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50138>; else goto <D.50139>;
    <D.50138>:
    iftmp.7394 = 4;
    goto <D.50140>;
    <D.50139>:
    iftmp.7394 = 0;
    <D.50140>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50141 = iftmp.7394 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50141;
    if (_amd64_rex_bits != 0) goto <D.50142>; else goto <D.50143>;
    <D.50142>:
    code.7395 = code;
    code = code.7395 + 1;
    D.50145 = _amd64_rex_bits | 64;
    *code.7395 = D.50145;
    <D.50143>:
  }
  code.7396 = code;
  code = code.7396 + 1;
  *code.7396 = 15;
  code.7397 = code;
  code = code.7397 + 1;
  *code.7397 = 230;
  code.7398 = code;
  code = code.7398 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7398 = D.33727;
  goto <D.25197>;
  <D.27761>:
  code.7399 = code;
  code = code.7399 + 1;
  *code.7399 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50151>; else goto <D.50152>;
    <D.50151>:
    iftmp.7400 = 4;
    goto <D.50153>;
    <D.50152>:
    iftmp.7400 = 0;
    <D.50153>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50154 = iftmp.7400 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50154;
    if (_amd64_rex_bits != 0) goto <D.50155>; else goto <D.50156>;
    <D.50155>:
    code.7401 = code;
    code = code.7401 + 1;
    D.50158 = _amd64_rex_bits | 64;
    *code.7401 = D.50158;
    <D.50156>:
  }
  code.7402 = code;
  code = code.7402 + 1;
  *code.7402 = 15;
  code.7403 = code;
  code = code.7403 + 1;
  *code.7403 = 91;
  code.7404 = code;
  code = code.7404 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7404 = D.33727;
  goto <D.25197>;
  <D.27763>:
  code.7405 = code;
  code = code.7405 + 1;
  *code.7405 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50164>; else goto <D.50165>;
    <D.50164>:
    iftmp.7406 = 4;
    goto <D.50166>;
    <D.50165>:
    iftmp.7406 = 0;
    <D.50166>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50167 = iftmp.7406 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50167;
    if (_amd64_rex_bits != 0) goto <D.50168>; else goto <D.50169>;
    <D.50168>:
    code.7407 = code;
    code = code.7407 + 1;
    D.50171 = _amd64_rex_bits | 64;
    *code.7407 = D.50171;
    <D.50169>:
  }
  code.7408 = code;
  code = code.7408 + 1;
  *code.7408 = 15;
  code.7409 = code;
  code = code.7409 + 1;
  *code.7409 = 110;
  code.7410 = code;
  code = code.7410 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7410 = D.33727;
  goto <D.25197>;
  <D.27765>:
  code.7411 = code;
  code = code.7411 + 1;
  *code.7411 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50177>; else goto <D.50178>;
    <D.50177>:
    iftmp.7412 = 4;
    goto <D.50179>;
    <D.50178>:
    iftmp.7412 = 0;
    <D.50179>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50180 = iftmp.7412 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50180;
    if (_amd64_rex_bits != 0) goto <D.50181>; else goto <D.50182>;
    <D.50181>:
    code.7413 = code;
    code = code.7413 + 1;
    D.50184 = _amd64_rex_bits | 64;
    *code.7413 = D.50184;
    <D.50182>:
  }
  code.7414 = code;
  code = code.7414 + 1;
  *code.7414 = 15;
  code.7415 = code;
  code = code.7415 + 1;
  *code.7415 = 126;
  code.7416 = code;
  code = code.7416 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.50188 = D.33819 | D.31632;
  D.50189 = (unsigned char) D.50188;
  *code.7416 = D.50189;
  goto <D.25197>;
  <D.27767>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 != 0) goto <D.50190>; else goto <D.50191>;
  <D.50190>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50193>; else goto <D.50194>;
    <D.50193>:
    iftmp.7417 = 5;
    goto <D.50195>;
    <D.50194>:
    iftmp.7417 = 4;
    <D.50195>:
    _amd64_rex_bits = iftmp.7417;
    if (_amd64_rex_bits != 0) goto <D.50196>; else goto <D.50197>;
    <D.50196>:
    code.7418 = code;
    code = code.7418 + 1;
    D.50199 = _amd64_rex_bits | 64;
    *code.7418 = D.50199;
    <D.50197>:
  }
  code.7419 = code;
  code = code.7419 + 1;
  *code.7419 = 15;
  code.7420 = code;
  code = code.7420 + 1;
  *code.7420 = 18;
  code.7421 = code;
  code = code.7421 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.33838 = D.31570 | -8;
  D.33839 = (unsigned char) D.33838;
  *code.7421 = D.33839;
  code.7422 = code;
  code = code.7422 + 1;
  *code.7422 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50205>; else goto <D.50206>;
    <D.50205>:
    iftmp.7423 = 13;
    goto <D.50207>;
    <D.50206>:
    iftmp.7423 = 12;
    <D.50207>:
    _amd64_rex_bits = iftmp.7423;
    if (_amd64_rex_bits != 0) goto <D.50208>; else goto <D.50209>;
    <D.50208>:
    code.7424 = code;
    code = code.7424 + 1;
    D.50211 = _amd64_rex_bits | 64;
    *code.7424 = D.50211;
    <D.50209>:
  }
  code.7425 = code;
  code = code.7425 + 1;
  *code.7425 = 15;
  code.7426 = code;
  code = code.7426 + 1;
  *code.7426 = 126;
  code.7427 = code;
  code = code.7427 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.38948 = D.31631 | -8;
  D.38949 = (unsigned char) D.38948;
  *code.7427 = D.38949;
  goto <D.50215>;
  <D.50191>:
  code.7428 = code;
  code = code.7428 + 1;
  *code.7428 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50218>; else goto <D.50219>;
    <D.50218>:
    iftmp.7429 = 12;
    goto <D.50220>;
    <D.50219>:
    iftmp.7429 = 8;
    <D.50220>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50221 = iftmp.7429 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50221;
    if (_amd64_rex_bits != 0) goto <D.50222>; else goto <D.50223>;
    <D.50222>:
    code.7430 = code;
    code = code.7430 + 1;
    D.50225 = _amd64_rex_bits | 64;
    *code.7430 = D.50225;
    <D.50223>:
  }
  code.7431 = code;
  code = code.7431 + 1;
  *code.7431 = 15;
  code.7432 = code;
  code = code.7432 + 1;
  *code.7432 = 126;
  code.7433 = code;
  code = code.7433 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.50188 = D.33819 | D.31632;
  D.50189 = (unsigned char) D.50188;
  *code.7433 = D.50189;
  <D.50215>:
  goto <D.25197>;
  <D.27771>:
  <D.27772>:
  code.7434 = code;
  code = code.7434 + 1;
  *code.7434 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50231>; else goto <D.50232>;
    <D.50231>:
    iftmp.7435 = 4;
    goto <D.50233>;
    <D.50232>:
    iftmp.7435 = 0;
    <D.50233>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50234 = iftmp.7435 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50234;
    if (_amd64_rex_bits != 0) goto <D.50235>; else goto <D.50236>;
    <D.50235>:
    code.7436 = code;
    code = code.7436 + 1;
    D.50238 = _amd64_rex_bits | 64;
    *code.7436 = D.50238;
    <D.50236>:
  }
  code.7437 = code;
  code = code.7437 + 1;
  *code.7437 = 15;
  code.7438 = code;
  code = code.7438 + 1;
  *code.7438 = 126;
  code.7439 = code;
  code = code.7439 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.50188 = D.33819 | D.31632;
  D.50189 = (unsigned char) D.50188;
  *code.7439 = D.50189;
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 != 0) goto <D.50242>; else goto <D.50243>;
  <D.50242>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50245>; else goto <D.50246>;
    <D.50245>:
    iftmp.7440 = 9;
    goto <D.50247>;
    <D.50246>:
    iftmp.7440 = 8;
    <D.50247>:
    _amd64_rex_bits = iftmp.7440;
    if (_amd64_rex_bits != 0) goto <D.50248>; else goto <D.50249>;
    <D.50248>:
    code.7441 = code;
    code = code.7441 + 1;
    D.50251 = _amd64_rex_bits | 64;
    *code.7441 = D.50251;
    <D.50249>:
  }
  D.31535 = ins->data.op[0].const_val;
  D.50252 = D.31535 * 8;
  if (D.50252 == 1) goto <D.50253>; else goto <D.50254>;
  <D.50253>:
  code.7442 = code;
  code = code.7442 + 1;
  *code.7442 = 209;
  code.7443 = code;
  code = code.7443 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.7443 = D.37319;
  goto <D.50257>;
  <D.50254>:
  code.7444 = code;
  code = code.7444 + 1;
  *code.7444 = 193;
  code.7445 = code;
  code = code.7445 + 1;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37318 = D.31632 | -24;
  D.37319 = (unsigned char) D.37318;
  *code.7445 = D.37319;
  D.31535 = ins->data.op[0].const_val;
  D.50260 = (unsigned char) D.31535;
  D.50261 = D.50260 * 8;
  *code = D.50261;
  code = code + 1;
  <D.50257>:
  <D.50243>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50263>; else goto <D.50264>;
    <D.50263>:
    iftmp.7446 = 12;
    goto <D.50265>;
    <D.50264>:
    iftmp.7446 = 8;
    <D.50265>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50266 = iftmp.7446 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50266;
    if (_amd64_rex_bits != 0) goto <D.50267>; else goto <D.50268>;
    <D.50267>:
    code.7447 = code;
    code = code.7447 + 1;
    D.50270 = _amd64_rex_bits | 64;
    *code.7447 = D.50270;
    <D.50268>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.50271>; else goto <D.50272>;
    <D.50271>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6339, "(0) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.50272>:
    code.7448 = code;
    code = code.7448 + 1;
    *code.7448 = 15;
    D.31464 = ins->opcode;
    if (D.31464 == 928) goto <D.50274>; else goto <D.50275>;
    <D.50274>:
    op = op + 8;
    <D.50275>:
    if (0 != 0) goto <D.50276>; else goto <D.50277>;
    <D.50276>:
    op = op + 1;
    <D.50277>:
    code.7449 = code;
    code = code.7449 + 1;
    *code.7449 = op;
    code.7450 = code;
    code = code.7450 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.7450 = D.37521;
  }
  goto <D.25197>;
  <D.27777>:
  <D.27778>:
  code.7451 = code;
  code = code.7451 + 1;
  *code.7451 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50282>; else goto <D.50283>;
    <D.50282>:
    iftmp.7452 = 4;
    goto <D.50284>;
    <D.50283>:
    iftmp.7452 = 0;
    <D.50284>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50285 = iftmp.7452 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50285;
    if (_amd64_rex_bits != 0) goto <D.50286>; else goto <D.50287>;
    <D.50286>:
    code.7453 = code;
    code = code.7453 + 1;
    D.50289 = _amd64_rex_bits | 64;
    *code.7453 = D.50289;
    <D.50287>:
  }
  code.7454 = code;
  code = code.7454 + 1;
  *code.7454 = 15;
  code.7455 = code;
  code = code.7455 + 1;
  *code.7455 = 197;
  code.7456 = code;
  code = code.7456 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7456 = D.33727;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50294>; else goto <D.50295>;
    <D.50294>:
    iftmp.7457 = 4;
    goto <D.50296>;
    <D.50295>:
    iftmp.7457 = 0;
    <D.50296>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50297 = iftmp.7457 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50297;
    if (_amd64_rex_bits != 0) goto <D.50298>; else goto <D.50299>;
    <D.50298>:
    code.7458 = code;
    code = code.7458 + 1;
    D.50301 = _amd64_rex_bits | 64;
    *code.7458 = D.50301;
    <D.50299>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.50302>; else goto <D.50303>;
    <D.50302>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6347, "(1) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.50303>:
    code.7459 = code;
    code = code.7459 + 1;
    *code.7459 = 15;
    D.31464 = ins->opcode;
    if (D.31464 == 926) goto <D.50305>; else goto <D.50306>;
    <D.50305>:
    op = op + 8;
    <D.50306>:
    if (1 != 0) goto <D.50307>; else goto <D.50308>;
    <D.50307>:
    op = op + 1;
    <D.50308>:
    code.7460 = code;
    code = code.7460 + 1;
    *code.7460 = op;
    code.7461 = code;
    code = code.7461 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.7461 = D.37521;
  }
  goto <D.25197>;
  <D.27782>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 != 0) goto <D.50311>; else goto <D.50312>;
  <D.50311>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50314>; else goto <D.50315>;
    <D.50314>:
    iftmp.7462 = 4;
    goto <D.50316>;
    <D.50315>:
    iftmp.7462 = 0;
    <D.50316>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50317 = iftmp.7462 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50317;
    if (_amd64_rex_bits != 0) goto <D.50318>; else goto <D.50319>;
    <D.50318>:
    code.7463 = code;
    code = code.7463 + 1;
    D.50321 = _amd64_rex_bits | 64;
    *code.7463 = D.50321;
    <D.50319>:
  }
  code.7464 = code;
  code = code.7464 + 1;
  *code.7464 = 15;
  code.7465 = code;
  code = code.7465 + 1;
  *code.7465 = 18;
  code.7466 = code;
  code = code.7466 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7466 = D.33727;
  goto <D.50325>;
  <D.50312>:
  code.7467 = code;
  code = code.7467 + 1;
  *code.7467 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50328>; else goto <D.50329>;
    <D.50328>:
    iftmp.7468 = 4;
    goto <D.50330>;
    <D.50329>:
    iftmp.7468 = 0;
    <D.50330>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50331 = iftmp.7468 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50331;
    if (_amd64_rex_bits != 0) goto <D.50332>; else goto <D.50333>;
    <D.50332>:
    code.7469 = code;
    code = code.7469 + 1;
    D.50335 = _amd64_rex_bits | 64;
    *code.7469 = D.50335;
    <D.50333>:
  }
  code.7470 = code;
  code = code.7470 + 1;
  *code.7470 = 15;
  code.7471 = code;
  code = code.7471 + 1;
  *code.7471 = 16;
  code.7472 = code;
  code = code.7472 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7472 = D.33727;
  <D.50325>:
  goto <D.25197>;
  <D.27785>:
  code.7473 = code;
  code = code.7473 + 1;
  *code.7473 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50341>; else goto <D.50342>;
    <D.50341>:
    iftmp.7474 = 4;
    goto <D.50343>;
    <D.50342>:
    iftmp.7474 = 0;
    <D.50343>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50344 = iftmp.7474 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50344;
    if (_amd64_rex_bits != 0) goto <D.50345>; else goto <D.50346>;
    <D.50345>:
    code.7475 = code;
    code = code.7475 + 1;
    D.50348 = _amd64_rex_bits | 64;
    *code.7475 = D.50348;
    <D.50346>:
  }
  code.7476 = code;
  code = code.7476 + 1;
  *code.7476 = 15;
  code.7477 = code;
  code = code.7477 + 1;
  *code.7477 = 196;
  code.7478 = code;
  code = code.7478 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7478 = D.33821;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27787>:
  code.7479 = code;
  code = code.7479 + 1;
  *code.7479 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50354>; else goto <D.50355>;
    <D.50354>:
    iftmp.7480 = 4;
    goto <D.50356>;
    <D.50355>:
    iftmp.7480 = 0;
    <D.50356>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50357 = iftmp.7480 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50357;
    if (_amd64_rex_bits != 0) goto <D.50358>; else goto <D.50359>;
    <D.50358>:
    code.7481 = code;
    code = code.7481 + 1;
    D.50361 = _amd64_rex_bits | 64;
    *code.7481 = D.50361;
    <D.50359>:
  }
  code.7482 = code;
  code = code.7482 + 1;
  *code.7482 = 15;
  code.7483 = code;
  code = code.7483 + 1;
  *code.7483 = 197;
  code.7484 = code;
  code = code.7484 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7484 = D.33727;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.25197>;
  <D.27789>:
  if (0 != 0) goto <D.50365>; else goto <D.50366>;
  <D.50365>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50368>; else goto <D.50369>;
    <D.50368>:
    iftmp.7485 = 9;
    goto <D.50370>;
    <D.50369>:
    iftmp.7485 = 8;
    <D.50370>:
    _amd64_rex_bits = iftmp.7485;
    if (_amd64_rex_bits != 0) goto <D.50371>; else goto <D.50372>;
    <D.50371>:
    code.7486 = code;
    code = code.7486 + 1;
    D.50374 = _amd64_rex_bits | 64;
    *code.7486 = D.50374;
    <D.50372>:
  }
  code.7487 = code;
  code = code.7487 + 1;
  *code.7487 = 131;
  code.7488 = code;
  code = code.7488 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.7488 = D.37432;
  D.31535 = ins->data.op[0].const_val;
  D.50378 = D.31535 & 1;
  if (D.50378 != 0) goto <D.50379>; else goto <D.50380>;
  <D.50379>:
  iftmp.7489 = 255;
  goto <D.50381>;
  <D.50380>:
  iftmp.7489 = 0;
  <D.50381>:
  *code = iftmp.7489;
  code = code + 1;
  goto <D.50382>;
  <D.50366>:
  D.31516 = ins->sreg1;
  if (D.31516 == 0) goto <D.50383>; else goto <D.50384>;
  <D.50383>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.50385>; else goto <D.50386>;
    <D.50385>:
    code.7490 = code;
    code = code.7490 + 1;
    D.50388 = _amd64_rex_bits | 64;
    *code.7490 = D.50388;
    <D.50386>:
  }
  code.7491 = code;
  code = code.7491 + 1;
  *code.7491 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.50378 = D.31535 & 1;
        if (D.50378 != 0) goto <D.50391>; else goto <D.50392>;
        <D.50391>:
        iftmp.7492 = 255;
        goto <D.50393>;
        <D.50392>:
        iftmp.7492 = 65280;
        <D.50393>:
        imb.val = iftmp.7492;
        code.7493 = code;
        code = code.7493 + 1;
        D.50395 = imb.b[0];
        *code.7493 = D.50395;
        code.7494 = code;
        code = code.7494 + 1;
        D.50397 = imb.b[1];
        *code.7494 = D.50397;
        code.7495 = code;
        code = code.7495 + 1;
        D.50399 = imb.b[2];
        *code.7495 = D.50399;
        code.7496 = code;
        code = code.7496 + 1;
        D.50401 = imb.b[3];
        *code.7496 = D.50401;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.50402>;
  <D.50384>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50404>; else goto <D.50405>;
    <D.50404>:
    iftmp.7497 = 9;
    goto <D.50406>;
    <D.50405>:
    iftmp.7497 = 8;
    <D.50406>:
    _amd64_rex_bits = iftmp.7497;
    if (_amd64_rex_bits != 0) goto <D.50407>; else goto <D.50408>;
    <D.50407>:
    code.7498 = code;
    code = code.7498 + 1;
    D.50410 = _amd64_rex_bits | 64;
    *code.7498 = D.50410;
    <D.50408>:
  }
  code.7499 = code;
  code = code.7499 + 1;
  *code.7499 = 129;
  code.7500 = code;
  code = code.7500 + 1;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.37431 = D.31571 | -32;
  D.37432 = (unsigned char) D.37431;
  *code.7500 = D.37432;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.50378 = D.31535 & 1;
        if (D.50378 != 0) goto <D.50414>; else goto <D.50415>;
        <D.50414>:
        iftmp.7501 = 255;
        goto <D.50416>;
        <D.50415>:
        iftmp.7501 = 65280;
        <D.50416>:
        imb.val = iftmp.7501;
        code.7502 = code;
        code = code.7502 + 1;
        D.50418 = imb.b[0];
        *code.7502 = D.50418;
        code.7503 = code;
        code = code.7503 + 1;
        D.50420 = imb.b[1];
        *code.7503 = D.50420;
        code.7504 = code;
        code = code.7504 + 1;
        D.50422 = imb.b[2];
        *code.7504 = D.50422;
        code.7505 = code;
        code = code.7505 + 1;
        D.50424 = imb.b[3];
        *code.7505 = D.50424;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50402>:
  <D.50382>:
  D.31535 = ins->data.op[0].const_val;
  D.50378 = D.31535 & 1;
  if (D.50378 != 0) goto <D.50425>; else goto <D.50426>;
  <D.50425>:
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    _amd64_rex_bits = (unsigned char) D.33810;
    if (_amd64_rex_bits != 0) goto <D.50427>; else goto <D.50428>;
    <D.50427>:
    code.7506 = code;
    code = code.7506 + 1;
    D.50430 = _amd64_rex_bits | 64;
    *code.7506 = D.50430;
    <D.50428>:
  }
  if (0 != 0) goto <D.50431>; else goto <D.50432>;
  <D.50431>:
  code.7507 = code;
  code = code.7507 + 1;
  *code.7507 = 209;
  code.7508 = code;
  code = code.7508 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.31514 = D.31501 | -32;
  D.31515 = (unsigned char) D.31514;
  *code.7508 = D.31515;
  goto <D.50435>;
  <D.50432>:
  code.7509 = code;
  code = code.7509 + 1;
  *code.7509 = 193;
  code.7510 = code;
  code = code.7510 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.31514 = D.31501 | -32;
  D.31515 = (unsigned char) D.31514;
  *code.7510 = D.31515;
  *code = 8;
  code = code + 1;
  <D.50435>:
  <D.50426>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50439>; else goto <D.50440>;
    <D.50439>:
    iftmp.7511 = 12;
    goto <D.50441>;
    <D.50440>:
    iftmp.7511 = 8;
    <D.50441>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50442 = iftmp.7511 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50442;
    if (_amd64_rex_bits != 0) goto <D.50443>; else goto <D.50444>;
    <D.50443>:
    code.7512 = code;
    code = code.7512 + 1;
    D.50446 = _amd64_rex_bits | 64;
    *code.7512 = D.50446;
    <D.50444>:
  }
  code.7513 = code;
  code = code.7513 + 1;
  *code.7513 = 11;
  code.7514 = code;
  code = code.7514 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33819 = D.32054 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.33820 = D.33819 | D.31501;
  D.33821 = (unsigned char) D.33820;
  *code.7514 = D.33821;
  code.7515 = code;
  code = code.7515 + 1;
  *code.7515 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50451>; else goto <D.50452>;
    <D.50451>:
    iftmp.7516 = 4;
    goto <D.50453>;
    <D.50452>:
    iftmp.7516 = 0;
    <D.50453>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.50454 = iftmp.7516 | D.33180;
    _amd64_rex_bits = (unsigned char) D.50454;
    if (_amd64_rex_bits != 0) goto <D.50455>; else goto <D.50456>;
    <D.50455>:
    code.7517 = code;
    code = code.7517 + 1;
    D.50458 = _amd64_rex_bits | 64;
    *code.7517 = D.50458;
    <D.50456>:
  }
  code.7518 = code;
  code = code.7518 + 1;
  *code.7518 = 15;
  code.7519 = code;
  code = code.7519 + 1;
  *code.7519 = 196;
  code.7520 = code;
  code = code.7520 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7520 = D.33727;
  D.31535 = ins->data.op[0].const_val;
  D.50462 = D.31535 / 2;
  D.50463 = (unsigned char) D.50462;
  *code = D.50463;
  code = code + 1;
  goto <D.25197>;
  <D.27798>:
  code.7521 = code;
  code = code.7521 + 1;
  *code.7521 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50466>; else goto <D.50467>;
    <D.50466>:
    iftmp.7522 = 4;
    goto <D.50468>;
    <D.50467>:
    iftmp.7522 = 0;
    <D.50468>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50469 = iftmp.7522 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50469;
    if (_amd64_rex_bits != 0) goto <D.50470>; else goto <D.50471>;
    <D.50470>:
    code.7523 = code;
    code = code.7523 + 1;
    D.50473 = _amd64_rex_bits | 64;
    *code.7523 = D.50473;
    <D.50471>:
  }
  code.7524 = code;
  code = code.7524 + 1;
  *code.7524 = 15;
  code.7525 = code;
  code = code.7525 + 1;
  *code.7525 = 196;
  code.7526 = code;
  code = code.7526 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7526 = D.39958;
  D.31535 = ins->data.op[0].const_val;
  D.50260 = (unsigned char) D.31535;
  D.50477 = D.50260 * 2;
  *code = D.50477;
  code = code + 1;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.50479>; else goto <D.50480>;
    <D.50479>:
    iftmp.7527 = 9;
    goto <D.50481>;
    <D.50480>:
    iftmp.7527 = 8;
    <D.50481>:
    _amd64_rex_bits = iftmp.7527;
    if (_amd64_rex_bits != 0) goto <D.50482>; else goto <D.50483>;
    <D.50482>:
    code.7528 = code;
    code = code.7528 + 1;
    D.50485 = _amd64_rex_bits | 64;
    *code.7528 = D.50485;
    <D.50483>:
  }
  if (0 != 0) goto <D.50486>; else goto <D.50487>;
  <D.50486>:
  code.7529 = code;
  code = code.7529 + 1;
  *code.7529 = 209;
  code.7530 = code;
  code = code.7530 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.31502 = D.31501 | -24;
  D.31503 = (unsigned char) D.31502;
  *code.7530 = D.31503;
  goto <D.50490>;
  <D.50487>:
  code.7531 = code;
  code = code.7531 + 1;
  *code.7531 = 193;
  code.7532 = code;
  code = code.7532 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.31502 = D.31501 | -24;
  D.31503 = (unsigned char) D.31502;
  *code.7532 = D.31503;
  *code = 16;
  code = code + 1;
  <D.50490>:
  code.7533 = code;
  code = code.7533 + 1;
  *code.7533 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50495>; else goto <D.50496>;
    <D.50495>:
    iftmp.7534 = 4;
    goto <D.50497>;
    <D.50496>:
    iftmp.7534 = 0;
    <D.50497>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50498 = iftmp.7534 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50498;
    if (_amd64_rex_bits != 0) goto <D.50499>; else goto <D.50500>;
    <D.50499>:
    code.7535 = code;
    code = code.7535 + 1;
    D.50502 = _amd64_rex_bits | 64;
    *code.7535 = D.50502;
    <D.50500>:
  }
  code.7536 = code;
  code = code.7536 + 1;
  *code.7536 = 15;
  code.7537 = code;
  code = code.7537 + 1;
  *code.7537 = 196;
  code.7538 = code;
  code = code.7538 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7538 = D.39958;
  D.31535 = ins->data.op[0].const_val;
  D.50260 = (unsigned char) D.31535;
  D.50477 = D.50260 * 2;
  D.50506 = D.50477 + 1;
  *code = D.50506;
  code = code + 1;
  goto <D.25197>;
  <D.27802>:
  code.7539 = code;
  code = code.7539 + 1;
  *code.7539 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31490 = ins->sreg2;
    if (D.31490 > 7) goto <D.50509>; else goto <D.50510>;
    <D.50509>:
    iftmp.7540 = 13;
    goto <D.50511>;
    <D.50510>:
    iftmp.7540 = 12;
    <D.50511>:
    _amd64_rex_bits = iftmp.7540;
    if (_amd64_rex_bits != 0) goto <D.50512>; else goto <D.50513>;
    <D.50512>:
    code.7541 = code;
    code = code.7541 + 1;
    D.50515 = _amd64_rex_bits | 64;
    *code.7541 = D.50515;
    <D.50513>:
  }
  code.7542 = code;
  code = code.7542 + 1;
  *code.7542 = 15;
  code.7543 = code;
  code = code.7543 + 1;
  *code.7543 = 110;
  code.7544 = code;
  code = code.7544 + 1;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.38212 = D.31500 | -8;
  D.38213 = (unsigned char) D.38212;
  *code.7544 = D.38213;
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 != 0) goto <D.50519>; else goto <D.50520>;
  <D.50519>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50522>; else goto <D.50523>;
    <D.50522>:
    iftmp.7545 = 5;
    goto <D.50524>;
    <D.50523>:
    iftmp.7545 = 1;
    <D.50524>:
    _amd64_rex_bits = iftmp.7545;
    if (_amd64_rex_bits != 0) goto <D.50525>; else goto <D.50526>;
    <D.50525>:
    code.7546 = code;
    code = code.7546 + 1;
    D.50528 = _amd64_rex_bits | 64;
    *code.7546 = D.50528;
    <D.50526>:
  }
  code.7547 = code;
  code = code.7547 + 1;
  *code.7547 = 15;
  code.7548 = code;
  code = code.7548 + 1;
  *code.7548 = 22;
  code.7549 = code;
  code = code.7549 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.50532 = D.32642 | -57;
  D.50533 = (unsigned char) D.50532;
  *code.7549 = D.50533;
  goto <D.50534>;
  <D.50520>:
  code.7550 = code;
  code = code.7550 + 1;
  *code.7550 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50537>; else goto <D.50538>;
    <D.50537>:
    iftmp.7551 = 5;
    goto <D.50539>;
    <D.50538>:
    iftmp.7551 = 1;
    <D.50539>:
    _amd64_rex_bits = iftmp.7551;
    if (_amd64_rex_bits != 0) goto <D.50540>; else goto <D.50541>;
    <D.50540>:
    code.7552 = code;
    code = code.7552 + 1;
    D.50543 = _amd64_rex_bits | 64;
    *code.7552 = D.50543;
    <D.50541>:
  }
  code.7553 = code;
  code = code.7553 + 1;
  *code.7553 = 15;
  code.7554 = code;
  code = code.7554 + 1;
  *code.7554 = 16;
  code.7555 = code;
  code = code.7555 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.50532 = D.32642 | -57;
  D.50533 = (unsigned char) D.50532;
  *code.7555 = D.50533;
  <D.50534>:
  goto <D.25197>;
  <D.27806>:
  D.31535 = ins->data.op[0].const_val;
  switch (D.31535) <default: <D.50677>, case 0: <D.27807>, case 1: <D.27810>, case 2: <D.27814>, case 3: <D.27818>>
  <D.27807>:
  code.7556 = code;
  code = code.7556 + 1;
  *code.7556 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50549>; else goto <D.50550>;
    <D.50549>:
    iftmp.7557 = 4;
    goto <D.50551>;
    <D.50550>:
    iftmp.7557 = 0;
    <D.50551>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50552 = iftmp.7557 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50552;
    if (_amd64_rex_bits != 0) goto <D.50553>; else goto <D.50554>;
    <D.50553>:
    code.7558 = code;
    code = code.7558 + 1;
    D.50556 = _amd64_rex_bits | 64;
    *code.7558 = D.50556;
    <D.50554>:
  }
  code.7559 = code;
  code = code.7559 + 1;
  *code.7559 = 15;
  code.7560 = code;
  code = code.7560 + 1;
  *code.7560 = 90;
  code.7561 = code;
  code = code.7561 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7561 = D.39958;
  goto <D.27809>;
  <D.27810>:
  code.7562 = code;
  code = code.7562 + 1;
  *code.7562 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50562>; else goto <D.50563>;
    <D.50562>:
    iftmp.7563 = 4;
    goto <D.50564>;
    <D.50563>:
    iftmp.7563 = 0;
    <D.50564>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50565 = iftmp.7563 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50565;
    if (_amd64_rex_bits != 0) goto <D.50566>; else goto <D.50567>;
    <D.50566>:
    code.7564 = code;
    code = code.7564 + 1;
    D.50569 = _amd64_rex_bits | 64;
    *code.7564 = D.50569;
    <D.50567>:
  }
  code.7565 = code;
  code = code.7565 + 1;
  *code.7565 = 15;
  code.7566 = code;
  code = code.7566 + 1;
  *code.7566 = 112;
  code.7567 = code;
  code = code.7567 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7567 = D.37521;
  *code = 225;
  code = code + 1;
  code.7568 = code;
  code = code.7568 + 1;
  *code.7568 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50575>; else goto <D.50576>;
    <D.50575>:
    iftmp.7569 = 4;
    goto <D.50577>;
    <D.50576>:
    iftmp.7569 = 0;
    <D.50577>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50578 = iftmp.7569 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50578;
    if (_amd64_rex_bits != 0) goto <D.50579>; else goto <D.50580>;
    <D.50579>:
    code.7570 = code;
    code = code.7570 + 1;
    D.50582 = _amd64_rex_bits | 64;
    *code.7570 = D.50582;
    <D.50580>:
  }
  code.7571 = code;
  code = code.7571 + 1;
  *code.7571 = 15;
  code.7572 = code;
  code = code.7572 + 1;
  *code.7572 = 90;
  code.7573 = code;
  code = code.7573 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7573 = D.39958;
  code.7574 = code;
  code = code.7574 + 1;
  *code.7574 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50588>; else goto <D.50589>;
    <D.50588>:
    iftmp.7575 = 4;
    goto <D.50590>;
    <D.50589>:
    iftmp.7575 = 0;
    <D.50590>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50591 = iftmp.7575 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50591;
    if (_amd64_rex_bits != 0) goto <D.50592>; else goto <D.50593>;
    <D.50592>:
    code.7576 = code;
    code = code.7576 + 1;
    D.50595 = _amd64_rex_bits | 64;
    *code.7576 = D.50595;
    <D.50593>:
  }
  code.7577 = code;
  code = code.7577 + 1;
  *code.7577 = 15;
  code.7578 = code;
  code = code.7578 + 1;
  *code.7578 = 112;
  code.7579 = code;
  code = code.7579 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7579 = D.37521;
  *code = 225;
  code = code + 1;
  goto <D.27809>;
  <D.27814>:
  code.7580 = code;
  code = code.7580 + 1;
  *code.7580 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50601>; else goto <D.50602>;
    <D.50601>:
    iftmp.7581 = 4;
    goto <D.50603>;
    <D.50602>:
    iftmp.7581 = 0;
    <D.50603>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50604 = iftmp.7581 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50604;
    if (_amd64_rex_bits != 0) goto <D.50605>; else goto <D.50606>;
    <D.50605>:
    code.7582 = code;
    code = code.7582 + 1;
    D.50608 = _amd64_rex_bits | 64;
    *code.7582 = D.50608;
    <D.50606>:
  }
  code.7583 = code;
  code = code.7583 + 1;
  *code.7583 = 15;
  code.7584 = code;
  code = code.7584 + 1;
  *code.7584 = 112;
  code.7585 = code;
  code = code.7585 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7585 = D.37521;
  *code = 198;
  code = code + 1;
  code.7586 = code;
  code = code.7586 + 1;
  *code.7586 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50614>; else goto <D.50615>;
    <D.50614>:
    iftmp.7587 = 4;
    goto <D.50616>;
    <D.50615>:
    iftmp.7587 = 0;
    <D.50616>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50617 = iftmp.7587 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50617;
    if (_amd64_rex_bits != 0) goto <D.50618>; else goto <D.50619>;
    <D.50618>:
    code.7588 = code;
    code = code.7588 + 1;
    D.50621 = _amd64_rex_bits | 64;
    *code.7588 = D.50621;
    <D.50619>:
  }
  code.7589 = code;
  code = code.7589 + 1;
  *code.7589 = 15;
  code.7590 = code;
  code = code.7590 + 1;
  *code.7590 = 90;
  code.7591 = code;
  code = code.7591 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7591 = D.39958;
  code.7592 = code;
  code = code.7592 + 1;
  *code.7592 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50627>; else goto <D.50628>;
    <D.50627>:
    iftmp.7593 = 4;
    goto <D.50629>;
    <D.50628>:
    iftmp.7593 = 0;
    <D.50629>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50630 = iftmp.7593 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50630;
    if (_amd64_rex_bits != 0) goto <D.50631>; else goto <D.50632>;
    <D.50631>:
    code.7594 = code;
    code = code.7594 + 1;
    D.50634 = _amd64_rex_bits | 64;
    *code.7594 = D.50634;
    <D.50632>:
  }
  code.7595 = code;
  code = code.7595 + 1;
  *code.7595 = 15;
  code.7596 = code;
  code = code.7596 + 1;
  *code.7596 = 112;
  code.7597 = code;
  code = code.7597 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7597 = D.37521;
  *code = 198;
  code = code + 1;
  goto <D.27809>;
  <D.27818>:
  code.7598 = code;
  code = code.7598 + 1;
  *code.7598 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50640>; else goto <D.50641>;
    <D.50640>:
    iftmp.7599 = 4;
    goto <D.50642>;
    <D.50641>:
    iftmp.7599 = 0;
    <D.50642>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50643 = iftmp.7599 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50643;
    if (_amd64_rex_bits != 0) goto <D.50644>; else goto <D.50645>;
    <D.50644>:
    code.7600 = code;
    code = code.7600 + 1;
    D.50647 = _amd64_rex_bits | 64;
    *code.7600 = D.50647;
    <D.50645>:
  }
  code.7601 = code;
  code = code.7601 + 1;
  *code.7601 = 15;
  code.7602 = code;
  code = code.7602 + 1;
  *code.7602 = 112;
  code.7603 = code;
  code = code.7603 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7603 = D.37521;
  *code = 39;
  code = code + 1;
  code.7604 = code;
  code = code.7604 + 1;
  *code.7604 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50653>; else goto <D.50654>;
    <D.50653>:
    iftmp.7605 = 4;
    goto <D.50655>;
    <D.50654>:
    iftmp.7605 = 0;
    <D.50655>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50656 = iftmp.7605 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50656;
    if (_amd64_rex_bits != 0) goto <D.50657>; else goto <D.50658>;
    <D.50657>:
    code.7606 = code;
    code = code.7606 + 1;
    D.50660 = _amd64_rex_bits | 64;
    *code.7606 = D.50660;
    <D.50658>:
  }
  code.7607 = code;
  code = code.7607 + 1;
  *code.7607 = 15;
  code.7608 = code;
  code = code.7608 + 1;
  *code.7608 = 90;
  code.7609 = code;
  code = code.7609 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7609 = D.39958;
  code.7610 = code;
  code = code.7610 + 1;
  *code.7610 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50666>; else goto <D.50667>;
    <D.50666>:
    iftmp.7611 = 4;
    goto <D.50668>;
    <D.50667>:
    iftmp.7611 = 0;
    <D.50668>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50669 = iftmp.7611 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50669;
    if (_amd64_rex_bits != 0) goto <D.50670>; else goto <D.50671>;
    <D.50670>:
    code.7612 = code;
    code = code.7612 + 1;
    D.50673 = _amd64_rex_bits | 64;
    *code.7612 = D.50673;
    <D.50671>:
  }
  code.7613 = code;
  code = code.7613 + 1;
  *code.7613 = 15;
  code.7614 = code;
  code = code.7614 + 1;
  *code.7614 = 112;
  code.7615 = code;
  code = code.7615 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7615 = D.37521;
  *code = 39;
  code = code + 1;
  goto <D.27809>;
  <D.50677>:
  <D.27809>:
  goto <D.25197>;
  <D.27822>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 != 0) goto <D.50678>; else goto <D.50679>;
  <D.50678>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50681>; else goto <D.50682>;
    <D.50681>:
    iftmp.7616 = 4;
    goto <D.50683>;
    <D.50682>:
    iftmp.7616 = 0;
    <D.50683>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50684 = iftmp.7616 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50684;
    if (_amd64_rex_bits != 0) goto <D.50685>; else goto <D.50686>;
    <D.50685>:
    code.7617 = code;
    code = code.7617 + 1;
    D.50688 = _amd64_rex_bits | 64;
    *code.7617 = D.50688;
    <D.50686>:
  }
  code.7618 = code;
  code = code.7618 + 1;
  *code.7618 = 15;
  code.7619 = code;
  code = code.7619 + 1;
  *code.7619 = 22;
  code.7620 = code;
  code = code.7620 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7620 = D.39958;
  goto <D.50692>;
  <D.50679>:
  code.7621 = code;
  code = code.7621 + 1;
  *code.7621 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50695>; else goto <D.50696>;
    <D.50695>:
    iftmp.7622 = 4;
    goto <D.50697>;
    <D.50696>:
    iftmp.7622 = 0;
    <D.50697>:
    D.31490 = ins->sreg2;
    D.33810 = D.31490 > 7;
    D.33811 = (signed char) D.33810;
    D.50698 = iftmp.7622 | D.33811;
    _amd64_rex_bits = (unsigned char) D.50698;
    if (_amd64_rex_bits != 0) goto <D.50699>; else goto <D.50700>;
    <D.50699>:
    code.7623 = code;
    code = code.7623 + 1;
    D.50702 = _amd64_rex_bits | 64;
    *code.7623 = D.50702;
    <D.50700>:
  }
  code.7624 = code;
  code = code.7624 + 1;
  *code.7624 = 15;
  code.7625 = code;
  code = code.7625 + 1;
  *code.7625 = 16;
  code.7626 = code;
  code = code.7626 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31490 = ins->sreg2;
  D.31500 = (signed char) D.31490;
  D.31501 = D.31500 & 7;
  D.39957 = D.33725 | D.31501;
  D.39958 = (unsigned char) D.39957;
  *code.7626 = D.39958;
  <D.50692>:
  goto <D.25197>;
  <D.27825>:
  <D.27826>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50707>; else goto <D.50708>;
    <D.50707>:
    iftmp.7627 = 4;
    goto <D.50709>;
    <D.50708>:
    iftmp.7627 = 0;
    <D.50709>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50710 = iftmp.7627 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50710;
    if (_amd64_rex_bits != 0) goto <D.50711>; else goto <D.50712>;
    <D.50711>:
    code.7628 = code;
    code = code.7628 + 1;
    D.50714 = _amd64_rex_bits | 64;
    *code.7628 = D.50714;
    <D.50712>:
  }
  code.7629 = code;
  code = code.7629 + 1;
  *code.7629 = 15;
  code.7630 = code;
  code = code.7630 + 1;
  *code.7630 = 17;
  D.31589 = ins->dreg;
  if (D.31589 == 16) goto <D.50717>; else goto <D.50718>;
  <D.50717>:
  code.7631 = code;
  code = code.7631 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.7631 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7632 = code;
        code = code.7632 + 1;
        D.50721 = imb.b[0];
        *code.7632 = D.50721;
        code.7633 = code;
        code = code.7633 + 1;
        D.50723 = imb.b[1];
        *code.7633 = D.50723;
        code.7634 = code;
        code = code.7634 + 1;
        D.50725 = imb.b[2];
        *code.7634 = D.50725;
        code.7635 = code;
        code = code.7635 + 1;
        D.50727 = imb.b[3];
        *code.7635 = D.50727;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.50728>;
  <D.50718>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.50729>; else goto <D.50730>;
  <D.50729>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50731>; else goto <D.50732>;
  <D.50731>:
  code.7636 = code;
  code = code.7636 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.7636 = D.32056;
  code.7637 = code;
  code = code.7637 + 1;
  *code.7637 = 36;
  goto <D.50735>;
  <D.50732>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50736>; else goto <D.50737>;
  <D.50736>:
  code.7638 = code;
  code = code.7638 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.7638 = D.32063;
  code.7639 = code;
  code = code.7639 + 1;
  *code.7639 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50740>;
  <D.50737>:
  code.7640 = code;
  code = code.7640 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.7640 = D.32068;
  code.7641 = code;
  code = code.7641 + 1;
  *code.7641 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7642 = code;
        code = code.7642 + 1;
        D.50744 = imb.b[0];
        *code.7642 = D.50744;
        code.7643 = code;
        code = code.7643 + 1;
        D.50746 = imb.b[1];
        *code.7643 = D.50746;
        code.7644 = code;
        code = code.7644 + 1;
        D.50748 = imb.b[2];
        *code.7644 = D.50748;
        code.7645 = code;
        code = code.7645 + 1;
        D.50750 = imb.b[3];
        *code.7645 = D.50750;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50740>:
  <D.50735>:
  goto <D.27830>;
  <D.50730>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50751>; else goto <D.50752>;
  <D.50751>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.50753>; else goto <D.50754>;
  <D.50753>:
  code.7646 = code;
  code = code.7646 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.7646 = D.32084;
  goto <D.27830>;
  <D.50754>:
  <D.50752>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50756>; else goto <D.50757>;
  <D.50756>:
  code.7647 = code;
  code = code.7647 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.7647 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50759>;
  <D.50757>:
  code.7648 = code;
  code = code.7648 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.7648 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7649 = code;
        code = code.7649 + 1;
        D.50762 = imb.b[0];
        *code.7649 = D.50762;
        code.7650 = code;
        code = code.7650 + 1;
        D.50764 = imb.b[1];
        *code.7650 = D.50764;
        code.7651 = code;
        code = code.7651 + 1;
        D.50766 = imb.b[2];
        *code.7651 = D.50766;
        code.7652 = code;
        code = code.7652 + 1;
        D.50768 = imb.b[3];
        *code.7652 = D.50768;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50759>:
  <D.27830>:
  <D.50728>:
  goto <D.25197>;
  <D.27832>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50770>; else goto <D.50771>;
    <D.50770>:
    iftmp.7653 = 4;
    goto <D.50772>;
    <D.50771>:
    iftmp.7653 = 0;
    <D.50772>:
    D.50773 = ins->sreg1;
    D.50774 = D.50773 != 16;
    D.50775 = D.50773 > 7;
    D.50776 = D.50774 & D.50775;
    D.50777 = (int) D.50776;
    D.50778 = (signed char) D.50777;
    D.50779 = iftmp.7653 | D.50778;
    _amd64_rex_bits = (unsigned char) D.50779;
    if (_amd64_rex_bits != 0) goto <D.50780>; else goto <D.50781>;
    <D.50780>:
    code.7654 = code;
    code = code.7654 + 1;
    D.50783 = _amd64_rex_bits | 64;
    *code.7654 = D.50783;
    <D.50781>:
  }
  code.7655 = code;
  code = code.7655 + 1;
  *code.7655 = 15;
  code.7656 = code;
  code = code.7656 + 1;
  *code.7656 = 16;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.50786>; else goto <D.50787>;
  <D.50786>:
  code.7657 = code;
  code = code.7657 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.7657 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7658 = code;
        code = code.7658 + 1;
        D.50790 = imb.b[0];
        *code.7658 = D.50790;
        code.7659 = code;
        code = code.7659 + 1;
        D.50792 = imb.b[1];
        *code.7659 = D.50792;
        code.7660 = code;
        code = code.7660 + 1;
        D.50794 = imb.b[2];
        *code.7660 = D.50794;
        code.7661 = code;
        code = code.7661 + 1;
        D.50796 = imb.b[3];
        *code.7661 = D.50796;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.50797>;
  <D.50787>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.50798>; else goto <D.50799>;
  <D.50798>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50800>; else goto <D.50801>;
  <D.50800>:
  code.7662 = code;
  code = code.7662 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.7662 = D.32644;
  code.7663 = code;
  code = code.7663 + 1;
  *code.7663 = 36;
  goto <D.50804>;
  <D.50801>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50805>; else goto <D.50806>;
  <D.50805>:
  code.7664 = code;
  code = code.7664 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.7664 = D.32735;
  code.7665 = code;
  code = code.7665 + 1;
  *code.7665 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50809>;
  <D.50806>:
  code.7666 = code;
  code = code.7666 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.7666 = D.32740;
  code.7667 = code;
  code = code.7667 + 1;
  *code.7667 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7668 = code;
        code = code.7668 + 1;
        D.50813 = imb.b[0];
        *code.7668 = D.50813;
        code.7669 = code;
        code = code.7669 + 1;
        D.50815 = imb.b[1];
        *code.7669 = D.50815;
        code.7670 = code;
        code = code.7670 + 1;
        D.50817 = imb.b[2];
        *code.7670 = D.50817;
        code.7671 = code;
        code = code.7671 + 1;
        D.50819 = imb.b[3];
        *code.7671 = D.50819;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50809>:
  <D.50804>:
  goto <D.27836>;
  <D.50799>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50820>; else goto <D.50821>;
  <D.50820>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.50822>; else goto <D.50823>;
  <D.50822>:
  code.7672 = code;
  code = code.7672 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.7672 = D.33228;
  goto <D.27836>;
  <D.50823>:
  <D.50821>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50825>; else goto <D.50826>;
  <D.50825>:
  code.7673 = code;
  code = code.7673 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.7673 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50828>;
  <D.50826>:
  code.7674 = code;
  code = code.7674 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.7674 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7675 = code;
        code = code.7675 + 1;
        D.50831 = imb.b[0];
        *code.7675 = D.50831;
        code.7676 = code;
        code = code.7676 + 1;
        D.50833 = imb.b[1];
        *code.7676 = D.50833;
        code.7677 = code;
        code = code.7677 + 1;
        D.50835 = imb.b[2];
        *code.7677 = D.50835;
        code.7678 = code;
        code = code.7678 + 1;
        D.50837 = imb.b[3];
        *code.7678 = D.50837;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50828>:
  <D.27836>:
  <D.50797>:
  goto <D.25197>;
  <D.27838>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50839>; else goto <D.50840>;
    <D.50839>:
    iftmp.7679 = 4;
    goto <D.50841>;
    <D.50840>:
    iftmp.7679 = 0;
    <D.50841>:
    D.50842 = ins->sreg1;
    D.50843 = D.50842 != 16;
    D.50844 = D.50842 > 7;
    D.50845 = D.50843 & D.50844;
    D.50846 = (int) D.50845;
    D.50847 = (signed char) D.50846;
    D.50848 = iftmp.7679 | D.50847;
    _amd64_rex_bits = (unsigned char) D.50848;
    if (_amd64_rex_bits != 0) goto <D.50849>; else goto <D.50850>;
    <D.50849>:
    code.7680 = code;
    code = code.7680 + 1;
    D.50852 = _amd64_rex_bits | 64;
    *code.7680 = D.50852;
    <D.50850>:
  }
  code.7681 = code;
  code = code.7681 + 1;
  *code.7681 = 15;
  code.7682 = code;
  code = code.7682 + 1;
  *code.7682 = 40;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.50855>; else goto <D.50856>;
  <D.50855>:
  code.7683 = code;
  code = code.7683 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.7683 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7684 = code;
        code = code.7684 + 1;
        D.50859 = imb.b[0];
        *code.7684 = D.50859;
        code.7685 = code;
        code = code.7685 + 1;
        D.50861 = imb.b[1];
        *code.7685 = D.50861;
        code.7686 = code;
        code = code.7686 + 1;
        D.50863 = imb.b[2];
        *code.7686 = D.50863;
        code.7687 = code;
        code = code.7687 + 1;
        D.50865 = imb.b[3];
        *code.7687 = D.50865;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.50866>;
  <D.50856>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.50867>; else goto <D.50868>;
  <D.50867>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50869>; else goto <D.50870>;
  <D.50869>:
  code.7688 = code;
  code = code.7688 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.7688 = D.32644;
  code.7689 = code;
  code = code.7689 + 1;
  *code.7689 = 36;
  goto <D.50873>;
  <D.50870>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50874>; else goto <D.50875>;
  <D.50874>:
  code.7690 = code;
  code = code.7690 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.7690 = D.32735;
  code.7691 = code;
  code = code.7691 + 1;
  *code.7691 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50878>;
  <D.50875>:
  code.7692 = code;
  code = code.7692 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.7692 = D.32740;
  code.7693 = code;
  code = code.7693 + 1;
  *code.7693 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7694 = code;
        code = code.7694 + 1;
        D.50882 = imb.b[0];
        *code.7694 = D.50882;
        code.7695 = code;
        code = code.7695 + 1;
        D.50884 = imb.b[1];
        *code.7695 = D.50884;
        code.7696 = code;
        code = code.7696 + 1;
        D.50886 = imb.b[2];
        *code.7696 = D.50886;
        code.7697 = code;
        code = code.7697 + 1;
        D.50888 = imb.b[3];
        *code.7697 = D.50888;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50878>:
  <D.50873>:
  goto <D.27842>;
  <D.50868>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50889>; else goto <D.50890>;
  <D.50889>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.50891>; else goto <D.50892>;
  <D.50891>:
  code.7698 = code;
  code = code.7698 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.7698 = D.33228;
  goto <D.27842>;
  <D.50892>:
  <D.50890>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50894>; else goto <D.50895>;
  <D.50894>:
  code.7699 = code;
  code = code.7699 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.7699 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50897>;
  <D.50895>:
  code.7700 = code;
  code = code.7700 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.7700 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7701 = code;
        code = code.7701 + 1;
        D.50900 = imb.b[0];
        *code.7701 = D.50900;
        code.7702 = code;
        code = code.7702 + 1;
        D.50902 = imb.b[1];
        *code.7702 = D.50902;
        code.7703 = code;
        code = code.7703 + 1;
        D.50904 = imb.b[2];
        *code.7703 = D.50904;
        code.7704 = code;
        code = code.7704 + 1;
        D.50906 = imb.b[3];
        *code.7704 = D.50906;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50897>:
  <D.27842>:
  <D.50866>:
  goto <D.25197>;
  <D.27844>:
  {
    unsigned char _amd64_rex_bits;

    D.31516 = ins->sreg1;
    if (D.31516 > 7) goto <D.50908>; else goto <D.50909>;
    <D.50908>:
    iftmp.7705 = 4;
    goto <D.50910>;
    <D.50909>:
    iftmp.7705 = 0;
    <D.50910>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.50911 = iftmp.7705 | D.32040;
    _amd64_rex_bits = (unsigned char) D.50911;
    if (_amd64_rex_bits != 0) goto <D.50912>; else goto <D.50913>;
    <D.50912>:
    code.7706 = code;
    code = code.7706 + 1;
    D.50915 = _amd64_rex_bits | 64;
    *code.7706 = D.50915;
    <D.50913>:
  }
  code.7707 = code;
  code = code.7707 + 1;
  *code.7707 = 15;
  code.7708 = code;
  code = code.7708 + 1;
  *code.7708 = 41;
  D.31589 = ins->dreg;
  if (D.31589 == 16) goto <D.50918>; else goto <D.50919>;
  <D.50918>:
  code.7709 = code;
  code = code.7709 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.33888 = D.32054 | 5;
  D.33889 = (unsigned char) D.33888;
  *code.7709 = D.33889;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7710 = code;
        code = code.7710 + 1;
        D.50922 = imb.b[0];
        *code.7710 = D.50922;
        code.7711 = code;
        code = code.7711 + 1;
        D.50924 = imb.b[1];
        *code.7711 = D.50924;
        code.7712 = code;
        code = code.7712 + 1;
        D.50926 = imb.b[2];
        *code.7712 = D.50926;
        code.7713 = code;
        code = code.7713 + 1;
        D.50928 = imb.b[3];
        *code.7713 = D.50928;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.50929>;
  <D.50919>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 == 4) goto <D.50930>; else goto <D.50931>;
  <D.50930>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50932>; else goto <D.50933>;
  <D.50932>:
  code.7714 = code;
  code = code.7714 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32055 = D.32054 | 4;
  D.32056 = (unsigned char) D.32055;
  *code.7714 = D.32056;
  code.7715 = code;
  code = code.7715 + 1;
  *code.7715 = 36;
  goto <D.50936>;
  <D.50933>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50937>; else goto <D.50938>;
  <D.50937>:
  code.7716 = code;
  code = code.7716 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32062 = D.32054 | 68;
  D.32063 = (unsigned char) D.32062;
  *code.7716 = D.32063;
  code.7717 = code;
  code = code.7717 + 1;
  *code.7717 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50941>;
  <D.50938>:
  code.7718 = code;
  code = code.7718 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32067 = D.32054 | -124;
  D.32068 = (unsigned char) D.32067;
  *code.7718 = D.32068;
  code.7719 = code;
  code = code.7719 + 1;
  *code.7719 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7720 = code;
        code = code.7720 + 1;
        D.50945 = imb.b[0];
        *code.7720 = D.50945;
        code.7721 = code;
        code = code.7721 + 1;
        D.50947 = imb.b[1];
        *code.7721 = D.50947;
        code.7722 = code;
        code = code.7722 + 1;
        D.50949 = imb.b[2];
        *code.7722 = D.50949;
        code.7723 = code;
        code = code.7723 + 1;
        D.50951 = imb.b[3];
        *code.7723 = D.50951;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50941>:
  <D.50936>:
  goto <D.27848>;
  <D.50931>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.50952>; else goto <D.50953>;
  <D.50952>:
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  if (D.31598 != 5) goto <D.50954>; else goto <D.50955>;
  <D.50954>:
  code.7724 = code;
  code = code.7724 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32083 = D.32054 | D.31632;
  D.32084 = (unsigned char) D.32083;
  *code.7724 = D.32084;
  goto <D.27848>;
  <D.50955>:
  <D.50953>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.50957>; else goto <D.50958>;
  <D.50957>:
  code.7725 = code;
  code = code.7725 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32088 = D.32054 | 64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32089 = D.32088 | D.31632;
  D.32090 = (unsigned char) D.32089;
  *code.7725 = D.32090;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.50960>;
  <D.50958>:
  code.7726 = code;
  code = code.7726 + 1;
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  D.32053 = D.31532 << 3;
  D.32054 = (signed char) D.32053;
  D.32093 = D.32054 | -128;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.32094 = D.32093 | D.31632;
  D.32095 = (unsigned char) D.32094;
  *code.7726 = D.32095;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7727 = code;
        code = code.7727 + 1;
        D.50963 = imb.b[0];
        *code.7727 = D.50963;
        code.7728 = code;
        code = code.7728 + 1;
        D.50965 = imb.b[1];
        *code.7728 = D.50965;
        code.7729 = code;
        code = code.7729 + 1;
        D.50967 = imb.b[2];
        *code.7729 = D.50967;
        code.7730 = code;
        code = code.7730 + 1;
        D.50969 = imb.b[3];
        *code.7730 = D.50969;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.50960>:
  <D.27848>:
  <D.50929>:
  goto <D.25197>;
  <D.27850>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.50971>; else goto <D.50972>;
    <D.50971>:
    iftmp.7731 = 4;
    goto <D.50973>;
    <D.50972>:
    iftmp.7731 = 0;
    <D.50973>:
    D.50974 = ins->sreg1;
    D.50975 = D.50974 != 16;
    D.50976 = D.50974 > 7;
    D.50977 = D.50975 & D.50976;
    D.50978 = (int) D.50977;
    D.50979 = (signed char) D.50978;
    D.50980 = iftmp.7731 | D.50979;
    _amd64_rex_bits = (unsigned char) D.50980;
    if (_amd64_rex_bits != 0) goto <D.50981>; else goto <D.50982>;
    <D.50981>:
    code.7732 = code;
    code = code.7732 + 1;
    D.50984 = _amd64_rex_bits | 64;
    *code.7732 = D.50984;
    <D.50982>:
  }
  code.7733 = code;
  code = code.7733 + 1;
  *code.7733 = 15;
  code.7734 = code;
  code = code.7734 + 1;
  *code.7734 = 43;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.50987>; else goto <D.50988>;
  <D.50987>:
  code.7735 = code;
  code = code.7735 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32713 = D.32642 | 5;
  D.32714 = (unsigned char) D.32713;
  *code.7735 = D.32714;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7736 = code;
        code = code.7736 + 1;
        D.50991 = imb.b[0];
        *code.7736 = D.50991;
        code.7737 = code;
        code = code.7737 + 1;
        D.50993 = imb.b[1];
        *code.7737 = D.50993;
        code.7738 = code;
        code = code.7738 + 1;
        D.50995 = imb.b[2];
        *code.7738 = D.50995;
        code.7739 = code;
        code = code.7739 + 1;
        D.50997 = imb.b[3];
        *code.7739 = D.50997;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.50998>;
  <D.50988>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.50999>; else goto <D.51000>;
  <D.50999>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.51001>; else goto <D.51002>;
  <D.51001>:
  code.7740 = code;
  code = code.7740 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32643 = D.32642 | 4;
  D.32644 = (unsigned char) D.32643;
  *code.7740 = D.32644;
  code.7741 = code;
  code = code.7741 + 1;
  *code.7741 = 36;
  goto <D.51005>;
  <D.51002>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.51006>; else goto <D.51007>;
  <D.51006>:
  code.7742 = code;
  code = code.7742 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32734 = D.32642 | 68;
  D.32735 = (unsigned char) D.32734;
  *code.7742 = D.32735;
  code.7743 = code;
  code = code.7743 + 1;
  *code.7743 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.51010>;
  <D.51007>:
  code.7744 = code;
  code = code.7744 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32739 = D.32642 | -124;
  D.32740 = (unsigned char) D.32739;
  *code.7744 = D.32740;
  code.7745 = code;
  code = code.7745 + 1;
  *code.7745 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7746 = code;
        code = code.7746 + 1;
        D.51014 = imb.b[0];
        *code.7746 = D.51014;
        code.7747 = code;
        code = code.7747 + 1;
        D.51016 = imb.b[1];
        *code.7747 = D.51016;
        code.7748 = code;
        code = code.7748 + 1;
        D.51018 = imb.b[2];
        *code.7748 = D.51018;
        code.7749 = code;
        code = code.7749 + 1;
        D.51020 = imb.b[3];
        *code.7749 = D.51020;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51010>:
  <D.51005>:
  goto <D.27854>;
  <D.51000>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.51021>; else goto <D.51022>;
  <D.51021>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.51023>; else goto <D.51024>;
  <D.51023>:
  code.7750 = code;
  code = code.7750 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33227 = D.32642 | D.31571;
  D.33228 = (unsigned char) D.33227;
  *code.7750 = D.33228;
  goto <D.27854>;
  <D.51024>:
  <D.51022>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.51026>; else goto <D.51027>;
  <D.51026>:
  code.7751 = code;
  code = code.7751 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32758 = D.32642 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33232 = D.32758 | D.31571;
  D.33233 = (unsigned char) D.33232;
  *code.7751 = D.33233;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.51029>;
  <D.51027>:
  code.7752 = code;
  code = code.7752 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.32763 = D.32642 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33236 = D.32763 | D.31571;
  D.33237 = (unsigned char) D.33236;
  *code.7752 = D.33237;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7753 = code;
        code = code.7753 + 1;
        D.51032 = imb.b[0];
        *code.7753 = D.51032;
        code.7754 = code;
        code = code.7754 + 1;
        D.51034 = imb.b[1];
        *code.7754 = D.51034;
        code.7755 = code;
        code = code.7755 + 1;
        D.51036 = imb.b[2];
        *code.7755 = D.51036;
        code.7756 = code;
        code = code.7756 + 1;
        D.51038 = imb.b[3];
        *code.7756 = D.51038;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51029>:
  <D.27854>:
  <D.50998>:
  goto <D.25197>;
  <D.27856>:
  {
    unsigned char _amd64_rex_bits;

    D.51040 = ins->backend.arg_info;
    if (D.51040 > 7) goto <D.51041>; else goto <D.51042>;
    <D.51041>:
    iftmp.7757 = 4;
    goto <D.51043>;
    <D.51042>:
    iftmp.7757 = 0;
    <D.51043>:
    D.51044 = ins->sreg1;
    D.51045 = D.51044 != 16;
    D.51046 = D.51044 > 7;
    D.51047 = D.51045 & D.51046;
    D.51048 = (int) D.51047;
    D.51049 = (signed char) D.51048;
    D.51050 = iftmp.7757 | D.51049;
    _amd64_rex_bits = (unsigned char) D.51050;
    if (_amd64_rex_bits != 0) goto <D.51051>; else goto <D.51052>;
    <D.51051>:
    code.7758 = code;
    code = code.7758 + 1;
    D.51054 = _amd64_rex_bits | 64;
    *code.7758 = D.51054;
    <D.51052>:
  }
  code.7759 = code;
  code = code.7759 + 1;
  *code.7759 = 15;
  code.7760 = code;
  code = code.7760 + 1;
  *code.7760 = 24;
  D.31516 = ins->sreg1;
  if (D.31516 == 16) goto <D.51057>; else goto <D.51058>;
  <D.51057>:
  code.7761 = code;
  code = code.7761 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.51063 = D.51062 | 5;
  D.51064 = (unsigned char) D.51063;
  *code.7761 = D.51064;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7762 = code;
        code = code.7762 + 1;
        D.51066 = imb.b[0];
        *code.7762 = D.51066;
        code.7763 = code;
        code = code.7763 + 1;
        D.51068 = imb.b[1];
        *code.7763 = D.51068;
        code.7764 = code;
        code = code.7764 + 1;
        D.51070 = imb.b[2];
        *code.7764 = D.51070;
        code.7765 = code;
        code = code.7765 + 1;
        D.51072 = imb.b[3];
        *code.7765 = D.51072;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.51073>;
  <D.51058>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 == 4) goto <D.51074>; else goto <D.51075>;
  <D.51074>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.51076>; else goto <D.51077>;
  <D.51076>:
  code.7766 = code;
  code = code.7766 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.51079 = D.51062 | 4;
  D.51080 = (unsigned char) D.51079;
  *code.7766 = D.51080;
  code.7767 = code;
  code = code.7767 + 1;
  *code.7767 = 36;
  goto <D.51082>;
  <D.51077>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.51083>; else goto <D.51084>;
  <D.51083>:
  code.7768 = code;
  code = code.7768 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.51086 = D.51062 | 68;
  D.51087 = (unsigned char) D.51086;
  *code.7768 = D.51087;
  code.7769 = code;
  code = code.7769 + 1;
  *code.7769 = 36;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.51089>;
  <D.51084>:
  code.7770 = code;
  code = code.7770 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.51091 = D.51062 | -124;
  D.51092 = (unsigned char) D.51091;
  *code.7770 = D.51092;
  code.7771 = code;
  code = code.7771 + 1;
  *code.7771 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7772 = code;
        code = code.7772 + 1;
        D.51095 = imb.b[0];
        *code.7772 = D.51095;
        code.7773 = code;
        code = code.7773 + 1;
        D.51097 = imb.b[1];
        *code.7773 = D.51097;
        code.7774 = code;
        code = code.7774 + 1;
        D.51099 = imb.b[2];
        *code.7774 = D.51099;
        code.7775 = code;
        code = code.7775 + 1;
        D.51101 = imb.b[3];
        *code.7775 = D.51101;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51089>:
  <D.51082>:
  goto <D.27860>;
  <D.51075>:
  D.31535 = ins->data.op[0].const_val;
  if (D.31535 == 0) goto <D.51102>; else goto <D.51103>;
  <D.51102>:
  D.31516 = ins->sreg1;
  D.31532 = D.31516 & 7;
  if (D.31532 != 5) goto <D.51104>; else goto <D.51105>;
  <D.51104>:
  code.7776 = code;
  code = code.7776 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.51107 = D.51062 | D.31571;
  D.51108 = (unsigned char) D.51107;
  *code.7776 = D.51108;
  goto <D.27860>;
  <D.51105>:
  <D.51103>:
  D.31535 = ins->data.op[0].const_val;
  D.31541 = (unsigned int) D.31535;
  D.31542 = D.31541 + 128;
  if (D.31542 <= 255) goto <D.51109>; else goto <D.51110>;
  <D.51109>:
  code.7777 = code;
  code = code.7777 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.51112 = D.51062 | 64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.51113 = D.51112 | D.31571;
  D.51114 = (unsigned char) D.51113;
  *code.7777 = D.51114;
  D.31535 = ins->data.op[0].const_val;
  D.31547 = (unsigned char) D.31535;
  *code = D.31547;
  code = code + 1;
  goto <D.51115>;
  <D.51110>:
  code.7778 = code;
  code = code.7778 + 1;
  D.51040 = ins->backend.arg_info;
  D.51060 = D.51040 & 7;
  D.51061 = D.51060 << 3;
  D.51062 = (signed char) D.51061;
  D.51117 = D.51062 | -128;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.51118 = D.51117 | D.31571;
  D.51119 = (unsigned char) D.51118;
  *code.7778 = D.51119;
  {
    union x86_imm_buf imb;

    try
      {
        D.31535 = ins->data.op[0].const_val;
        D.31551 = (int) D.31535;
        imb.val = D.31551;
        code.7779 = code;
        code = code.7779 + 1;
        D.51121 = imb.b[0];
        *code.7779 = D.51121;
        code.7780 = code;
        code = code.7780 + 1;
        D.51123 = imb.b[1];
        *code.7780 = D.51123;
        code.7781 = code;
        code = code.7781 + 1;
        D.51125 = imb.b[2];
        *code.7781 = D.51125;
        code.7782 = code;
        code = code.7782 + 1;
        D.51127 = imb.b[3];
        *code.7782 = D.51127;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.51115>:
  <D.27860>:
  <D.51073>:
  goto <D.25197>;
  <D.27862>:
  D.31589 = ins->dreg;
  D.31516 = ins->sreg1;
  if (D.31589 != D.31516) goto <D.51128>; else goto <D.51129>;
  <D.51128>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51131>; else goto <D.51132>;
    <D.51131>:
    iftmp.7783 = 4;
    goto <D.51133>;
    <D.51132>:
    iftmp.7783 = 0;
    <D.51133>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51134 = iftmp.7783 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51134;
    if (_amd64_rex_bits != 0) goto <D.51135>; else goto <D.51136>;
    <D.51135>:
    code.7784 = code;
    code = code.7784 + 1;
    D.51138 = _amd64_rex_bits | 64;
    *code.7784 = D.51138;
    <D.51136>:
  }
  code.7785 = code;
  code = code.7785 + 1;
  *code.7785 = 15;
  code.7786 = code;
  code = code.7786 + 1;
  *code.7786 = 40;
  code.7787 = code;
  code = code.7787 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7787 = D.33727;
  <D.51129>:
  goto <D.25197>;
  <D.27864>:
  code.7788 = code;
  code = code.7788 + 1;
  *code.7788 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51144>; else goto <D.51145>;
    <D.51144>:
    iftmp.7789 = 4;
    goto <D.51146>;
    <D.51145>:
    iftmp.7789 = 0;
    <D.51146>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51147 = iftmp.7789 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51147;
    if (_amd64_rex_bits != 0) goto <D.51148>; else goto <D.51149>;
    <D.51148>:
    code.7790 = code;
    code = code.7790 + 1;
    D.51151 = _amd64_rex_bits | 64;
    *code.7790 = D.51151;
    <D.51149>:
  }
  code.7791 = code;
  code = code.7791 + 1;
  *code.7791 = 15;
  code.7792 = code;
  code = code.7792 + 1;
  *code.7792 = 239;
  code.7793 = code;
  code = code.7793 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7793 = D.37521;
  goto <D.25197>;
  <D.27866>:
  code.7794 = code;
  code = code.7794 + 1;
  *code.7794 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51157>; else goto <D.51158>;
    <D.51157>:
    iftmp.7795 = 4;
    goto <D.51159>;
    <D.51158>:
    iftmp.7795 = 0;
    <D.51159>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51160 = iftmp.7795 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51160;
    if (_amd64_rex_bits != 0) goto <D.51161>; else goto <D.51162>;
    <D.51161>:
    code.7796 = code;
    code = code.7796 + 1;
    D.51164 = _amd64_rex_bits | 64;
    *code.7796 = D.51164;
    <D.51162>:
  }
  code.7797 = code;
  code = code.7797 + 1;
  *code.7797 = 15;
  code.7798 = code;
  code = code.7798 + 1;
  *code.7798 = 110;
  code.7799 = code;
  code = code.7799 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7799 = D.33727;
  code.7800 = code;
  code = code.7800 + 1;
  *code.7800 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51170>; else goto <D.51171>;
    <D.51170>:
    iftmp.7801 = 4;
    goto <D.51172>;
    <D.51171>:
    iftmp.7801 = 0;
    <D.51172>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51173 = iftmp.7801 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51173;
    if (_amd64_rex_bits != 0) goto <D.51174>; else goto <D.51175>;
    <D.51174>:
    code.7802 = code;
    code = code.7802 + 1;
    D.51177 = _amd64_rex_bits | 64;
    *code.7802 = D.51177;
    <D.51175>:
  }
  code.7803 = code;
  code = code.7803 + 1;
  *code.7803 = 15;
  code.7804 = code;
  code = code.7804 + 1;
  *code.7804 = 90;
  code.7805 = code;
  code = code.7805 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7805 = D.37521;
  goto <D.25197>;
  <D.27869>:
  code.7806 = code;
  code = code.7806 + 1;
  *code.7806 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51183>; else goto <D.51184>;
    <D.51183>:
    iftmp.7807 = 4;
    goto <D.51185>;
    <D.51184>:
    iftmp.7807 = 0;
    <D.51185>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51186 = iftmp.7807 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51186;
    if (_amd64_rex_bits != 0) goto <D.51187>; else goto <D.51188>;
    <D.51187>:
    code.7808 = code;
    code = code.7808 + 1;
    D.51190 = _amd64_rex_bits | 64;
    *code.7808 = D.51190;
    <D.51188>:
  }
  code.7809 = code;
  code = code.7809 + 1;
  *code.7809 = 15;
  code.7810 = code;
  code = code.7810 + 1;
  *code.7810 = 16;
  code.7811 = code;
  code = code.7811 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7811 = D.33727;
  goto <D.25197>;
  <D.27871>:
  code.7812 = code;
  code = code.7812 + 1;
  *code.7812 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51196>; else goto <D.51197>;
    <D.51196>:
    iftmp.7813 = 4;
    goto <D.51198>;
    <D.51197>:
    iftmp.7813 = 0;
    <D.51198>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51199 = iftmp.7813 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51199;
    if (_amd64_rex_bits != 0) goto <D.51200>; else goto <D.51201>;
    <D.51200>:
    code.7814 = code;
    code = code.7814 + 1;
    D.51203 = _amd64_rex_bits | 64;
    *code.7814 = D.51203;
    <D.51201>:
  }
  code.7815 = code;
  code = code.7815 + 1;
  *code.7815 = 15;
  code.7816 = code;
  code = code.7816 + 1;
  *code.7816 = 44;
  code.7817 = code;
  code = code.7817 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7817 = D.33727;
  D.51207 = ins->backend.source_opcode;
  D.51208 = (int) D.51207;
  switch (D.51208) <default: <D.51281>, case 681: <D.27873>, case 682: <D.27880>, case 689: <D.27883>, case 690: <D.27877>>
  <D.27873>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51210>; else goto <D.51211>;
    <D.51210>:
    iftmp.7818 = 12;
    goto <D.51212>;
    <D.51211>:
    iftmp.7818 = 8;
    <D.51212>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51213 = iftmp.7818 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51213;
    if (_amd64_rex_bits != 0) goto <D.51214>; else goto <D.51215>;
    <D.51214>:
    code.7819 = code;
    code = code.7819 + 1;
    D.51217 = _amd64_rex_bits | 64;
    *code.7819 = D.51217;
    <D.51215>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.51218>; else goto <D.51219>;
    <D.51218>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6457, "(0) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.51219>:
    code.7820 = code;
    code = code.7820 + 1;
    *code.7820 = 15;
    if (1 != 0) goto <D.51221>; else goto <D.51222>;
    <D.51221>:
    op = op + 8;
    <D.51222>:
    if (0 != 0) goto <D.51223>; else goto <D.51224>;
    <D.51223>:
    op = op + 1;
    <D.51224>:
    code.7821 = code;
    code = code.7821 + 1;
    *code.7821 = op;
    code.7822 = code;
    code = code.7822 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.7822 = D.37521;
  }
  goto <D.27876>;
  <D.27877>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51228>; else goto <D.51229>;
    <D.51228>:
    iftmp.7823 = 12;
    goto <D.51230>;
    <D.51229>:
    iftmp.7823 = 8;
    <D.51230>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51231 = iftmp.7823 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51231;
    if (_amd64_rex_bits != 0) goto <D.51232>; else goto <D.51233>;
    <D.51232>:
    code.7824 = code;
    code = code.7824 + 1;
    D.51235 = _amd64_rex_bits | 64;
    *code.7824 = D.51235;
    <D.51233>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.51236>; else goto <D.51237>;
    <D.51236>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6460, "(0) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.51237>:
    code.7825 = code;
    code = code.7825 + 1;
    *code.7825 = 15;
    if (0 != 0) goto <D.51239>; else goto <D.51240>;
    <D.51239>:
    op = op + 8;
    <D.51240>:
    if (0 != 0) goto <D.51241>; else goto <D.51242>;
    <D.51241>:
    op = op + 1;
    <D.51242>:
    code.7826 = code;
    code = code.7826 + 1;
    *code.7826 = op;
    code.7827 = code;
    code = code.7827 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.7827 = D.37521;
  }
  goto <D.27876>;
  <D.27880>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51246>; else goto <D.51247>;
    <D.51246>:
    iftmp.7828 = 12;
    goto <D.51248>;
    <D.51247>:
    iftmp.7828 = 8;
    <D.51248>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51249 = iftmp.7828 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51249;
    if (_amd64_rex_bits != 0) goto <D.51250>; else goto <D.51251>;
    <D.51250>:
    code.7829 = code;
    code = code.7829 + 1;
    D.51253 = _amd64_rex_bits | 64;
    *code.7829 = D.51253;
    <D.51251>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.51254>; else goto <D.51255>;
    <D.51254>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6463, "(1) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.51255>:
    code.7830 = code;
    code = code.7830 + 1;
    *code.7830 = 15;
    if (1 != 0) goto <D.51257>; else goto <D.51258>;
    <D.51257>:
    op = op + 8;
    <D.51258>:
    if (1 != 0) goto <D.51259>; else goto <D.51260>;
    <D.51259>:
    op = op + 1;
    <D.51260>:
    code.7831 = code;
    code = code.7831 + 1;
    *code.7831 = op;
    code.7832 = code;
    code = code.7832 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.7832 = D.37521;
  }
  goto <D.27876>;
  <D.27883>:
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51264>; else goto <D.51265>;
    <D.51264>:
    iftmp.7833 = 12;
    goto <D.51266>;
    <D.51265>:
    iftmp.7833 = 8;
    <D.51266>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51267 = iftmp.7833 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51267;
    if (_amd64_rex_bits != 0) goto <D.51268>; else goto <D.51269>;
    <D.51268>:
    code.7834 = code;
    code = code.7834 + 1;
    D.51271 = _amd64_rex_bits | 64;
    *code.7834 = D.51271;
    <D.51269>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.51272>; else goto <D.51273>;
    <D.51272>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6466, "(1) || X86_IS_BYTE_REG (((ins->dreg)&0x7))");
    <D.51273>:
    code.7835 = code;
    code = code.7835 + 1;
    *code.7835 = 15;
    if (0 != 0) goto <D.51275>; else goto <D.51276>;
    <D.51275>:
    op = op + 8;
    <D.51276>:
    if (1 != 0) goto <D.51277>; else goto <D.51278>;
    <D.51277>:
    op = op + 1;
    <D.51278>:
    code.7836 = code;
    code = code.7836 + 1;
    *code.7836 = op;
    code.7837 = code;
    code = code.7837 + 1;
    D.31589 = ins->dreg;
    D.31598 = D.31589 & 7;
    D.32641 = D.31598 << 3;
    D.32642 = (signed char) D.32641;
    D.33725 = D.32642 | -64;
    D.31589 = ins->dreg;
    D.31631 = (signed char) D.31589;
    D.31632 = D.31631 & 7;
    D.37520 = D.33725 | D.31632;
    D.37521 = (unsigned char) D.37520;
    *code.7837 = D.37521;
  }
  goto <D.27876>;
  <D.51281>:
  <D.27876>:
  goto <D.25197>;
  <D.27886>:
  code.7838 = code;
  code = code.7838 + 1;
  *code.7838 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51284>; else goto <D.51285>;
    <D.51284>:
    iftmp.7839 = 4;
    goto <D.51286>;
    <D.51285>:
    iftmp.7839 = 0;
    <D.51286>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51287 = iftmp.7839 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51287;
    if (_amd64_rex_bits != 0) goto <D.51288>; else goto <D.51289>;
    <D.51288>:
    code.7840 = code;
    code = code.7840 + 1;
    D.51291 = _amd64_rex_bits | 64;
    *code.7840 = D.51291;
    <D.51289>:
  }
  code.7841 = code;
  code = code.7841 + 1;
  *code.7841 = 15;
  code.7842 = code;
  code = code.7842 + 1;
  *code.7842 = 196;
  code.7843 = code;
  code = code.7843 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7843 = D.33727;
  *code = 0;
  code = code + 1;
  code.7844 = code;
  code = code.7844 + 1;
  *code.7844 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51297>; else goto <D.51298>;
    <D.51297>:
    iftmp.7845 = 4;
    goto <D.51299>;
    <D.51298>:
    iftmp.7845 = 0;
    <D.51299>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51300 = iftmp.7845 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51300;
    if (_amd64_rex_bits != 0) goto <D.51301>; else goto <D.51302>;
    <D.51301>:
    code.7846 = code;
    code = code.7846 + 1;
    D.51304 = _amd64_rex_bits | 64;
    *code.7846 = D.51304;
    <D.51302>:
  }
  code.7847 = code;
  code = code.7847 + 1;
  *code.7847 = 15;
  code.7848 = code;
  code = code.7848 + 1;
  *code.7848 = 196;
  code.7849 = code;
  code = code.7849 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7849 = D.33727;
  *code = 1;
  code = code + 1;
  code.7850 = code;
  code = code.7850 + 1;
  *code.7850 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51310>; else goto <D.51311>;
    <D.51310>:
    iftmp.7851 = 4;
    goto <D.51312>;
    <D.51311>:
    iftmp.7851 = 0;
    <D.51312>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51313 = iftmp.7851 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51313;
    if (_amd64_rex_bits != 0) goto <D.51314>; else goto <D.51315>;
    <D.51314>:
    code.7852 = code;
    code = code.7852 + 1;
    D.51317 = _amd64_rex_bits | 64;
    *code.7852 = D.51317;
    <D.51315>:
  }
  code.7853 = code;
  code = code.7853 + 1;
  *code.7853 = 15;
  code.7854 = code;
  code = code.7854 + 1;
  *code.7854 = 112;
  code.7855 = code;
  code = code.7855 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7855 = D.37521;
  *code = 0;
  code = code + 1;
  goto <D.25197>;
  <D.27890>:
  code.7856 = code;
  code = code.7856 + 1;
  *code.7856 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51323>; else goto <D.51324>;
    <D.51323>:
    iftmp.7857 = 4;
    goto <D.51325>;
    <D.51324>:
    iftmp.7857 = 0;
    <D.51325>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51326 = iftmp.7857 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51326;
    if (_amd64_rex_bits != 0) goto <D.51327>; else goto <D.51328>;
    <D.51327>:
    code.7858 = code;
    code = code.7858 + 1;
    D.51330 = _amd64_rex_bits | 64;
    *code.7858 = D.51330;
    <D.51328>:
  }
  code.7859 = code;
  code = code.7859 + 1;
  *code.7859 = 15;
  code.7860 = code;
  code = code.7860 + 1;
  *code.7860 = 110;
  code.7861 = code;
  code = code.7861 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7861 = D.33727;
  code.7862 = code;
  code = code.7862 + 1;
  *code.7862 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51336>; else goto <D.51337>;
    <D.51336>:
    iftmp.7863 = 4;
    goto <D.51338>;
    <D.51337>:
    iftmp.7863 = 0;
    <D.51338>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51339 = iftmp.7863 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51339;
    if (_amd64_rex_bits != 0) goto <D.51340>; else goto <D.51341>;
    <D.51340>:
    code.7864 = code;
    code = code.7864 + 1;
    D.51343 = _amd64_rex_bits | 64;
    *code.7864 = D.51343;
    <D.51341>:
  }
  code.7865 = code;
  code = code.7865 + 1;
  *code.7865 = 15;
  code.7866 = code;
  code = code.7866 + 1;
  *code.7866 = 112;
  code.7867 = code;
  code = code.7867 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7867 = D.37521;
  *code = 0;
  code = code + 1;
  goto <D.25197>;
  <D.27893>:
  code.7868 = code;
  code = code.7868 + 1;
  *code.7868 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51349>; else goto <D.51350>;
    <D.51349>:
    iftmp.7869 = 12;
    goto <D.51351>;
    <D.51350>:
    iftmp.7869 = 8;
    <D.51351>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51352 = iftmp.7869 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51352;
    if (_amd64_rex_bits != 0) goto <D.51353>; else goto <D.51354>;
    <D.51353>:
    code.7870 = code;
    code = code.7870 + 1;
    D.51356 = _amd64_rex_bits | 64;
    *code.7870 = D.51356;
    <D.51354>:
  }
  code.7871 = code;
  code = code.7871 + 1;
  *code.7871 = 15;
  code.7872 = code;
  code = code.7872 + 1;
  *code.7872 = 110;
  code.7873 = code;
  code = code.7873 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7873 = D.33727;
  code.7874 = code;
  code = code.7874 + 1;
  *code.7874 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51362>; else goto <D.51363>;
    <D.51362>:
    iftmp.7875 = 4;
    goto <D.51364>;
    <D.51363>:
    iftmp.7875 = 0;
    <D.51364>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51365 = iftmp.7875 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51365;
    if (_amd64_rex_bits != 0) goto <D.51366>; else goto <D.51367>;
    <D.51366>:
    code.7876 = code;
    code = code.7876 + 1;
    D.51369 = _amd64_rex_bits | 64;
    *code.7876 = D.51369;
    <D.51367>:
  }
  code.7877 = code;
  code = code.7877 + 1;
  *code.7877 = 15;
  code.7878 = code;
  code = code.7878 + 1;
  *code.7878 = 112;
  code.7879 = code;
  code = code.7879 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7879 = D.37521;
  *code = 68;
  code = code + 1;
  goto <D.25197>;
  <D.27896>:
  code.7880 = code;
  code = code.7880 + 1;
  *code.7880 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51375>; else goto <D.51376>;
    <D.51375>:
    iftmp.7881 = 4;
    goto <D.51377>;
    <D.51376>:
    iftmp.7881 = 0;
    <D.51377>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51378 = iftmp.7881 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51378;
    if (_amd64_rex_bits != 0) goto <D.51379>; else goto <D.51380>;
    <D.51379>:
    code.7882 = code;
    code = code.7882 + 1;
    D.51382 = _amd64_rex_bits | 64;
    *code.7882 = D.51382;
    <D.51380>:
  }
  code.7883 = code;
  code = code.7883 + 1;
  *code.7883 = 15;
  code.7884 = code;
  code = code.7884 + 1;
  *code.7884 = 16;
  code.7885 = code;
  code = code.7885 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7885 = D.33727;
  code.7886 = code;
  code = code.7886 + 1;
  *code.7886 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51388>; else goto <D.51389>;
    <D.51388>:
    iftmp.7887 = 4;
    goto <D.51390>;
    <D.51389>:
    iftmp.7887 = 0;
    <D.51390>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51391 = iftmp.7887 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51391;
    if (_amd64_rex_bits != 0) goto <D.51392>; else goto <D.51393>;
    <D.51392>:
    code.7888 = code;
    code = code.7888 + 1;
    D.51395 = _amd64_rex_bits | 64;
    *code.7888 = D.51395;
    <D.51393>:
  }
  code.7889 = code;
  code = code.7889 + 1;
  *code.7889 = 15;
  code.7890 = code;
  code = code.7890 + 1;
  *code.7890 = 90;
  code.7891 = code;
  code = code.7891 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7891 = D.37521;
  code.7892 = code;
  code = code.7892 + 1;
  *code.7892 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51401>; else goto <D.51402>;
    <D.51401>:
    iftmp.7893 = 4;
    goto <D.51403>;
    <D.51402>:
    iftmp.7893 = 0;
    <D.51403>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51404 = iftmp.7893 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51404;
    if (_amd64_rex_bits != 0) goto <D.51405>; else goto <D.51406>;
    <D.51405>:
    code.7894 = code;
    code = code.7894 + 1;
    D.51408 = _amd64_rex_bits | 64;
    *code.7894 = D.51408;
    <D.51406>:
  }
  code.7895 = code;
  code = code.7895 + 1;
  *code.7895 = 15;
  code.7896 = code;
  code = code.7896 + 1;
  *code.7896 = 112;
  code.7897 = code;
  code = code.7897 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7897 = D.37521;
  *code = 0;
  code = code + 1;
  goto <D.25197>;
  <D.27900>:
  code.7898 = code;
  code = code.7898 + 1;
  *code.7898 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51414>; else goto <D.51415>;
    <D.51414>:
    iftmp.7899 = 4;
    goto <D.51416>;
    <D.51415>:
    iftmp.7899 = 0;
    <D.51416>:
    D.31516 = ins->sreg1;
    D.31517 = D.31516 > 7;
    D.33180 = (signed char) D.31517;
    D.51417 = iftmp.7899 | D.33180;
    _amd64_rex_bits = (unsigned char) D.51417;
    if (_amd64_rex_bits != 0) goto <D.51418>; else goto <D.51419>;
    <D.51418>:
    code.7900 = code;
    code = code.7900 + 1;
    D.51421 = _amd64_rex_bits | 64;
    *code.7900 = D.51421;
    <D.51419>:
  }
  code.7901 = code;
  code = code.7901 + 1;
  *code.7901 = 15;
  code.7902 = code;
  code = code.7902 + 1;
  *code.7902 = 16;
  code.7903 = code;
  code = code.7903 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31516 = ins->sreg1;
  D.31570 = (signed char) D.31516;
  D.31571 = D.31570 & 7;
  D.33726 = D.33725 | D.31571;
  D.33727 = (unsigned char) D.33726;
  *code.7903 = D.33727;
  code.7904 = code;
  code = code.7904 + 1;
  *code.7904 = 102;
  {
    unsigned char _amd64_rex_bits;

    D.31589 = ins->dreg;
    if (D.31589 > 7) goto <D.51427>; else goto <D.51428>;
    <D.51427>:
    iftmp.7905 = 4;
    goto <D.51429>;
    <D.51428>:
    iftmp.7905 = 0;
    <D.51429>:
    D.31589 = ins->dreg;
    D.31590 = D.31589 > 7;
    D.32040 = (signed char) D.31590;
    D.51430 = iftmp.7905 | D.32040;
    _amd64_rex_bits = (unsigned char) D.51430;
    if (_amd64_rex_bits != 0) goto <D.51431>; else goto <D.51432>;
    <D.51431>:
    code.7906 = code;
    code = code.7906 + 1;
    D.51434 = _amd64_rex_bits | 64;
    *code.7906 = D.51434;
    <D.51432>:
  }
  code.7907 = code;
  code = code.7907 + 1;
  *code.7907 = 15;
  code.7908 = code;
  code = code.7908 + 1;
  *code.7908 = 112;
  code.7909 = code;
  code = code.7909 + 1;
  D.31589 = ins->dreg;
  D.31598 = D.31589 & 7;
  D.32641 = D.31598 << 3;
  D.32642 = (signed char) D.32641;
  D.33725 = D.32642 | -64;
  D.31589 = ins->dreg;
  D.31631 = (signed char) D.31589;
  D.31632 = D.31631 & 7;
  D.37520 = D.33725 | D.31632;
  D.37521 = (unsigned char) D.37520;
  *code.7909 = D.37521;
  *code = 68;
  code = code + 1;
  goto <D.25197>;
  <D.27903>:
  D.31347 = cfg->verbose_level;
  if (D.31347 > 1) goto <D.51438>; else goto <D.51439>;
  <D.51438>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  D.51440 = cfg->vars;
  D.31535 = ins->data.op[0].const_val;
  D.39979 = (long unsigned int) D.31535;
  D.51441 = D.39979 * 80;
  D.51442 = D.51440 + D.51441;
  D.51443 = D.51442->vreg;
  printf ("R%d START=0x%x\n", D.51443, D.36947);
  <D.51439>:
  D.51440 = cfg->vars;
  D.31535 = ins->data.op[0].const_val;
  D.39979 = (long unsigned int) D.31535;
  D.51441 = D.39979 * 80;
  D.51442 = D.51440 + D.51441;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.51444 = (int) D.31452;
  D.51442->live_range_start = D.51444;
  goto <D.25197>;
  <D.27904>:
  D.31347 = cfg->verbose_level;
  if (D.31347 > 1) goto <D.51445>; else goto <D.51446>;
  <D.51445>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  D.51440 = cfg->vars;
  D.31535 = ins->data.op[0].const_val;
  D.39979 = (long unsigned int) D.31535;
  D.51441 = D.39979 * 80;
  D.51442 = D.51440 + D.51441;
  D.51443 = D.51442->vreg;
  printf ("R%d END=0x%x\n", D.51443, D.36947);
  <D.51446>:
  D.51440 = cfg->vars;
  D.31535 = ins->data.op[0].const_val;
  D.39979 = (long unsigned int) D.31535;
  D.51441 = D.39979 * 80;
  D.51442 = D.51440 + D.51441;
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.51444 = (int) D.31452;
  D.51442->live_range_end = D.51444;
  goto <D.25197>;
  <D.27905>:
  goto <D.25197>;
  <D.27906>:
  <D.27907>:
  <D.27908>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  goto <D.25197>;
  <D.27909>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.36947 = (int) D.31452;
  ins->backend.pc_offset = D.36947;
  D.51447 = bb->spill_slot_defs;
  D.51448 = cfg->mempool;
  D.51449 = g_slist_prepend_mempool (D.51448, D.51447, ins);
  bb->spill_slot_defs = D.51449;
  goto <D.25197>;
  <D.27910>:
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.51450 = mono_inst_name (D.31465);
  monoeg_g_log (0B, 16, "unknown opcode %s in %s()\n", D.51450, &__FUNCTION__);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 6533);
  <D.25197>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.51451 = (long int) offset;
  D.51452 = D.31452 - D.51451;
  D.51453 = (long int) max_len;
  if (D.51452 > D.51453) goto <D.51454>; else goto <D.51455>;
  <D.51454>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.51451 = (long int) offset;
  D.51452 = D.31452 - D.51451;
  D.31464 = ins->opcode;
  D.31465 = (int) D.31464;
  D.51456 = mono_inst_name (D.31465);
  monoeg_g_log (0B, 16, "wrong maximal instruction length of instruction %s (expected %d, got %ld)", D.51456, max_len, D.51452);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 6540);
  <D.51455>:
  last_ins = ins;
  last_offset = offset;
  <D.27409>:
  ins = ins->next;
  <D.27913>:
  if (ins != 0B) goto <D.27912>; else goto <D.27914>;
  <D.27914>:
  code.211 = (long int) code;
  D.31283 = cfg->native_code;
  D.31451 = (long int) D.31283;
  D.31452 = code.211 - D.31451;
  D.51457 = (unsigned int) D.31452;
  cfg->code_len = D.51457;
}


emit_move_return_value (struct MonoCompile * cfg, struct MonoInst * ins, guint8 * code)
{
  short unsigned int D.51483;
  int D.51484;
  int D.51485;
  _Bool D.51486;
  long int D.51487;
  long int D.51488;
  struct MonoMethodSignature * D.51491;
  struct MonoType * D.51492;
  unsigned char D.51493;
  guint8 * code.7910;
  unsigned char iftmp.7911;
  guint8 * code.7912;
  unsigned char D.51504;
  guint8 * code.7913;
  guint8 * code.7914;
  guint8 * code.7915;
  int D.51508;
  int D.51509;
  signed char D.51510;
  signed char D.51511;
  unsigned char D.51512;
  guint8 * code.7916;
  unsigned char iftmp.7917;
  guint8 * code.7918;
  unsigned char D.51524;
  guint8 * code.7919;
  guint8 * code.7920;
  guint8 * code.7921;
  struct MonoMemPool * D.51528;
  struct MonoGenericSharingContext * D.51529;
  <unnamed type> D.51530;
  short unsigned int D.51533;
  _Bool D.51534;
  long int D.51535;
  long int D.51536;
  guint8 * code.7922;
  unsigned char iftmp.7923;
  int D.51543;
  guint8 * code.7924;
  unsigned char D.51550;
  guint8 * code.7925;
  guint8 * code.7926;
  guint8 * code.7927;
  long int D.51556;
  int D.51557;
  guint8 * code.7928;
  unsigned char D.51559;
  guint8 * code.7929;
  unsigned char D.51561;
  guint8 * code.7930;
  unsigned char D.51563;
  guint8 * code.7931;
  unsigned char D.51565;
  int D.51567;
  guint8 * code.7932;
  guint8 * code.7933;
  unsigned int D.51575;
  unsigned int D.51576;
  guint8 * code.7934;
  guint8 * code.7935;
  unsigned char D.51581;
  guint8 * code.7936;
  guint8 * code.7937;
  guint8 * code.7938;
  unsigned char D.51586;
  guint8 * code.7939;
  unsigned char D.51588;
  guint8 * code.7940;
  unsigned char D.51590;
  guint8 * code.7941;
  unsigned char D.51592;
  guint8 * code.7942;
  signed char D.51598;
  signed char D.51599;
  signed char D.51600;
  unsigned char D.51601;
  guint8 * code.7943;
  signed char D.51605;
  unsigned char D.51606;
  guint8 * code.7944;
  signed char D.51609;
  unsigned char D.51610;
  guint8 * code.7945;
  unsigned char D.51612;
  guint8 * code.7946;
  unsigned char D.51614;
  guint8 * code.7947;
  unsigned char D.51616;
  guint8 * code.7948;
  unsigned char D.51618;
  <unnamed type> D.51619;
  guint8 * code.7949;
  unsigned char iftmp.7950;
  signed char D.51624;
  guint8 * code.7951;
  unsigned char D.51631;
  guint8 * code.7952;
  guint8 * code.7953;
  long unsigned int D.51636;
  long unsigned int D.51637;
  guint8 * code.7954;
  int D.51641;
  int D.51642;
  int D.51643;
  signed char D.51644;
  signed char D.51645;
  unsigned char D.51646;
  guint8 * code.7955;
  unsigned int D.51651;
  int D.51652;
  guint8 * code.7956;
  signed char D.51656;
  unsigned char D.51657;
  guint8 * code.7957;
  unsigned char D.51659;
  unsigned char D.51660;
  guint8 * code.7958;
  signed char D.51662;
  unsigned char D.51663;
  guint8 * code.7959;
  guint8 * code.7960;
  unsigned char D.51666;
  guint8 * code.7961;
  unsigned char D.51668;
  guint8 * code.7962;
  unsigned char D.51670;
  guint8 * code.7963;
  unsigned char D.51672;
  guint8 * code.7964;
  signed char D.51676;
  unsigned char D.51677;
  guint8 * code.7965;
  signed char D.51683;
  unsigned char D.51684;
  guint8 * code.7966;
  signed char D.51686;
  unsigned char D.51687;
  guint8 * code.7967;
  unsigned char D.51689;
  guint8 * code.7968;
  unsigned char D.51691;
  guint8 * code.7969;
  unsigned char D.51693;
  guint8 * code.7970;
  unsigned char D.51695;
  guint8 * code.7971;
  unsigned char iftmp.7972;
  guint8 * code.7973;
  unsigned char D.51704;
  guint8 * code.7974;
  guint8 * code.7975;
  unsigned int D.51709;
  guint8 * code.7976;
  guint8 * code.7977;
  int D.51717;
  guint8 * code.7978;
  guint8 * code.7979;
  guint8 * code.7980;
  guint8 * code.7981;
  guint8 * code.7982;
  unsigned char D.51725;
  guint8 * code.7983;
  unsigned char D.51727;
  guint8 * code.7984;
  unsigned char D.51729;
  guint8 * code.7985;
  unsigned char D.51731;
  guint8 * code.7986;
  guint8 * code.7987;
  guint8 * code.7988;
  guint8 * code.7989;
  unsigned char D.51742;
  guint8 * code.7990;
  unsigned char D.51744;
  guint8 * code.7991;
  unsigned char D.51746;
  guint8 * code.7992;
  unsigned char D.51748;
  guint8 * code.7993;
  unsigned char iftmp.7994;
  guint8 * code.7995;
  unsigned char D.51757;
  guint8 * code.7996;
  guint8 * code.7997;
  guint8 * code.7998;
  guint8 * code.7999;
  guint8 * code.8000;
  guint8 * code.8001;
  guint8 * code.8002;
  guint8 * code.8003;
  guint8 * code.8004;
  unsigned char D.51776;
  guint8 * code.8005;
  unsigned char D.51778;
  guint8 * code.8006;
  unsigned char D.51780;
  guint8 * code.8007;
  unsigned char D.51782;
  guint8 * code.8008;
  guint8 * code.8009;
  guint8 * code.8010;
  guint8 * code.8011;
  unsigned char D.51793;
  guint8 * code.8012;
  unsigned char D.51795;
  guint8 * code.8013;
  unsigned char D.51797;
  guint8 * code.8014;
  unsigned char D.51799;
  guint8 * D.51801;
  struct CallInfo * cinfo;
  guint32 quad;
  static const char __PRETTY_FUNCTION__[23] = "emit_move_return_value";

  D.51483 = ins->opcode;
  D.51484 = (int) D.51483;
  switch (D.51484) <default: <D.51800>, case 346: <D.24931>, case 347: <D.24932>, case 348: <D.24933>, case 349: <D.24938>, case 350: <D.24939>, case 351: <D.24940>, case 352: <D.24934>, case 353: <D.24935>, case 354: <D.24936>, case 355: <D.24943>, case 356: <D.24944>, case 357: <D.24945>, case 358: <D.24946>, case 359: <D.24947>, case 360: <D.24948>>
  <D.24931>:
  <D.24932>:
  <D.24933>:
  <D.24934>:
  <D.24935>:
  <D.24936>:
  D.51485 = ins->dreg;
  D.51486 = D.51485 != 0;
  D.51487 = (long int) D.51486;
  D.51488 = __builtin_expect (D.51487, 0);
  if (D.51488 != 0) goto <D.51489>; else goto <D.51490>;
  <D.51489>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 3530, "ins->dreg == AMD64_RAX");
  <D.51490>:
  goto <D.24937>;
  <D.24938>:
  <D.24939>:
  <D.24940>:
  D.51491 = MEM[(struct MonoCallInst *)ins].signature;
  D.51492 = D.51491->ret;
  D.51493 = D.51492->type;
  if (D.51493 == 12) goto <D.51494>; else goto <D.51495>;
  <D.51494>:
  code.7910 = code;
  code = code.7910 + 1;
  *code.7910 = 243;
  {
    unsigned char _amd64_rex_bits;

    D.51485 = ins->dreg;
    if (D.51485 > 7) goto <D.51498>; else goto <D.51499>;
    <D.51498>:
    iftmp.7911 = 4;
    goto <D.51500>;
    <D.51499>:
    iftmp.7911 = 0;
    <D.51500>:
    _amd64_rex_bits = iftmp.7911;
    if (_amd64_rex_bits != 0) goto <D.51501>; else goto <D.51502>;
    <D.51501>:
    code.7912 = code;
    code = code.7912 + 1;
    D.51504 = _amd64_rex_bits | 64;
    *code.7912 = D.51504;
    <D.51502>:
  }
  code.7913 = code;
  code = code.7913 + 1;
  *code.7913 = 15;
  code.7914 = code;
  code = code.7914 + 1;
  *code.7914 = 90;
  code.7915 = code;
  code = code.7915 + 1;
  D.51485 = ins->dreg;
  D.51508 = D.51485 & 7;
  D.51509 = D.51508 << 3;
  D.51510 = (signed char) D.51509;
  D.51511 = D.51510 | -64;
  D.51512 = (unsigned char) D.51511;
  *code.7915 = D.51512;
  goto <D.51513>;
  <D.51495>:
  D.51485 = ins->dreg;
  if (D.51485 != 0) goto <D.51514>; else goto <D.51515>;
  <D.51514>:
  code.7916 = code;
  code = code.7916 + 1;
  *code.7916 = 242;
  {
    unsigned char _amd64_rex_bits;

    D.51485 = ins->dreg;
    if (D.51485 > 7) goto <D.51518>; else goto <D.51519>;
    <D.51518>:
    iftmp.7917 = 4;
    goto <D.51520>;
    <D.51519>:
    iftmp.7917 = 0;
    <D.51520>:
    _amd64_rex_bits = iftmp.7917;
    if (_amd64_rex_bits != 0) goto <D.51521>; else goto <D.51522>;
    <D.51521>:
    code.7918 = code;
    code = code.7918 + 1;
    D.51524 = _amd64_rex_bits | 64;
    *code.7918 = D.51524;
    <D.51522>:
  }
  code.7919 = code;
  code = code.7919 + 1;
  *code.7919 = 15;
  code.7920 = code;
  code = code.7920 + 1;
  *code.7920 = 16;
  code.7921 = code;
  code = code.7921 + 1;
  D.51485 = ins->dreg;
  D.51508 = D.51485 & 7;
  D.51509 = D.51508 << 3;
  D.51510 = (signed char) D.51509;
  D.51511 = D.51510 | -64;
  D.51512 = (unsigned char) D.51511;
  *code.7921 = D.51512;
  <D.51515>:
  <D.51513>:
  goto <D.24937>;
  <D.24943>:
  <D.24944>:
  <D.24945>:
  <D.24946>:
  <D.24947>:
  <D.24948>:
  D.51491 = MEM[(struct MonoCallInst *)ins].signature;
  D.51528 = cfg->mempool;
  D.51529 = cfg->generic_sharing_context;
  cinfo = get_call_info (D.51529, D.51528, D.51491);
  D.51530 = cinfo->ret.storage;
  if (D.51530 == 4) goto <D.51531>; else goto <D.51532>;
  <D.51531>:
  {
    struct MonoInst * loc;

    loc = cfg->arch.vret_addr_loc;
    D.51533 = loc->opcode;
    D.51534 = D.51533 != 367;
    D.51535 = (long int) D.51534;
    D.51536 = __builtin_expect (D.51535, 0);
    if (D.51536 != 0) goto <D.51537>; else goto <D.51538>;
    <D.51537>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 3554, "loc->opcode == OP_REGOFFSET");
    <D.51538>:
    if (0 != 0) goto <D.51539>; else goto <D.51540>;
    <D.51539>:
    code.7922 = code;
    code = code.7922 + 1;
    *code.7922 = 102;
    <D.51540>:
    {
      unsigned char _amd64_rex_bits;

      D.51543 = loc->sreg1;
      if (D.51543 > 7) goto <D.51544>; else goto <D.51545>;
      <D.51544>:
      iftmp.7923 = 9;
      goto <D.51546>;
      <D.51545>:
      iftmp.7923 = 8;
      <D.51546>:
      _amd64_rex_bits = iftmp.7923;
      if (_amd64_rex_bits != 0) goto <D.51547>; else goto <D.51548>;
      <D.51547>:
      code.7924 = code;
      code = code.7924 + 1;
      D.51550 = _amd64_rex_bits | 64;
      *code.7924 = D.51550;
      <D.51548>:
    }
    switch (8) <default: <D.24956>, case 1: <D.24951>, case 2: <D.24953>, case 4: <D.24954>, case 8: <D.24955>>
    <D.24951>:
    code.7925 = code;
    code = code.7925 + 1;
    *code.7925 = 138;
    goto <D.24952>;
    <D.24953>:
    <D.24954>:
    <D.24955>:
    code.7926 = code;
    code = code.7926 + 1;
    *code.7926 = 139;
    goto <D.24952>;
    <D.24956>:
    __assert_fail ("0", "mini-amd64.c", 3555, &__PRETTY_FUNCTION__);
    <D.24952>:
    D.51543 = loc->sreg1;
    if (D.51543 == 16) goto <D.51553>; else goto <D.51554>;
    <D.51553>:
    code.7927 = code;
    code = code.7927 + 1;
    *code.7927 = 13;
    {
      union x86_imm_buf imb;

      try
        {
          D.51556 = loc->data.op[0].const_val;
          D.51557 = (int) D.51556;
          imb.val = D.51557;
          code.7928 = code;
          code = code.7928 + 1;
          D.51559 = imb.b[0];
          *code.7928 = D.51559;
          code.7929 = code;
          code = code.7929 + 1;
          D.51561 = imb.b[1];
          *code.7929 = D.51561;
          code.7930 = code;
          code = code.7930 + 1;
          D.51563 = imb.b[2];
          *code.7930 = D.51563;
          code.7931 = code;
          code = code.7931 + 1;
          D.51565 = imb.b[3];
          *code.7931 = D.51565;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.51566>;
    <D.51554>:
    D.51543 = loc->sreg1;
    D.51567 = D.51543 & 7;
    if (D.51567 == 4) goto <D.51568>; else goto <D.51569>;
    <D.51568>:
    D.51556 = loc->data.op[0].const_val;
    if (D.51556 == 0) goto <D.51570>; else goto <D.51571>;
    <D.51570>:
    code.7932 = code;
    code = code.7932 + 1;
    *code.7932 = 12;
    code.7933 = code;
    code = code.7933 + 1;
    *code.7933 = 36;
    goto <D.51574>;
    <D.51571>:
    D.51556 = loc->data.op[0].const_val;
    D.51575 = (unsigned int) D.51556;
    D.51576 = D.51575 + 128;
    if (D.51576 <= 255) goto <D.51577>; else goto <D.51578>;
    <D.51577>:
    code.7934 = code;
    code = code.7934 + 1;
    *code.7934 = 76;
    code.7935 = code;
    code = code.7935 + 1;
    *code.7935 = 36;
    D.51556 = loc->data.op[0].const_val;
    D.51581 = (unsigned char) D.51556;
    *code = D.51581;
    code = code + 1;
    goto <D.51582>;
    <D.51578>:
    code.7936 = code;
    code = code.7936 + 1;
    *code.7936 = 140;
    code.7937 = code;
    code = code.7937 + 1;
    *code.7937 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.51556 = loc->data.op[0].const_val;
          D.51557 = (int) D.51556;
          imb.val = D.51557;
          code.7938 = code;
          code = code.7938 + 1;
          D.51586 = imb.b[0];
          *code.7938 = D.51586;
          code.7939 = code;
          code = code.7939 + 1;
          D.51588 = imb.b[1];
          *code.7939 = D.51588;
          code.7940 = code;
          code = code.7940 + 1;
          D.51590 = imb.b[2];
          *code.7940 = D.51590;
          code.7941 = code;
          code = code.7941 + 1;
          D.51592 = imb.b[3];
          *code.7941 = D.51592;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51582>:
    <D.51574>:
    goto <D.24960>;
    <D.51569>:
    D.51556 = loc->data.op[0].const_val;
    if (D.51556 == 0) goto <D.51593>; else goto <D.51594>;
    <D.51593>:
    D.51543 = loc->sreg1;
    D.51567 = D.51543 & 7;
    if (D.51567 != 5) goto <D.51595>; else goto <D.51596>;
    <D.51595>:
    code.7942 = code;
    code = code.7942 + 1;
    D.51543 = loc->sreg1;
    D.51598 = (signed char) D.51543;
    D.51599 = D.51598 & 7;
    D.51600 = D.51599 | 8;
    D.51601 = (unsigned char) D.51600;
    *code.7942 = D.51601;
    goto <D.24960>;
    <D.51596>:
    <D.51594>:
    D.51556 = loc->data.op[0].const_val;
    D.51575 = (unsigned int) D.51556;
    D.51576 = D.51575 + 128;
    if (D.51576 <= 255) goto <D.51602>; else goto <D.51603>;
    <D.51602>:
    code.7943 = code;
    code = code.7943 + 1;
    D.51543 = loc->sreg1;
    D.51598 = (signed char) D.51543;
    D.51599 = D.51598 & 7;
    D.51605 = D.51599 | 72;
    D.51606 = (unsigned char) D.51605;
    *code.7943 = D.51606;
    D.51556 = loc->data.op[0].const_val;
    D.51581 = (unsigned char) D.51556;
    *code = D.51581;
    code = code + 1;
    goto <D.51607>;
    <D.51603>:
    code.7944 = code;
    code = code.7944 + 1;
    D.51543 = loc->sreg1;
    D.51598 = (signed char) D.51543;
    D.51599 = D.51598 & 7;
    D.51609 = D.51599 | -120;
    D.51610 = (unsigned char) D.51609;
    *code.7944 = D.51610;
    {
      union x86_imm_buf imb;

      try
        {
          D.51556 = loc->data.op[0].const_val;
          D.51557 = (int) D.51556;
          imb.val = D.51557;
          code.7945 = code;
          code = code.7945 + 1;
          D.51612 = imb.b[0];
          *code.7945 = D.51612;
          code.7946 = code;
          code = code.7946 + 1;
          D.51614 = imb.b[1];
          *code.7946 = D.51614;
          code.7947 = code;
          code = code.7947 + 1;
          D.51616 = imb.b[2];
          *code.7947 = D.51616;
          code.7948 = code;
          code = code.7948 + 1;
          D.51618 = imb.b[3];
          *code.7948 = D.51618;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51607>:
    <D.24960>:
    <D.51566>:
    quad = 0;
    goto <D.24987>;
    <D.24986>:
    D.51619 = cinfo->ret.pair_storage[quad];
    switch (D.51619) <default: <D.24985>, case 0: <D.24962>, case 1: <D.24974>, case 2: <D.24979>, case 6: <D.24984>>
    <D.24962>:
    if (0 != 0) goto <D.51620>; else goto <D.51621>;
    <D.51620>:
    code.7949 = code;
    code = code.7949 + 1;
    *code.7949 = 102;
    <D.51621>:
    {
      unsigned char _amd64_rex_bits;

      D.51624 = cinfo->ret.pair_regs[quad];
      if (D.51624 > 7) goto <D.51625>; else goto <D.51626>;
      <D.51625>:
      iftmp.7950 = 12;
      goto <D.51627>;
      <D.51626>:
      iftmp.7950 = 8;
      <D.51627>:
      _amd64_rex_bits = iftmp.7950;
      if (_amd64_rex_bits != 0) goto <D.51628>; else goto <D.51629>;
      <D.51628>:
      code.7951 = code;
      code = code.7951 + 1;
      D.51631 = _amd64_rex_bits | 64;
      *code.7951 = D.51631;
      <D.51629>:
    }
    switch (8) <default: <D.24969>, case 1: <D.24964>, case 2: <D.24966>, case 4: <D.24967>, case 8: <D.24968>>
    <D.24964>:
    code.7952 = code;
    code = code.7952 + 1;
    *code.7952 = 136;
    goto <D.24965>;
    <D.24966>:
    <D.24967>:
    <D.24968>:
    code.7953 = code;
    code = code.7953 + 1;
    *code.7953 = 137;
    goto <D.24965>;
    <D.24969>:
    __assert_fail ("0", "mini-amd64.c", 3560, &__PRETTY_FUNCTION__);
    <D.24965>:
    if (0 != 0) goto <D.51634>; else goto <D.51635>;
    <D.51634>:
    D.51636 = (long unsigned int) quad;
    D.51637 = D.51636 * 8;
    if (D.51637 == 0) goto <D.51638>; else goto <D.51639>;
    <D.51638>:
    code.7954 = code;
    code = code.7954 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51645 = D.51644 | 4;
    D.51646 = (unsigned char) D.51645;
    *code.7954 = D.51646;
    code.7955 = code;
    code = code.7955 + 1;
    *code.7955 = 36;
    goto <D.51648>;
    <D.51639>:
    D.51651 = quad * 8;
    D.51652 = (int) D.51651;
    if (D.51652 >= -128) goto <D.51653>; else goto <D.51649>;
    <D.51653>:
    D.51651 = quad * 8;
    D.51652 = (int) D.51651;
    if (D.51652 <= 127) goto <D.51654>; else goto <D.51649>;
    <D.51654>:
    code.7956 = code;
    code = code.7956 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51656 = D.51644 | 68;
    D.51657 = (unsigned char) D.51656;
    *code.7956 = D.51657;
    code.7957 = code;
    code = code.7957 + 1;
    *code.7957 = 36;
    D.51659 = (unsigned char) quad;
    D.51660 = D.51659 * 8;
    *code = D.51660;
    code = code + 1;
    goto <D.51650>;
    <D.51649>:
    code.7958 = code;
    code = code.7958 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51662 = D.51644 | -124;
    D.51663 = (unsigned char) D.51662;
    *code.7958 = D.51663;
    code.7959 = code;
    code = code.7959 + 1;
    *code.7959 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.51651 = quad * 8;
          D.51652 = (int) D.51651;
          imb.val = D.51652;
          code.7960 = code;
          code = code.7960 + 1;
          D.51666 = imb.b[0];
          *code.7960 = D.51666;
          code.7961 = code;
          code = code.7961 + 1;
          D.51668 = imb.b[1];
          *code.7961 = D.51668;
          code.7962 = code;
          code = code.7962 + 1;
          D.51670 = imb.b[2];
          *code.7962 = D.51670;
          code.7963 = code;
          code = code.7963 + 1;
          D.51672 = imb.b[3];
          *code.7963 = D.51672;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51650>:
    <D.51648>:
    goto <D.24971>;
    <D.51635>:
    D.51636 = (long unsigned int) quad;
    D.51637 = D.51636 * 8;
    if (D.51637 == 0) goto <D.51673>; else goto <D.51674>;
    <D.51673>:
    code.7964 = code;
    code = code.7964 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51676 = D.51644 | 1;
    D.51677 = (unsigned char) D.51676;
    *code.7964 = D.51677;
    goto <D.24971>;
    <D.51674>:
    D.51651 = quad * 8;
    D.51652 = (int) D.51651;
    if (D.51652 >= -128) goto <D.51680>; else goto <D.51678>;
    <D.51680>:
    D.51651 = quad * 8;
    D.51652 = (int) D.51651;
    if (D.51652 <= 127) goto <D.51681>; else goto <D.51678>;
    <D.51681>:
    code.7965 = code;
    code = code.7965 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51683 = D.51644 | 65;
    D.51684 = (unsigned char) D.51683;
    *code.7965 = D.51684;
    D.51659 = (unsigned char) quad;
    D.51660 = D.51659 * 8;
    *code = D.51660;
    code = code + 1;
    goto <D.51679>;
    <D.51678>:
    code.7966 = code;
    code = code.7966 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51686 = D.51644 | -127;
    D.51687 = (unsigned char) D.51686;
    *code.7966 = D.51687;
    {
      union x86_imm_buf imb;

      try
        {
          D.51651 = quad * 8;
          D.51652 = (int) D.51651;
          imb.val = D.51652;
          code.7967 = code;
          code = code.7967 + 1;
          D.51689 = imb.b[0];
          *code.7967 = D.51689;
          code.7968 = code;
          code = code.7968 + 1;
          D.51691 = imb.b[1];
          *code.7968 = D.51691;
          code.7969 = code;
          code = code.7969 + 1;
          D.51693 = imb.b[2];
          *code.7969 = D.51693;
          code.7970 = code;
          code = code.7970 + 1;
          D.51695 = imb.b[3];
          *code.7970 = D.51695;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51679>:
    <D.24971>:
    goto <D.24973>;
    <D.24974>:
    code.7971 = code;
    code = code.7971 + 1;
    *code.7971 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.51624 = cinfo->ret.pair_regs[quad];
      if (D.51624 > 7) goto <D.51698>; else goto <D.51699>;
      <D.51698>:
      iftmp.7972 = 4;
      goto <D.51700>;
      <D.51699>:
      iftmp.7972 = 0;
      <D.51700>:
      _amd64_rex_bits = iftmp.7972;
      if (_amd64_rex_bits != 0) goto <D.51701>; else goto <D.51702>;
      <D.51701>:
      code.7973 = code;
      code = code.7973 + 1;
      D.51704 = _amd64_rex_bits | 64;
      *code.7973 = D.51704;
      <D.51702>:
    }
    code.7974 = code;
    code = code.7974 + 1;
    *code.7974 = 15;
    code.7975 = code;
    code = code.7975 + 1;
    *code.7975 = 17;
    if (0 != 0) goto <D.51707>; else goto <D.51708>;
    <D.51707>:
    D.51709 = quad * 8;
    if (D.51709 == 0) goto <D.51710>; else goto <D.51711>;
    <D.51710>:
    code.7976 = code;
    code = code.7976 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51645 = D.51644 | 4;
    D.51646 = (unsigned char) D.51645;
    *code.7976 = D.51646;
    code.7977 = code;
    code = code.7977 + 1;
    *code.7977 = 36;
    goto <D.51714>;
    <D.51711>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 >= -128) goto <D.51718>; else goto <D.51715>;
    <D.51718>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 <= 127) goto <D.51719>; else goto <D.51715>;
    <D.51719>:
    code.7978 = code;
    code = code.7978 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51656 = D.51644 | 68;
    D.51657 = (unsigned char) D.51656;
    *code.7978 = D.51657;
    code.7979 = code;
    code = code.7979 + 1;
    *code.7979 = 36;
    D.51659 = (unsigned char) quad;
    D.51660 = D.51659 * 8;
    *code = D.51660;
    code = code + 1;
    goto <D.51716>;
    <D.51715>:
    code.7980 = code;
    code = code.7980 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51662 = D.51644 | -124;
    D.51663 = (unsigned char) D.51662;
    *code.7980 = D.51663;
    code.7981 = code;
    code = code.7981 + 1;
    *code.7981 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.51709 = quad * 8;
          D.51717 = (int) D.51709;
          imb.val = D.51717;
          code.7982 = code;
          code = code.7982 + 1;
          D.51725 = imb.b[0];
          *code.7982 = D.51725;
          code.7983 = code;
          code = code.7983 + 1;
          D.51727 = imb.b[1];
          *code.7983 = D.51727;
          code.7984 = code;
          code = code.7984 + 1;
          D.51729 = imb.b[2];
          *code.7984 = D.51729;
          code.7985 = code;
          code = code.7985 + 1;
          D.51731 = imb.b[3];
          *code.7985 = D.51731;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51716>:
    <D.51714>:
    goto <D.24977>;
    <D.51708>:
    D.51709 = quad * 8;
    if (D.51709 == 0) goto <D.51732>; else goto <D.51733>;
    <D.51732>:
    code.7986 = code;
    code = code.7986 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51676 = D.51644 | 1;
    D.51677 = (unsigned char) D.51676;
    *code.7986 = D.51677;
    goto <D.24977>;
    <D.51733>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 >= -128) goto <D.51737>; else goto <D.51735>;
    <D.51737>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 <= 127) goto <D.51738>; else goto <D.51735>;
    <D.51738>:
    code.7987 = code;
    code = code.7987 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51683 = D.51644 | 65;
    D.51684 = (unsigned char) D.51683;
    *code.7987 = D.51684;
    D.51659 = (unsigned char) quad;
    D.51660 = D.51659 * 8;
    *code = D.51660;
    code = code + 1;
    goto <D.51736>;
    <D.51735>:
    code.7988 = code;
    code = code.7988 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51686 = D.51644 | -127;
    D.51687 = (unsigned char) D.51686;
    *code.7988 = D.51687;
    {
      union x86_imm_buf imb;

      try
        {
          D.51709 = quad * 8;
          D.51717 = (int) D.51709;
          imb.val = D.51717;
          code.7989 = code;
          code = code.7989 + 1;
          D.51742 = imb.b[0];
          *code.7989 = D.51742;
          code.7990 = code;
          code = code.7990 + 1;
          D.51744 = imb.b[1];
          *code.7990 = D.51744;
          code.7991 = code;
          code = code.7991 + 1;
          D.51746 = imb.b[2];
          *code.7991 = D.51746;
          code.7992 = code;
          code = code.7992 + 1;
          D.51748 = imb.b[3];
          *code.7992 = D.51748;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51736>:
    <D.24977>:
    goto <D.24973>;
    <D.24979>:
    code.7993 = code;
    code = code.7993 + 1;
    *code.7993 = 242;
    {
      unsigned char _amd64_rex_bits;

      D.51624 = cinfo->ret.pair_regs[quad];
      if (D.51624 > 7) goto <D.51751>; else goto <D.51752>;
      <D.51751>:
      iftmp.7994 = 4;
      goto <D.51753>;
      <D.51752>:
      iftmp.7994 = 0;
      <D.51753>:
      _amd64_rex_bits = iftmp.7994;
      if (_amd64_rex_bits != 0) goto <D.51754>; else goto <D.51755>;
      <D.51754>:
      code.7995 = code;
      code = code.7995 + 1;
      D.51757 = _amd64_rex_bits | 64;
      *code.7995 = D.51757;
      <D.51755>:
    }
    code.7996 = code;
    code = code.7996 + 1;
    *code.7996 = 15;
    code.7997 = code;
    code = code.7997 + 1;
    *code.7997 = 17;
    if (0 != 0) goto <D.51760>; else goto <D.51761>;
    <D.51760>:
    D.51709 = quad * 8;
    if (D.51709 == 0) goto <D.51762>; else goto <D.51763>;
    <D.51762>:
    code.7998 = code;
    code = code.7998 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51645 = D.51644 | 4;
    D.51646 = (unsigned char) D.51645;
    *code.7998 = D.51646;
    code.7999 = code;
    code = code.7999 + 1;
    *code.7999 = 36;
    goto <D.51766>;
    <D.51763>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 >= -128) goto <D.51769>; else goto <D.51767>;
    <D.51769>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 <= 127) goto <D.51770>; else goto <D.51767>;
    <D.51770>:
    code.8000 = code;
    code = code.8000 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51656 = D.51644 | 68;
    D.51657 = (unsigned char) D.51656;
    *code.8000 = D.51657;
    code.8001 = code;
    code = code.8001 + 1;
    *code.8001 = 36;
    D.51659 = (unsigned char) quad;
    D.51660 = D.51659 * 8;
    *code = D.51660;
    code = code + 1;
    goto <D.51768>;
    <D.51767>:
    code.8002 = code;
    code = code.8002 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51662 = D.51644 | -124;
    D.51663 = (unsigned char) D.51662;
    *code.8002 = D.51663;
    code.8003 = code;
    code = code.8003 + 1;
    *code.8003 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.51709 = quad * 8;
          D.51717 = (int) D.51709;
          imb.val = D.51717;
          code.8004 = code;
          code = code.8004 + 1;
          D.51776 = imb.b[0];
          *code.8004 = D.51776;
          code.8005 = code;
          code = code.8005 + 1;
          D.51778 = imb.b[1];
          *code.8005 = D.51778;
          code.8006 = code;
          code = code.8006 + 1;
          D.51780 = imb.b[2];
          *code.8006 = D.51780;
          code.8007 = code;
          code = code.8007 + 1;
          D.51782 = imb.b[3];
          *code.8007 = D.51782;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51768>:
    <D.51766>:
    goto <D.24982>;
    <D.51761>:
    D.51709 = quad * 8;
    if (D.51709 == 0) goto <D.51783>; else goto <D.51784>;
    <D.51783>:
    code.8008 = code;
    code = code.8008 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51676 = D.51644 | 1;
    D.51677 = (unsigned char) D.51676;
    *code.8008 = D.51677;
    goto <D.24982>;
    <D.51784>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 >= -128) goto <D.51788>; else goto <D.51786>;
    <D.51788>:
    D.51709 = quad * 8;
    D.51717 = (int) D.51709;
    if (D.51717 <= 127) goto <D.51789>; else goto <D.51786>;
    <D.51789>:
    code.8009 = code;
    code = code.8009 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51683 = D.51644 | 65;
    D.51684 = (unsigned char) D.51683;
    *code.8009 = D.51684;
    D.51659 = (unsigned char) quad;
    D.51660 = D.51659 * 8;
    *code = D.51660;
    code = code + 1;
    goto <D.51787>;
    <D.51786>:
    code.8010 = code;
    code = code.8010 + 1;
    D.51624 = cinfo->ret.pair_regs[quad];
    D.51641 = (int) D.51624;
    D.51642 = D.51641 & 7;
    D.51643 = D.51642 << 3;
    D.51644 = (signed char) D.51643;
    D.51686 = D.51644 | -127;
    D.51687 = (unsigned char) D.51686;
    *code.8010 = D.51687;
    {
      union x86_imm_buf imb;

      try
        {
          D.51709 = quad * 8;
          D.51717 = (int) D.51709;
          imb.val = D.51717;
          code.8011 = code;
          code = code.8011 + 1;
          D.51793 = imb.b[0];
          *code.8011 = D.51793;
          code.8012 = code;
          code = code.8012 + 1;
          D.51795 = imb.b[1];
          *code.8012 = D.51795;
          code.8013 = code;
          code = code.8013 + 1;
          D.51797 = imb.b[2];
          *code.8013 = D.51797;
          code.8014 = code;
          code = code.8014 + 1;
          D.51799 = imb.b[3];
          *code.8014 = D.51799;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.51787>:
    <D.24982>:
    goto <D.24973>;
    <D.24984>:
    goto <D.24973>;
    <D.24985>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 3571);
    <D.24973>:
    quad = quad + 1;
    <D.24987>:
    if (quad <= 1) goto <D.24986>; else goto <D.24988>;
    <D.24988>:
  }
  <D.51532>:
  goto <D.24937>;
  <D.51800>:
  <D.24937>:
  D.51801 = code;
  return D.51801;
}


mono_emit_stack_alloc (struct MonoCompile * cfg, guchar * code, struct MonoInst * tree)
{
  unsigned char D.51805;
  unsigned char iftmp.8015;
  guchar * code.8016;
  unsigned char D.51817;
  int D.51818;
  guchar * code.8017;
  guchar * code.8018;
  guchar * code.8019;
  signed char D.51825;
  signed char D.51826;
  signed char D.51827;
  unsigned char D.51828;
  guchar * code.8020;
  unsigned char D.51830;
  guchar * code.8021;
  unsigned char D.51832;
  guchar * code.8022;
  unsigned char D.51834;
  guchar * code.8023;
  unsigned char D.51836;
  guchar * code.8024;
  unsigned char D.51840;
  guchar * code.8025;
  unsigned char D.51843;
  guchar * code.8026;
  unsigned char D.51849;
  guchar * code.8027;
  guchar * code.8028;
  guchar * code.8029;
  unsigned char D.51858;
  guchar * code.8030;
  guchar * code.8031;
  unsigned char D.51861;
  guchar * code.8032;
  unsigned char D.51863;
  guchar * code.8033;
  unsigned char D.51865;
  guchar * code.8034;
  unsigned char D.51867;
  guchar * code.8035;
  unsigned char D.51872;
  guchar * code.8036;
  guchar * code.8037;
  guchar * code.8038;
  unsigned char D.51876;
  guchar * code.8039;
  unsigned char D.51878;
  guchar * code.8040;
  unsigned char D.51880;
  guchar * code.8041;
  unsigned char D.51882;
  guchar * code.8042;
  unsigned char D.51886;
  guchar * code.8043;
  guchar * code.8044;
  guchar * code.8045;
  guchar * code.8046;
  guchar * code.8047;
  guchar * code.8048;
  guchar * code.8049;
  guchar * code.8050;
  unsigned char D.51903;
  guchar * code.8051;
  unsigned char D.51905;
  guchar * code.8052;
  unsigned char D.51907;
  guchar * code.8053;
  unsigned char D.51909;
  guchar * code.8054;
  guchar * code.8055;
  guchar * code.8056;
  guchar * code.8057;
  unsigned char D.51919;
  guchar * code.8058;
  unsigned char D.51921;
  guchar * code.8059;
  unsigned char D.51923;
  guchar * code.8060;
  unsigned char D.51925;
  unsigned char iftmp.8061;
  guchar * code.8062;
  unsigned char D.51935;
  guchar * code.8063;
  guchar * code.8064;
  signed char D.51938;
  unsigned char D.51939;
  guchar * code.8065;
  unsigned char D.51946;
  guchar * code.8066;
  guchar * code.8067;
  unsigned char D.51949;
  guchar * code.8068;
  unsigned char D.51951;
  guchar * code.8069;
  unsigned char D.51953;
  guchar * code.8070;
  unsigned char D.51955;
  unsigned char iftmp.8071;
  guchar * code.8072;
  unsigned char D.51964;
  guchar * code.8073;
  guchar * code.8074;
  guchar * code.8075;
  unsigned char D.51968;
  guchar * code.8076;
  unsigned char D.51970;
  guchar * code.8077;
  unsigned char D.51972;
  guchar * code.8078;
  unsigned char D.51974;
  unsigned char iftmp.8079;
  guchar * code.8080;
  unsigned char D.51984;
  guchar * code.8081;
  guchar * code.8082;
  signed char D.51987;
  unsigned char D.51988;
  guchar * code.8083;
  unsigned char D.51995;
  guchar * code.8084;
  guchar * code.8085;
  unsigned char D.51998;
  guchar * code.8086;
  unsigned char D.52000;
  guchar * code.8087;
  unsigned char D.52002;
  guchar * code.8088;
  unsigned char D.52004;
  unsigned char iftmp.8089;
  guchar * code.8090;
  unsigned char D.52013;
  guchar * code.8091;
  guchar * code.8092;
  guchar * code.8093;
  unsigned char D.52017;
  guchar * code.8094;
  unsigned char D.52019;
  guchar * code.8095;
  unsigned char D.52021;
  guchar * code.8096;
  unsigned char D.52023;
  guchar * code.8097;
  unsigned char D.52027;
  guchar * code.8098;
  unsigned char D.52030;
  guint8 * D.52031;
  guint8 * D.52032;
  signed char iftmp.8099;
  _Bool D.52037;
  signed char D.52038;
  signed char D.52039;
  guchar * code.8100;
  unsigned char D.52043;
  guchar * code.8101;
  guchar * code.8102;
  int D.52046;
  signed char D.52047;
  signed char D.52048;
  signed char D.52049;
  unsigned char D.52050;
  guchar * code.8103;
  guchar * code.8104;
  unsigned char iftmp.8105;
  guchar * code.8106;
  unsigned char D.52063;
  guchar * code.8107;
  guchar * code.8108;
  signed char D.52066;
  unsigned char D.52067;
  guchar * code.8109;
  guint8 * D.52069;
  unsigned char iftmp.8110;
  guchar * code.8111;
  unsigned char D.52077;
  guchar * code.8112;
  guchar * code.8113;
  guint8 * D.52080;
  guint8 * D.52081;
  unsigned char iftmp.8114;
  int D.52084;
  guchar * code.8115;
  unsigned char D.52091;
  guchar * code.8116;
  guchar * code.8117;
  signed char D.52094;
  signed char D.52095;
  signed char D.52096;
  unsigned char D.52097;
  int D.52098;
  int D.52099;
  int D.52102;
  guchar * code.8118;
  unsigned char D.52110;
  guchar * code.8119;
  guchar * code.8120;
  unsigned char D.52119;
  guchar * code.8121;
  guchar * code.8122;
  unsigned char D.52128;
  guchar * code.8123;
  unsigned char iftmp.8124;
  guchar * code.8125;
  unsigned char D.52137;
  guchar * code.8126;
  guchar * code.8127;
  guchar * code.8128;
  guchar * code.8129;
  guchar * code.8130;
  unsigned char iftmp.8131;
  guchar * code.8132;
  unsigned char D.52157;
  guchar * code.8133;
  guchar * code.8134;
  guchar * code.8135;
  signed char D.52161;
  unsigned char D.52162;
  guchar * code.8136;
  unsigned char D.52166;
  guchar * code.8137;
  guchar * code.8138;
  guchar * code.8139;
  unsigned char D.52172;
  guchar * code.8140;
  guchar * code.8141;
  guchar * code.8142;
  unsigned char D.52178;
  guchar * code.8143;
  unsigned char D.52180;
  guchar * code.8144;
  unsigned char D.52182;
  guchar * code.8145;
  unsigned char D.52184;
  guchar * code.8146;
  guchar * code.8147;
  unsigned int offset.8148;
  unsigned int D.52194;
  guchar * code.8149;
  guchar * code.8150;
  unsigned char D.52199;
  guchar * code.8151;
  guchar * code.8152;
  guchar * code.8153;
  unsigned char D.52204;
  guchar * code.8154;
  unsigned char D.52206;
  guchar * code.8155;
  unsigned char D.52208;
  guchar * code.8156;
  unsigned char D.52210;
  guchar * code.8157;
  guchar * code.8158;
  guchar * code.8159;
  guchar * code.8160;
  unsigned char D.52220;
  guchar * code.8161;
  unsigned char D.52222;
  guchar * code.8162;
  unsigned char D.52224;
  guchar * code.8163;
  unsigned char D.52226;
  unsigned int D.52227;
  int D.52230;
  int D.52235;
  guchar * code.8164;
  unsigned char D.52241;
  guchar * code.8165;
  guchar * code.8166;
  unsigned char D.52244;
  guchar * code.8167;
  unsigned char D.52250;
  guchar * code.8168;
  guchar * code.8169;
  unsigned char D.52253;
  guchar * code.8170;
  unsigned char D.52255;
  guchar * code.8171;
  unsigned char D.52257;
  guchar * code.8172;
  unsigned char D.52259;
  guchar * code.8173;
  unsigned char D.52264;
  guchar * code.8174;
  guchar * code.8175;
  guchar * code.8176;
  unsigned char D.52268;
  guchar * code.8177;
  unsigned char D.52270;
  guchar * code.8178;
  unsigned char D.52272;
  guchar * code.8179;
  unsigned char D.52274;
  guchar * code.8180;
  unsigned char D.52278;
  guchar * code.8181;
  guchar * code.8182;
  guchar * code.8183;
  unsigned char D.52284;
  guchar * code.8184;
  guchar * code.8185;
  unsigned char D.52293;
  guchar * code.8186;
  guchar * code.8187;
  unsigned char D.52302;
  guchar * code.8188;
  guchar * code.8189;
  unsigned char D.52311;
  guchar * code.8190;
  unsigned char * D.52313;
  int sreg;
  int need_touch;
  static const char __PRETTY_FUNCTION__[22] = "mono_emit_stack_alloc";

  sreg = tree->sreg1;
  need_touch = 0;
  D.51805 = tree->flags;
  if (D.51805 == 0) goto <D.51806>; else goto <D.51807>;
  <D.51806>:
  need_touch = 1;
  <D.51807>:
  if (need_touch != 0) goto <D.51808>; else goto <D.51809>;
  <D.51808>:
  {
    guint8 * br[5];

    try
      {
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.51811>; else goto <D.51812>;
          <D.51811>:
          iftmp.8015 = 9;
          goto <D.51813>;
          <D.51812>:
          iftmp.8015 = 8;
          <D.51813>:
          _amd64_rex_bits = iftmp.8015;
          if (_amd64_rex_bits != 0) goto <D.51814>; else goto <D.51815>;
          <D.51814>:
          code.8016 = code;
          code = code.8016 + 1;
          D.51817 = _amd64_rex_bits | 64;
          *code.8016 = D.51817;
          <D.51815>:
        }
        D.51818 = sreg & 7;
        if (D.51818 == 0) goto <D.51819>; else goto <D.51820>;
        <D.51819>:
        code.8017 = code;
        code = code.8017 + 1;
        *code.8017 = 169;
        goto <D.51822>;
        <D.51820>:
        code.8018 = code;
        code = code.8018 + 1;
        *code.8018 = 247;
        code.8019 = code;
        code = code.8019 + 1;
        D.51825 = (signed char) sreg;
        D.51826 = D.51825 & 7;
        D.51827 = D.51826 | -64;
        D.51828 = (unsigned char) D.51827;
        *code.8019 = D.51828;
        <D.51822>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -4096;
              code.8020 = code;
              code = code.8020 + 1;
              D.51830 = imb.b[0];
              *code.8020 = D.51830;
              code.8021 = code;
              code = code.8021 + 1;
              D.51832 = imb.b[1];
              *code.8021 = D.51832;
              code.8022 = code;
              code = code.8022 + 1;
              D.51834 = imb.b[2];
              *code.8022 = D.51834;
              code.8023 = code;
              code = code.8023 + 1;
              D.51836 = imb.b[3];
              *code.8023 = D.51836;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        br[0] = code;
        if (0 != 0) goto <D.51837>; else goto <D.51838>;
        <D.51837>:
        code.8024 = code;
        code = code.8024 + 1;
        D.51840 = 116;
        *code.8024 = D.51840;
        goto <D.51841>;
        <D.51838>:
        code.8025 = code;
        code = code.8025 + 1;
        D.51843 = 116;
        *code.8025 = D.51843;
        <D.51841>:
        *code = 0;
        code = code + 1;
        br[2] = code;
        if (0 != 0) goto <D.51844>; else goto <D.51845>;
        <D.51844>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.51846>; else goto <D.51847>;
          <D.51846>:
          code.8026 = code;
          code = code.8026 + 1;
          D.51849 = _amd64_rex_bits | 64;
          *code.8026 = D.51849;
          <D.51847>:
        }
        code.8027 = code;
        code = code.8027 + 1;
        *code.8027 = 131;
        code.8028 = code;
        code = code.8028 + 1;
        *code.8028 = 236;
        *code = 0;
        code = code + 1;
        goto <D.51852>;
        <D.51845>:
        if (0 != 0) goto <D.51853>; else goto <D.51854>;
        <D.51853>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.51855>; else goto <D.51856>;
          <D.51855>:
          code.8029 = code;
          code = code.8029 + 1;
          D.51858 = _amd64_rex_bits | 64;
          *code.8029 = D.51858;
          <D.51856>:
        }
        code.8030 = code;
        code = code.8030 + 1;
        *code.8030 = 45;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.8031 = code;
              code = code.8031 + 1;
              D.51861 = imb.b[0];
              *code.8031 = D.51861;
              code.8032 = code;
              code = code.8032 + 1;
              D.51863 = imb.b[1];
              *code.8032 = D.51863;
              code.8033 = code;
              code = code.8033 + 1;
              D.51865 = imb.b[2];
              *code.8033 = D.51865;
              code.8034 = code;
              code = code.8034 + 1;
              D.51867 = imb.b[3];
              *code.8034 = D.51867;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.51868>;
        <D.51854>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.51869>; else goto <D.51870>;
          <D.51869>:
          code.8035 = code;
          code = code.8035 + 1;
          D.51872 = _amd64_rex_bits | 64;
          *code.8035 = D.51872;
          <D.51870>:
        }
        code.8036 = code;
        code = code.8036 + 1;
        *code.8036 = 129;
        code.8037 = code;
        code = code.8037 + 1;
        *code.8037 = 236;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.8038 = code;
              code = code.8038 + 1;
              D.51876 = imb.b[0];
              *code.8038 = D.51876;
              code.8039 = code;
              code = code.8039 + 1;
              D.51878 = imb.b[1];
              *code.8039 = D.51878;
              code.8040 = code;
              code = code.8040 + 1;
              D.51880 = imb.b[2];
              *code.8040 = D.51880;
              code.8041 = code;
              code = code.8041 + 1;
              D.51882 = imb.b[3];
              *code.8041 = D.51882;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51868>:
        <D.51852>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.51883>; else goto <D.51884>;
          <D.51883>:
          code.8042 = code;
          code = code.8042 + 1;
          D.51886 = _amd64_rex_bits | 64;
          *code.8042 = D.51886;
          <D.51884>:
        }
        code.8043 = code;
        code = code.8043 + 1;
        *code.8043 = 133;
        if (1 != 0) goto <D.51888>; else goto <D.51889>;
        <D.51888>:
        if (1 != 0) goto <D.51890>; else goto <D.51891>;
        <D.51890>:
        code.8044 = code;
        code = code.8044 + 1;
        *code.8044 = 36;
        code.8045 = code;
        code = code.8045 + 1;
        *code.8045 = 36;
        goto <D.51894>;
        <D.51891>:
        if (1 != 0) goto <D.51895>; else goto <D.51896>;
        <D.51895>:
        code.8046 = code;
        code = code.8046 + 1;
        *code.8046 = 100;
        code.8047 = code;
        code = code.8047 + 1;
        *code.8047 = 36;
        *code = 0;
        code = code + 1;
        goto <D.51899>;
        <D.51896>:
        code.8048 = code;
        code = code.8048 + 1;
        *code.8048 = 164;
        code.8049 = code;
        code = code.8049 + 1;
        *code.8049 = 36;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.8050 = code;
              code = code.8050 + 1;
              D.51903 = imb.b[0];
              *code.8050 = D.51903;
              code.8051 = code;
              code = code.8051 + 1;
              D.51905 = imb.b[1];
              *code.8051 = D.51905;
              code.8052 = code;
              code = code.8052 + 1;
              D.51907 = imb.b[2];
              *code.8052 = D.51907;
              code.8053 = code;
              code = code.8053 + 1;
              D.51909 = imb.b[3];
              *code.8053 = D.51909;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51899>:
        <D.51894>:
        goto <D.24879>;
        <D.51889>:
        if (1 != 0) goto <D.51910>; else goto <D.51911>;
        <D.51910>:
        code.8054 = code;
        code = code.8054 + 1;
        *code.8054 = 36;
        goto <D.24879>;
        <D.51911>:
        if (1 != 0) goto <D.51913>; else goto <D.51914>;
        <D.51913>:
        code.8055 = code;
        code = code.8055 + 1;
        *code.8055 = 100;
        *code = 0;
        code = code + 1;
        goto <D.51916>;
        <D.51914>:
        code.8056 = code;
        code = code.8056 + 1;
        *code.8056 = 164;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.8057 = code;
              code = code.8057 + 1;
              D.51919 = imb.b[0];
              *code.8057 = D.51919;
              code.8058 = code;
              code = code.8058 + 1;
              D.51921 = imb.b[1];
              *code.8058 = D.51921;
              code.8059 = code;
              code = code.8059 + 1;
              D.51923 = imb.b[2];
              *code.8059 = D.51923;
              code.8060 = code;
              code = code.8060 + 1;
              D.51925 = imb.b[3];
              *code.8060 = D.51925;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51916>:
        <D.24879>:
        if (0 != 0) goto <D.51926>; else goto <D.51927>;
        <D.51926>:
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.51929>; else goto <D.51930>;
          <D.51929>:
          iftmp.8061 = 9;
          goto <D.51931>;
          <D.51930>:
          iftmp.8061 = 8;
          <D.51931>:
          _amd64_rex_bits = iftmp.8061;
          if (_amd64_rex_bits != 0) goto <D.51932>; else goto <D.51933>;
          <D.51932>:
          code.8062 = code;
          code = code.8062 + 1;
          D.51935 = _amd64_rex_bits | 64;
          *code.8062 = D.51935;
          <D.51933>:
        }
        code.8063 = code;
        code = code.8063 + 1;
        *code.8063 = 131;
        code.8064 = code;
        code = code.8064 + 1;
        D.51825 = (signed char) sreg;
        D.51826 = D.51825 & 7;
        D.51938 = D.51826 | -24;
        D.51939 = (unsigned char) D.51938;
        *code.8064 = D.51939;
        *code = 0;
        code = code + 1;
        goto <D.51940>;
        <D.51927>:
        if (sreg == 0) goto <D.51941>; else goto <D.51942>;
        <D.51941>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.51943>; else goto <D.51944>;
          <D.51943>:
          code.8065 = code;
          code = code.8065 + 1;
          D.51946 = _amd64_rex_bits | 64;
          *code.8065 = D.51946;
          <D.51944>:
        }
        code.8066 = code;
        code = code.8066 + 1;
        *code.8066 = 45;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.8067 = code;
              code = code.8067 + 1;
              D.51949 = imb.b[0];
              *code.8067 = D.51949;
              code.8068 = code;
              code = code.8068 + 1;
              D.51951 = imb.b[1];
              *code.8068 = D.51951;
              code.8069 = code;
              code = code.8069 + 1;
              D.51953 = imb.b[2];
              *code.8069 = D.51953;
              code.8070 = code;
              code = code.8070 + 1;
              D.51955 = imb.b[3];
              *code.8070 = D.51955;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.51956>;
        <D.51942>:
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.51958>; else goto <D.51959>;
          <D.51958>:
          iftmp.8071 = 9;
          goto <D.51960>;
          <D.51959>:
          iftmp.8071 = 8;
          <D.51960>:
          _amd64_rex_bits = iftmp.8071;
          if (_amd64_rex_bits != 0) goto <D.51961>; else goto <D.51962>;
          <D.51961>:
          code.8072 = code;
          code = code.8072 + 1;
          D.51964 = _amd64_rex_bits | 64;
          *code.8072 = D.51964;
          <D.51962>:
        }
        code.8073 = code;
        code = code.8073 + 1;
        *code.8073 = 129;
        code.8074 = code;
        code = code.8074 + 1;
        D.51825 = (signed char) sreg;
        D.51826 = D.51825 & 7;
        D.51938 = D.51826 | -24;
        D.51939 = (unsigned char) D.51938;
        *code.8074 = D.51939;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.8075 = code;
              code = code.8075 + 1;
              D.51968 = imb.b[0];
              *code.8075 = D.51968;
              code.8076 = code;
              code = code.8076 + 1;
              D.51970 = imb.b[1];
              *code.8076 = D.51970;
              code.8077 = code;
              code = code.8077 + 1;
              D.51972 = imb.b[2];
              *code.8077 = D.51972;
              code.8078 = code;
              code = code.8078 + 1;
              D.51974 = imb.b[3];
              *code.8078 = D.51974;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.51956>:
        <D.51940>:
        if (0 != 0) goto <D.51975>; else goto <D.51976>;
        <D.51975>:
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.51978>; else goto <D.51979>;
          <D.51978>:
          iftmp.8079 = 9;
          goto <D.51980>;
          <D.51979>:
          iftmp.8079 = 8;
          <D.51980>:
          _amd64_rex_bits = iftmp.8079;
          if (_amd64_rex_bits != 0) goto <D.51981>; else goto <D.51982>;
          <D.51981>:
          code.8080 = code;
          code = code.8080 + 1;
          D.51984 = _amd64_rex_bits | 64;
          *code.8080 = D.51984;
          <D.51982>:
        }
        code.8081 = code;
        code = code.8081 + 1;
        *code.8081 = 131;
        code.8082 = code;
        code = code.8082 + 1;
        D.51825 = (signed char) sreg;
        D.51987 = D.51825 | -8;
        D.51988 = (unsigned char) D.51987;
        *code.8082 = D.51988;
        *code = 0;
        code = code + 1;
        goto <D.51989>;
        <D.51976>:
        if (sreg == 0) goto <D.51990>; else goto <D.51991>;
        <D.51990>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.51992>; else goto <D.51993>;
          <D.51992>:
          code.8083 = code;
          code = code.8083 + 1;
          D.51995 = _amd64_rex_bits | 64;
          *code.8083 = D.51995;
          <D.51993>:
        }
        code.8084 = code;
        code = code.8084 + 1;
        *code.8084 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.8085 = code;
              code = code.8085 + 1;
              D.51998 = imb.b[0];
              *code.8085 = D.51998;
              code.8086 = code;
              code = code.8086 + 1;
              D.52000 = imb.b[1];
              *code.8086 = D.52000;
              code.8087 = code;
              code = code.8087 + 1;
              D.52002 = imb.b[2];
              *code.8087 = D.52002;
              code.8088 = code;
              code = code.8088 + 1;
              D.52004 = imb.b[3];
              *code.8088 = D.52004;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.52005>;
        <D.51991>:
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.52007>; else goto <D.52008>;
          <D.52007>:
          iftmp.8089 = 9;
          goto <D.52009>;
          <D.52008>:
          iftmp.8089 = 8;
          <D.52009>:
          _amd64_rex_bits = iftmp.8089;
          if (_amd64_rex_bits != 0) goto <D.52010>; else goto <D.52011>;
          <D.52010>:
          code.8090 = code;
          code = code.8090 + 1;
          D.52013 = _amd64_rex_bits | 64;
          *code.8090 = D.52013;
          <D.52011>:
        }
        code.8091 = code;
        code = code.8091 + 1;
        *code.8091 = 129;
        code.8092 = code;
        code = code.8092 + 1;
        D.51825 = (signed char) sreg;
        D.51987 = D.51825 | -8;
        D.51988 = (unsigned char) D.51987;
        *code.8092 = D.51988;
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 4096;
              code.8093 = code;
              code = code.8093 + 1;
              D.52017 = imb.b[0];
              *code.8093 = D.52017;
              code.8094 = code;
              code = code.8094 + 1;
              D.52019 = imb.b[1];
              *code.8094 = D.52019;
              code.8095 = code;
              code = code.8095 + 1;
              D.52021 = imb.b[2];
              *code.8095 = D.52021;
              code.8096 = code;
              code = code.8096 + 1;
              D.52023 = imb.b[3];
              *code.8096 = D.52023;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.52005>:
        <D.51989>:
        br[3] = code;
        if (0 != 0) goto <D.52024>; else goto <D.52025>;
        <D.52024>:
        code.8097 = code;
        code = code.8097 + 1;
        D.52027 = 125;
        *code.8097 = D.52027;
        goto <D.52028>;
        <D.52025>:
        code.8098 = code;
        code = code.8098 + 1;
        D.52030 = 115;
        *code.8098 = D.52030;
        <D.52028>:
        *code = 0;
        code = code + 1;
        D.52031 = br[2];
        D.52032 = br[3];
        amd64_patch (D.52032, D.52031);
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.52034>; else goto <D.52035>;
          <D.52034>:
          iftmp.8099 = 12;
          goto <D.52036>;
          <D.52035>:
          iftmp.8099 = 8;
          <D.52036>:
          D.52037 = sreg > 7;
          D.52038 = (signed char) D.52037;
          D.52039 = iftmp.8099 | D.52038;
          _amd64_rex_bits = (unsigned char) D.52039;
          if (_amd64_rex_bits != 0) goto <D.52040>; else goto <D.52041>;
          <D.52040>:
          code.8100 = code;
          code = code.8100 + 1;
          D.52043 = _amd64_rex_bits | 64;
          *code.8100 = D.52043;
          <D.52041>:
        }
        code.8101 = code;
        code = code.8101 + 1;
        *code.8101 = 133;
        code.8102 = code;
        code = code.8102 + 1;
        D.51818 = sreg & 7;
        D.52046 = D.51818 << 3;
        D.52047 = (signed char) D.52046;
        D.52048 = D.52047 | -64;
        D.51825 = (signed char) sreg;
        D.51826 = D.51825 & 7;
        D.52049 = D.52048 | D.51826;
        D.52050 = (unsigned char) D.52049;
        *code.8102 = D.52050;
        br[4] = code;
        if (0 != 0) goto <D.52051>; else goto <D.52052>;
        <D.52051>:
        code.8103 = code;
        code = code.8103 + 1;
        D.51840 = 116;
        *code.8103 = D.51840;
        goto <D.52054>;
        <D.52052>:
        code.8104 = code;
        code = code.8104 + 1;
        D.51843 = 116;
        *code.8104 = D.51843;
        <D.52054>:
        *code = 0;
        code = code + 1;
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.52057>; else goto <D.52058>;
          <D.52057>:
          iftmp.8105 = 9;
          goto <D.52059>;
          <D.52058>:
          iftmp.8105 = 8;
          <D.52059>:
          _amd64_rex_bits = iftmp.8105;
          if (_amd64_rex_bits != 0) goto <D.52060>; else goto <D.52061>;
          <D.52060>:
          code.8106 = code;
          code = code.8106 + 1;
          D.52063 = _amd64_rex_bits | 64;
          *code.8106 = D.52063;
          <D.52061>:
        }
        code.8107 = code;
        code = code.8107 + 1;
        *code.8107 = 43;
        code.8108 = code;
        code = code.8108 + 1;
        D.51825 = (signed char) sreg;
        D.51826 = D.51825 & 7;
        D.52066 = D.51826 | -32;
        D.52067 = (unsigned char) D.52066;
        *code.8108 = D.52067;
        br[1] = code;
        code.8109 = code;
        code = code.8109 + 1;
        *code.8109 = 235;
        *code = 0;
        code = code + 1;
        D.52069 = br[0];
        amd64_patch (D.52069, code);
        {
          unsigned char _amd64_rex_bits;

          if (sreg > 7) goto <D.52071>; else goto <D.52072>;
          <D.52071>:
          iftmp.8110 = 9;
          goto <D.52073>;
          <D.52072>:
          iftmp.8110 = 8;
          <D.52073>:
          _amd64_rex_bits = iftmp.8110;
          if (_amd64_rex_bits != 0) goto <D.52074>; else goto <D.52075>;
          <D.52074>:
          code.8111 = code;
          code = code.8111 + 1;
          D.52077 = _amd64_rex_bits | 64;
          *code.8111 = D.52077;
          <D.52075>:
        }
        code.8112 = code;
        code = code.8112 + 1;
        *code.8112 = 43;
        code.8113 = code;
        code = code.8113 + 1;
        D.51825 = (signed char) sreg;
        D.51826 = D.51825 & 7;
        D.52066 = D.51826 | -32;
        D.52067 = (unsigned char) D.52066;
        *code.8113 = D.52067;
        D.52080 = br[1];
        amd64_patch (D.52080, code);
        D.52081 = br[4];
        amd64_patch (D.52081, code);
      }
    finally
      {
        br = {CLOBBER};
      }
  }
  goto <D.52082>;
  <D.51809>:
  {
    unsigned char _amd64_rex_bits;

    D.52084 = tree->sreg1;
    if (D.52084 > 7) goto <D.52085>; else goto <D.52086>;
    <D.52085>:
    iftmp.8114 = 9;
    goto <D.52087>;
    <D.52086>:
    iftmp.8114 = 8;
    <D.52087>:
    _amd64_rex_bits = iftmp.8114;
    if (_amd64_rex_bits != 0) goto <D.52088>; else goto <D.52089>;
    <D.52088>:
    code.8115 = code;
    code = code.8115 + 1;
    D.52091 = _amd64_rex_bits | 64;
    *code.8115 = D.52091;
    <D.52089>:
  }
  code.8116 = code;
  code = code.8116 + 1;
  *code.8116 = 43;
  code.8117 = code;
  code = code.8117 + 1;
  D.52084 = tree->sreg1;
  D.52094 = (signed char) D.52084;
  D.52095 = D.52094 & 7;
  D.52096 = D.52095 | -32;
  D.52097 = (unsigned char) D.52096;
  *code.8117 = D.52097;
  <D.52082>:
  D.51805 = tree->flags;
  D.52098 = (int) D.51805;
  D.52099 = D.52098 & 1;
  if (D.52099 != 0) goto <D.52100>; else goto <D.52101>;
  <D.52100>:
  {
    int offset;

    offset = 0;
    D.52102 = tree->dreg;
    if (D.52102 != 0) goto <D.52103>; else goto <D.52104>;
    <D.52103>:
    if (sreg != 0) goto <D.52105>; else goto <D.52106>;
    <D.52105>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52107>; else goto <D.52108>;
      <D.52107>:
      code.8118 = code;
      code = code.8118 + 1;
      D.52110 = _amd64_rex_bits | 64;
      *code.8118 = D.52110;
      <D.52108>:
    }
    code.8119 = code;
    code = code.8119 + 1;
    *code.8119 = 80;
    offset = offset + 8;
    <D.52106>:
    <D.52104>:
    D.52102 = tree->dreg;
    if (D.52102 != 1) goto <D.52112>; else goto <D.52113>;
    <D.52112>:
    if (sreg != 1) goto <D.52114>; else goto <D.52115>;
    <D.52114>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52116>; else goto <D.52117>;
      <D.52116>:
      code.8120 = code;
      code = code.8120 + 1;
      D.52119 = _amd64_rex_bits | 64;
      *code.8120 = D.52119;
      <D.52117>:
    }
    code.8121 = code;
    code = code.8121 + 1;
    *code.8121 = 81;
    offset = offset + 8;
    <D.52115>:
    <D.52113>:
    D.52102 = tree->dreg;
    if (D.52102 != 7) goto <D.52121>; else goto <D.52122>;
    <D.52121>:
    if (sreg != 7) goto <D.52123>; else goto <D.52124>;
    <D.52123>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52125>; else goto <D.52126>;
      <D.52125>:
      code.8122 = code;
      code = code.8122 + 1;
      D.52128 = _amd64_rex_bits | 64;
      *code.8122 = D.52128;
      <D.52126>:
    }
    code.8123 = code;
    code = code.8123 + 1;
    *code.8123 = 87;
    offset = offset + 8;
    <D.52124>:
    <D.52122>:
    {
      unsigned char _amd64_rex_bits;

      if (sreg > 7) goto <D.52131>; else goto <D.52132>;
      <D.52131>:
      iftmp.8124 = 9;
      goto <D.52133>;
      <D.52132>:
      iftmp.8124 = 8;
      <D.52133>:
      _amd64_rex_bits = iftmp.8124;
      if (_amd64_rex_bits != 0) goto <D.52134>; else goto <D.52135>;
      <D.52134>:
      code.8125 = code;
      code = code.8125 + 1;
      D.52137 = _amd64_rex_bits | 64;
      *code.8125 = D.52137;
      <D.52135>:
    }
    if (0 != 0) goto <D.52138>; else goto <D.52139>;
    <D.52138>:
    code.8126 = code;
    code = code.8126 + 1;
    *code.8126 = 209;
    code.8127 = code;
    code = code.8127 + 1;
    D.51825 = (signed char) sreg;
    D.51826 = D.51825 & 7;
    D.51938 = D.51826 | -24;
    D.51939 = (unsigned char) D.51938;
    *code.8127 = D.51939;
    goto <D.52142>;
    <D.52139>:
    code.8128 = code;
    code = code.8128 + 1;
    *code.8128 = 193;
    code.8129 = code;
    code = code.8129 + 1;
    D.51825 = (signed char) sreg;
    D.51826 = D.51825 & 7;
    D.51938 = D.51826 | -24;
    D.51939 = (unsigned char) D.51938;
    *code.8129 = D.51939;
    *code = 3;
    code = code + 1;
    <D.52142>:
    if (sreg != 1) goto <D.52145>; else goto <D.52146>;
    <D.52145>:
    if (0 != 0) goto <D.52147>; else goto <D.52148>;
    <D.52147>:
    code.8130 = code;
    code = code.8130 + 1;
    *code.8130 = 102;
    <D.52148>:
    {
      unsigned char _amd64_rex_bits;

      if (sreg > 7) goto <D.52151>; else goto <D.52152>;
      <D.52151>:
      iftmp.8131 = 9;
      goto <D.52153>;
      <D.52152>:
      iftmp.8131 = 8;
      <D.52153>:
      _amd64_rex_bits = iftmp.8131;
      if (_amd64_rex_bits != 0) goto <D.52154>; else goto <D.52155>;
      <D.52154>:
      code.8132 = code;
      code = code.8132 + 1;
      D.52157 = _amd64_rex_bits | 64;
      *code.8132 = D.52157;
      <D.52155>:
    }
    switch (8) <default: <D.24906>, case 1: <D.24901>, case 2: <D.24903>, case 4: <D.24904>, case 8: <D.24905>>
    <D.24901>:
    code.8133 = code;
    code = code.8133 + 1;
    *code.8133 = 138;
    goto <D.24902>;
    <D.24903>:
    <D.24904>:
    <D.24905>:
    code.8134 = code;
    code = code.8134 + 1;
    *code.8134 = 139;
    goto <D.24902>;
    <D.24906>:
    __assert_fail ("0", "mini-amd64.c", 3483, &__PRETTY_FUNCTION__);
    <D.24902>:
    code.8135 = code;
    code = code.8135 + 1;
    D.51825 = (signed char) sreg;
    D.51826 = D.51825 & 7;
    D.52161 = D.51826 | -56;
    D.52162 = (unsigned char) D.52161;
    *code.8135 = D.52162;
    <D.52146>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.52163>; else goto <D.52164>;
      <D.52163>:
      code.8136 = code;
      code = code.8136 + 1;
      D.52166 = _amd64_rex_bits | 64;
      *code.8136 = D.52166;
      <D.52164>:
    }
    code.8137 = code;
    code = code.8137 + 1;
    *code.8137 = 51;
    code.8138 = code;
    code = code.8138 + 1;
    *code.8138 = 192;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.52169>; else goto <D.52170>;
      <D.52169>:
      code.8139 = code;
      code = code.8139 + 1;
      D.52172 = _amd64_rex_bits | 64;
      *code.8139 = D.52172;
      <D.52170>:
    }
    code.8140 = code;
    code = code.8140 + 1;
    *code.8140 = 141;
    if (0 != 0) goto <D.52174>; else goto <D.52175>;
    <D.52174>:
    code.8141 = code;
    code = code.8141 + 1;
    *code.8141 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.8142 = code;
          code = code.8142 + 1;
          D.52178 = imb.b[0];
          *code.8142 = D.52178;
          code.8143 = code;
          code = code.8143 + 1;
          D.52180 = imb.b[1];
          *code.8143 = D.52180;
          code.8144 = code;
          code = code.8144 + 1;
          D.52182 = imb.b[2];
          *code.8144 = D.52182;
          code.8145 = code;
          code = code.8145 + 1;
          D.52184 = imb.b[3];
          *code.8145 = D.52184;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.52185>;
    <D.52175>:
    if (1 != 0) goto <D.52186>; else goto <D.52187>;
    <D.52186>:
    if (offset == 0) goto <D.52188>; else goto <D.52189>;
    <D.52188>:
    code.8146 = code;
    code = code.8146 + 1;
    *code.8146 = 60;
    code.8147 = code;
    code = code.8147 + 1;
    *code.8147 = 36;
    goto <D.52192>;
    <D.52189>:
    offset.8148 = (unsigned int) offset;
    D.52194 = offset.8148 + 128;
    if (D.52194 <= 255) goto <D.52195>; else goto <D.52196>;
    <D.52195>:
    code.8149 = code;
    code = code.8149 + 1;
    *code.8149 = 124;
    code.8150 = code;
    code = code.8150 + 1;
    *code.8150 = 36;
    D.52199 = (unsigned char) offset;
    *code = D.52199;
    code = code + 1;
    goto <D.52200>;
    <D.52196>:
    code.8151 = code;
    code = code.8151 + 1;
    *code.8151 = 188;
    code.8152 = code;
    code = code.8152 + 1;
    *code.8152 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.8153 = code;
          code = code.8153 + 1;
          D.52204 = imb.b[0];
          *code.8153 = D.52204;
          code.8154 = code;
          code = code.8154 + 1;
          D.52206 = imb.b[1];
          *code.8154 = D.52206;
          code.8155 = code;
          code = code.8155 + 1;
          D.52208 = imb.b[2];
          *code.8155 = D.52208;
          code.8156 = code;
          code = code.8156 + 1;
          D.52210 = imb.b[3];
          *code.8156 = D.52210;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.52200>:
    <D.52192>:
    goto <D.24912>;
    <D.52187>:
    if (offset == 0) goto <D.52211>; else goto <D.52212>;
    <D.52211>:
    code.8157 = code;
    code = code.8157 + 1;
    *code.8157 = 60;
    goto <D.24912>;
    <D.52212>:
    offset.8148 = (unsigned int) offset;
    D.52194 = offset.8148 + 128;
    if (D.52194 <= 255) goto <D.52214>; else goto <D.52215>;
    <D.52214>:
    code.8158 = code;
    code = code.8158 + 1;
    *code.8158 = 124;
    D.52199 = (unsigned char) offset;
    *code = D.52199;
    code = code + 1;
    goto <D.52217>;
    <D.52215>:
    code.8159 = code;
    code = code.8159 + 1;
    *code.8159 = 188;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = offset;
          code.8160 = code;
          code = code.8160 + 1;
          D.52220 = imb.b[0];
          *code.8160 = D.52220;
          code.8161 = code;
          code = code.8161 + 1;
          D.52222 = imb.b[1];
          *code.8161 = D.52222;
          code.8162 = code;
          code = code.8162 + 1;
          D.52224 = imb.b[2];
          *code.8162 = D.52224;
          code.8163 = code;
          code = code.8163 + 1;
          D.52226 = imb.b[3];
          *code.8163 = D.52226;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.52217>:
    <D.24912>:
    <D.52185>:
    D.52227 = cfg->param_area;
    if (D.52227 != 0) goto <D.52228>; else goto <D.52229>;
    <D.52228>:
    D.52230 = cfg->arch.no_pushes;
    if (D.52230 != 0) goto <D.52231>; else goto <D.52232>;
    <D.52231>:
    D.52227 = cfg->param_area;
    D.52235 = (int) D.52227;
    if (D.52235 >= -128) goto <D.52236>; else goto <D.52233>;
    <D.52236>:
    D.52227 = cfg->param_area;
    D.52235 = (int) D.52227;
    if (D.52235 <= 127) goto <D.52237>; else goto <D.52233>;
    <D.52237>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.52238>; else goto <D.52239>;
      <D.52238>:
      code.8164 = code;
      code = code.8164 + 1;
      D.52241 = _amd64_rex_bits | 64;
      *code.8164 = D.52241;
      <D.52239>:
    }
    code.8165 = code;
    code = code.8165 + 1;
    *code.8165 = 131;
    code.8166 = code;
    code = code.8166 + 1;
    *code.8166 = 199;
    D.52227 = cfg->param_area;
    D.52244 = (unsigned char) D.52227;
    *code = D.52244;
    code = code + 1;
    goto <D.52234>;
    <D.52233>:
    if (0 != 0) goto <D.52245>; else goto <D.52246>;
    <D.52245>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.52247>; else goto <D.52248>;
      <D.52247>:
      code.8167 = code;
      code = code.8167 + 1;
      D.52250 = _amd64_rex_bits | 64;
      *code.8167 = D.52250;
      <D.52248>:
    }
    code.8168 = code;
    code = code.8168 + 1;
    *code.8168 = 5;
    {
      union x86_imm_buf imb;

      try
        {
          D.52227 = cfg->param_area;
          D.52235 = (int) D.52227;
          imb.val = D.52235;
          code.8169 = code;
          code = code.8169 + 1;
          D.52253 = imb.b[0];
          *code.8169 = D.52253;
          code.8170 = code;
          code = code.8170 + 1;
          D.52255 = imb.b[1];
          *code.8170 = D.52255;
          code.8171 = code;
          code = code.8171 + 1;
          D.52257 = imb.b[2];
          *code.8171 = D.52257;
          code.8172 = code;
          code = code.8172 + 1;
          D.52259 = imb.b[3];
          *code.8172 = D.52259;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.52260>;
    <D.52246>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.52261>; else goto <D.52262>;
      <D.52261>:
      code.8173 = code;
      code = code.8173 + 1;
      D.52264 = _amd64_rex_bits | 64;
      *code.8173 = D.52264;
      <D.52262>:
    }
    code.8174 = code;
    code = code.8174 + 1;
    *code.8174 = 129;
    code.8175 = code;
    code = code.8175 + 1;
    *code.8175 = 199;
    {
      union x86_imm_buf imb;

      try
        {
          D.52227 = cfg->param_area;
          D.52235 = (int) D.52227;
          imb.val = D.52235;
          code.8176 = code;
          code = code.8176 + 1;
          D.52268 = imb.b[0];
          *code.8176 = D.52268;
          code.8177 = code;
          code = code.8177 + 1;
          D.52270 = imb.b[1];
          *code.8177 = D.52270;
          code.8178 = code;
          code = code.8178 + 1;
          D.52272 = imb.b[2];
          *code.8178 = D.52272;
          code.8179 = code;
          code = code.8179 + 1;
          D.52274 = imb.b[3];
          *code.8179 = D.52274;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.52260>:
    <D.52234>:
    <D.52232>:
    <D.52229>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52275>; else goto <D.52276>;
      <D.52275>:
      code.8180 = code;
      code = code.8180 + 1;
      D.52278 = _amd64_rex_bits | 64;
      *code.8180 = D.52278;
      <D.52276>:
    }
    code.8181 = code;
    code = code.8181 + 1;
    *code.8181 = 252;
    code.8182 = code;
    code = code.8182 + 1;
    *code.8182 = 243;
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.52281>; else goto <D.52282>;
      <D.52281>:
      code.8183 = code;
      code = code.8183 + 1;
      D.52284 = _amd64_rex_bits | 64;
      *code.8183 = D.52284;
      <D.52282>:
    }
    code.8184 = code;
    code = code.8184 + 1;
    *code.8184 = 171;
    D.52102 = tree->dreg;
    if (D.52102 != 7) goto <D.52286>; else goto <D.52287>;
    <D.52286>:
    if (sreg != 7) goto <D.52288>; else goto <D.52289>;
    <D.52288>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52290>; else goto <D.52291>;
      <D.52290>:
      code.8185 = code;
      code = code.8185 + 1;
      D.52293 = _amd64_rex_bits | 64;
      *code.8185 = D.52293;
      <D.52291>:
    }
    code.8186 = code;
    code = code.8186 + 1;
    *code.8186 = 95;
    <D.52289>:
    <D.52287>:
    D.52102 = tree->dreg;
    if (D.52102 != 1) goto <D.52295>; else goto <D.52296>;
    <D.52295>:
    if (sreg != 1) goto <D.52297>; else goto <D.52298>;
    <D.52297>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52299>; else goto <D.52300>;
      <D.52299>:
      code.8187 = code;
      code = code.8187 + 1;
      D.52302 = _amd64_rex_bits | 64;
      *code.8187 = D.52302;
      <D.52300>:
    }
    code.8188 = code;
    code = code.8188 + 1;
    *code.8188 = 89;
    <D.52298>:
    <D.52296>:
    D.52102 = tree->dreg;
    if (D.52102 != 0) goto <D.52304>; else goto <D.52305>;
    <D.52304>:
    if (sreg != 0) goto <D.52306>; else goto <D.52307>;
    <D.52306>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.52308>; else goto <D.52309>;
      <D.52308>:
      code.8189 = code;
      code = code.8189 + 1;
      D.52311 = _amd64_rex_bits | 64;
      *code.8189 = D.52311;
      <D.52309>:
    }
    code.8190 = code;
    code = code.8190 + 1;
    *code.8190 = 88;
    <D.52307>:
    <D.52305>:
  }
  <D.52101>:
  D.52313 = code;
  return D.52313;
}


emit_call (struct MonoCompile * cfg, guint8 * code, guint32 patch_type, const void * data, gboolean win64_adjust_stack)
{
  guint8 * D.52315;

  code = emit_call_body (cfg, code, patch_type, data);
  D.52315 = code;
  return D.52315;
}


emit_call_body (struct MonoCompile * cfg, guint8 * code, guint32 patch_type, const void * data)
{
  unsigned int D.52319;
  struct MonoClass * D.52322;
  struct MonoImage * D.52323;
  void * D.52324;
  unsigned char D.52327;
  unsigned char D.52328;
  long unsigned int target.8191;
  long unsigned int D.52336;
  struct GHashTable * D.52340;
  <unnamed type> D.52345;
  const char * D.52348;
  const void * D.52351;
  long unsigned int D.52352;
  long unsigned int D.52353;
  const void * D.52360;
  const void * D.52361;
  long unsigned int D.52364;
  long unsigned int D.52365;
  const char * D.52371;
  char D.52372;
  char * D.52374;
  char * D.52376;
  long unsigned int data.8192;
  long unsigned int D.52379;
  struct MonoMethod * D.52382;
  unsigned char D.52383;
  unsigned char D.52384;
  int optimize_for_xen.8193;
  unsigned char D.52390;
  unsigned char D.52391;
  guint8 * D.52398;
  long int D.52399;
  unsigned char * D.52400;
  long int D.52401;
  long int D.52402;
  unsigned int D.52403;
  unsigned int D.52404;
  guint8 * code.8194;
  guint8 * code.8195;
  guint8 * code.8196;
  guint8 * code.8197;
  guint8 * code.8198;
  guint8 * code.8199;
  guint8 * code.8200;
  unsigned char D.52416;
  unsigned int D.52417;
  guint8 * code.8201;
  guint8 * code.8202;
  guint8 * code.8203;
  guint8 * code.8204;
  guint8 * code.8205;
  guint8 * code.8206;
  guint8 * code.8207;
  guint8 * code.8208;
  guint8 * code.8209;
  guint8 * code.8210;
  guint8 * code.8211;
  guint8 * code.8212;
  guint8 * code.8213;
  guint8 * code.8214;
  guint8 * code.8215;
  guint8 * code.8216;
  guint8 * code.8217;
  guint8 * code.8218;
  guint8 * code.8219;
  guint8 * code.8220;
  guint8 * code.8221;
  guint8 * code.8222;
  guint8 * code.8223;
  guint8 * code.8224;
  guint8 * code.8225;
  guint8 * code.8226;
  guint8 * code.8227;
  guint8 * code.8228;
  long int code.8229;
  long int D.52447;
  int D.52448;
  unsigned int D.52449;
  unsigned int D.52450;
  guint8 * code.8230;
  guint8 * code.8231;
  unsigned char D.52453;
  guint8 * code.8232;
  unsigned char D.52455;
  guint8 * code.8233;
  unsigned char D.52457;
  guint8 * code.8234;
  unsigned char D.52459;
  guint8 * code.8235;
  unsigned char D.52464;
  guint8 * code.8236;
  guint8 * code.8237;
  unsigned char D.52469;
  guint8 * code.8238;
  unsigned char D.52471;
  guint8 * code.8239;
  unsigned char D.52473;
  guint8 * code.8240;
  unsigned char D.52475;
  guint8 * code.8241;
  unsigned char D.52477;
  guint8 * code.8242;
  unsigned char D.52479;
  guint8 * code.8243;
  unsigned char D.52481;
  guint8 * code.8244;
  unsigned char D.52483;
  guint8 * code.8245;
  unsigned char D.52486;
  guint8 * code.8246;
  unsigned char D.52488;
  guint8 * code.8247;
  unsigned char D.52490;
  guint8 * code.8248;
  unsigned char D.52492;
  guint8 * code.8249;
  unsigned char D.52496;
  guint8 * code.8250;
  guint8 * code.8251;
  guint8 * D.52499;
  gboolean no_patch;
  static const char __PRETTY_FUNCTION__[15] = "emit_call_body";

  no_patch = 0;
  {
    gboolean near_call;

    near_call = 0;
    if (patch_type != 1) goto <D.52317>; else goto <D.52318>;
    <D.52317>:
    near_call = 1;
    D.52319 = patch_type + 4294967293;
    if (D.52319 <= 1) goto <D.52320>; else goto <D.52321>;
    <D.52320>:
    D.52322 = MEM[(struct MonoMethod *)data].klass;
    D.52323 = D.52322->image;
    D.52324 = D.52323->aot_module;
    if (D.52324 != 0B) goto <D.52325>; else goto <D.52326>;
    <D.52325>:
    near_call = 0;
    <D.52326>:
    D.52327 = BIT_FIELD_REF <MEM[(struct MonoMethod *)data], 8, 264>;
    D.52328 = D.52327 & 2;
    if (D.52328 != 0) goto <D.52329>; else goto <D.52330>;
    <D.52329>:
    near_call = 0;
    <D.52330>:
    <D.52321>:
    if (patch_type == 7) goto <D.52331>; else goto <D.52332>;
    <D.52331>:
    {
      struct MonoJitICallInfo * mi;

      mi = mono_find_jit_icall_by_name (data);
      if (mi != 0B) goto <D.52333>; else goto <D.52334>;
      <D.52333>:
      {
        const void * target;

        target = mono_icall_get_wrapper (mi);
        target.8191 = (long unsigned int) target;
        D.52336 = target.8191 >> 32;
        if (D.52336 != 0) goto <D.52337>; else goto <D.52338>;
        <D.52337>:
        near_call = 0;
        <D.52338>:
      }
      <D.52334>:
    }
    <D.52332>:
    goto <D.52339>;
    <D.52318>:
    {
      struct MonoJumpInfo * jinfo;

      jinfo = 0B;
      D.52340 = cfg->abs_patches;
      if (D.52340 != 0B) goto <D.52341>; else goto <D.52342>;
      <D.52341>:
      D.52340 = cfg->abs_patches;
      jinfo = monoeg_g_hash_table_lookup (D.52340, data);
      <D.52342>:
      if (jinfo != 0B) goto <D.52343>; else goto <D.52344>;
      <D.52343>:
      D.52345 = jinfo->type;
      if (D.52345 == 32) goto <D.52346>; else goto <D.52347>;
      <D.52346>:
      {
        struct MonoJitICallInfo * mi;

        D.52348 = jinfo->data.name;
        mi = mono_find_jit_icall_by_name (D.52348);
        if (mi != 0B) goto <D.52349>; else goto <D.52350>;
        <D.52349>:
        D.52351 = mi->func;
        D.52352 = (long unsigned int) D.52351;
        D.52353 = D.52352 >> 32;
        if (D.52353 == 0) goto <D.52354>; else goto <D.52355>;
        <D.52354>:
        near_call = 1;
        <D.52355>:
        <D.52350>:
        no_patch = 1;
      }
      goto <D.52356>;
      <D.52347>:
      near_call = 1;
      <D.52356>:
      goto <D.52357>;
      <D.52344>:
      {
        struct MonoJitICallInfo * info;

        info = mono_find_jit_icall_by_addr (data);
        if (info != 0B) goto <D.52358>; else goto <D.52359>;
        <D.52358>:
        D.52360 = info->func;
        D.52361 = info->wrapper;
        if (D.52360 == D.52361) goto <D.52362>; else goto <D.52363>;
        <D.52362>:
        D.52360 = info->func;
        D.52364 = (long unsigned int) D.52360;
        D.52365 = D.52364 >> 32;
        if (D.52365 == 0) goto <D.52366>; else goto <D.52367>;
        <D.52366>:
        near_call = 1;
        <D.52367>:
        goto <D.52368>;
        <D.52363>:
        D.52371 = info->name;
        D.52372 = *D.52371;
        if (D.52372 != 118) goto <D.52369>; else goto <D.52373>;
        <D.52373>:
        D.52371 = info->name;
        D.52374 = strstr (D.52371, "ves_array_new_va_");
        if (D.52374 == 0B) goto <D.52375>; else goto <D.52370>;
        <D.52375>:
        D.52371 = info->name;
        D.52376 = strstr (D.52371, "ves_array_element_address_");
        if (D.52376 == 0B) goto <D.52369>; else goto <D.52370>;
        <D.52369>:
        near_call = 1;
        <D.52370>:
        <D.52368>:
        goto <D.52377>;
        <D.52359>:
        data.8192 = (long unsigned int) data;
        D.52379 = data.8192 >> 32;
        if (D.52379 == 0) goto <D.52380>; else goto <D.52381>;
        <D.52380>:
        near_call = 1;
        no_patch = 1;
        <D.52381>:
        <D.52377>:
      }
      <D.52357>:
    }
    <D.52339>:
    D.52382 = cfg->method;
    D.52383 = BIT_FIELD_REF <*D.52382, 8, 264>;
    D.52384 = D.52383 & 2;
    if (D.52384 != 0) goto <D.52385>; else goto <D.52386>;
    <D.52385>:
    near_call = 0;
    <D.52386>:
    optimize_for_xen.8193 = optimize_for_xen;
    if (optimize_for_xen.8193 != 0) goto <D.52388>; else goto <D.52389>;
    <D.52388>:
    near_call = 0;
    <D.52389>:
    D.52390 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.52391 = D.52390 & 64;
    if (D.52391 != 0) goto <D.52392>; else goto <D.52393>;
    <D.52392>:
    near_call = 1;
    no_patch = 1;
    <D.52393>:
    if (near_call != 0) goto <D.52394>; else goto <D.52395>;
    <D.52394>:
    if (no_patch == 0) goto <D.52396>; else goto <D.52397>;
    <D.52396>:
    D.52398 = code + 1;
    D.52399 = (long int) D.52398;
    D.52400 = cfg->native_code;
    D.52401 = (long int) D.52400;
    D.52402 = D.52399 - D.52401;
    D.52403 = (unsigned int) D.52402;
    D.52404 = D.52403 & 3;
    if (D.52404 != 0) goto <D.52405>; else goto <D.52406>;
    <D.52405>:
    {
      guint32 pad_size;

      D.52398 = code + 1;
      D.52399 = (long int) D.52398;
      D.52400 = cfg->native_code;
      D.52401 = (long int) D.52400;
      D.52402 = D.52399 - D.52401;
      D.52403 = (unsigned int) D.52402;
      D.52404 = D.52403 & 3;
      pad_size = 4 - D.52404;
      switch (pad_size) <default: <D.24743>, case 1: <D.24739>, case 2: <D.24741>, case 3: <D.24742>>
      <D.24739>:
      code.8194 = code;
      code = code.8194 + 1;
      *code.8194 = 144;
      goto <D.24740>;
      <D.24741>:
      code.8195 = code;
      code = code.8195 + 1;
      *code.8195 = 102;
      code.8196 = code;
      code = code.8196 + 1;
      *code.8196 = 144;
      goto <D.24740>;
      <D.24742>:
      code.8197 = code;
      code = code.8197 + 1;
      *code.8197 = 102;
      code.8198 = code;
      code = code.8198 + 1;
      *code.8198 = 102;
      code.8199 = code;
      code = code.8199 + 1;
      *code.8199 = 144;
      goto <D.24740>;
      <D.24743>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.52413>; else goto <D.52414>;
        <D.52413>:
        code.8200 = code;
        code = code.8200 + 1;
        D.52416 = _amd64_rex_bits | 64;
        *code.8200 = D.52416;
        <D.52414>:
      }
      D.52417 = pad_size + 4294967295;
      switch (D.52417) <default: <D.24753>, case 1: <D.24745>, case 2: <D.24747>, case 3: <D.24748>, case 4: <D.24749>, case 5: <D.24750>, case 6: <D.24751>, case 7: <D.24752>>
      <D.24745>:
      code.8201 = code;
      code = code.8201 + 1;
      *code.8201 = 144;
      goto <D.24746>;
      <D.24747>:
      code.8202 = code;
      code = code.8202 + 1;
      *code.8202 = 139;
      code.8203 = code;
      code = code.8203 + 1;
      *code.8203 = 192;
      goto <D.24746>;
      <D.24748>:
      code.8204 = code;
      code = code.8204 + 1;
      *code.8204 = 141;
      code.8205 = code;
      code = code.8205 + 1;
      *code.8205 = 109;
      code.8206 = code;
      code = code.8206 + 1;
      *code.8206 = 0;
      goto <D.24746>;
      <D.24749>:
      code.8207 = code;
      code = code.8207 + 1;
      *code.8207 = 141;
      code.8208 = code;
      code = code.8208 + 1;
      *code.8208 = 100;
      code.8209 = code;
      code = code.8209 + 1;
      *code.8209 = 36;
      code.8210 = code;
      code = code.8210 + 1;
      *code.8210 = 0;
      goto <D.24746>;
      <D.24750>:
      code.8211 = code;
      code = code.8211 + 1;
      *code.8211 = 141;
      code.8212 = code;
      code = code.8212 + 1;
      *code.8212 = 100;
      code.8213 = code;
      code = code.8213 + 1;
      *code.8213 = 36;
      code.8214 = code;
      code = code.8214 + 1;
      *code.8214 = 0;
      code.8215 = code;
      code = code.8215 + 1;
      *code.8215 = 144;
      goto <D.24746>;
      <D.24751>:
      code.8216 = code;
      code = code.8216 + 1;
      *code.8216 = 141;
      code.8217 = code;
      code = code.8217 + 1;
      *code.8217 = 173;
      code.8218 = code;
      code = code.8218 + 1;
      *code.8218 = 0;
      code.8219 = code;
      code = code.8219 + 1;
      *code.8219 = 0;
      code.8220 = code;
      code = code.8220 + 1;
      *code.8220 = 0;
      code.8221 = code;
      code = code.8221 + 1;
      *code.8221 = 0;
      goto <D.24746>;
      <D.24752>:
      code.8222 = code;
      code = code.8222 + 1;
      *code.8222 = 141;
      code.8223 = code;
      code = code.8223 + 1;
      *code.8223 = 164;
      code.8224 = code;
      code = code.8224 + 1;
      *code.8224 = 36;
      code.8225 = code;
      code = code.8225 + 1;
      *code.8225 = 0;
      code.8226 = code;
      code = code.8226 + 1;
      *code.8226 = 0;
      code.8227 = code;
      code = code.8227 + 1;
      *code.8227 = 0;
      code.8228 = code;
      code = code.8228 + 1;
      *code.8228 = 0;
      goto <D.24746>;
      <D.24753>:
      __assert_fail ("0", "mini-amd64.c", 3062, &__PRETTY_FUNCTION__);
      <D.24746>:
      <D.24740>:
    }
    <D.52406>:
    <D.52397>:
    code.8229 = (long int) code;
    D.52400 = cfg->native_code;
    D.52401 = (long int) D.52400;
    D.52447 = code.8229 - D.52401;
    D.52448 = (int) D.52447;
    mono_add_patch_info (cfg, D.52448, patch_type, data);
    {
      int _x86_offset;

      code.8229 = (long int) code;
      D.52449 = (unsigned int) code.8229;
      D.52450 = -D.52449;
      _x86_offset = (int) D.52450;
      _x86_offset = _x86_offset + -5;
      code.8230 = code;
      code = code.8230 + 1;
      *code.8230 = 232;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = _x86_offset;
            code.8231 = code;
            code = code.8231 + 1;
            D.52453 = imb.b[0];
            *code.8231 = D.52453;
            code.8232 = code;
            code = code.8232 + 1;
            D.52455 = imb.b[1];
            *code.8232 = D.52455;
            code.8233 = code;
            code = code.8233 + 1;
            D.52457 = imb.b[2];
            *code.8233 = D.52457;
            code.8234 = code;
            code = code.8234 + 1;
            D.52459 = imb.b[3];
            *code.8234 = D.52459;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
    }
    goto <D.52460>;
    <D.52395>:
    code.8229 = (long int) code;
    D.52400 = cfg->native_code;
    D.52401 = (long int) D.52400;
    D.52447 = code.8229 - D.52401;
    D.52448 = (int) D.52447;
    mono_add_patch_info (cfg, D.52448, patch_type, data);
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 9;
      if (_amd64_rex_bits != 0) goto <D.52461>; else goto <D.52462>;
      <D.52461>:
      code.8235 = code;
      code = code.8235 + 1;
      D.52464 = _amd64_rex_bits | 64;
      *code.8235 = D.52464;
      <D.52462>:
    }
    code.8236 = code;
    code = code.8236 + 1;
    *code.8236 = 187;
    if (1 != 0) goto <D.52466>; else goto <D.52467>;
    <D.52466>:
    {
      union amd64_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8237 = code;
          code = code.8237 + 1;
          D.52469 = imb.b[0];
          *code.8237 = D.52469;
          code.8238 = code;
          code = code.8238 + 1;
          D.52471 = imb.b[1];
          *code.8238 = D.52471;
          code.8239 = code;
          code = code.8239 + 1;
          D.52473 = imb.b[2];
          *code.8239 = D.52473;
          code.8240 = code;
          code = code.8240 + 1;
          D.52475 = imb.b[3];
          *code.8240 = D.52475;
          code.8241 = code;
          code = code.8241 + 1;
          D.52477 = imb.b[4];
          *code.8241 = D.52477;
          code.8242 = code;
          code = code.8242 + 1;
          D.52479 = imb.b[5];
          *code.8242 = D.52479;
          code.8243 = code;
          code = code.8243 + 1;
          D.52481 = imb.b[6];
          *code.8243 = D.52481;
          code.8244 = code;
          code = code.8244 + 1;
          D.52483 = imb.b[7];
          *code.8244 = D.52483;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.52484>;
    <D.52467>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8245 = code;
          code = code.8245 + 1;
          D.52486 = imb.b[0];
          *code.8245 = D.52486;
          code.8246 = code;
          code = code.8246 + 1;
          D.52488 = imb.b[1];
          *code.8246 = D.52488;
          code.8247 = code;
          code = code.8247 + 1;
          D.52490 = imb.b[2];
          *code.8247 = D.52490;
          code.8248 = code;
          code = code.8248 + 1;
          D.52492 = imb.b[3];
          *code.8248 = D.52492;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.52484>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 1;
      if (_amd64_rex_bits != 0) goto <D.52493>; else goto <D.52494>;
      <D.52493>:
      code.8249 = code;
      code = code.8249 + 1;
      D.52496 = _amd64_rex_bits | 64;
      *code.8249 = D.52496;
      <D.52494>:
    }
    code.8250 = code;
    code = code.8250 + 1;
    *code.8250 = 255;
    code.8251 = code;
    code = code.8251 + 1;
    *code.8251 = 211;
    <D.52460>:
  }
  D.52499 = code;
  return D.52499;
}


__signbit (double __x)
{
  int D.52501;
  int D.52502;
  _Bool D.52503;
  int __m;

  __asm__("pmovmskb %1, %0" : "=r" __m : "x" __x);
  D.52502 = __m & 128;
  D.52503 = D.52502 != 0;
  D.52501 = (int) D.52503;
  return D.52501;
}


__signbitf (float __x)
{
  int D.52505;
  int D.52506;
  _Bool D.52507;
  int __m;

  __asm__("pmovmskb %1, %0" : "=r" __m : "x" __x);
  D.52506 = __m & 8;
  D.52507 = D.52506 != 0;
  D.52505 = (int) D.52507;
  return D.52505;
}


emit_float_to_int (struct MonoCompile * cfg, guchar * code, int dreg, int sreg, int size, gboolean is_signed)
{
  guchar * code.8252;
  signed char iftmp.8253;
  _Bool D.52514;
  signed char D.52515;
  signed char D.52516;
  guchar * code.8254;
  unsigned char D.52520;
  guchar * code.8255;
  guchar * code.8256;
  guchar * code.8257;
  int D.52524;
  int D.52525;
  signed char D.52526;
  signed char D.52527;
  signed char D.52528;
  signed char D.52529;
  signed char D.52530;
  unsigned char D.52531;
  signed char iftmp.8258;
  _Bool D.52538;
  signed char D.52539;
  signed char D.52540;
  guchar * code.8259;
  unsigned char D.52544;
  guchar * code.8260;
  guchar * code.8261;
  guchar * code.8262;
  signed char D.52554;
  signed char D.52555;
  signed char D.52556;
  unsigned char D.52557;
  signed char iftmp.8263;
  signed char D.52565;
  guchar * code.8264;
  unsigned char D.52569;
  guchar * code.8265;
  guchar * code.8266;
  guchar * code.8267;
  unsigned char * D.52579;

  code.8252 = code;
  code = code.8252 + 1;
  *code.8252 = 242;
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.52511>; else goto <D.52512>;
    <D.52511>:
    iftmp.8253 = 12;
    goto <D.52513>;
    <D.52512>:
    iftmp.8253 = 8;
    <D.52513>:
    D.52514 = sreg > 7;
    D.52515 = (signed char) D.52514;
    D.52516 = iftmp.8253 | D.52515;
    _amd64_rex_bits = (unsigned char) D.52516;
    if (_amd64_rex_bits != 0) goto <D.52517>; else goto <D.52518>;
    <D.52517>:
    code.8254 = code;
    code = code.8254 + 1;
    D.52520 = _amd64_rex_bits | 64;
    *code.8254 = D.52520;
    <D.52518>:
  }
  code.8255 = code;
  code = code.8255 + 1;
  *code.8255 = 15;
  code.8256 = code;
  code = code.8256 + 1;
  *code.8256 = 44;
  code.8257 = code;
  code = code.8257 + 1;
  D.52524 = dreg & 7;
  D.52525 = D.52524 << 3;
  D.52526 = (signed char) D.52525;
  D.52527 = D.52526 | -64;
  D.52528 = (signed char) sreg;
  D.52529 = D.52528 & 7;
  D.52530 = D.52527 | D.52529;
  D.52531 = (unsigned char) D.52530;
  *code.8257 = D.52531;
  if (size == 1) goto <D.52532>; else goto <D.52533>;
  <D.52532>:
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.52535>; else goto <D.52536>;
    <D.52535>:
    iftmp.8258 = 12;
    goto <D.52537>;
    <D.52536>:
    iftmp.8258 = 8;
    <D.52537>:
    D.52538 = dreg > 7;
    D.52539 = (signed char) D.52538;
    D.52540 = iftmp.8258 | D.52539;
    _amd64_rex_bits = (unsigned char) D.52540;
    if (_amd64_rex_bits != 0) goto <D.52541>; else goto <D.52542>;
    <D.52541>:
    code.8259 = code;
    code = code.8259 + 1;
    D.52544 = _amd64_rex_bits | 64;
    *code.8259 = D.52544;
    <D.52542>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.52545>; else goto <D.52546>;
    <D.52545>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 3408, "(0) || X86_IS_BYTE_REG (((dreg)&0x7))");
    <D.52546>:
    code.8260 = code;
    code = code.8260 + 1;
    *code.8260 = 15;
    if (is_signed != 0) goto <D.52548>; else goto <D.52549>;
    <D.52548>:
    op = op + 8;
    <D.52549>:
    if (0 != 0) goto <D.52550>; else goto <D.52551>;
    <D.52550>:
    op = op + 1;
    <D.52551>:
    code.8261 = code;
    code = code.8261 + 1;
    *code.8261 = op;
    code.8262 = code;
    code = code.8262 + 1;
    D.52524 = dreg & 7;
    D.52525 = D.52524 << 3;
    D.52526 = (signed char) D.52525;
    D.52527 = D.52526 | -64;
    D.52554 = (signed char) dreg;
    D.52555 = D.52554 & 7;
    D.52556 = D.52527 | D.52555;
    D.52557 = (unsigned char) D.52556;
    *code.8262 = D.52557;
  }
  goto <D.52558>;
  <D.52533>:
  if (size == 2) goto <D.52559>; else goto <D.52560>;
  <D.52559>:
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.52562>; else goto <D.52563>;
    <D.52562>:
    iftmp.8263 = 12;
    goto <D.52564>;
    <D.52563>:
    iftmp.8263 = 8;
    <D.52564>:
    D.52538 = dreg > 7;
    D.52539 = (signed char) D.52538;
    D.52565 = iftmp.8263 | D.52539;
    _amd64_rex_bits = (unsigned char) D.52565;
    if (_amd64_rex_bits != 0) goto <D.52566>; else goto <D.52567>;
    <D.52566>:
    code.8264 = code;
    code = code.8264 + 1;
    D.52569 = _amd64_rex_bits | 64;
    *code.8264 = D.52569;
    <D.52567>:
  }
  {
    unsigned char op;

    op = 182;
    if (0 != 0) goto <D.52570>; else goto <D.52571>;
    <D.52570>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 3410, "(1) || X86_IS_BYTE_REG (((dreg)&0x7))");
    <D.52571>:
    code.8265 = code;
    code = code.8265 + 1;
    *code.8265 = 15;
    if (is_signed != 0) goto <D.52573>; else goto <D.52574>;
    <D.52573>:
    op = op + 8;
    <D.52574>:
    if (1 != 0) goto <D.52575>; else goto <D.52576>;
    <D.52575>:
    op = op + 1;
    <D.52576>:
    code.8266 = code;
    code = code.8266 + 1;
    *code.8266 = op;
    code.8267 = code;
    code = code.8267 + 1;
    D.52524 = dreg & 7;
    D.52525 = D.52524 << 3;
    D.52526 = (signed char) D.52525;
    D.52527 = D.52526 | -64;
    D.52554 = (signed char) dreg;
    D.52555 = D.52554 & 7;
    D.52556 = D.52527 | D.52555;
    D.52557 = (unsigned char) D.52556;
    *code.8267 = D.52557;
  }
  <D.52560>:
  <D.52558>:
  D.52579 = code;
  return D.52579;
}


emit_tls_get_reg (guint8 * code, int dreg, int offset_reg)
{
  _Bool D.52583;
  guint8 * code.8268;
  unsigned char iftmp.8269;
  guint8 * code.8270;
  unsigned char D.52594;
  guint8 * code.8271;
  guint8 * code.8272;
  guint8 * code.8273;
  int D.52602;
  int D.52603;
  signed char D.52604;
  signed char D.52605;
  unsigned char D.52606;
  guint8 * code.8274;
  guint8 * code.8275;
  signed char D.52612;
  unsigned char D.52613;
  guint8 * code.8276;
  guint8 * code.8277;
  signed char D.52617;
  unsigned char D.52618;
  guint8 * code.8278;
  guint8 * code.8279;
  unsigned char D.52621;
  guint8 * code.8280;
  unsigned char D.52623;
  guint8 * code.8281;
  unsigned char D.52625;
  guint8 * code.8282;
  unsigned char D.52627;
  guint8 * code.8283;
  guint8 * code.8284;
  guint8 * code.8285;
  guint8 * code.8286;
  unsigned char D.52637;
  guint8 * code.8287;
  unsigned char D.52639;
  guint8 * code.8288;
  unsigned char D.52641;
  guint8 * code.8289;
  unsigned char D.52643;
  guint8 * code.8290;
  signed char iftmp.8291;
  _Bool D.52651;
  signed char D.52652;
  signed char D.52653;
  guint8 * code.8292;
  unsigned char D.52657;
  guint8 * code.8293;
  guint8 * code.8294;
  guint8 * code.8295;
  signed char D.52661;
  signed char D.52662;
  signed char D.52663;
  signed char D.52664;
  unsigned char D.52665;
  guint8 * code.8296;
  guint8 * code.8297;
  unsigned char iftmp.8298;
  guint8 * code.8299;
  unsigned char D.52677;
  guint8 * code.8300;
  guint8 * code.8301;
  guint8 * code.8302;
  int D.52681;
  int D.52682;
  signed char D.52683;
  signed char D.52684;
  unsigned char D.52685;
  guint8 * code.8303;
  guint8 * code.8304;
  unsigned char D.52688;
  guint8 * code.8305;
  unsigned char D.52690;
  guint8 * code.8306;
  unsigned char D.52692;
  guint8 * code.8307;
  unsigned char D.52694;
  signed char iftmp.8308;
  signed char iftmp.8309;
  signed char D.52703;
  _Bool D.52704;
  signed char D.52705;
  signed char D.52706;
  guint8 * code.8310;
  unsigned char D.52710;
  guint8 * code.8311;
  guint8 * code.8312;
  guint8 * code.8313;
  guint8 * code.8314;
  guint8 * code.8315;
  int D.52718;
  int D.52719;
  signed char D.52720;
  signed char D.52721;
  unsigned char D.52722;
  guint8 * code.8316;
  unsigned char D.52724;
  guint8 * code.8317;
  unsigned char D.52726;
  guint8 * code.8318;
  unsigned char D.52728;
  guint8 * code.8319;
  unsigned char D.52730;
  guint8 * code.8320;
  guint8 * code.8321;
  signed char D.52736;
  signed char D.52737;
  signed char D.52738;
  unsigned char D.52739;
  guint8 * code.8322;
  signed char D.52744;
  unsigned char D.52745;
  guint8 * code.8323;
  guint8 * code.8324;
  signed char D.52749;
  unsigned char D.52750;
  guint8 * code.8325;
  guint8 * code.8326;
  unsigned char D.52753;
  guint8 * code.8327;
  unsigned char D.52755;
  guint8 * code.8328;
  unsigned char D.52757;
  guint8 * code.8329;
  unsigned char D.52759;
  guint8 * code.8330;
  unsigned char iftmp.8331;
  guint8 * code.8332;
  unsigned char D.52772;
  guint8 * code.8333;
  guint8 * code.8334;
  guint8 * code.8335;
  signed char D.52778;
  unsigned char D.52779;
  guint8 * code.8336;
  unsigned char D.52781;
  guint8 * code.8337;
  unsigned char D.52783;
  guint8 * code.8338;
  unsigned char D.52785;
  guint8 * code.8339;
  unsigned char D.52787;
  guint8 * code.8340;
  guint8 * code.8341;
  guint8 * code.8342;
  guint8 * code.8343;
  guint8 * code.8344;
  guint8 * code.8345;
  guint8 * code.8346;
  unsigned char D.52804;
  guint8 * code.8347;
  unsigned char D.52806;
  guint8 * code.8348;
  unsigned char D.52808;
  guint8 * code.8349;
  unsigned char D.52810;
  guint8 * code.8350;
  guint8 * code.8351;
  guint8 * code.8352;
  guint8 * code.8353;
  unsigned char D.52820;
  guint8 * code.8354;
  unsigned char D.52822;
  guint8 * code.8355;
  unsigned char D.52824;
  guint8 * code.8356;
  unsigned char D.52826;
  guint8 * D.52827;
  int tmpreg;
  static const char __PRETTY_FUNCTION__[17] = "emit_tls_get_reg";

  tmpreg = -1;
  if (dreg == offset_reg) goto <D.52581>; else goto <D.52582>;
  <D.52581>:
  D.52583 = dreg == 0;
  tmpreg = (int) D.52583;
  if (0 != 0) goto <D.52584>; else goto <D.52585>;
  <D.52584>:
  code.8268 = code;
  code = code.8268 + 1;
  *code.8268 = 102;
  <D.52585>:
  {
    unsigned char _amd64_rex_bits;

    if (tmpreg > 7) goto <D.52588>; else goto <D.52589>;
    <D.52588>:
    iftmp.8269 = 12;
    goto <D.52590>;
    <D.52589>:
    iftmp.8269 = 8;
    <D.52590>:
    _amd64_rex_bits = iftmp.8269;
    if (_amd64_rex_bits != 0) goto <D.52591>; else goto <D.52592>;
    <D.52591>:
    code.8270 = code;
    code = code.8270 + 1;
    D.52594 = _amd64_rex_bits | 64;
    *code.8270 = D.52594;
    <D.52592>:
  }
  switch (8) <default: <D.25040>, case 1: <D.25035>, case 2: <D.25037>, case 4: <D.25038>, case 8: <D.25039>>
  <D.25035>:
  code.8271 = code;
  code = code.8271 + 1;
  *code.8271 = 136;
  goto <D.25036>;
  <D.25037>:
  <D.25038>:
  <D.25039>:
  code.8272 = code;
  code = code.8272 + 1;
  *code.8272 = 137;
  goto <D.25036>;
  <D.25040>:
  __assert_fail ("0", "mini-amd64.c", 3687, &__PRETTY_FUNCTION__);
  <D.25036>:
  if (1 != 0) goto <D.52597>; else goto <D.52598>;
  <D.52597>:
  if (0 != 0) goto <D.52599>; else goto <D.52600>;
  <D.52599>:
  code.8273 = code;
  code = code.8273 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52605 = D.52604 | 4;
  D.52606 = (unsigned char) D.52605;
  *code.8273 = D.52606;
  code.8274 = code;
  code = code.8274 + 1;
  *code.8274 = 36;
  goto <D.52608>;
  <D.52600>:
  if (1 != 0) goto <D.52609>; else goto <D.52610>;
  <D.52609>:
  code.8275 = code;
  code = code.8275 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52612 = D.52604 | 68;
  D.52613 = (unsigned char) D.52612;
  *code.8275 = D.52613;
  code.8276 = code;
  code = code.8276 + 1;
  *code.8276 = 36;
  *code = 248;
  code = code + 1;
  goto <D.52615>;
  <D.52610>:
  code.8277 = code;
  code = code.8277 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52617 = D.52604 | -124;
  D.52618 = (unsigned char) D.52617;
  *code.8277 = D.52618;
  code.8278 = code;
  code = code.8278 + 1;
  *code.8278 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8279 = code;
        code = code.8279 + 1;
        D.52621 = imb.b[0];
        *code.8279 = D.52621;
        code.8280 = code;
        code = code.8280 + 1;
        D.52623 = imb.b[1];
        *code.8280 = D.52623;
        code.8281 = code;
        code = code.8281 + 1;
        D.52625 = imb.b[2];
        *code.8281 = D.52625;
        code.8282 = code;
        code = code.8282 + 1;
        D.52627 = imb.b[3];
        *code.8282 = D.52627;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52615>:
  <D.52608>:
  goto <D.25043>;
  <D.52598>:
  if (0 != 0) goto <D.52628>; else goto <D.52629>;
  <D.52628>:
  code.8283 = code;
  code = code.8283 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52605 = D.52604 | 4;
  D.52606 = (unsigned char) D.52605;
  *code.8283 = D.52606;
  goto <D.25043>;
  <D.52629>:
  if (1 != 0) goto <D.52631>; else goto <D.52632>;
  <D.52631>:
  code.8284 = code;
  code = code.8284 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52612 = D.52604 | 68;
  D.52613 = (unsigned char) D.52612;
  *code.8284 = D.52613;
  *code = 248;
  code = code + 1;
  goto <D.52634>;
  <D.52632>:
  code.8285 = code;
  code = code.8285 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52617 = D.52604 | -124;
  D.52618 = (unsigned char) D.52617;
  *code.8285 = D.52618;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8286 = code;
        code = code.8286 + 1;
        D.52637 = imb.b[0];
        *code.8286 = D.52637;
        code.8287 = code;
        code = code.8287 + 1;
        D.52639 = imb.b[1];
        *code.8287 = D.52639;
        code.8288 = code;
        code = code.8288 + 1;
        D.52641 = imb.b[2];
        *code.8288 = D.52641;
        code.8289 = code;
        code = code.8289 + 1;
        D.52643 = imb.b[3];
        *code.8289 = D.52643;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52634>:
  <D.25043>:
  if (0 != 0) goto <D.52644>; else goto <D.52645>;
  <D.52644>:
  code.8290 = code;
  code = code.8290 + 1;
  *code.8290 = 102;
  <D.52645>:
  {
    unsigned char _amd64_rex_bits;

    if (tmpreg > 7) goto <D.52648>; else goto <D.52649>;
    <D.52648>:
    iftmp.8291 = 12;
    goto <D.52650>;
    <D.52649>:
    iftmp.8291 = 8;
    <D.52650>:
    D.52651 = offset_reg > 7;
    D.52652 = (signed char) D.52651;
    D.52653 = iftmp.8291 | D.52652;
    _amd64_rex_bits = (unsigned char) D.52653;
    if (_amd64_rex_bits != 0) goto <D.52654>; else goto <D.52655>;
    <D.52654>:
    code.8292 = code;
    code = code.8292 + 1;
    D.52657 = _amd64_rex_bits | 64;
    *code.8292 = D.52657;
    <D.52655>:
  }
  switch (8) <default: <D.25051>, case 1: <D.25046>, case 2: <D.25048>, case 4: <D.25049>, case 8: <D.25050>>
  <D.25046>:
  code.8293 = code;
  code = code.8293 + 1;
  *code.8293 = 138;
  goto <D.25047>;
  <D.25048>:
  <D.25049>:
  <D.25050>:
  code.8294 = code;
  code = code.8294 + 1;
  *code.8294 = 139;
  goto <D.25047>;
  <D.25051>:
  __assert_fail ("0", "mini-amd64.c", 3688, &__PRETTY_FUNCTION__);
  <D.25047>:
  code.8295 = code;
  code = code.8295 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52661 = D.52604 | -64;
  D.52662 = (signed char) offset_reg;
  D.52663 = D.52662 & 7;
  D.52664 = D.52661 | D.52663;
  D.52665 = (unsigned char) D.52664;
  *code.8295 = D.52665;
  offset_reg = tmpreg;
  <D.52582>:
  code.8296 = code;
  code = code.8296 + 1;
  *code.8296 = 100;
  if (0 != 0) goto <D.52667>; else goto <D.52668>;
  <D.52667>:
  code.8297 = code;
  code = code.8297 + 1;
  *code.8297 = 102;
  <D.52668>:
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.52671>; else goto <D.52672>;
    <D.52671>:
    iftmp.8298 = 12;
    goto <D.52673>;
    <D.52672>:
    iftmp.8298 = 8;
    <D.52673>:
    _amd64_rex_bits = iftmp.8298;
    if (_amd64_rex_bits != 0) goto <D.52674>; else goto <D.52675>;
    <D.52674>:
    code.8299 = code;
    code = code.8299 + 1;
    D.52677 = _amd64_rex_bits | 64;
    *code.8299 = D.52677;
    <D.52675>:
  }
  switch (8) <default: <D.25058>, case 1: <D.25053>, case 2: <D.25055>, case 4: <D.25056>, case 8: <D.25057>>
  <D.25053>:
  code.8300 = code;
  code = code.8300 + 1;
  *code.8300 = 138;
  goto <D.25054>;
  <D.25055>:
  <D.25056>:
  <D.25057>:
  code.8301 = code;
  code = code.8301 + 1;
  *code.8301 = 139;
  goto <D.25054>;
  <D.25058>:
  __assert_fail ("0", "mini-amd64.c", 3692, &__PRETTY_FUNCTION__);
  <D.25054>:
  code.8302 = code;
  code = code.8302 + 1;
  D.52681 = dreg & 7;
  D.52682 = D.52681 << 3;
  D.52683 = (signed char) D.52682;
  D.52684 = D.52683 | 4;
  D.52685 = (unsigned char) D.52684;
  *code.8302 = D.52685;
  code.8303 = code;
  code = code.8303 + 1;
  *code.8303 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8304 = code;
        code = code.8304 + 1;
        D.52688 = imb.b[0];
        *code.8304 = D.52688;
        code.8305 = code;
        code = code.8305 + 1;
        D.52690 = imb.b[1];
        *code.8305 = D.52690;
        code.8306 = code;
        code = code.8306 + 1;
        D.52692 = imb.b[2];
        *code.8306 = D.52692;
        code.8307 = code;
        code = code.8307 + 1;
        D.52694 = imb.b[3];
        *code.8307 = D.52694;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  {
    unsigned char _amd64_rex_bits;

    if (dreg > 7) goto <D.52696>; else goto <D.52697>;
    <D.52696>:
    iftmp.8308 = 12;
    goto <D.52698>;
    <D.52697>:
    iftmp.8308 = 8;
    <D.52698>:
    if (offset_reg > 7) goto <D.52700>; else goto <D.52701>;
    <D.52700>:
    iftmp.8309 = 2;
    goto <D.52702>;
    <D.52701>:
    iftmp.8309 = 0;
    <D.52702>:
    D.52703 = iftmp.8308 | iftmp.8309;
    D.52704 = dreg > 7;
    D.52705 = (signed char) D.52704;
    D.52706 = D.52703 | D.52705;
    _amd64_rex_bits = (unsigned char) D.52706;
    if (_amd64_rex_bits != 0) goto <D.52707>; else goto <D.52708>;
    <D.52707>:
    code.8310 = code;
    code = code.8310 + 1;
    D.52710 = _amd64_rex_bits | 64;
    *code.8310 = D.52710;
    <D.52708>:
  }
  switch (4) <default: <D.25065>, case 1: <D.25061>, case 2: <D.25063>, case 4: <D.25064>>
  <D.25061>:
  code.8311 = code;
  code = code.8311 + 1;
  *code.8311 = 138;
  goto <D.25062>;
  <D.25063>:
  code.8312 = code;
  code = code.8312 + 1;
  *code.8312 = 102;
  <D.25064>:
  code.8313 = code;
  code = code.8313 + 1;
  *code.8313 = 139;
  goto <D.25062>;
  <D.25065>:
  __assert_fail ("0", "mini-amd64.c", 3693, &__PRETTY_FUNCTION__);
  <D.25062>:
  if (0 != 0) goto <D.52714>; else goto <D.52715>;
  <D.52714>:
  code.8314 = code;
  code = code.8314 + 1;
  D.52681 = dreg & 7;
  D.52682 = D.52681 << 3;
  D.52683 = (signed char) D.52682;
  D.52684 = D.52683 | 4;
  D.52685 = (unsigned char) D.52684;
  *code.8314 = D.52685;
  code.8315 = code;
  code = code.8315 + 1;
  D.52718 = offset_reg & 7;
  D.52719 = D.52718 << 3;
  D.52720 = (signed char) D.52719;
  D.52721 = D.52720 | 5;
  D.52722 = (unsigned char) D.52721;
  *code.8315 = D.52722;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8316 = code;
        code = code.8316 + 1;
        D.52724 = imb.b[0];
        *code.8316 = D.52724;
        code.8317 = code;
        code = code.8317 + 1;
        D.52726 = imb.b[1];
        *code.8317 = D.52726;
        code.8318 = code;
        code = code.8318 + 1;
        D.52728 = imb.b[2];
        *code.8318 = D.52728;
        code.8319 = code;
        code = code.8319 + 1;
        D.52730 = imb.b[3];
        *code.8319 = D.52730;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.52731>;
  <D.52715>:
  D.52681 = dreg & 7;
  if (D.52681 != 5) goto <D.52732>; else goto <D.52733>;
  <D.52732>:
  code.8320 = code;
  code = code.8320 + 1;
  D.52681 = dreg & 7;
  D.52682 = D.52681 << 3;
  D.52683 = (signed char) D.52682;
  D.52684 = D.52683 | 4;
  D.52685 = (unsigned char) D.52684;
  *code.8320 = D.52685;
  code.8321 = code;
  code = code.8321 + 1;
  D.52718 = offset_reg & 7;
  D.52719 = D.52718 << 3;
  D.52720 = (signed char) D.52719;
  D.52736 = (signed char) dreg;
  D.52737 = D.52736 & 7;
  D.52738 = D.52720 | D.52737;
  D.52739 = (unsigned char) D.52738;
  *code.8321 = D.52739;
  goto <D.52740>;
  <D.52733>:
  if (1 != 0) goto <D.52741>; else goto <D.52742>;
  <D.52741>:
  code.8322 = code;
  code = code.8322 + 1;
  D.52681 = dreg & 7;
  D.52682 = D.52681 << 3;
  D.52683 = (signed char) D.52682;
  D.52744 = D.52683 | 68;
  D.52745 = (unsigned char) D.52744;
  *code.8322 = D.52745;
  code.8323 = code;
  code = code.8323 + 1;
  D.52718 = offset_reg & 7;
  D.52719 = D.52718 << 3;
  D.52720 = (signed char) D.52719;
  D.52736 = (signed char) dreg;
  D.52737 = D.52736 & 7;
  D.52738 = D.52720 | D.52737;
  D.52739 = (unsigned char) D.52738;
  *code.8323 = D.52739;
  *code = 0;
  code = code + 1;
  goto <D.52747>;
  <D.52742>:
  code.8324 = code;
  code = code.8324 + 1;
  D.52681 = dreg & 7;
  D.52682 = D.52681 << 3;
  D.52683 = (signed char) D.52682;
  D.52749 = D.52683 | -124;
  D.52750 = (unsigned char) D.52749;
  *code.8324 = D.52750;
  code.8325 = code;
  code = code.8325 + 1;
  D.52718 = offset_reg & 7;
  D.52719 = D.52718 << 3;
  D.52720 = (signed char) D.52719;
  D.52736 = (signed char) dreg;
  D.52737 = D.52736 & 7;
  D.52738 = D.52720 | D.52737;
  D.52739 = (unsigned char) D.52738;
  *code.8325 = D.52739;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8326 = code;
        code = code.8326 + 1;
        D.52753 = imb.b[0];
        *code.8326 = D.52753;
        code.8327 = code;
        code = code.8327 + 1;
        D.52755 = imb.b[1];
        *code.8327 = D.52755;
        code.8328 = code;
        code = code.8328 + 1;
        D.52757 = imb.b[2];
        *code.8328 = D.52757;
        code.8329 = code;
        code = code.8329 + 1;
        D.52759 = imb.b[3];
        *code.8329 = D.52759;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52747>:
  <D.52740>:
  <D.52731>:
  if (tmpreg != -1) goto <D.52760>; else goto <D.52761>;
  <D.52760>:
  if (0 != 0) goto <D.52762>; else goto <D.52763>;
  <D.52762>:
  code.8330 = code;
  code = code.8330 + 1;
  *code.8330 = 102;
  <D.52763>:
  {
    unsigned char _amd64_rex_bits;

    if (tmpreg > 7) goto <D.52766>; else goto <D.52767>;
    <D.52766>:
    iftmp.8331 = 12;
    goto <D.52768>;
    <D.52767>:
    iftmp.8331 = 8;
    <D.52768>:
    _amd64_rex_bits = iftmp.8331;
    if (_amd64_rex_bits != 0) goto <D.52769>; else goto <D.52770>;
    <D.52769>:
    code.8332 = code;
    code = code.8332 + 1;
    D.52772 = _amd64_rex_bits | 64;
    *code.8332 = D.52772;
    <D.52770>:
  }
  switch (8) <default: <D.25074>, case 1: <D.25069>, case 2: <D.25071>, case 4: <D.25072>, case 8: <D.25073>>
  <D.25069>:
  code.8333 = code;
  code = code.8333 + 1;
  *code.8333 = 138;
  goto <D.25070>;
  <D.25071>:
  <D.25072>:
  <D.25073>:
  code.8334 = code;
  code = code.8334 + 1;
  *code.8334 = 139;
  goto <D.25070>;
  <D.25074>:
  __assert_fail ("0", "mini-amd64.c", 3695, &__PRETTY_FUNCTION__);
  <D.25070>:
  if (0 != 0) goto <D.52775>; else goto <D.52776>;
  <D.52775>:
  code.8335 = code;
  code = code.8335 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52778 = D.52604 | 5;
  D.52779 = (unsigned char) D.52778;
  *code.8335 = D.52779;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8336 = code;
        code = code.8336 + 1;
        D.52781 = imb.b[0];
        *code.8336 = D.52781;
        code.8337 = code;
        code = code.8337 + 1;
        D.52783 = imb.b[1];
        *code.8337 = D.52783;
        code.8338 = code;
        code = code.8338 + 1;
        D.52785 = imb.b[2];
        *code.8338 = D.52785;
        code.8339 = code;
        code = code.8339 + 1;
        D.52787 = imb.b[3];
        *code.8339 = D.52787;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.52788>;
  <D.52776>:
  if (1 != 0) goto <D.52789>; else goto <D.52790>;
  <D.52789>:
  if (0 != 0) goto <D.52791>; else goto <D.52792>;
  <D.52791>:
  code.8340 = code;
  code = code.8340 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52605 = D.52604 | 4;
  D.52606 = (unsigned char) D.52605;
  *code.8340 = D.52606;
  code.8341 = code;
  code = code.8341 + 1;
  *code.8341 = 36;
  goto <D.52795>;
  <D.52792>:
  if (1 != 0) goto <D.52796>; else goto <D.52797>;
  <D.52796>:
  code.8342 = code;
  code = code.8342 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52612 = D.52604 | 68;
  D.52613 = (unsigned char) D.52612;
  *code.8342 = D.52613;
  code.8343 = code;
  code = code.8343 + 1;
  *code.8343 = 36;
  *code = 248;
  code = code + 1;
  goto <D.52800>;
  <D.52797>:
  code.8344 = code;
  code = code.8344 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52617 = D.52604 | -124;
  D.52618 = (unsigned char) D.52617;
  *code.8344 = D.52618;
  code.8345 = code;
  code = code.8345 + 1;
  *code.8345 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8346 = code;
        code = code.8346 + 1;
        D.52804 = imb.b[0];
        *code.8346 = D.52804;
        code.8347 = code;
        code = code.8347 + 1;
        D.52806 = imb.b[1];
        *code.8347 = D.52806;
        code.8348 = code;
        code = code.8348 + 1;
        D.52808 = imb.b[2];
        *code.8348 = D.52808;
        code.8349 = code;
        code = code.8349 + 1;
        D.52810 = imb.b[3];
        *code.8349 = D.52810;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52800>:
  <D.52795>:
  goto <D.25077>;
  <D.52790>:
  if (0 != 0) goto <D.52811>; else goto <D.52812>;
  <D.52811>:
  code.8350 = code;
  code = code.8350 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52605 = D.52604 | 4;
  D.52606 = (unsigned char) D.52605;
  *code.8350 = D.52606;
  goto <D.25077>;
  <D.52812>:
  if (1 != 0) goto <D.52814>; else goto <D.52815>;
  <D.52814>:
  code.8351 = code;
  code = code.8351 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52612 = D.52604 | 68;
  D.52613 = (unsigned char) D.52612;
  *code.8351 = D.52613;
  *code = 248;
  code = code + 1;
  goto <D.52817>;
  <D.52815>:
  code.8352 = code;
  code = code.8352 + 1;
  D.52602 = tmpreg & 7;
  D.52603 = D.52602 << 3;
  D.52604 = (signed char) D.52603;
  D.52617 = D.52604 | -124;
  D.52618 = (unsigned char) D.52617;
  *code.8352 = D.52618;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8353 = code;
        code = code.8353 + 1;
        D.52820 = imb.b[0];
        *code.8353 = D.52820;
        code.8354 = code;
        code = code.8354 + 1;
        D.52822 = imb.b[1];
        *code.8354 = D.52822;
        code.8355 = code;
        code = code.8355 + 1;
        D.52824 = imb.b[2];
        *code.8355 = D.52824;
        code.8356 = code;
        code = code.8356 + 1;
        D.52826 = imb.b[3];
        *code.8356 = D.52826;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52817>:
  <D.25077>:
  <D.52788>:
  <D.52761>:
  D.52827 = code;
  return D.52827;
}


amd64_emit_tls_set (guint8 * code, int sreg, int tls_offset)
{
  int optimize_for_xen.8357;
  _Bool D.52830;
  long int D.52831;
  long int D.52832;
  guint8 * code.8358;
  guint8 * code.8359;
  unsigned char iftmp.8360;
  guint8 * code.8361;
  unsigned char D.52846;
  guint8 * code.8362;
  guint8 * code.8363;
  guint8 * code.8364;
  int D.52850;
  int D.52851;
  signed char D.52852;
  signed char D.52853;
  unsigned char D.52854;
  guint8 * code.8365;
  guint8 * code.8366;
  unsigned char D.52857;
  guint8 * code.8367;
  unsigned char D.52859;
  guint8 * code.8368;
  unsigned char D.52861;
  guint8 * code.8369;
  unsigned char D.52863;
  guint8 * D.52864;
  static const char __PRETTY_FUNCTION__[19] = "amd64_emit_tls_set";

  optimize_for_xen.8357 = optimize_for_xen;
  D.52830 = optimize_for_xen.8357 != 0;
  D.52831 = (long int) D.52830;
  D.52832 = __builtin_expect (D.52831, 0);
  if (D.52832 != 0) goto <D.52833>; else goto <D.52834>;
  <D.52833>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 3711, "!optimize_for_xen");
  <D.52834>:
  code.8358 = code;
  code = code.8358 + 1;
  *code.8358 = 100;
  if (0 != 0) goto <D.52836>; else goto <D.52837>;
  <D.52836>:
  code.8359 = code;
  code = code.8359 + 1;
  *code.8359 = 102;
  <D.52837>:
  {
    unsigned char _amd64_rex_bits;

    if (sreg > 7) goto <D.52840>; else goto <D.52841>;
    <D.52840>:
    iftmp.8360 = 12;
    goto <D.52842>;
    <D.52841>:
    iftmp.8360 = 8;
    <D.52842>:
    _amd64_rex_bits = iftmp.8360;
    if (_amd64_rex_bits != 0) goto <D.52843>; else goto <D.52844>;
    <D.52843>:
    code.8361 = code;
    code = code.8361 + 1;
    D.52846 = _amd64_rex_bits | 64;
    *code.8361 = D.52846;
    <D.52844>:
  }
  switch (8) <default: <D.25090>, case 1: <D.25085>, case 2: <D.25087>, case 4: <D.25088>, case 8: <D.25089>>
  <D.25085>:
  code.8362 = code;
  code = code.8362 + 1;
  *code.8362 = 136;
  goto <D.25086>;
  <D.25087>:
  <D.25088>:
  <D.25089>:
  code.8363 = code;
  code = code.8363 + 1;
  *code.8363 = 137;
  goto <D.25086>;
  <D.25090>:
  __assert_fail ("0", "mini-amd64.c", 3713, &__PRETTY_FUNCTION__);
  <D.25086>:
  code.8364 = code;
  code = code.8364 + 1;
  D.52850 = sreg & 7;
  D.52851 = D.52850 << 3;
  D.52852 = (signed char) D.52851;
  D.52853 = D.52852 | 4;
  D.52854 = (unsigned char) D.52853;
  *code.8364 = D.52854;
  code.8365 = code;
  code = code.8365 + 1;
  *code.8365 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = tls_offset;
        code.8366 = code;
        code = code.8366 + 1;
        D.52857 = imb.b[0];
        *code.8366 = D.52857;
        code.8367 = code;
        code = code.8367 + 1;
        D.52859 = imb.b[1];
        *code.8367 = D.52859;
        code.8368 = code;
        code = code.8368 + 1;
        D.52861 = imb.b[2];
        *code.8368 = D.52861;
        code.8369 = code;
        code = code.8369 + 1;
        D.52863 = imb.b[3];
        *code.8369 = D.52863;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  D.52864 = code;
  return D.52864;
}


amd64_emit_tls_set_reg (guint8 * code, int sreg, int offset_reg)
{
  guint8 * code.8370;
  guint8 * code.8371;
  signed char iftmp.8372;
  _Bool D.52874;
  signed char D.52875;
  signed char D.52876;
  guint8 * code.8373;
  unsigned char D.52880;
  guint8 * code.8374;
  guint8 * code.8375;
  int D.52883;
  guint8 * code.8376;
  int D.52889;
  int D.52890;
  signed char D.52891;
  signed char D.52892;
  unsigned char D.52893;
  guint8 * code.8377;
  guint8 * code.8378;
  signed char D.52899;
  unsigned char D.52900;
  guint8 * code.8379;
  guint8 * code.8380;
  signed char D.52904;
  unsigned char D.52905;
  guint8 * code.8381;
  guint8 * code.8382;
  unsigned char D.52908;
  guint8 * code.8383;
  unsigned char D.52910;
  guint8 * code.8384;
  unsigned char D.52912;
  guint8 * code.8385;
  unsigned char D.52914;
  guint8 * code.8386;
  signed char D.52918;
  signed char D.52919;
  signed char D.52920;
  unsigned char D.52921;
  guint8 * code.8387;
  signed char D.52925;
  signed char D.52926;
  unsigned char D.52927;
  guint8 * code.8388;
  signed char D.52930;
  signed char D.52931;
  unsigned char D.52932;
  guint8 * code.8389;
  unsigned char D.52934;
  guint8 * code.8390;
  unsigned char D.52936;
  guint8 * code.8391;
  unsigned char D.52938;
  guint8 * code.8392;
  unsigned char D.52940;
  guint8 * D.52941;
  static const char __PRETTY_FUNCTION__[23] = "amd64_emit_tls_set_reg";

  code.8370 = code;
  code = code.8370 + 1;
  *code.8370 = 100;
  if (0 != 0) goto <D.52867>; else goto <D.52868>;
  <D.52867>:
  code.8371 = code;
  code = code.8371 + 1;
  *code.8371 = 102;
  <D.52868>:
  {
    unsigned char _amd64_rex_bits;

    if (sreg > 7) goto <D.52871>; else goto <D.52872>;
    <D.52871>:
    iftmp.8372 = 12;
    goto <D.52873>;
    <D.52872>:
    iftmp.8372 = 8;
    <D.52873>:
    D.52874 = offset_reg > 7;
    D.52875 = (signed char) D.52874;
    D.52876 = iftmp.8372 | D.52875;
    _amd64_rex_bits = (unsigned char) D.52876;
    if (_amd64_rex_bits != 0) goto <D.52877>; else goto <D.52878>;
    <D.52877>:
    code.8373 = code;
    code = code.8373 + 1;
    D.52880 = _amd64_rex_bits | 64;
    *code.8373 = D.52880;
    <D.52878>:
  }
  switch (8) <default: <D.25104>, case 1: <D.25099>, case 2: <D.25101>, case 4: <D.25102>, case 8: <D.25103>>
  <D.25099>:
  code.8374 = code;
  code = code.8374 + 1;
  *code.8374 = 136;
  goto <D.25100>;
  <D.25101>:
  <D.25102>:
  <D.25103>:
  code.8375 = code;
  code = code.8375 + 1;
  *code.8375 = 137;
  goto <D.25100>;
  <D.25104>:
  __assert_fail ("0", "mini-amd64.c", 3729, &__PRETTY_FUNCTION__);
  <D.25100>:
  D.52883 = offset_reg & 7;
  if (D.52883 == 4) goto <D.52884>; else goto <D.52885>;
  <D.52884>:
  if (1 != 0) goto <D.52886>; else goto <D.52887>;
  <D.52886>:
  code.8376 = code;
  code = code.8376 + 1;
  D.52889 = sreg & 7;
  D.52890 = D.52889 << 3;
  D.52891 = (signed char) D.52890;
  D.52892 = D.52891 | 4;
  D.52893 = (unsigned char) D.52892;
  *code.8376 = D.52893;
  code.8377 = code;
  code = code.8377 + 1;
  *code.8377 = 36;
  goto <D.52895>;
  <D.52887>:
  if (1 != 0) goto <D.52896>; else goto <D.52897>;
  <D.52896>:
  code.8378 = code;
  code = code.8378 + 1;
  D.52889 = sreg & 7;
  D.52890 = D.52889 << 3;
  D.52891 = (signed char) D.52890;
  D.52899 = D.52891 | 68;
  D.52900 = (unsigned char) D.52899;
  *code.8378 = D.52900;
  code.8379 = code;
  code = code.8379 + 1;
  *code.8379 = 36;
  *code = 0;
  code = code + 1;
  goto <D.52902>;
  <D.52897>:
  code.8380 = code;
  code = code.8380 + 1;
  D.52889 = sreg & 7;
  D.52890 = D.52889 << 3;
  D.52891 = (signed char) D.52890;
  D.52904 = D.52891 | -124;
  D.52905 = (unsigned char) D.52904;
  *code.8380 = D.52905;
  code.8381 = code;
  code = code.8381 + 1;
  *code.8381 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8382 = code;
        code = code.8382 + 1;
        D.52908 = imb.b[0];
        *code.8382 = D.52908;
        code.8383 = code;
        code = code.8383 + 1;
        D.52910 = imb.b[1];
        *code.8383 = D.52910;
        code.8384 = code;
        code = code.8384 + 1;
        D.52912 = imb.b[2];
        *code.8384 = D.52912;
        code.8385 = code;
        code = code.8385 + 1;
        D.52914 = imb.b[3];
        *code.8385 = D.52914;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52902>:
  <D.52895>:
  goto <D.25107>;
  <D.52885>:
  D.52883 = offset_reg & 7;
  if (D.52883 != 5) goto <D.52915>; else goto <D.52916>;
  <D.52915>:
  code.8386 = code;
  code = code.8386 + 1;
  D.52889 = sreg & 7;
  D.52890 = D.52889 << 3;
  D.52891 = (signed char) D.52890;
  D.52918 = (signed char) offset_reg;
  D.52919 = D.52918 & 7;
  D.52920 = D.52891 | D.52919;
  D.52921 = (unsigned char) D.52920;
  *code.8386 = D.52921;
  goto <D.25107>;
  <D.52916>:
  if (1 != 0) goto <D.52922>; else goto <D.52923>;
  <D.52922>:
  code.8387 = code;
  code = code.8387 + 1;
  D.52889 = sreg & 7;
  D.52890 = D.52889 << 3;
  D.52891 = (signed char) D.52890;
  D.52925 = D.52891 | 64;
  D.52918 = (signed char) offset_reg;
  D.52919 = D.52918 & 7;
  D.52926 = D.52925 | D.52919;
  D.52927 = (unsigned char) D.52926;
  *code.8387 = D.52927;
  *code = 0;
  code = code + 1;
  goto <D.52928>;
  <D.52923>:
  code.8388 = code;
  code = code.8388 + 1;
  D.52889 = sreg & 7;
  D.52890 = D.52889 << 3;
  D.52891 = (signed char) D.52890;
  D.52930 = D.52891 | -128;
  D.52918 = (signed char) offset_reg;
  D.52919 = D.52918 & 7;
  D.52931 = D.52930 | D.52919;
  D.52932 = (unsigned char) D.52931;
  *code.8388 = D.52932;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8389 = code;
        code = code.8389 + 1;
        D.52934 = imb.b[0];
        *code.8389 = D.52934;
        code.8390 = code;
        code = code.8390 + 1;
        D.52936 = imb.b[1];
        *code.8390 = D.52936;
        code.8391 = code;
        code = code.8391 + 1;
        D.52938 = imb.b[2];
        *code.8391 = D.52938;
        code.8392 = code;
        code = code.8392 + 1;
        D.52940 = imb.b[3];
        *code.8392 = D.52940;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.52928>:
  <D.25107>:
  D.52941 = code;
  return D.52941;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.52943;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = list;
  D.52943 = new_list;
  return D.52943;
}


mono_arch_register_lowlevel_calls ()
{
  struct MonoMethodSignature * D.52945;

  D.52945 = mono_create_icall_signature ("void");
  mono_register_jit_icall (mono_amd64_throw_exception, "mono_amd64_throw_exception", D.52945, 1);
}


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.52946;
  int D.52947;
  sizetype D.52948;
  <unnamed type> D.52951;
  int D.52952;
  long int target.8393;
  long int ip.8394;
  unsigned long disp.8395;
  unsigned long D.52958;
  const char * D.52961;
  struct MonoMethod * D.52962;
  const char * D.52963;
  struct MonoJumpInfo * patch_info;
  gboolean compile_aot;

  D.52946 = run_cctors == 0;
  compile_aot = (gboolean) D.52946;
  patch_info = ji;
  goto <D.27949>;
  <D.27948>:
  {
    unsigned char * ip;
    unsigned char * target;

    D.52947 = patch_info->ip.i;
    D.52948 = (sizetype) D.52947;
    ip = code + D.52948;
    if (compile_aot != 0) goto <D.52949>; else goto <D.52950>;
    <D.52949>:
    D.52951 = patch_info->type;
    switch (D.52951) <default: <D.27933>, case 0: <D.27930>, case 2: <D.27931>>
    <D.27930>:
    <D.27931>:
    goto <D.27932>;
    <D.27933>:
    // predicted unlikely by continue predictor.
    goto <D.27934>;
    <D.27932>:
    <D.52950>:
    target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
    D.52951 = patch_info->type;
    switch (D.52951) <default: <D.27941>, case 0: <D.27939>, case 5: <D.27936>, case 20: <D.27938>, case 21: <D.27937>, case 51: <D.27935>>
    <D.27935>:
    // predicted unlikely by continue predictor.
    goto <D.27934>;
    <D.27936>:
    <D.27937>:
    <D.27938>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 6589);
    <D.27939>:
    goto <D.27940>;
    <D.27941>:
    goto <D.27940>;
    <D.27940>:
    D.52952 = amd64_is_near_call (ip);
    if (D.52952 != 0) goto <D.52953>; else goto <D.52954>;
    <D.52953>:
    {
      gint64 disp;

      target.8393 = (long int) target;
      ip.8394 = (long int) ip;
      disp = target.8393 - ip.8394;
      disp.8395 = (unsigned long) disp;
      D.52958 = disp.8395 + 2147483648;
      if (D.52958 > 4294967295) goto <D.52959>; else goto <D.52960>;
      <D.52959>:
      D.52951 = patch_info->type;
      printf ("TYPE: %d\n", D.52951);
      D.52951 = patch_info->type;
      switch (D.52951) <default: <D.27947>, case 3: <D.27946>, case 4: <D.27945>, case 7: <D.27943>>
      <D.27943>:
      D.52961 = patch_info->data.name;
      printf ("V: %s\n", D.52961);
      goto <D.27944>;
      <D.27945>:
      <D.27946>:
      D.52962 = patch_info->data.method;
      D.52963 = D.52962->name;
      printf ("V: %s\n", D.52963);
      goto <D.27944>;
      <D.27947>:
      goto <D.27944>;
      <D.27944>:
      <D.52960>:
    }
    <D.52954>:
    amd64_patch (ip, target);
  }
  <D.27934>:
  patch_info = patch_info->next;
  <D.27949>:
  if (patch_info != 0B) goto <D.27948>; else goto <D.27950>;
  <D.27950>:
}


amd64_is_near_call (guint8 * code)
{
  unsigned char D.52967;
  unsigned char D.52968;
  gboolean D.52971;
  _Bool D.52972;

  D.52967 = *code;
  D.52968 = D.52967 + 192;
  if (D.52968 <= 15) goto <D.52969>; else goto <D.52970>;
  <D.52969>:
  code = code + 1;
  <D.52970>:
  D.52967 = *code;
  D.52972 = D.52967 == 232;
  D.52971 = (gboolean) D.52972;
  return D.52971;
}


mono_arch_emit_prolog (struct MonoCompile * cfg)
{
  struct MonoMethodHeader * D.52974;
  unsigned int D.52975;
  unsigned int D.52976;
  unsigned int D.52977;
  unsigned int D.52978;
  long unsigned int D.52979;
  void * D.52980;
  struct MonoTraceSpec * mono_jit_trace_calls.8396;
  int D.52984;
  long int code.8397;
  unsigned char * D.52988;
  long int D.52989;
  long int D.52990;
  int D.52991;
  int D.52992;
  struct MonoMethodDesc * mono_inject_async_exc_method.8398;
  struct MonoMethod * D.52996;
  int D.52997;
  int D.53000;
  int mono_inject_async_exc_pos.8399;
  guint8 * code.8400;
  guint8 * code.8401;
  unsigned char D.53010;
  guint8 * code.8402;
  guint8 * code.8403;
  guint8 * code.8404;
  guint8 * code.8405;
  guint8 * code.8406;
  unsigned char D.53016;
  guint8 * code.8407;
  unsigned char D.53018;
  guint8 * code.8408;
  unsigned char D.53020;
  guint8 * code.8409;
  unsigned char D.53022;
  int D.53023;
  int D.53024;
  guint8 * code.8410;
  unsigned char D.53030;
  guint8 * code.8411;
  int D.53034;
  guint8 * code.8412;
  guint8 * code.8413;
  unsigned char D.53045;
  guint8 * code.8414;
  guint8 * code.8415;
  guint8 * code.8416;
  guint8 * code.8417;
  guint8 * code.8418;
  unsigned char D.53051;
  guint8 * code.8419;
  unsigned char D.53053;
  guint8 * code.8420;
  unsigned char D.53055;
  guint8 * code.8421;
  unsigned char D.53057;
  guint8 * code.8422;
  guint8 * code.8423;
  unsigned char D.53064;
  guint8 * code.8424;
  guint8 * code.8425;
  guint8 * code.8426;
  int D.53070;
  guint8 * code.8427;
  guint8 * code.8428;
  unsigned char D.53081;
  guint8 * code.8429;
  guint8 * code.8430;
  guint8 * code.8431;
  guint8 * code.8432;
  guint8 * code.8433;
  unsigned char D.53087;
  guint8 * code.8434;
  unsigned char D.53089;
  guint8 * code.8435;
  unsigned char D.53091;
  guint8 * code.8436;
  unsigned char D.53093;
  int D.53094;
  unsigned int D.53097;
  int D.53102;
  unsigned int D.53103;
  unsigned int D.53104;
  unsigned int D.53105;
  unsigned int D.53106;
  int D.53107;
  unsigned int D.53110;
  int D.53111;
  unsigned int alloc_size.8437;
  unsigned int D.53113;
  unsigned int cfa_offset.8438;
  unsigned int D.53117;
  int D.53118;
  unsigned int D.53120;
  int D.53121;
  unsigned int alloc_size.8439;
  unsigned int D.53125;
  int D.53126;
  unsigned int D.53129;
  unsigned int D.53130;
  unsigned int D.53131;
  _Bool D.53132;
  long int D.53133;
  long int D.53134;
  unsigned int D.53137;
  void * D.53138;
  sizetype D.53139;
  int D.53140;
  int D.53141;
  guint8 * code.8440;
  unsigned char D.53147;
  guint8 * code.8441;
  guint8 * code.8442;
  guint8 * code.8443;
  unsigned char D.53156;
  guint8 * code.8444;
  guint8 * code.8445;
  unsigned char D.53159;
  guint8 * code.8446;
  unsigned char D.53161;
  guint8 * code.8447;
  unsigned char D.53163;
  guint8 * code.8448;
  unsigned char D.53165;
  guint8 * code.8449;
  unsigned char D.53170;
  guint8 * code.8450;
  guint8 * code.8451;
  guint8 * code.8452;
  unsigned char D.53174;
  guint8 * code.8453;
  unsigned char D.53176;
  guint8 * code.8454;
  unsigned char D.53178;
  guint8 * code.8455;
  unsigned char D.53180;
  int D.53185;
  guint8 * code.8456;
  guint8 * code.8457;
  unsigned char D.53196;
  guint8 * code.8458;
  guint8 * code.8459;
  guint8 * code.8460;
  guint8 * code.8461;
  guint8 * code.8462;
  unsigned char D.53202;
  guint8 * code.8463;
  unsigned char D.53204;
  guint8 * code.8464;
  unsigned char D.53206;
  guint8 * code.8465;
  unsigned char D.53208;
  guint8 * code.8466;
  unsigned char D.53212;
  guint8 * code.8467;
  guint8 * code.8468;
  guint8 * code.8469;
  guint8 * code.8470;
  guint8 * code.8471;
  guint8 * code.8472;
  guint8 * code.8473;
  guint8 * code.8474;
  unsigned char D.53229;
  guint8 * code.8475;
  unsigned char D.53231;
  guint8 * code.8476;
  unsigned char D.53233;
  guint8 * code.8477;
  unsigned char D.53235;
  guint8 * code.8478;
  guint8 * code.8479;
  guint8 * code.8480;
  guint8 * code.8481;
  unsigned char D.53245;
  guint8 * code.8482;
  unsigned char D.53247;
  guint8 * code.8483;
  unsigned char D.53249;
  guint8 * code.8484;
  unsigned char D.53251;
  int remaining_size.8485;
  _Bool D.53255;
  _Bool D.53256;
  _Bool D.53257;
  guint8 * code.8486;
  unsigned char D.53263;
  guint8 * code.8487;
  guint8 * code.8488;
  unsigned char D.53266;
  guint8 * code.8489;
  unsigned char D.53273;
  guint8 * code.8490;
  guint8 * code.8491;
  unsigned char D.53276;
  guint8 * code.8492;
  unsigned char D.53278;
  guint8 * code.8493;
  unsigned char D.53280;
  guint8 * code.8494;
  unsigned char D.53282;
  guint8 * code.8495;
  unsigned char D.53287;
  guint8 * code.8496;
  guint8 * code.8497;
  guint8 * code.8498;
  unsigned char D.53291;
  guint8 * code.8499;
  unsigned char D.53293;
  guint8 * code.8500;
  unsigned char D.53295;
  guint8 * code.8501;
  unsigned char D.53297;
  unsigned int cfa_offset.8502;
  unsigned int D.53301;
  int D.53304;
  guint8 * code.8503;
  guint8 * code.8504;
  unsigned char D.53315;
  guint8 * code.8505;
  guint8 * code.8506;
  guint8 * code.8507;
  guint8 * code.8508;
  guint8 * code.8509;
  unsigned char D.53321;
  guint8 * code.8510;
  unsigned char D.53323;
  guint8 * code.8511;
  unsigned char D.53325;
  guint8 * code.8512;
  unsigned char D.53327;
  struct MonoDebugOptions * D.53328;
  int D.53329;
  guint8 * code.8513;
  guint8 * code.8514;
  unsigned char D.53338;
  guint8 * code.8515;
  guint8 * code.8516;
  guint8 * code.8517;
  guint8 * code.8518;
  guint8 * code.8519;
  guint8 * code.8520;
  guint8 * code.8521;
  guint8 * code.8522;
  guint8 * code.8523;
  unsigned char D.53356;
  guint8 * code.8524;
  unsigned char D.53358;
  guint8 * code.8525;
  unsigned char D.53360;
  guint8 * code.8526;
  unsigned char D.53362;
  guint8 * code.8527;
  guint8 * code.8528;
  guint8 * code.8529;
  guint8 * code.8530;
  unsigned char D.53372;
  guint8 * code.8531;
  unsigned char D.53374;
  guint8 * code.8532;
  unsigned char D.53376;
  guint8 * code.8533;
  unsigned char D.53378;
  guint8 * code.8534;
  guint8 * code.8535;
  unsigned char D.53385;
  guint8 * code.8536;
  guint8 * code.8537;
  guint8 * code.8538;
  guint8 * code.8539;
  guint8 * code.8540;
  guint8 * code.8541;
  guint8 * code.8542;
  guint8 * code.8543;
  guint8 * code.8544;
  unsigned char D.53403;
  guint8 * code.8545;
  unsigned char D.53405;
  guint8 * code.8546;
  unsigned char D.53407;
  guint8 * code.8547;
  unsigned char D.53409;
  guint8 * code.8548;
  guint8 * code.8549;
  guint8 * code.8550;
  guint8 * code.8551;
  unsigned char D.53419;
  guint8 * code.8552;
  unsigned char D.53421;
  guint8 * code.8553;
  unsigned char D.53423;
  guint8 * code.8554;
  unsigned char D.53425;
  unsigned char iftmp.8555;
  guint8 * code.8556;
  unsigned char D.53433;
  guint8 * code.8557;
  guint8 * code.8558;
  unsigned char D.53438;
  guint8 * code.8559;
  unsigned char D.53440;
  guint8 * code.8560;
  unsigned char D.53442;
  guint8 * code.8561;
  unsigned char D.53444;
  guint8 * code.8562;
  unsigned char D.53446;
  guint8 * code.8563;
  unsigned char D.53448;
  guint8 * code.8564;
  unsigned char D.53450;
  guint8 * code.8565;
  unsigned char D.53452;
  guint8 * code.8566;
  unsigned char D.53455;
  guint8 * code.8567;
  unsigned char D.53457;
  guint8 * code.8568;
  unsigned char D.53459;
  guint8 * code.8569;
  unsigned char D.53461;
  unsigned char iftmp.8570;
  guint8 * code.8571;
  unsigned char D.53469;
  guint8 * code.8572;
  int D.53473;
  long unsigned int D.53474;
  guint8 * code.8573;
  unsigned char D.53476;
  guint8 * code.8574;
  unsigned char D.53478;
  guint8 * code.8575;
  unsigned char D.53480;
  guint8 * code.8576;
  unsigned char D.53482;
  guint8 * code.8577;
  unsigned char D.53484;
  guint8 * code.8578;
  unsigned char D.53486;
  guint8 * code.8579;
  unsigned char D.53488;
  guint8 * code.8580;
  unsigned char D.53490;
  guint8 * code.8581;
  unsigned char D.53493;
  guint8 * code.8582;
  unsigned char D.53495;
  guint8 * code.8583;
  unsigned char D.53497;
  guint8 * code.8584;
  unsigned char D.53499;
  guint8 * code.8585;
  guint8 * code.8586;
  unsigned char D.53506;
  guint8 * code.8587;
  guint8 * code.8588;
  guint8 * code.8589;
  guint8 * code.8590;
  unsigned char D.53513;
  guint8 * code.8591;
  guint8 * code.8592;
  guint8 * code.8593;
  unsigned char D.53519;
  guint8 * code.8594;
  guint8 * code.8595;
  guint8 * code.8596;
  unsigned char D.53527;
  guint8 * code.8597;
  guint8 * code.8598;
  guint8 * code.8599;
  guint8 * code.8600;
  unsigned char D.53534;
  guint8 * code.8601;
  unsigned char D.53536;
  guint8 * code.8602;
  unsigned char D.53538;
  guint8 * code.8603;
  unsigned char D.53540;
  guint8 * code.8604;
  guint8 * code.8605;
  guint8 * code.8606;
  guint8 * code.8607;
  guint8 * code.8608;
  guint8 * code.8609;
  guint8 * code.8610;
  unsigned char D.53557;
  guint8 * code.8611;
  unsigned char D.53559;
  guint8 * code.8612;
  unsigned char D.53561;
  guint8 * code.8613;
  unsigned char D.53563;
  guint8 * code.8614;
  guint8 * code.8615;
  guint8 * code.8616;
  guint8 * code.8617;
  unsigned char D.53573;
  guint8 * code.8618;
  unsigned char D.53575;
  guint8 * code.8619;
  unsigned char D.53577;
  guint8 * code.8620;
  unsigned char D.53579;
  guint8 * code.8621;
  guint8 * code.8622;
  unsigned char D.53586;
  guint8 * code.8623;
  guint8 * code.8624;
  guint8 * code.8625;
  guint8 * code.8626;
  unsigned char D.53593;
  guint8 * code.8627;
  unsigned char D.53595;
  guint8 * code.8628;
  unsigned char D.53597;
  guint8 * code.8629;
  unsigned char D.53599;
  guint8 * code.8630;
  guint8 * code.8631;
  guint8 * code.8632;
  guint8 * code.8633;
  guint8 * code.8634;
  guint8 * code.8635;
  guint8 * code.8636;
  unsigned char D.53616;
  guint8 * code.8637;
  unsigned char D.53618;
  guint8 * code.8638;
  unsigned char D.53620;
  guint8 * code.8639;
  unsigned char D.53622;
  guint8 * code.8640;
  guint8 * code.8641;
  guint8 * code.8642;
  guint8 * code.8643;
  unsigned char D.53632;
  guint8 * code.8644;
  unsigned char D.53634;
  guint8 * code.8645;
  unsigned char D.53636;
  guint8 * code.8646;
  unsigned char D.53638;
  unsigned char D.53639;
  unsigned char D.53640;
  long int D.53643;
  int D.53644;
  int D.53650;
  int D.53651;
  long unsigned int D.53654;
  int D.53655;
  long unsigned int D.53656;
  long unsigned int D.53657;
  guint8 * code.8647;
  signed char iftmp.8648;
  unsigned int D.53667;
  _Bool D.53668;
  signed char D.53669;
  signed char D.53670;
  guint8 * code.8649;
  unsigned char D.53674;
  guint8 * code.8650;
  guint8 * code.8651;
  unsigned int D.53677;
  guint8 * code.8652;
  int D.53683;
  int D.53684;
  signed char D.53685;
  signed char D.53686;
  unsigned char D.53687;
  guint8 * code.8653;
  unsigned int save_area_offset.8654;
  unsigned int D.53691;
  guint8 * code.8655;
  signed char D.53695;
  unsigned char D.53696;
  guint8 * code.8656;
  unsigned char D.53698;
  guint8 * code.8657;
  signed char D.53701;
  unsigned char D.53702;
  guint8 * code.8658;
  guint8 * code.8659;
  unsigned char D.53705;
  guint8 * code.8660;
  unsigned char D.53707;
  guint8 * code.8661;
  unsigned char D.53709;
  guint8 * code.8662;
  unsigned char D.53711;
  guint8 * code.8663;
  unsigned char D.53717;
  unsigned char D.53718;
  unsigned char D.53719;
  unsigned char D.53720;
  unsigned char D.53721;
  unsigned char D.53722;
  guint8 * code.8664;
  unsigned char D.53726;
  guint8 * code.8665;
  unsigned char D.53729;
  guint8 * code.8666;
  unsigned char D.53731;
  guint8 * code.8667;
  unsigned char D.53733;
  guint8 * code.8668;
  unsigned char D.53735;
  guint8 * code.8669;
  unsigned char D.53737;
  int D.53740;
  int D.53742;
  int D.53745;
  guint8 * code.8670;
  guint8 * code.8671;
  unsigned char D.53756;
  guint8 * code.8672;
  guint8 * code.8673;
  guint8 * code.8674;
  guint8 * code.8675;
  guint8 * code.8676;
  unsigned char D.53762;
  guint8 * code.8677;
  unsigned char D.53764;
  guint8 * code.8678;
  unsigned char D.53766;
  guint8 * code.8679;
  unsigned char D.53768;
  struct MonoInst * D.53769;
  int iftmp.8680;
  short unsigned int D.53776;
  int D.53778;
  unsigned int D.53779;
  unsigned int D.53780;
  _Bool D.53781;
  long int D.53782;
  long int D.53783;
  guint8 * code.8681;
  unsigned char iftmp.8682;
  guint8 * code.8683;
  unsigned char D.53796;
  guint8 * code.8684;
  guint8 * code.8685;
  int D.53799;
  long int D.53802;
  guint8 * code.8686;
  guint8 * code.8687;
  unsigned int D.53808;
  unsigned int D.53809;
  guint8 * code.8688;
  guint8 * code.8689;
  unsigned char D.53814;
  guint8 * code.8690;
  guint8 * code.8691;
  int D.53818;
  guint8 * code.8692;
  unsigned char D.53820;
  guint8 * code.8693;
  unsigned char D.53822;
  guint8 * code.8694;
  unsigned char D.53824;
  guint8 * code.8695;
  unsigned char D.53826;
  guint8 * code.8696;
  signed char D.53832;
  signed char D.53833;
  signed char D.53834;
  unsigned char D.53835;
  guint8 * code.8697;
  signed char D.53839;
  unsigned char D.53840;
  guint8 * code.8698;
  signed char D.53843;
  unsigned char D.53844;
  guint8 * code.8699;
  unsigned char D.53846;
  guint8 * code.8700;
  unsigned char D.53848;
  guint8 * code.8701;
  unsigned char D.53850;
  guint8 * code.8702;
  unsigned char D.53852;
  unsigned int D.53853;
  unsigned int D.53854;
  unsigned int D.53857;
  unsigned int D.53858;
  unsigned int D.53861;
  signed char D.53864;
  signed char D.53867;
  short unsigned int D.53870;
  int D.53871;
  int D.53872;
  short unsigned int D.53873;
  sizetype D.53874;
  sizetype D.53875;
  guint8 * D.53876;
  unsigned char D.53877;
  int D.53878;
  struct MonoBasicBlock * D.53881;
  struct MonoBasicBlock * D.53883;
  struct MonoType * D.53884;
  unsigned char D.53885;
  struct MonoInst * D.53888;
  short unsigned int D.53891;
  guint8 * code.8703;
  signed char iftmp.8704;
  signed char D.53898;
  int D.53902;
  _Bool D.53903;
  signed char D.53904;
  signed char D.53905;
  guint8 * code.8705;
  unsigned char D.53909;
  guint8 * code.8706;
  guint8 * code.8707;
  int D.53912;
  long int D.53915;
  guint8 * code.8708;
  int D.53919;
  int D.53920;
  int D.53921;
  signed char D.53922;
  signed char D.53923;
  unsigned char D.53924;
  guint8 * code.8709;
  unsigned int D.53927;
  unsigned int D.53928;
  guint8 * code.8710;
  signed char D.53932;
  unsigned char D.53933;
  guint8 * code.8711;
  unsigned char D.53935;
  guint8 * code.8712;
  signed char D.53938;
  unsigned char D.53939;
  guint8 * code.8713;
  int D.53941;
  guint8 * code.8714;
  unsigned char D.53943;
  guint8 * code.8715;
  unsigned char D.53945;
  guint8 * code.8716;
  unsigned char D.53947;
  guint8 * code.8717;
  unsigned char D.53949;
  guint8 * code.8718;
  signed char D.53955;
  signed char D.53956;
  signed char D.53957;
  unsigned char D.53958;
  guint8 * code.8719;
  signed char D.53962;
  signed char D.53963;
  unsigned char D.53964;
  guint8 * code.8720;
  signed char D.53967;
  signed char D.53968;
  unsigned char D.53969;
  guint8 * code.8721;
  unsigned char D.53971;
  guint8 * code.8722;
  unsigned char D.53973;
  guint8 * code.8723;
  unsigned char D.53975;
  guint8 * code.8724;
  unsigned char D.53977;
  sizetype D.53978;
  struct MonoInst * * D.53979;
  long unsigned int D.53980;
  long unsigned int D.53981;
  struct MonoInst * * D.53982;
  unsigned char D.53983;
  int D.53984;
  int D.53985;
  unsigned char D.53992;
  unsigned char D.53993;
  struct MonoClass * D.53996;
  <unnamed-unsigned:1> D.53997;
  int D.53998;
  int D.53999;
  short int D.54000;
  int D.54001;
  unsigned char D.54002;
  unsigned char D.54003;
  <unnamed type> D.54006;
  guint8 * code.8725;
  signed char iftmp.8726;
  signed char D.54009;
  _Bool D.54013;
  signed char D.54014;
  signed char D.54015;
  guint8 * code.8727;
  unsigned char D.54019;
  guint8 * code.8728;
  guint8 * code.8729;
  guint8 * code.8730;
  int D.54023;
  int D.54024;
  int D.54025;
  signed char D.54026;
  signed char D.54027;
  signed char D.54028;
  signed char D.54029;
  unsigned char D.54030;
  <unnamed type> D.54031;
  guint8 * code.8731;
  signed char iftmp.8732;
  signed char D.54036;
  int D.54040;
  _Bool D.54041;
  signed char D.54042;
  signed char D.54043;
  guint8 * code.8733;
  unsigned char D.54047;
  guint8 * code.8734;
  guint8 * code.8735;
  int D.54050;
  long int D.54053;
  long unsigned int D.54054;
  long unsigned int D.54055;
  long unsigned int D.54056;
  long unsigned int D.54057;
  guint8 * code.8736;
  int D.54061;
  int D.54062;
  int D.54063;
  signed char D.54064;
  signed char D.54065;
  unsigned char D.54066;
  guint8 * code.8737;
  unsigned int D.54071;
  unsigned int D.54072;
  unsigned int D.54073;
  unsigned int D.54074;
  int D.54075;
  guint8 * code.8738;
  signed char D.54079;
  unsigned char D.54080;
  guint8 * code.8739;
  unsigned char D.54082;
  unsigned char D.54083;
  unsigned char D.54084;
  unsigned char D.54085;
  guint8 * code.8740;
  signed char D.54087;
  unsigned char D.54088;
  guint8 * code.8741;
  guint8 * code.8742;
  unsigned char D.54091;
  guint8 * code.8743;
  unsigned char D.54093;
  guint8 * code.8744;
  unsigned char D.54095;
  guint8 * code.8745;
  unsigned char D.54097;
  guint8 * code.8746;
  signed char D.54103;
  signed char D.54104;
  signed char D.54105;
  unsigned char D.54106;
  guint8 * code.8747;
  signed char D.54112;
  signed char D.54113;
  unsigned char D.54114;
  guint8 * code.8748;
  signed char D.54116;
  signed char D.54117;
  unsigned char D.54118;
  guint8 * code.8749;
  unsigned char D.54120;
  guint8 * code.8750;
  unsigned char D.54122;
  guint8 * code.8751;
  unsigned char D.54124;
  guint8 * code.8752;
  unsigned char D.54126;
  guint8 * code.8753;
  signed char iftmp.8754;
  signed char D.54132;
  guint8 * code.8755;
  unsigned char D.54136;
  guint8 * code.8756;
  guint8 * code.8757;
  guint8 * code.8758;
  guint8 * code.8759;
  guint8 * code.8760;
  guint8 * code.8761;
  guint8 * code.8762;
  guint8 * code.8763;
  guint8 * code.8764;
  unsigned char D.54155;
  guint8 * code.8765;
  unsigned char D.54157;
  guint8 * code.8766;
  unsigned char D.54159;
  guint8 * code.8767;
  unsigned char D.54161;
  guint8 * code.8768;
  guint8 * code.8769;
  guint8 * code.8770;
  guint8 * code.8771;
  unsigned char D.54174;
  guint8 * code.8772;
  unsigned char D.54176;
  guint8 * code.8773;
  unsigned char D.54178;
  guint8 * code.8774;
  unsigned char D.54180;
  guint8 * code.8775;
  signed char iftmp.8776;
  signed char D.54186;
  guint8 * code.8777;
  unsigned char D.54190;
  guint8 * code.8778;
  guint8 * code.8779;
  guint8 * code.8780;
  guint8 * code.8781;
  guint8 * code.8782;
  guint8 * code.8783;
  guint8 * code.8784;
  guint8 * code.8785;
  guint8 * code.8786;
  unsigned char D.54209;
  guint8 * code.8787;
  unsigned char D.54211;
  guint8 * code.8788;
  unsigned char D.54213;
  guint8 * code.8789;
  unsigned char D.54215;
  guint8 * code.8790;
  guint8 * code.8791;
  guint8 * code.8792;
  guint8 * code.8793;
  unsigned char D.54228;
  guint8 * code.8794;
  unsigned char D.54230;
  guint8 * code.8795;
  unsigned char D.54232;
  guint8 * code.8796;
  unsigned char D.54234;
  short unsigned int D.54235;
  guint8 * code.8797;
  signed char iftmp.8798;
  signed char iftmp.8799;
  signed char D.54249;
  signed char D.54250;
  _Bool D.54251;
  _Bool D.54252;
  _Bool D.54253;
  guint8 * code.8800;
  unsigned char D.54257;
  guint8 * code.8801;
  guint8 * code.8802;
  guint8 * code.8803;
  signed char D.54265;
  unsigned char D.54266;
  guint8 * code.8804;
  unsigned int D.54269;
  unsigned int D.54270;
  guint8 * code.8805;
  signed char D.54274;
  unsigned char D.54275;
  guint8 * code.8806;
  unsigned char D.54277;
  guint8 * code.8807;
  signed char D.54280;
  unsigned char D.54281;
  guint8 * code.8808;
  int D.54283;
  guint8 * code.8809;
  unsigned char D.54285;
  guint8 * code.8810;
  unsigned char D.54287;
  guint8 * code.8811;
  unsigned char D.54289;
  guint8 * code.8812;
  unsigned char D.54291;
  guint8 * code.8813;
  signed char D.54297;
  unsigned char D.54298;
  guint8 * code.8814;
  signed char D.54302;
  signed char D.54303;
  unsigned char D.54304;
  guint8 * code.8815;
  signed char D.54307;
  signed char D.54308;
  unsigned char D.54309;
  guint8 * code.8816;
  unsigned char D.54311;
  guint8 * code.8817;
  unsigned char D.54313;
  guint8 * code.8818;
  unsigned char D.54315;
  guint8 * code.8819;
  unsigned char D.54317;
  struct MonoInst * D.54318;
  guint8 * code.8820;
  signed char iftmp.8821;
  signed char D.54326;
  guint8 * code.8822;
  unsigned char D.54330;
  guint8 * code.8823;
  guint8 * code.8824;
  guint8 * code.8825;
  guint8 * code.8826;
  guint8 * code.8827;
  guint8 * code.8828;
  guint8 * code.8829;
  guint8 * code.8830;
  guint8 * code.8831;
  unsigned char D.54348;
  guint8 * code.8832;
  unsigned char D.54350;
  guint8 * code.8833;
  unsigned char D.54352;
  guint8 * code.8834;
  unsigned char D.54354;
  guint8 * code.8835;
  guint8 * code.8836;
  guint8 * code.8837;
  guint8 * code.8838;
  unsigned char D.54366;
  guint8 * code.8839;
  unsigned char D.54368;
  guint8 * code.8840;
  unsigned char D.54370;
  guint8 * code.8841;
  unsigned char D.54372;
  guint8 * code.8842;
  signed char iftmp.8843;
  signed char D.54378;
  guint8 * code.8844;
  unsigned char D.54382;
  guint8 * code.8845;
  guint8 * code.8846;
  guint8 * code.8847;
  guint8 * code.8848;
  guint8 * code.8849;
  guint8 * code.8850;
  guint8 * code.8851;
  guint8 * code.8852;
  guint8 * code.8853;
  unsigned char D.54400;
  guint8 * code.8854;
  unsigned char D.54402;
  guint8 * code.8855;
  unsigned char D.54404;
  guint8 * code.8856;
  unsigned char D.54406;
  guint8 * code.8857;
  guint8 * code.8858;
  guint8 * code.8859;
  guint8 * code.8860;
  unsigned char D.54418;
  guint8 * code.8861;
  unsigned char D.54420;
  guint8 * code.8862;
  unsigned char D.54422;
  guint8 * code.8863;
  unsigned char D.54424;
  guint8 * code.8864;
  signed char iftmp.8865;
  signed char D.54432;
  guint8 * code.8866;
  unsigned char D.54436;
  guint8 * code.8867;
  guint8 * code.8868;
  guint8 * code.8869;
  guint8 * code.8870;
  guint8 * code.8871;
  guint8 * code.8872;
  guint8 * code.8873;
  guint8 * code.8874;
  guint8 * code.8875;
  unsigned char D.54455;
  guint8 * code.8876;
  unsigned char D.54457;
  guint8 * code.8877;
  unsigned char D.54459;
  guint8 * code.8878;
  unsigned char D.54461;
  guint8 * code.8879;
  guint8 * code.8880;
  guint8 * code.8881;
  guint8 * code.8882;
  unsigned char D.54474;
  guint8 * code.8883;
  unsigned char D.54476;
  guint8 * code.8884;
  unsigned char D.54478;
  guint8 * code.8885;
  unsigned char D.54480;
  guint8 * code.8886;
  signed char iftmp.8887;
  signed char D.54486;
  guint8 * code.8888;
  unsigned char D.54490;
  guint8 * code.8889;
  guint8 * code.8890;
  guint8 * code.8891;
  guint8 * code.8892;
  guint8 * code.8893;
  guint8 * code.8894;
  guint8 * code.8895;
  guint8 * code.8896;
  guint8 * code.8897;
  unsigned char D.54509;
  guint8 * code.8898;
  unsigned char D.54511;
  guint8 * code.8899;
  unsigned char D.54513;
  guint8 * code.8900;
  unsigned char D.54515;
  guint8 * code.8901;
  guint8 * code.8902;
  guint8 * code.8903;
  guint8 * code.8904;
  unsigned char D.54528;
  guint8 * code.8905;
  unsigned char D.54530;
  guint8 * code.8906;
  unsigned char D.54532;
  guint8 * code.8907;
  unsigned char D.54534;
  guint8 * code.8908;
  signed char iftmp.8909;
  signed char D.54540;
  guint8 * code.8910;
  unsigned char D.54544;
  guint8 * code.8911;
  guint8 * code.8912;
  guint8 * code.8913;
  guint8 * code.8914;
  guint8 * code.8915;
  guint8 * code.8916;
  guint8 * code.8917;
  guint8 * code.8918;
  guint8 * code.8919;
  unsigned char D.54563;
  guint8 * code.8920;
  unsigned char D.54565;
  guint8 * code.8921;
  unsigned char D.54567;
  guint8 * code.8922;
  unsigned char D.54569;
  guint8 * code.8923;
  guint8 * code.8924;
  guint8 * code.8925;
  guint8 * code.8926;
  unsigned char D.54582;
  guint8 * code.8927;
  unsigned char D.54584;
  guint8 * code.8928;
  unsigned char D.54586;
  guint8 * code.8929;
  unsigned char D.54588;
  <unnamed type> D.54589;
  guint8 * code.8930;
  signed char iftmp.8931;
  signed char D.54596;
  struct MonoInst * D.54600;
  int D.54601;
  _Bool D.54602;
  signed char D.54603;
  signed char D.54604;
  guint8 * code.8932;
  unsigned char D.54608;
  guint8 * code.8933;
  guint8 * code.8934;
  int D.54611;
  long int D.54614;
  guint8 * code.8935;
  int D.54618;
  int D.54619;
  int D.54620;
  signed char D.54621;
  signed char D.54622;
  unsigned char D.54623;
  guint8 * code.8936;
  unsigned int D.54626;
  unsigned int D.54627;
  guint8 * code.8937;
  signed char D.54631;
  unsigned char D.54632;
  guint8 * code.8938;
  unsigned char D.54634;
  guint8 * code.8939;
  signed char D.54637;
  unsigned char D.54638;
  guint8 * code.8940;
  int D.54640;
  guint8 * code.8941;
  unsigned char D.54642;
  guint8 * code.8942;
  unsigned char D.54644;
  guint8 * code.8943;
  unsigned char D.54646;
  guint8 * code.8944;
  unsigned char D.54648;
  guint8 * code.8945;
  signed char D.54654;
  signed char D.54655;
  signed char D.54656;
  unsigned char D.54657;
  guint8 * code.8946;
  signed char D.54661;
  signed char D.54662;
  unsigned char D.54663;
  guint8 * code.8947;
  signed char D.54666;
  signed char D.54667;
  unsigned char D.54668;
  guint8 * code.8948;
  unsigned char D.54670;
  guint8 * code.8949;
  unsigned char D.54672;
  guint8 * code.8950;
  unsigned char D.54674;
  guint8 * code.8951;
  unsigned char D.54676;
  guint8 * code.8952;
  signed char iftmp.8953;
  int D.54682;
  signed char D.54686;
  guint8 * code.8954;
  unsigned char D.54690;
  guint8 * code.8955;
  guint8 * code.8956;
  guint8 * code.8957;
  int D.54694;
  int D.54695;
  signed char D.54696;
  signed char D.54697;
  signed char D.54698;
  unsigned char D.54699;
  guint8 * code.8958;
  unsigned char iftmp.8959;
  guint8 * code.8960;
  unsigned char D.54710;
  guint8 * code.8961;
  guint8 * code.8962;
  guint8 * code.8963;
  signed char D.54716;
  unsigned char D.54717;
  int D.54718;
  guint8 * code.8964;
  unsigned char D.54720;
  guint8 * code.8965;
  unsigned char D.54722;
  guint8 * code.8966;
  unsigned char D.54724;
  guint8 * code.8967;
  unsigned char D.54726;
  guint8 * code.8968;
  signed char D.54733;
  unsigned char D.54734;
  guint8 * code.8969;
  unsigned short D.54737;
  unsigned short D.54738;
  guint8 * code.8970;
  signed char D.54742;
  unsigned char D.54743;
  guint8 * code.8971;
  unsigned char D.54745;
  unsigned char D.54746;
  guint8 * code.8972;
  signed char D.54749;
  unsigned char D.54750;
  guint8 * code.8973;
  guint8 * code.8974;
  unsigned char D.54753;
  guint8 * code.8975;
  unsigned char D.54755;
  guint8 * code.8976;
  unsigned char D.54757;
  guint8 * code.8977;
  unsigned char D.54759;
  guint8 * code.8978;
  guint8 * code.8979;
  signed char D.54766;
  unsigned char D.54767;
  guint8 * code.8980;
  signed char D.54770;
  unsigned char D.54771;
  guint8 * code.8981;
  unsigned char D.54773;
  guint8 * code.8982;
  unsigned char D.54775;
  guint8 * code.8983;
  unsigned char D.54777;
  guint8 * code.8984;
  unsigned char D.54779;
  short unsigned int D.54782;
  int D.54783;
  int D.54784;
  unsigned int D.54787;
  struct MonoBasicBlock * D.54794;
  short int D.54797;
  <unnamed type> D.54802;
  short unsigned int D.54803;
  _Bool D.54804;
  _Bool D.54805;
  _Bool D.54806;
  int D.54809;
  long int D.54812;
  int D.54815;
  signed char D.54816;
  int D.54817;
  int D.54820;
  int D.54821;
  int D.54823;
  short unsigned int D.54828;
  unsigned char D.54839;
  unsigned char D.54840;
  unsigned char D.54843;
  unsigned char D.54844;
  guint8 * code.8985;
  guint8 * code.8986;
  unsigned char D.54853;
  guint8 * code.8987;
  guint8 * code.8988;
  guint8 * code.8989;
  guint8 * code.8990;
  unsigned char D.54860;
  guint8 * code.8991;
  unsigned char D.54862;
  guint8 * code.8992;
  unsigned char D.54864;
  guint8 * code.8993;
  unsigned char D.54866;
  guint8 * code.8994;
  guint8 * code.8995;
  guint8 * code.8996;
  guint8 * code.8997;
  guint8 * code.8998;
  guint8 * code.8999;
  guint8 * code.9000;
  unsigned char D.54883;
  guint8 * code.9001;
  unsigned char D.54885;
  guint8 * code.9002;
  unsigned char D.54887;
  guint8 * code.9003;
  unsigned char D.54889;
  guint8 * code.9004;
  guint8 * code.9005;
  guint8 * code.9006;
  guint8 * code.9007;
  unsigned char D.54899;
  guint8 * code.9008;
  unsigned char D.54901;
  guint8 * code.9009;
  unsigned char D.54903;
  guint8 * code.9010;
  unsigned char D.54905;
  short unsigned int D.54906;
  _Bool D.54907;
  long int D.54908;
  long int D.54909;
  guint8 * code.9011;
  unsigned char iftmp.9012;
  int D.54916;
  guint8 * code.9013;
  unsigned char D.54923;
  guint8 * code.9014;
  guint8 * code.9015;
  int D.54926;
  long int D.54929;
  guint8 * code.9016;
  guint8 * code.9017;
  unsigned int D.54935;
  unsigned int D.54936;
  guint8 * code.9018;
  guint8 * code.9019;
  unsigned char D.54941;
  guint8 * code.9020;
  guint8 * code.9021;
  int D.54945;
  guint8 * code.9022;
  unsigned char D.54947;
  guint8 * code.9023;
  unsigned char D.54949;
  guint8 * code.9024;
  unsigned char D.54951;
  guint8 * code.9025;
  unsigned char D.54953;
  guint8 * code.9026;
  signed char D.54959;
  signed char D.54960;
  signed char D.54961;
  unsigned char D.54962;
  guint8 * code.9027;
  signed char D.54966;
  unsigned char D.54967;
  guint8 * code.9028;
  signed char D.54970;
  unsigned char D.54971;
  guint8 * code.9029;
  unsigned char D.54973;
  guint8 * code.9030;
  unsigned char D.54975;
  guint8 * code.9031;
  unsigned char D.54977;
  guint8 * code.9032;
  unsigned char D.54979;
  _Bool D.54980;
  long int D.54981;
  long int D.54982;
  guint8 * code.9033;
  unsigned char iftmp.9034;
  guint8 * code.9035;
  unsigned char D.54997;
  guint8 * code.9036;
  guint8 * code.9037;
  guint8 * code.9038;
  guint8 * code.9039;
  unsigned char D.55004;
  guint8 * code.9040;
  unsigned char D.55006;
  guint8 * code.9041;
  unsigned char D.55008;
  guint8 * code.9042;
  unsigned char D.55010;
  guint8 * code.9043;
  guint8 * code.9044;
  guint8 * code.9045;
  guint8 * code.9046;
  guint8 * code.9047;
  guint8 * code.9048;
  guint8 * code.9049;
  unsigned char D.55027;
  guint8 * code.9050;
  unsigned char D.55029;
  guint8 * code.9051;
  unsigned char D.55031;
  guint8 * code.9052;
  unsigned char D.55033;
  guint8 * code.9053;
  guint8 * code.9054;
  guint8 * code.9055;
  guint8 * code.9056;
  unsigned char D.55045;
  guint8 * code.9057;
  unsigned char D.55047;
  guint8 * code.9058;
  unsigned char D.55049;
  guint8 * code.9059;
  unsigned char D.55051;
  guint8 * code.9060;
  guint8 * code.9061;
  unsigned char D.55058;
  guint8 * code.9062;
  guint8 * code.9063;
  guint8 * code.9064;
  guint8 * code.9065;
  unsigned char D.55065;
  guint8 * code.9066;
  unsigned char D.55067;
  guint8 * code.9067;
  unsigned char D.55069;
  guint8 * code.9068;
  unsigned char D.55071;
  guint8 * code.9069;
  guint8 * code.9070;
  guint8 * code.9071;
  guint8 * code.9072;
  guint8 * code.9073;
  guint8 * code.9074;
  guint8 * code.9075;
  unsigned char D.55088;
  guint8 * code.9076;
  unsigned char D.55090;
  guint8 * code.9077;
  unsigned char D.55092;
  guint8 * code.9078;
  unsigned char D.55094;
  guint8 * code.9079;
  guint8 * code.9080;
  guint8 * code.9081;
  guint8 * code.9082;
  unsigned char D.55104;
  guint8 * code.9083;
  unsigned char D.55106;
  guint8 * code.9084;
  unsigned char D.55108;
  guint8 * code.9085;
  unsigned char D.55110;
  void * ss_trigger_page.9086;
  long unsigned int ss_trigger_page.9087;
  long int ss_trigger_page.9088;
  int D.55115;
  long unsigned int D.55116;
  _Bool D.55117;
  unsigned char iftmp.9089;
  guint8 * code.9090;
  unsigned char D.55125;
  guint8 * code.9091;
  guint8 * code.9092;
  unsigned char D.55130;
  guint8 * code.9093;
  unsigned char D.55132;
  guint8 * code.9094;
  unsigned char D.55134;
  guint8 * code.9095;
  unsigned char D.55136;
  guint8 * code.9096;
  unsigned char D.55138;
  guint8 * code.9097;
  unsigned char D.55140;
  guint8 * code.9098;
  unsigned char D.55142;
  guint8 * code.9099;
  unsigned char D.55144;
  guint8 * code.9100;
  unsigned char D.55147;
  guint8 * code.9101;
  unsigned char D.55149;
  guint8 * code.9102;
  unsigned char D.55151;
  guint8 * code.9103;
  unsigned char D.55153;
  guint8 * code.9104;
  unsigned char iftmp.9105;
  guint8 * code.9106;
  unsigned char D.55164;
  guint8 * code.9107;
  guint8 * code.9108;
  guint8 * code.9109;
  guint8 * code.9110;
  guint8 * code.9111;
  guint8 * code.9112;
  guint8 * code.9113;
  guint8 * code.9114;
  guint8 * code.9115;
  unsigned char D.55182;
  guint8 * code.9116;
  unsigned char D.55184;
  guint8 * code.9117;
  unsigned char D.55186;
  guint8 * code.9118;
  unsigned char D.55188;
  guint8 * code.9119;
  signed char D.55194;
  unsigned char D.55195;
  guint8 * code.9120;
  signed char D.55199;
  unsigned char D.55200;
  guint8 * code.9121;
  signed char D.55203;
  unsigned char D.55204;
  guint8 * code.9122;
  unsigned char D.55206;
  guint8 * code.9123;
  unsigned char D.55208;
  guint8 * code.9124;
  unsigned char D.55210;
  guint8 * code.9125;
  unsigned char D.55212;
  unsigned int D.55213;
  unsigned int D.55214;
  _Bool D.55215;
  long int D.55216;
  long int D.55217;
  guint8 * D.55220;
  struct MonoMethod * method;
  struct MonoBasicBlock * bb;
  struct MonoMethodSignature * sig;
  struct MonoInst * ins;
  int alloc_size;
  int pos;
  int i;
  int cfa_offset;
  int quad;
  int max_epilog_size;
  guint8 * code;
  struct CallInfo * cinfo;
  struct MonoInst * lmf_var;
  gboolean args_clobbered;
  gboolean trace;
  static const char __PRETTY_FUNCTION__[22] = "mono_arch_emit_prolog";

  method = cfg->method;
  lmf_var = cfg->lmf_var;
  args_clobbered = 0;
  trace = 0;
  D.52974 = cfg->header;
  D.52975 = D.52974->code_size;
  D.52976 = D.52975 * 4;
  D.52977 = MAX_EXPR <D.52976, 10240>;
  cfg->code_size = D.52977;
  D.52978 = cfg->code_size;
  D.52979 = (long unsigned int) D.52978;
  D.52980 = monoeg_malloc (D.52979);
  cfg->native_code = D.52980;
  code = cfg->native_code;
  mono_jit_trace_calls.8396 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.8396 != 0B) goto <D.52982>; else goto <D.52983>;
  <D.52982>:
  D.52984 = mono_trace_eval (method);
  if (D.52984 != 0) goto <D.52985>; else goto <D.52986>;
  <D.52985>:
  trace = 1;
  <D.52986>:
  <D.52983>:
  pos = 0;
  cfa_offset = 0;
  cfa_offset = 8;
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  mono_emit_unwind_op (cfg, D.52991, 12, 4, 8);
  cfg->cfa_reg = 4;
  cfg->cfa_offset = 8;
  D.52992 = -cfa_offset;
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  mono_emit_unwind_op (cfg, D.52991, 128, 16, D.52992);
  mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.8398 != 0B) goto <D.52994>; else goto <D.52995>;
  <D.52994>:
  D.52996 = cfg->method;
  mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
  D.52997 = mono_method_desc_full_match (mono_inject_async_exc_method.8398, D.52996);
  if (D.52997 != 0) goto <D.52998>; else goto <D.52999>;
  <D.52998>:
  D.53000 = cfg->arch.async_point_count;
  mono_inject_async_exc_pos.8399 = mono_inject_async_exc_pos;
  if (D.53000 == mono_inject_async_exc_pos.8399) goto <D.53002>; else goto <D.53003>;
  <D.53002>:
  if (0 != 0) goto <D.53004>; else goto <D.53005>;
  <D.53004>:
  code.8400 = code;
  code = code.8400 + 1;
  *code.8400 = 102;
  <D.53005>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.53007>; else goto <D.53008>;
    <D.53007>:
    code.8401 = code;
    code = code.8401 + 1;
    D.53010 = _amd64_rex_bits | 64;
    *code.8401 = D.53010;
    <D.53008>:
  }
  switch (4) <default: <D.27979>, case 1: <D.27974>, case 2: <D.27976>, case 4: <D.27977>, case 8: <D.27978>>
  <D.27974>:
  code.8402 = code;
  code = code.8402 + 1;
  *code.8402 = 138;
  goto <D.27975>;
  <D.27976>:
  <D.27977>:
  <D.27978>:
  code.8403 = code;
  code = code.8403 + 1;
  *code.8403 = 139;
  goto <D.27975>;
  <D.27979>:
  __assert_fail ("0", "mini-amd64.c", 6722, &__PRETTY_FUNCTION__);
  <D.27975>:
  code.8404 = code;
  code = code.8404 + 1;
  *code.8404 = 4;
  code.8405 = code;
  code = code.8405 + 1;
  *code.8405 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8406 = code;
        code = code.8406 + 1;
        D.53016 = imb.b[0];
        *code.8406 = D.53016;
        code.8407 = code;
        code = code.8407 + 1;
        D.53018 = imb.b[1];
        *code.8407 = D.53018;
        code.8408 = code;
        code = code.8408 + 1;
        D.53020 = imb.b[2];
        *code.8408 = D.53020;
        code.8409 = code;
        code = code.8409 + 1;
        D.53022 = imb.b[3];
        *code.8409 = D.53022;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53003>:
  D.53000 = cfg->arch.async_point_count;
  D.53023 = D.53000 + 1;
  cfg->arch.async_point_count = D.53023;
  <D.52999>:
  <D.52995>:
  D.52992 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.52992, 0);
  D.53024 = cfg->arch.omit_fp;
  if (D.53024 == 0) goto <D.53025>; else goto <D.53026>;
  <D.53025>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.53027>; else goto <D.53028>;
    <D.53027>:
    code.8410 = code;
    code = code.8410 + 1;
    D.53030 = _amd64_rex_bits | 64;
    *code.8410 = D.53030;
    <D.53028>:
  }
  code.8411 = code;
  code = code.8411 + 1;
  *code.8411 = 85;
  cfa_offset = cfa_offset + 8;
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  mono_emit_unwind_op (cfg, D.52991, 14, 0, cfa_offset);
  cfg->cfa_offset = cfa_offset;
  D.52992 = -cfa_offset;
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  mono_emit_unwind_op (cfg, D.52991, 128, 5, D.52992);
  mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.8398 != 0B) goto <D.53032>; else goto <D.53033>;
  <D.53032>:
  D.52996 = cfg->method;
  mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
  D.53034 = mono_method_desc_full_match (mono_inject_async_exc_method.8398, D.52996);
  if (D.53034 != 0) goto <D.53035>; else goto <D.53036>;
  <D.53035>:
  D.53000 = cfg->arch.async_point_count;
  mono_inject_async_exc_pos.8399 = mono_inject_async_exc_pos;
  if (D.53000 == mono_inject_async_exc_pos.8399) goto <D.53037>; else goto <D.53038>;
  <D.53037>:
  if (0 != 0) goto <D.53039>; else goto <D.53040>;
  <D.53039>:
  code.8412 = code;
  code = code.8412 + 1;
  *code.8412 = 102;
  <D.53040>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.53042>; else goto <D.53043>;
    <D.53042>:
    code.8413 = code;
    code = code.8413 + 1;
    D.53045 = _amd64_rex_bits | 64;
    *code.8413 = D.53045;
    <D.53043>:
  }
  switch (4) <default: <D.27989>, case 1: <D.27984>, case 2: <D.27986>, case 4: <D.27987>, case 8: <D.27988>>
  <D.27984>:
  code.8414 = code;
  code = code.8414 + 1;
  *code.8414 = 138;
  goto <D.27985>;
  <D.27986>:
  <D.27987>:
  <D.27988>:
  code.8415 = code;
  code = code.8415 + 1;
  *code.8415 = 139;
  goto <D.27985>;
  <D.27989>:
  __assert_fail ("0", "mini-amd64.c", 6730, &__PRETTY_FUNCTION__);
  <D.27985>:
  code.8416 = code;
  code = code.8416 + 1;
  *code.8416 = 4;
  code.8417 = code;
  code = code.8417 + 1;
  *code.8417 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8418 = code;
        code = code.8418 + 1;
        D.53051 = imb.b[0];
        *code.8418 = D.53051;
        code.8419 = code;
        code = code.8419 + 1;
        D.53053 = imb.b[1];
        *code.8419 = D.53053;
        code.8420 = code;
        code = code.8420 + 1;
        D.53055 = imb.b[2];
        *code.8420 = D.53055;
        code.8421 = code;
        code = code.8421 + 1;
        D.53057 = imb.b[3];
        *code.8421 = D.53057;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53038>:
  D.53000 = cfg->arch.async_point_count;
  D.53023 = D.53000 + 1;
  cfg->arch.async_point_count = D.53023;
  <D.53036>:
  <D.53033>:
  D.52992 = -cfa_offset;
  mini_gc_set_slot_type_from_cfa (cfg, D.52992, 0);
  if (0 != 0) goto <D.53058>; else goto <D.53059>;
  <D.53058>:
  code.8422 = code;
  code = code.8422 + 1;
  *code.8422 = 102;
  <D.53059>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53061>; else goto <D.53062>;
    <D.53061>:
    code.8423 = code;
    code = code.8423 + 1;
    D.53064 = _amd64_rex_bits | 64;
    *code.8423 = D.53064;
    <D.53062>:
  }
  switch (8) <default: <D.27997>, case 1: <D.27992>, case 2: <D.27994>, case 4: <D.27995>, case 8: <D.27996>>
  <D.27992>:
  code.8424 = code;
  code = code.8424 + 1;
  *code.8424 = 138;
  goto <D.27993>;
  <D.27994>:
  <D.27995>:
  <D.27996>:
  code.8425 = code;
  code = code.8425 + 1;
  *code.8425 = 139;
  goto <D.27993>;
  <D.27997>:
  __assert_fail ("0", "mini-amd64.c", 6737, &__PRETTY_FUNCTION__);
  <D.27993>:
  code.8426 = code;
  code = code.8426 + 1;
  *code.8426 = 236;
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  mono_emit_unwind_op (cfg, D.52991, 13, 5, 0);
  cfg->cfa_reg = 5;
  mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.8398 != 0B) goto <D.53068>; else goto <D.53069>;
  <D.53068>:
  D.52996 = cfg->method;
  mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
  D.53070 = mono_method_desc_full_match (mono_inject_async_exc_method.8398, D.52996);
  if (D.53070 != 0) goto <D.53071>; else goto <D.53072>;
  <D.53071>:
  D.53000 = cfg->arch.async_point_count;
  mono_inject_async_exc_pos.8399 = mono_inject_async_exc_pos;
  if (D.53000 == mono_inject_async_exc_pos.8399) goto <D.53073>; else goto <D.53074>;
  <D.53073>:
  if (0 != 0) goto <D.53075>; else goto <D.53076>;
  <D.53075>:
  code.8427 = code;
  code = code.8427 + 1;
  *code.8427 = 102;
  <D.53076>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.53078>; else goto <D.53079>;
    <D.53078>:
    code.8428 = code;
    code = code.8428 + 1;
    D.53081 = _amd64_rex_bits | 64;
    *code.8428 = D.53081;
    <D.53079>:
  }
  switch (4) <default: <D.28004>, case 1: <D.27999>, case 2: <D.28001>, case 4: <D.28002>, case 8: <D.28003>>
  <D.27999>:
  code.8429 = code;
  code = code.8429 + 1;
  *code.8429 = 138;
  goto <D.28000>;
  <D.28001>:
  <D.28002>:
  <D.28003>:
  code.8430 = code;
  code = code.8430 + 1;
  *code.8430 = 139;
  goto <D.28000>;
  <D.28004>:
  __assert_fail ("0", "mini-amd64.c", 6739, &__PRETTY_FUNCTION__);
  <D.28000>:
  code.8431 = code;
  code = code.8431 + 1;
  *code.8431 = 4;
  code.8432 = code;
  code = code.8432 + 1;
  *code.8432 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.8433 = code;
        code = code.8433 + 1;
        D.53087 = imb.b[0];
        *code.8433 = D.53087;
        code.8434 = code;
        code = code.8434 + 1;
        D.53089 = imb.b[1];
        *code.8434 = D.53089;
        code.8435 = code;
        code = code.8435 + 1;
        D.53091 = imb.b[2];
        *code.8435 = D.53091;
        code.8436 = code;
        code = code.8436 + 1;
        D.53093 = imb.b[3];
        *code.8436 = D.53093;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53074>:
  D.53000 = cfg->arch.async_point_count;
  D.53023 = D.53000 + 1;
  cfg->arch.async_point_count = D.53023;
  <D.53072>:
  <D.53069>:
  <D.53026>:
  D.53094 = cfg->arch.no_pushes;
  if (D.53094 != 0) goto <D.53095>; else goto <D.53096>;
  <D.53095>:
  D.53097 = cfg->param_area;
  if (D.53097 != 0) goto <D.53098>; else goto <D.53099>;
  <D.53098>:
  D.53024 = cfg->arch.omit_fp;
  if (D.53024 != 0) goto <D.53100>; else goto <D.53101>;
  <D.53100>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 6750);
  <D.53101>:
  D.53102 = cfg->stack_offset;
  D.53103 = (unsigned int) D.53102;
  D.53097 = cfg->param_area;
  D.53104 = D.53097 + 7;
  D.53105 = D.53104 & 4294967288;
  D.53106 = D.53103 + D.53105;
  D.53107 = (int) D.53106;
  cfg->stack_offset = D.53107;
  <D.53099>:
  <D.53096>:
  D.53024 = cfg->arch.omit_fp;
  if (D.53024 != 0) goto <D.53108>; else goto <D.53109>;
  <D.53108>:
  D.53102 = cfg->stack_offset;
  D.53103 = (unsigned int) D.53102;
  D.53110 = D.53103 + 7;
  D.53111 = (int) D.53110;
  alloc_size = D.53111 & -8;
  alloc_size.8437 = (unsigned int) alloc_size;
  D.53113 = alloc_size.8437 & 15;
  if (D.53113 == 0) goto <D.53114>; else goto <D.53115>;
  <D.53114>:
  alloc_size = alloc_size + 8;
  cfa_offset.8438 = (unsigned int) cfa_offset;
  D.53117 = 4294967288 - cfa_offset.8438;
  D.53118 = (int) D.53117;
  mini_gc_set_slot_type_from_cfa (cfg, D.53118, 0);
  <D.53115>:
  goto <D.53119>;
  <D.53109>:
  D.53102 = cfg->stack_offset;
  D.53103 = (unsigned int) D.53102;
  D.53120 = D.53103 + 15;
  D.53121 = (int) D.53120;
  alloc_size = D.53121 & -16;
  D.53102 = cfg->stack_offset;
  if (D.53102 != alloc_size) goto <D.53122>; else goto <D.53123>;
  <D.53122>:
  D.53097 = cfg->param_area;
  alloc_size.8439 = (unsigned int) alloc_size;
  D.53125 = D.53097 - alloc_size.8439;
  D.53126 = (int) D.53125;
  mini_gc_set_slot_type_from_fp (cfg, D.53126, 0);
  <D.53123>:
  cfg->arch.sp_fp_offset = alloc_size;
  alloc_size = alloc_size - pos;
  <D.53119>:
  cfg->arch.stack_alloc_size = alloc_size;
  if (alloc_size != 0) goto <D.53127>; else goto <D.53128>;
  <D.53127>:
  {
    guint32 remaining_size;
    guint32 required_code_size;
    guint32 offset;

    remaining_size = (guint32) alloc_size;
    D.53129 = remaining_size / 4096;
    D.53130 = D.53129 + 1;
    required_code_size = D.53130 * 10;
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    offset = (guint32) D.52990;
    D.52978 = cfg->code_size;
    D.53131 = D.52978 - offset;
    D.53132 = D.53131 <= required_code_size;
    D.53133 = (long int) D.53132;
    D.53134 = __builtin_expect (D.53133, 0);
    if (D.53134 != 0) goto <D.53135>; else goto <D.53136>;
    <D.53135>:
    goto <D.28010>;
    <D.28009>:
    D.52978 = cfg->code_size;
    D.53137 = D.52978 * 2;
    cfg->code_size = D.53137;
    <D.28010>:
    D.52978 = cfg->code_size;
    D.53131 = D.52978 - offset;
    if (D.53131 <= required_code_size) goto <D.28009>; else goto <D.28011>;
    <D.28011>:
    D.53138 = mono_realloc_native_code (cfg);
    cfg->native_code = D.53138;
    D.52988 = cfg->native_code;
    D.53139 = (sizetype) offset;
    code = D.52988 + D.53139;
    D.53140 = cfg->stat_code_reallocs;
    D.53141 = D.53140 + 1;
    cfg->stat_code_reallocs = D.53141;
    <D.53136>:
    goto <D.28030>;
    <D.28029>:
    if (0 != 0) goto <D.53142>; else goto <D.53143>;
    <D.53142>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53144>; else goto <D.53145>;
      <D.53144>:
      code.8440 = code;
      code = code.8440 + 1;
      D.53147 = _amd64_rex_bits | 64;
      *code.8440 = D.53147;
      <D.53145>:
    }
    code.8441 = code;
    code = code.8441 + 1;
    *code.8441 = 131;
    code.8442 = code;
    code = code.8442 + 1;
    *code.8442 = 236;
    *code = 0;
    code = code + 1;
    goto <D.53150>;
    <D.53143>:
    if (0 != 0) goto <D.53151>; else goto <D.53152>;
    <D.53151>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53153>; else goto <D.53154>;
      <D.53153>:
      code.8443 = code;
      code = code.8443 + 1;
      D.53156 = _amd64_rex_bits | 64;
      *code.8443 = D.53156;
      <D.53154>:
    }
    code.8444 = code;
    code = code.8444 + 1;
    *code.8444 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 4096;
          code.8445 = code;
          code = code.8445 + 1;
          D.53159 = imb.b[0];
          *code.8445 = D.53159;
          code.8446 = code;
          code = code.8446 + 1;
          D.53161 = imb.b[1];
          *code.8446 = D.53161;
          code.8447 = code;
          code = code.8447 + 1;
          D.53163 = imb.b[2];
          *code.8447 = D.53163;
          code.8448 = code;
          code = code.8448 + 1;
          D.53165 = imb.b[3];
          *code.8448 = D.53165;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.53166>;
    <D.53152>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53167>; else goto <D.53168>;
      <D.53167>:
      code.8449 = code;
      code = code.8449 + 1;
      D.53170 = _amd64_rex_bits | 64;
      *code.8449 = D.53170;
      <D.53168>:
    }
    code.8450 = code;
    code = code.8450 + 1;
    *code.8450 = 129;
    code.8451 = code;
    code = code.8451 + 1;
    *code.8451 = 236;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 4096;
          code.8452 = code;
          code = code.8452 + 1;
          D.53174 = imb.b[0];
          *code.8452 = D.53174;
          code.8453 = code;
          code = code.8453 + 1;
          D.53176 = imb.b[1];
          *code.8453 = D.53176;
          code.8454 = code;
          code = code.8454 + 1;
          D.53178 = imb.b[2];
          *code.8454 = D.53178;
          code.8455 = code;
          code = code.8455 + 1;
          D.53180 = imb.b[3];
          *code.8455 = D.53180;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53166>:
    <D.53150>:
    D.53024 = cfg->arch.omit_fp;
    if (D.53024 != 0) goto <D.53181>; else goto <D.53182>;
    <D.53181>:
    cfa_offset = cfa_offset + 4096;
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    mono_emit_unwind_op (cfg, D.52991, 14, 0, cfa_offset);
    cfg->cfa_offset = cfa_offset;
    <D.53182>:
    mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
    if (mono_inject_async_exc_method.8398 != 0B) goto <D.53183>; else goto <D.53184>;
    <D.53183>:
    D.52996 = cfg->method;
    mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
    D.53185 = mono_method_desc_full_match (mono_inject_async_exc_method.8398, D.52996);
    if (D.53185 != 0) goto <D.53186>; else goto <D.53187>;
    <D.53186>:
    D.53000 = cfg->arch.async_point_count;
    mono_inject_async_exc_pos.8399 = mono_inject_async_exc_pos;
    if (D.53000 == mono_inject_async_exc_pos.8399) goto <D.53188>; else goto <D.53189>;
    <D.53188>:
    if (0 != 0) goto <D.53190>; else goto <D.53191>;
    <D.53190>:
    code.8456 = code;
    code = code.8456 + 1;
    *code.8456 = 102;
    <D.53191>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.53193>; else goto <D.53194>;
      <D.53193>:
      code.8457 = code;
      code = code.8457 + 1;
      D.53196 = _amd64_rex_bits | 64;
      *code.8457 = D.53196;
      <D.53194>:
    }
    switch (4) <default: <D.28023>, case 1: <D.28018>, case 2: <D.28020>, case 4: <D.28021>, case 8: <D.28022>>
    <D.28018>:
    code.8458 = code;
    code = code.8458 + 1;
    *code.8458 = 138;
    goto <D.28019>;
    <D.28020>:
    <D.28021>:
    <D.28022>:
    code.8459 = code;
    code = code.8459 + 1;
    *code.8459 = 139;
    goto <D.28019>;
    <D.28023>:
    __assert_fail ("0", "mini-amd64.c", 6800, &__PRETTY_FUNCTION__);
    <D.28019>:
    code.8460 = code;
    code = code.8460 + 1;
    *code.8460 = 4;
    code.8461 = code;
    code = code.8461 + 1;
    *code.8461 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8462 = code;
          code = code.8462 + 1;
          D.53202 = imb.b[0];
          *code.8462 = D.53202;
          code.8463 = code;
          code = code.8463 + 1;
          D.53204 = imb.b[1];
          *code.8463 = D.53204;
          code.8464 = code;
          code = code.8464 + 1;
          D.53206 = imb.b[2];
          *code.8464 = D.53206;
          code.8465 = code;
          code = code.8465 + 1;
          D.53208 = imb.b[3];
          *code.8465 = D.53208;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53189>:
    D.53000 = cfg->arch.async_point_count;
    D.53023 = D.53000 + 1;
    cfg->arch.async_point_count = D.53023;
    <D.53187>:
    <D.53184>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53209>; else goto <D.53210>;
      <D.53209>:
      code.8466 = code;
      code = code.8466 + 1;
      D.53212 = _amd64_rex_bits | 64;
      *code.8466 = D.53212;
      <D.53210>:
    }
    code.8467 = code;
    code = code.8467 + 1;
    *code.8467 = 133;
    if (1 != 0) goto <D.53214>; else goto <D.53215>;
    <D.53214>:
    if (1 != 0) goto <D.53216>; else goto <D.53217>;
    <D.53216>:
    code.8468 = code;
    code = code.8468 + 1;
    *code.8468 = 36;
    code.8469 = code;
    code = code.8469 + 1;
    *code.8469 = 36;
    goto <D.53220>;
    <D.53217>:
    if (1 != 0) goto <D.53221>; else goto <D.53222>;
    <D.53221>:
    code.8470 = code;
    code = code.8470 + 1;
    *code.8470 = 100;
    code.8471 = code;
    code = code.8471 + 1;
    *code.8471 = 36;
    *code = 0;
    code = code + 1;
    goto <D.53225>;
    <D.53222>:
    code.8472 = code;
    code = code.8472 + 1;
    *code.8472 = 164;
    code.8473 = code;
    code = code.8473 + 1;
    *code.8473 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8474 = code;
          code = code.8474 + 1;
          D.53229 = imb.b[0];
          *code.8474 = D.53229;
          code.8475 = code;
          code = code.8475 + 1;
          D.53231 = imb.b[1];
          *code.8475 = D.53231;
          code.8476 = code;
          code = code.8476 + 1;
          D.53233 = imb.b[2];
          *code.8476 = D.53233;
          code.8477 = code;
          code = code.8477 + 1;
          D.53235 = imb.b[3];
          *code.8477 = D.53235;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53225>:
    <D.53220>:
    goto <D.28027>;
    <D.53215>:
    if (1 != 0) goto <D.53236>; else goto <D.53237>;
    <D.53236>:
    code.8478 = code;
    code = code.8478 + 1;
    *code.8478 = 36;
    goto <D.28027>;
    <D.53237>:
    if (1 != 0) goto <D.53239>; else goto <D.53240>;
    <D.53239>:
    code.8479 = code;
    code = code.8479 + 1;
    *code.8479 = 100;
    *code = 0;
    code = code + 1;
    goto <D.53242>;
    <D.53240>:
    code.8480 = code;
    code = code.8480 + 1;
    *code.8480 = 164;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8481 = code;
          code = code.8481 + 1;
          D.53245 = imb.b[0];
          *code.8481 = D.53245;
          code.8482 = code;
          code = code.8482 + 1;
          D.53247 = imb.b[1];
          *code.8482 = D.53247;
          code.8483 = code;
          code = code.8483 + 1;
          D.53249 = imb.b[2];
          *code.8483 = D.53249;
          code.8484 = code;
          code = code.8484 + 1;
          D.53251 = imb.b[3];
          *code.8484 = D.53251;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53242>:
    <D.28027>:
    remaining_size = remaining_size + 4294963200;
    <D.28030>:
    if (remaining_size > 4095) goto <D.28029>; else goto <D.28031>;
    <D.28031>:
    if (remaining_size != 0) goto <D.53252>; else goto <D.53253>;
    <D.53252>:
    remaining_size.8485 = (int) remaining_size;
    D.53255 = remaining_size.8485 >= -128;
    remaining_size.8485 = (int) remaining_size;
    D.53256 = remaining_size.8485 <= 127;
    D.53257 = D.53255 & D.53256;
    if (D.53257 != 0) goto <D.53258>; else goto <D.53259>;
    <D.53258>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53260>; else goto <D.53261>;
      <D.53260>:
      code.8486 = code;
      code = code.8486 + 1;
      D.53263 = _amd64_rex_bits | 64;
      *code.8486 = D.53263;
      <D.53261>:
    }
    code.8487 = code;
    code = code.8487 + 1;
    *code.8487 = 131;
    code.8488 = code;
    code = code.8488 + 1;
    *code.8488 = 236;
    D.53266 = (unsigned char) remaining_size;
    *code = D.53266;
    code = code + 1;
    goto <D.53267>;
    <D.53259>:
    if (0 != 0) goto <D.53268>; else goto <D.53269>;
    <D.53268>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53270>; else goto <D.53271>;
      <D.53270>:
      code.8489 = code;
      code = code.8489 + 1;
      D.53273 = _amd64_rex_bits | 64;
      *code.8489 = D.53273;
      <D.53271>:
    }
    code.8490 = code;
    code = code.8490 + 1;
    *code.8490 = 45;
    {
      union x86_imm_buf imb;

      try
        {
          remaining_size.8485 = (int) remaining_size;
          imb.val = remaining_size.8485;
          code.8491 = code;
          code = code.8491 + 1;
          D.53276 = imb.b[0];
          *code.8491 = D.53276;
          code.8492 = code;
          code = code.8492 + 1;
          D.53278 = imb.b[1];
          *code.8492 = D.53278;
          code.8493 = code;
          code = code.8493 + 1;
          D.53280 = imb.b[2];
          *code.8493 = D.53280;
          code.8494 = code;
          code = code.8494 + 1;
          D.53282 = imb.b[3];
          *code.8494 = D.53282;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.53283>;
    <D.53269>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.53284>; else goto <D.53285>;
      <D.53284>:
      code.8495 = code;
      code = code.8495 + 1;
      D.53287 = _amd64_rex_bits | 64;
      *code.8495 = D.53287;
      <D.53285>:
    }
    code.8496 = code;
    code = code.8496 + 1;
    *code.8496 = 129;
    code.8497 = code;
    code = code.8497 + 1;
    *code.8497 = 236;
    {
      union x86_imm_buf imb;

      try
        {
          remaining_size.8485 = (int) remaining_size;
          imb.val = remaining_size.8485;
          code.8498 = code;
          code = code.8498 + 1;
          D.53291 = imb.b[0];
          *code.8498 = D.53291;
          code.8499 = code;
          code = code.8499 + 1;
          D.53293 = imb.b[1];
          *code.8499 = D.53293;
          code.8500 = code;
          code = code.8500 + 1;
          D.53295 = imb.b[2];
          *code.8500 = D.53295;
          code.8501 = code;
          code = code.8501 + 1;
          D.53297 = imb.b[3];
          *code.8501 = D.53297;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53283>:
    <D.53267>:
    D.53024 = cfg->arch.omit_fp;
    if (D.53024 != 0) goto <D.53298>; else goto <D.53299>;
    <D.53298>:
    cfa_offset.8502 = (unsigned int) cfa_offset;
    D.53301 = cfa_offset.8502 + remaining_size;
    cfa_offset = (int) D.53301;
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    mono_emit_unwind_op (cfg, D.52991, 14, 0, cfa_offset);
    cfg->cfa_offset = cfa_offset;
    mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
    if (mono_inject_async_exc_method.8398 != 0B) goto <D.53302>; else goto <D.53303>;
    <D.53302>:
    D.52996 = cfg->method;
    mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
    D.53304 = mono_method_desc_full_match (mono_inject_async_exc_method.8398, D.52996);
    if (D.53304 != 0) goto <D.53305>; else goto <D.53306>;
    <D.53305>:
    D.53000 = cfg->arch.async_point_count;
    mono_inject_async_exc_pos.8399 = mono_inject_async_exc_pos;
    if (D.53000 == mono_inject_async_exc_pos.8399) goto <D.53307>; else goto <D.53308>;
    <D.53307>:
    if (0 != 0) goto <D.53309>; else goto <D.53310>;
    <D.53309>:
    code.8503 = code;
    code = code.8503 + 1;
    *code.8503 = 102;
    <D.53310>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.53312>; else goto <D.53313>;
      <D.53312>:
      code.8504 = code;
      code = code.8504 + 1;
      D.53315 = _amd64_rex_bits | 64;
      *code.8504 = D.53315;
      <D.53313>:
    }
    switch (4) <default: <D.28043>, case 1: <D.28038>, case 2: <D.28040>, case 4: <D.28041>, case 8: <D.28042>>
    <D.28038>:
    code.8505 = code;
    code = code.8505 + 1;
    *code.8505 = 138;
    goto <D.28039>;
    <D.28040>:
    <D.28041>:
    <D.28042>:
    code.8506 = code;
    code = code.8506 + 1;
    *code.8506 = 139;
    goto <D.28039>;
    <D.28043>:
    __assert_fail ("0", "mini-amd64.c", 6814, &__PRETTY_FUNCTION__);
    <D.28039>:
    code.8507 = code;
    code = code.8507 + 1;
    *code.8507 = 4;
    code.8508 = code;
    code = code.8508 + 1;
    *code.8508 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8509 = code;
          code = code.8509 + 1;
          D.53321 = imb.b[0];
          *code.8509 = D.53321;
          code.8510 = code;
          code = code.8510 + 1;
          D.53323 = imb.b[1];
          *code.8510 = D.53323;
          code.8511 = code;
          code = code.8511 + 1;
          D.53325 = imb.b[2];
          *code.8511 = D.53325;
          code.8512 = code;
          code = code.8512 + 1;
          D.53327 = imb.b[3];
          *code.8512 = D.53327;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53308>:
    D.53000 = cfg->arch.async_point_count;
    D.53023 = D.53000 + 1;
    cfg->arch.async_point_count = D.53023;
    <D.53306>:
    <D.53303>:
    <D.53299>:
    <D.53253>:
  }
  <D.53128>:
  D.53328 = mini_get_debug_options ();
  D.53329 = D.53328->init_stacks;
  if (D.53329 != 0) goto <D.53330>; else goto <D.53331>;
  <D.53330>:
  if (0 != 0) goto <D.53332>; else goto <D.53333>;
  <D.53332>:
  code.8513 = code;
  code = code.8513 + 1;
  *code.8513 = 102;
  <D.53333>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53335>; else goto <D.53336>;
    <D.53335>:
    code.8514 = code;
    code = code.8514 + 1;
    D.53338 = _amd64_rex_bits | 64;
    *code.8514 = D.53338;
    <D.53336>:
  }
  switch (8) <default: <D.28051>, case 1: <D.28046>, case 2: <D.28048>, case 4: <D.28049>, case 8: <D.28050>>
  <D.28046>:
  code.8515 = code;
  code = code.8515 + 1;
  *code.8515 = 136;
  goto <D.28047>;
  <D.28048>:
  <D.28049>:
  <D.28050>:
  code.8516 = code;
  code = code.8516 + 1;
  *code.8516 = 137;
  goto <D.28047>;
  <D.28051>:
  __assert_fail ("0", "mini-amd64.c", 6847, &__PRETTY_FUNCTION__);
  <D.28047>:
  if (1 != 0) goto <D.53341>; else goto <D.53342>;
  <D.53341>:
  if (0 != 0) goto <D.53343>; else goto <D.53344>;
  <D.53343>:
  code.8517 = code;
  code = code.8517 + 1;
  *code.8517 = 60;
  code.8518 = code;
  code = code.8518 + 1;
  *code.8518 = 36;
  goto <D.53347>;
  <D.53344>:
  if (1 != 0) goto <D.53348>; else goto <D.53349>;
  <D.53348>:
  code.8519 = code;
  code = code.8519 + 1;
  *code.8519 = 124;
  code.8520 = code;
  code = code.8520 + 1;
  *code.8520 = 36;
  *code = 248;
  code = code + 1;
  goto <D.53352>;
  <D.53349>:
  code.8521 = code;
  code = code.8521 + 1;
  *code.8521 = 188;
  code.8522 = code;
  code = code.8522 + 1;
  *code.8522 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8523 = code;
        code = code.8523 + 1;
        D.53356 = imb.b[0];
        *code.8523 = D.53356;
        code.8524 = code;
        code = code.8524 + 1;
        D.53358 = imb.b[1];
        *code.8524 = D.53358;
        code.8525 = code;
        code = code.8525 + 1;
        D.53360 = imb.b[2];
        *code.8525 = D.53360;
        code.8526 = code;
        code = code.8526 + 1;
        D.53362 = imb.b[3];
        *code.8526 = D.53362;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53352>:
  <D.53347>:
  goto <D.28053>;
  <D.53342>:
  if (0 != 0) goto <D.53363>; else goto <D.53364>;
  <D.53363>:
  code.8527 = code;
  code = code.8527 + 1;
  *code.8527 = 60;
  goto <D.28053>;
  <D.53364>:
  if (1 != 0) goto <D.53366>; else goto <D.53367>;
  <D.53366>:
  code.8528 = code;
  code = code.8528 + 1;
  *code.8528 = 124;
  *code = 248;
  code = code + 1;
  goto <D.53369>;
  <D.53367>:
  code.8529 = code;
  code = code.8529 + 1;
  *code.8529 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8530 = code;
        code = code.8530 + 1;
        D.53372 = imb.b[0];
        *code.8530 = D.53372;
        code.8531 = code;
        code = code.8531 + 1;
        D.53374 = imb.b[1];
        *code.8531 = D.53374;
        code.8532 = code;
        code = code.8532 + 1;
        D.53376 = imb.b[2];
        *code.8532 = D.53376;
        code.8533 = code;
        code = code.8533 + 1;
        D.53378 = imb.b[3];
        *code.8533 = D.53378;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53369>:
  <D.28053>:
  if (0 != 0) goto <D.53379>; else goto <D.53380>;
  <D.53379>:
  code.8534 = code;
  code = code.8534 + 1;
  *code.8534 = 102;
  <D.53380>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53382>; else goto <D.53383>;
    <D.53382>:
    code.8535 = code;
    code = code.8535 + 1;
    D.53385 = _amd64_rex_bits | 64;
    *code.8535 = D.53385;
    <D.53383>:
  }
  switch (8) <default: <D.28061>, case 1: <D.28056>, case 2: <D.28058>, case 4: <D.28059>, case 8: <D.28060>>
  <D.28056>:
  code.8536 = code;
  code = code.8536 + 1;
  *code.8536 = 136;
  goto <D.28057>;
  <D.28058>:
  <D.28059>:
  <D.28060>:
  code.8537 = code;
  code = code.8537 + 1;
  *code.8537 = 137;
  goto <D.28057>;
  <D.28061>:
  __assert_fail ("0", "mini-amd64.c", 6848, &__PRETTY_FUNCTION__);
  <D.28057>:
  if (1 != 0) goto <D.53388>; else goto <D.53389>;
  <D.53388>:
  if (0 != 0) goto <D.53390>; else goto <D.53391>;
  <D.53390>:
  code.8538 = code;
  code = code.8538 + 1;
  *code.8538 = 12;
  code.8539 = code;
  code = code.8539 + 1;
  *code.8539 = 36;
  goto <D.53394>;
  <D.53391>:
  if (1 != 0) goto <D.53395>; else goto <D.53396>;
  <D.53395>:
  code.8540 = code;
  code = code.8540 + 1;
  *code.8540 = 76;
  code.8541 = code;
  code = code.8541 + 1;
  *code.8541 = 36;
  *code = 240;
  code = code + 1;
  goto <D.53399>;
  <D.53396>:
  code.8542 = code;
  code = code.8542 + 1;
  *code.8542 = 140;
  code.8543 = code;
  code = code.8543 + 1;
  *code.8543 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.8544 = code;
        code = code.8544 + 1;
        D.53403 = imb.b[0];
        *code.8544 = D.53403;
        code.8545 = code;
        code = code.8545 + 1;
        D.53405 = imb.b[1];
        *code.8545 = D.53405;
        code.8546 = code;
        code = code.8546 + 1;
        D.53407 = imb.b[2];
        *code.8546 = D.53407;
        code.8547 = code;
        code = code.8547 + 1;
        D.53409 = imb.b[3];
        *code.8547 = D.53409;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53399>:
  <D.53394>:
  goto <D.28063>;
  <D.53389>:
  if (0 != 0) goto <D.53410>; else goto <D.53411>;
  <D.53410>:
  code.8548 = code;
  code = code.8548 + 1;
  *code.8548 = 12;
  goto <D.28063>;
  <D.53411>:
  if (1 != 0) goto <D.53413>; else goto <D.53414>;
  <D.53413>:
  code.8549 = code;
  code = code.8549 + 1;
  *code.8549 = 76;
  *code = 240;
  code = code + 1;
  goto <D.53416>;
  <D.53414>:
  code.8550 = code;
  code = code.8550 + 1;
  *code.8550 = 140;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.8551 = code;
        code = code.8551 + 1;
        D.53419 = imb.b[0];
        *code.8551 = D.53419;
        code.8552 = code;
        code = code.8552 + 1;
        D.53421 = imb.b[1];
        *code.8552 = D.53421;
        code.8553 = code;
        code = code.8553 + 1;
        D.53423 = imb.b[2];
        *code.8553 = D.53423;
        code.8554 = code;
        code = code.8554 + 1;
        D.53425 = imb.b[3];
        *code.8554 = D.53425;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53416>:
  <D.28063>:
  {
    int _amd64_width_temp;

    _amd64_width_temp = 0;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.53427>; else goto <D.53428>;
      <D.53427>:
      iftmp.8555 = 8;
      goto <D.53429>;
      <D.53428>:
      iftmp.8555 = 0;
      <D.53429>:
      _amd64_rex_bits = iftmp.8555;
      if (_amd64_rex_bits != 0) goto <D.53430>; else goto <D.53431>;
      <D.53430>:
      code.8556 = code;
      code = code.8556 + 1;
      D.53433 = _amd64_rex_bits | 64;
      *code.8556 = D.53433;
      <D.53431>:
    }
    code.8557 = code;
    code = code.8557 + 1;
    *code.8557 = 184;
    if (_amd64_width_temp == 0) goto <D.53435>; else goto <D.53436>;
    <D.53435>:
    {
      union amd64_imm_buf imb;

      try
        {
          imb.val = 3038287259199220266;
          code.8558 = code;
          code = code.8558 + 1;
          D.53438 = imb.b[0];
          *code.8558 = D.53438;
          code.8559 = code;
          code = code.8559 + 1;
          D.53440 = imb.b[1];
          *code.8559 = D.53440;
          code.8560 = code;
          code = code.8560 + 1;
          D.53442 = imb.b[2];
          *code.8560 = D.53442;
          code.8561 = code;
          code = code.8561 + 1;
          D.53444 = imb.b[3];
          *code.8561 = D.53444;
          code.8562 = code;
          code = code.8562 + 1;
          D.53446 = imb.b[4];
          *code.8562 = D.53446;
          code.8563 = code;
          code = code.8563 + 1;
          D.53448 = imb.b[5];
          *code.8563 = D.53448;
          code.8564 = code;
          code = code.8564 + 1;
          D.53450 = imb.b[6];
          *code.8564 = D.53450;
          code.8565 = code;
          code = code.8565 + 1;
          D.53452 = imb.b[7];
          *code.8565 = D.53452;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.53453>;
    <D.53436>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 707406378;
          code.8566 = code;
          code = code.8566 + 1;
          D.53455 = imb.b[0];
          *code.8566 = D.53455;
          code.8567 = code;
          code = code.8567 + 1;
          D.53457 = imb.b[1];
          *code.8567 = D.53457;
          code.8568 = code;
          code = code.8568 + 1;
          D.53459 = imb.b[2];
          *code.8568 = D.53459;
          code.8569 = code;
          code = code.8569 + 1;
          D.53461 = imb.b[3];
          *code.8569 = D.53461;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53453>:
  }
  {
    int _amd64_width_temp;

    _amd64_width_temp = 1;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.53463>; else goto <D.53464>;
      <D.53463>:
      iftmp.8570 = 8;
      goto <D.53465>;
      <D.53464>:
      iftmp.8570 = 0;
      <D.53465>:
      _amd64_rex_bits = iftmp.8570;
      if (_amd64_rex_bits != 0) goto <D.53466>; else goto <D.53467>;
      <D.53466>:
      code.8571 = code;
      code = code.8571 + 1;
      D.53469 = _amd64_rex_bits | 64;
      *code.8571 = D.53469;
      <D.53467>:
    }
    code.8572 = code;
    code = code.8572 + 1;
    *code.8572 = 185;
    if (_amd64_width_temp == 0) goto <D.53471>; else goto <D.53472>;
    <D.53471>:
    {
      union amd64_imm_buf imb;

      try
        {
          D.53473 = alloc_size / 8;
          D.53474 = (long unsigned int) D.53473;
          imb.val = D.53474;
          code.8573 = code;
          code = code.8573 + 1;
          D.53476 = imb.b[0];
          *code.8573 = D.53476;
          code.8574 = code;
          code = code.8574 + 1;
          D.53478 = imb.b[1];
          *code.8574 = D.53478;
          code.8575 = code;
          code = code.8575 + 1;
          D.53480 = imb.b[2];
          *code.8575 = D.53480;
          code.8576 = code;
          code = code.8576 + 1;
          D.53482 = imb.b[3];
          *code.8576 = D.53482;
          code.8577 = code;
          code = code.8577 + 1;
          D.53484 = imb.b[4];
          *code.8577 = D.53484;
          code.8578 = code;
          code = code.8578 + 1;
          D.53486 = imb.b[5];
          *code.8578 = D.53486;
          code.8579 = code;
          code = code.8579 + 1;
          D.53488 = imb.b[6];
          *code.8579 = D.53488;
          code.8580 = code;
          code = code.8580 + 1;
          D.53490 = imb.b[7];
          *code.8580 = D.53490;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.53491>;
    <D.53472>:
    {
      union x86_imm_buf imb;

      try
        {
          D.53473 = alloc_size / 8;
          imb.val = D.53473;
          code.8581 = code;
          code = code.8581 + 1;
          D.53493 = imb.b[0];
          *code.8581 = D.53493;
          code.8582 = code;
          code = code.8582 + 1;
          D.53495 = imb.b[1];
          *code.8582 = D.53495;
          code.8583 = code;
          code = code.8583 + 1;
          D.53497 = imb.b[2];
          *code.8583 = D.53497;
          code.8584 = code;
          code = code.8584 + 1;
          D.53499 = imb.b[3];
          *code.8584 = D.53499;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53491>:
  }
  if (0 != 0) goto <D.53500>; else goto <D.53501>;
  <D.53500>:
  code.8585 = code;
  code = code.8585 + 1;
  *code.8585 = 102;
  <D.53501>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53503>; else goto <D.53504>;
    <D.53503>:
    code.8586 = code;
    code = code.8586 + 1;
    D.53506 = _amd64_rex_bits | 64;
    *code.8586 = D.53506;
    <D.53504>:
  }
  switch (8) <default: <D.28079>, case 1: <D.28074>, case 2: <D.28076>, case 4: <D.28077>, case 8: <D.28078>>
  <D.28074>:
  code.8587 = code;
  code = code.8587 + 1;
  *code.8587 = 138;
  goto <D.28075>;
  <D.28076>:
  <D.28077>:
  <D.28078>:
  code.8588 = code;
  code = code.8588 + 1;
  *code.8588 = 139;
  goto <D.28075>;
  <D.28079>:
  __assert_fail ("0", "mini-amd64.c", 6852, &__PRETTY_FUNCTION__);
  <D.28075>:
  code.8589 = code;
  code = code.8589 + 1;
  *code.8589 = 252;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.53510>; else goto <D.53511>;
    <D.53510>:
    code.8590 = code;
    code = code.8590 + 1;
    D.53513 = _amd64_rex_bits | 64;
    *code.8590 = D.53513;
    <D.53511>:
  }
  code.8591 = code;
  code = code.8591 + 1;
  *code.8591 = 252;
  code.8592 = code;
  code = code.8592 + 1;
  *code.8592 = 243;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53516>; else goto <D.53517>;
    <D.53516>:
    code.8593 = code;
    code = code.8593 + 1;
    D.53519 = _amd64_rex_bits | 64;
    *code.8593 = D.53519;
    <D.53517>:
  }
  code.8594 = code;
  code = code.8594 + 1;
  *code.8594 = 171;
  if (0 != 0) goto <D.53521>; else goto <D.53522>;
  <D.53521>:
  code.8595 = code;
  code = code.8595 + 1;
  *code.8595 = 102;
  <D.53522>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53524>; else goto <D.53525>;
    <D.53524>:
    code.8596 = code;
    code = code.8596 + 1;
    D.53527 = _amd64_rex_bits | 64;
    *code.8596 = D.53527;
    <D.53525>:
  }
  switch (8) <default: <D.28088>, case 1: <D.28083>, case 2: <D.28085>, case 4: <D.28086>, case 8: <D.28087>>
  <D.28083>:
  code.8597 = code;
  code = code.8597 + 1;
  *code.8597 = 138;
  goto <D.28084>;
  <D.28085>:
  <D.28086>:
  <D.28087>:
  code.8598 = code;
  code = code.8598 + 1;
  *code.8598 = 139;
  goto <D.28084>;
  <D.28088>:
  __assert_fail ("0", "mini-amd64.c", 6870, &__PRETTY_FUNCTION__);
  <D.28084>:
  if (0 != 0) goto <D.53530>; else goto <D.53531>;
  <D.53530>:
  code.8599 = code;
  code = code.8599 + 1;
  *code.8599 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8600 = code;
        code = code.8600 + 1;
        D.53534 = imb.b[0];
        *code.8600 = D.53534;
        code.8601 = code;
        code = code.8601 + 1;
        D.53536 = imb.b[1];
        *code.8601 = D.53536;
        code.8602 = code;
        code = code.8602 + 1;
        D.53538 = imb.b[2];
        *code.8602 = D.53538;
        code.8603 = code;
        code = code.8603 + 1;
        D.53540 = imb.b[3];
        *code.8603 = D.53540;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.53541>;
  <D.53531>:
  if (1 != 0) goto <D.53542>; else goto <D.53543>;
  <D.53542>:
  if (0 != 0) goto <D.53544>; else goto <D.53545>;
  <D.53544>:
  code.8604 = code;
  code = code.8604 + 1;
  *code.8604 = 60;
  code.8605 = code;
  code = code.8605 + 1;
  *code.8605 = 36;
  goto <D.53548>;
  <D.53545>:
  if (1 != 0) goto <D.53549>; else goto <D.53550>;
  <D.53549>:
  code.8606 = code;
  code = code.8606 + 1;
  *code.8606 = 124;
  code.8607 = code;
  code = code.8607 + 1;
  *code.8607 = 36;
  *code = 248;
  code = code + 1;
  goto <D.53553>;
  <D.53550>:
  code.8608 = code;
  code = code.8608 + 1;
  *code.8608 = 188;
  code.8609 = code;
  code = code.8609 + 1;
  *code.8609 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8610 = code;
        code = code.8610 + 1;
        D.53557 = imb.b[0];
        *code.8610 = D.53557;
        code.8611 = code;
        code = code.8611 + 1;
        D.53559 = imb.b[1];
        *code.8611 = D.53559;
        code.8612 = code;
        code = code.8612 + 1;
        D.53561 = imb.b[2];
        *code.8612 = D.53561;
        code.8613 = code;
        code = code.8613 + 1;
        D.53563 = imb.b[3];
        *code.8613 = D.53563;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53553>:
  <D.53548>:
  goto <D.28091>;
  <D.53543>:
  if (0 != 0) goto <D.53564>; else goto <D.53565>;
  <D.53564>:
  code.8614 = code;
  code = code.8614 + 1;
  *code.8614 = 60;
  goto <D.28091>;
  <D.53565>:
  if (1 != 0) goto <D.53567>; else goto <D.53568>;
  <D.53567>:
  code.8615 = code;
  code = code.8615 + 1;
  *code.8615 = 124;
  *code = 248;
  code = code + 1;
  goto <D.53570>;
  <D.53568>:
  code.8616 = code;
  code = code.8616 + 1;
  *code.8616 = 188;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -8;
        code.8617 = code;
        code = code.8617 + 1;
        D.53573 = imb.b[0];
        *code.8617 = D.53573;
        code.8618 = code;
        code = code.8618 + 1;
        D.53575 = imb.b[1];
        *code.8618 = D.53575;
        code.8619 = code;
        code = code.8619 + 1;
        D.53577 = imb.b[2];
        *code.8619 = D.53577;
        code.8620 = code;
        code = code.8620 + 1;
        D.53579 = imb.b[3];
        *code.8620 = D.53579;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53570>:
  <D.28091>:
  <D.53541>:
  if (0 != 0) goto <D.53580>; else goto <D.53581>;
  <D.53580>:
  code.8621 = code;
  code = code.8621 + 1;
  *code.8621 = 102;
  <D.53581>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.53583>; else goto <D.53584>;
    <D.53583>:
    code.8622 = code;
    code = code.8622 + 1;
    D.53586 = _amd64_rex_bits | 64;
    *code.8622 = D.53586;
    <D.53584>:
  }
  switch (8) <default: <D.28099>, case 1: <D.28094>, case 2: <D.28096>, case 4: <D.28097>, case 8: <D.28098>>
  <D.28094>:
  code.8623 = code;
  code = code.8623 + 1;
  *code.8623 = 138;
  goto <D.28095>;
  <D.28096>:
  <D.28097>:
  <D.28098>:
  code.8624 = code;
  code = code.8624 + 1;
  *code.8624 = 139;
  goto <D.28095>;
  <D.28099>:
  __assert_fail ("0", "mini-amd64.c", 6871, &__PRETTY_FUNCTION__);
  <D.28095>:
  if (0 != 0) goto <D.53589>; else goto <D.53590>;
  <D.53589>:
  code.8625 = code;
  code = code.8625 + 1;
  *code.8625 = 13;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.8626 = code;
        code = code.8626 + 1;
        D.53593 = imb.b[0];
        *code.8626 = D.53593;
        code.8627 = code;
        code = code.8627 + 1;
        D.53595 = imb.b[1];
        *code.8627 = D.53595;
        code.8628 = code;
        code = code.8628 + 1;
        D.53597 = imb.b[2];
        *code.8628 = D.53597;
        code.8629 = code;
        code = code.8629 + 1;
        D.53599 = imb.b[3];
        *code.8629 = D.53599;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.53600>;
  <D.53590>:
  if (1 != 0) goto <D.53601>; else goto <D.53602>;
  <D.53601>:
  if (0 != 0) goto <D.53603>; else goto <D.53604>;
  <D.53603>:
  code.8630 = code;
  code = code.8630 + 1;
  *code.8630 = 12;
  code.8631 = code;
  code = code.8631 + 1;
  *code.8631 = 36;
  goto <D.53607>;
  <D.53604>:
  if (1 != 0) goto <D.53608>; else goto <D.53609>;
  <D.53608>:
  code.8632 = code;
  code = code.8632 + 1;
  *code.8632 = 76;
  code.8633 = code;
  code = code.8633 + 1;
  *code.8633 = 36;
  *code = 240;
  code = code + 1;
  goto <D.53612>;
  <D.53609>:
  code.8634 = code;
  code = code.8634 + 1;
  *code.8634 = 140;
  code.8635 = code;
  code = code.8635 + 1;
  *code.8635 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.8636 = code;
        code = code.8636 + 1;
        D.53616 = imb.b[0];
        *code.8636 = D.53616;
        code.8637 = code;
        code = code.8637 + 1;
        D.53618 = imb.b[1];
        *code.8637 = D.53618;
        code.8638 = code;
        code = code.8638 + 1;
        D.53620 = imb.b[2];
        *code.8638 = D.53620;
        code.8639 = code;
        code = code.8639 + 1;
        D.53622 = imb.b[3];
        *code.8639 = D.53622;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53612>:
  <D.53607>:
  goto <D.28102>;
  <D.53602>:
  if (0 != 0) goto <D.53623>; else goto <D.53624>;
  <D.53623>:
  code.8640 = code;
  code = code.8640 + 1;
  *code.8640 = 12;
  goto <D.28102>;
  <D.53624>:
  if (1 != 0) goto <D.53626>; else goto <D.53627>;
  <D.53626>:
  code.8641 = code;
  code = code.8641 + 1;
  *code.8641 = 76;
  *code = 240;
  code = code + 1;
  goto <D.53629>;
  <D.53627>:
  code.8642 = code;
  code = code.8642 + 1;
  *code.8642 = 140;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = -16;
        code.8643 = code;
        code = code.8643 + 1;
        D.53632 = imb.b[0];
        *code.8643 = D.53632;
        code.8644 = code;
        code = code.8644 + 1;
        D.53634 = imb.b[1];
        *code.8644 = D.53634;
        code.8645 = code;
        code = code.8645 + 1;
        D.53636 = imb.b[2];
        *code.8645 = D.53636;
        code.8646 = code;
        code = code.8646 + 1;
        D.53638 = imb.b[3];
        *code.8646 = D.53638;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53629>:
  <D.28102>:
  <D.53600>:
  <D.53331>:
  D.53639 = BIT_FIELD_REF <*method, 8, 264>;
  D.53640 = D.53639 & 1;
  if (D.53640 != 0) goto <D.53641>; else goto <D.53642>;
  <D.53641>:
  D.53643 = lmf_var->data.op[0].const_val;
  D.53644 = (int) D.53643;
  code = emit_setup_lmf (cfg, code, D.53644, cfa_offset);
  <D.53642>:
  D.53639 = BIT_FIELD_REF <*method, 8, 264>;
  D.53640 = D.53639 & 1;
  if (D.53640 == 0) goto <D.53645>; else goto <D.53646>;
  <D.53645>:
  {
    gint32 save_area_offset;

    D.53024 = cfg->arch.omit_fp;
    if (D.53024 != 0) goto <D.53647>; else goto <D.53648>;
    <D.53647>:
    save_area_offset = cfg->arch.reg_save_area_offset;
    goto <D.53649>;
    <D.53648>:
    save_area_offset = cfg->arch.reg_save_area_offset;
    <D.53649>:
    i = 0;
    goto <D.28124>;
    <D.28123>:
    D.53650 = 61480 >> i;
    D.53651 = D.53650 & 1;
    if (D.53651 != 0) goto <D.53652>; else goto <D.53653>;
    <D.53652>:
    D.53654 = cfg->used_int_regs;
    D.53655 = 1 << i;
    D.53656 = (long unsigned int) D.53655;
    D.53657 = D.53654 & D.53656;
    if (D.53657 != 0) goto <D.53658>; else goto <D.53659>;
    <D.53658>:
    if (0 != 0) goto <D.53660>; else goto <D.53661>;
    <D.53660>:
    code.8647 = code;
    code = code.8647 + 1;
    *code.8647 = 102;
    <D.53661>:
    {
      unsigned char _amd64_rex_bits;

      if (i > 7) goto <D.53664>; else goto <D.53665>;
      <D.53664>:
      iftmp.8648 = 12;
      goto <D.53666>;
      <D.53665>:
      iftmp.8648 = 8;
      <D.53666>:
      D.53667 = cfg->frame_reg;
      D.53668 = D.53667 > 7;
      D.53669 = (signed char) D.53668;
      D.53670 = iftmp.8648 | D.53669;
      _amd64_rex_bits = (unsigned char) D.53670;
      if (_amd64_rex_bits != 0) goto <D.53671>; else goto <D.53672>;
      <D.53671>:
      code.8649 = code;
      code = code.8649 + 1;
      D.53674 = _amd64_rex_bits | 64;
      *code.8649 = D.53674;
      <D.53672>:
    }
    switch (8) <default: <D.28111>, case 1: <D.28106>, case 2: <D.28108>, case 4: <D.28109>, case 8: <D.28110>>
    <D.28106>:
    code.8650 = code;
    code = code.8650 + 1;
    *code.8650 = 136;
    goto <D.28107>;
    <D.28108>:
    <D.28109>:
    <D.28110>:
    code.8651 = code;
    code = code.8651 + 1;
    *code.8651 = 137;
    goto <D.28107>;
    <D.28111>:
    __assert_fail ("0", "mini-amd64.c", 6896, &__PRETTY_FUNCTION__);
    <D.28107>:
    D.53667 = cfg->frame_reg;
    D.53677 = D.53667 & 7;
    if (D.53677 == 4) goto <D.53678>; else goto <D.53679>;
    <D.53678>:
    if (save_area_offset == 0) goto <D.53680>; else goto <D.53681>;
    <D.53680>:
    code.8652 = code;
    code = code.8652 + 1;
    D.53683 = i & 7;
    D.53684 = D.53683 << 3;
    D.53685 = (signed char) D.53684;
    D.53686 = D.53685 | 4;
    D.53687 = (unsigned char) D.53686;
    *code.8652 = D.53687;
    code.8653 = code;
    code = code.8653 + 1;
    *code.8653 = 36;
    goto <D.53689>;
    <D.53681>:
    save_area_offset.8654 = (unsigned int) save_area_offset;
    D.53691 = save_area_offset.8654 + 128;
    if (D.53691 <= 255) goto <D.53692>; else goto <D.53693>;
    <D.53692>:
    code.8655 = code;
    code = code.8655 + 1;
    D.53683 = i & 7;
    D.53684 = D.53683 << 3;
    D.53685 = (signed char) D.53684;
    D.53695 = D.53685 | 68;
    D.53696 = (unsigned char) D.53695;
    *code.8655 = D.53696;
    code.8656 = code;
    code = code.8656 + 1;
    *code.8656 = 36;
    D.53698 = (unsigned char) save_area_offset;
    *code = D.53698;
    code = code + 1;
    goto <D.53699>;
    <D.53693>:
    code.8657 = code;
    code = code.8657 + 1;
    D.53683 = i & 7;
    D.53684 = D.53683 << 3;
    D.53685 = (signed char) D.53684;
    D.53701 = D.53685 | -124;
    D.53702 = (unsigned char) D.53701;
    *code.8657 = D.53702;
    code.8658 = code;
    code = code.8658 + 1;
    *code.8658 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.8659 = code;
          code = code.8659 + 1;
          D.53705 = imb.b[0];
          *code.8659 = D.53705;
          code.8660 = code;
          code = code.8660 + 1;
          D.53707 = imb.b[1];
          *code.8660 = D.53707;
          code.8661 = code;
          code = code.8661 + 1;
          D.53709 = imb.b[2];
          *code.8661 = D.53709;
          code.8662 = code;
          code = code.8662 + 1;
          D.53711 = imb.b[3];
          *code.8662 = D.53711;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53699>:
    <D.53689>:
    goto <D.28113>;
    <D.53679>:
    if (save_area_offset == 0) goto <D.53712>; else goto <D.53713>;
    <D.53712>:
    D.53667 = cfg->frame_reg;
    D.53677 = D.53667 & 7;
    if (D.53677 != 5) goto <D.53714>; else goto <D.53715>;
    <D.53714>:
    code.8663 = code;
    code = code.8663 + 1;
    D.53717 = (unsigned char) i;
    D.53718 = D.53717 & 7;
    D.53719 = D.53718 << 3;
    D.53667 = cfg->frame_reg;
    D.53720 = (unsigned char) D.53667;
    D.53721 = D.53720 & 7;
    D.53722 = D.53719 | D.53721;
    *code.8663 = D.53722;
    goto <D.28113>;
    <D.53715>:
    <D.53713>:
    save_area_offset.8654 = (unsigned int) save_area_offset;
    D.53691 = save_area_offset.8654 + 128;
    if (D.53691 <= 255) goto <D.53723>; else goto <D.53724>;
    <D.53723>:
    code.8664 = code;
    code = code.8664 + 1;
    D.53717 = (unsigned char) i;
    D.53718 = D.53717 & 7;
    D.53719 = D.53718 << 3;
    D.53667 = cfg->frame_reg;
    D.53720 = (unsigned char) D.53667;
    D.53721 = D.53720 & 7;
    D.53722 = D.53719 | D.53721;
    D.53726 = D.53722 | 64;
    *code.8664 = D.53726;
    D.53698 = (unsigned char) save_area_offset;
    *code = D.53698;
    code = code + 1;
    goto <D.53727>;
    <D.53724>:
    code.8665 = code;
    code = code.8665 + 1;
    D.53717 = (unsigned char) i;
    D.53718 = D.53717 & 7;
    D.53719 = D.53718 << 3;
    D.53667 = cfg->frame_reg;
    D.53720 = (unsigned char) D.53667;
    D.53721 = D.53720 & 7;
    D.53722 = D.53719 | D.53721;
    D.53729 = D.53722 | 128;
    *code.8665 = D.53729;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.8666 = code;
          code = code.8666 + 1;
          D.53731 = imb.b[0];
          *code.8666 = D.53731;
          code.8667 = code;
          code = code.8667 + 1;
          D.53733 = imb.b[1];
          *code.8667 = D.53733;
          code.8668 = code;
          code = code.8668 + 1;
          D.53735 = imb.b[2];
          *code.8668 = D.53735;
          code.8669 = code;
          code = code.8669 + 1;
          D.53737 = imb.b[3];
          *code.8669 = D.53737;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53727>:
    <D.28113>:
    D.53024 = cfg->arch.omit_fp;
    if (D.53024 != 0) goto <D.53738>; else goto <D.53739>;
    <D.53738>:
    D.53740 = save_area_offset - cfa_offset;
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    mono_emit_unwind_op (cfg, D.52991, 128, i, D.53740);
    D.53740 = save_area_offset - cfa_offset;
    mini_gc_set_slot_type_from_cfa (cfg, D.53740, 0);
    goto <D.53741>;
    <D.53739>:
    D.53742 = save_area_offset + -16;
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    mono_emit_unwind_op (cfg, D.52991, 128, i, D.53742);
    <D.53741>:
    save_area_offset = save_area_offset + 8;
    mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
    if (mono_inject_async_exc_method.8398 != 0B) goto <D.53743>; else goto <D.53744>;
    <D.53743>:
    D.52996 = cfg->method;
    mono_inject_async_exc_method.8398 = mono_inject_async_exc_method;
    D.53745 = mono_method_desc_full_match (mono_inject_async_exc_method.8398, D.52996);
    if (D.53745 != 0) goto <D.53746>; else goto <D.53747>;
    <D.53746>:
    D.53000 = cfg->arch.async_point_count;
    mono_inject_async_exc_pos.8399 = mono_inject_async_exc_pos;
    if (D.53000 == mono_inject_async_exc_pos.8399) goto <D.53748>; else goto <D.53749>;
    <D.53748>:
    if (0 != 0) goto <D.53750>; else goto <D.53751>;
    <D.53750>:
    code.8670 = code;
    code = code.8670 + 1;
    *code.8670 = 102;
    <D.53751>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 0;
      if (_amd64_rex_bits != 0) goto <D.53753>; else goto <D.53754>;
      <D.53753>:
      code.8671 = code;
      code = code.8671 + 1;
      D.53756 = _amd64_rex_bits | 64;
      *code.8671 = D.53756;
      <D.53754>:
    }
    switch (4) <default: <D.28121>, case 1: <D.28116>, case 2: <D.28118>, case 4: <D.28119>, case 8: <D.28120>>
    <D.28116>:
    code.8672 = code;
    code = code.8672 + 1;
    *code.8672 = 138;
    goto <D.28117>;
    <D.28118>:
    <D.28119>:
    <D.28120>:
    code.8673 = code;
    code = code.8673 + 1;
    *code.8673 = 139;
    goto <D.28117>;
    <D.28121>:
    __assert_fail ("0", "mini-amd64.c", 6908, &__PRETTY_FUNCTION__);
    <D.28117>:
    code.8674 = code;
    code = code.8674 + 1;
    *code.8674 = 4;
    code.8675 = code;
    code = code.8675 + 1;
    *code.8675 = 37;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8676 = code;
          code = code.8676 + 1;
          D.53762 = imb.b[0];
          *code.8676 = D.53762;
          code.8677 = code;
          code = code.8677 + 1;
          D.53764 = imb.b[1];
          *code.8677 = D.53764;
          code.8678 = code;
          code = code.8678 + 1;
          D.53766 = imb.b[2];
          *code.8678 = D.53766;
          code.8679 = code;
          code = code.8679 + 1;
          D.53768 = imb.b[3];
          *code.8679 = D.53768;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.53749>:
    D.53000 = cfg->arch.async_point_count;
    D.53023 = D.53000 + 1;
    cfg->arch.async_point_count = D.53023;
    <D.53747>:
    <D.53744>:
    <D.53659>:
    <D.53653>:
    i = i + 1;
    <D.28124>:
    if (i <= 16) goto <D.28123>; else goto <D.28125>;
    <D.28125>:
  }
  <D.53646>:
  D.53769 = cfg->rgctx_var;
  if (D.53769 != 0B) goto <D.53770>; else goto <D.53771>;
  <D.53770>:
  D.53769 = cfg->rgctx_var;
  D.53776 = D.53769->opcode;
  if (D.53776 != 367) goto <D.53773>; else goto <D.53777>;
  <D.53777>:
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53779 = (unsigned int) D.53778;
  D.53780 = D.53779 + 4294967292;
  if (D.53780 > 1) goto <D.53773>; else goto <D.53774>;
  <D.53773>:
  iftmp.8680 = 1;
  goto <D.53775>;
  <D.53774>:
  iftmp.8680 = 0;
  <D.53775>:
  D.53781 = iftmp.8680 != 0;
  D.53782 = (long int) D.53781;
  D.53783 = __builtin_expect (D.53782, 0);
  if (D.53783 != 0) goto <D.53784>; else goto <D.53785>;
  <D.53784>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 6915, "cfg->rgctx_var->opcode == OP_REGOFFSET && (cfg->rgctx_var->inst_basereg == AMD64_RBP || cfg->rgctx_var->inst_basereg == AMD64_RSP)");
  <D.53785>:
  if (0 != 0) goto <D.53786>; else goto <D.53787>;
  <D.53786>:
  code.8681 = code;
  code = code.8681 + 1;
  *code.8681 = 102;
  <D.53787>:
  {
    unsigned char _amd64_rex_bits;

    D.53769 = cfg->rgctx_var;
    D.53778 = D.53769->sreg1;
    if (D.53778 > 7) goto <D.53790>; else goto <D.53791>;
    <D.53790>:
    iftmp.8682 = 13;
    goto <D.53792>;
    <D.53791>:
    iftmp.8682 = 12;
    <D.53792>:
    _amd64_rex_bits = iftmp.8682;
    if (_amd64_rex_bits != 0) goto <D.53793>; else goto <D.53794>;
    <D.53793>:
    code.8683 = code;
    code = code.8683 + 1;
    D.53796 = _amd64_rex_bits | 64;
    *code.8683 = D.53796;
    <D.53794>:
  }
  switch (8) <default: <D.28132>, case 1: <D.28127>, case 2: <D.28129>, case 4: <D.28130>, case 8: <D.28131>>
  <D.28127>:
  code.8684 = code;
  code = code.8684 + 1;
  *code.8684 = 136;
  goto <D.28128>;
  <D.28129>:
  <D.28130>:
  <D.28131>:
  code.8685 = code;
  code = code.8685 + 1;
  *code.8685 = 137;
  goto <D.28128>;
  <D.28132>:
  __assert_fail ("0", "mini-amd64.c", 6917, &__PRETTY_FUNCTION__);
  <D.28128>:
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53799 = D.53778 & 7;
  if (D.53799 == 4) goto <D.53800>; else goto <D.53801>;
  <D.53800>:
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  if (D.53802 == 0) goto <D.53803>; else goto <D.53804>;
  <D.53803>:
  code.8686 = code;
  code = code.8686 + 1;
  *code.8686 = 20;
  code.8687 = code;
  code = code.8687 + 1;
  *code.8687 = 36;
  goto <D.53807>;
  <D.53804>:
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  D.53808 = (unsigned int) D.53802;
  D.53809 = D.53808 + 128;
  if (D.53809 <= 255) goto <D.53810>; else goto <D.53811>;
  <D.53810>:
  code.8688 = code;
  code = code.8688 + 1;
  *code.8688 = 84;
  code.8689 = code;
  code = code.8689 + 1;
  *code.8689 = 36;
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  D.53814 = (unsigned char) D.53802;
  *code = D.53814;
  code = code + 1;
  goto <D.53815>;
  <D.53811>:
  code.8690 = code;
  code = code.8690 + 1;
  *code.8690 = 148;
  code.8691 = code;
  code = code.8691 + 1;
  *code.8691 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.53769 = cfg->rgctx_var;
        D.53802 = D.53769->data.op[0].const_val;
        D.53818 = (int) D.53802;
        imb.val = D.53818;
        code.8692 = code;
        code = code.8692 + 1;
        D.53820 = imb.b[0];
        *code.8692 = D.53820;
        code.8693 = code;
        code = code.8693 + 1;
        D.53822 = imb.b[1];
        *code.8693 = D.53822;
        code.8694 = code;
        code = code.8694 + 1;
        D.53824 = imb.b[2];
        *code.8694 = D.53824;
        code.8695 = code;
        code = code.8695 + 1;
        D.53826 = imb.b[3];
        *code.8695 = D.53826;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53815>:
  <D.53807>:
  goto <D.28134>;
  <D.53801>:
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  if (D.53802 == 0) goto <D.53827>; else goto <D.53828>;
  <D.53827>:
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53799 = D.53778 & 7;
  if (D.53799 != 5) goto <D.53829>; else goto <D.53830>;
  <D.53829>:
  code.8696 = code;
  code = code.8696 + 1;
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53832 = (signed char) D.53778;
  D.53833 = D.53832 & 7;
  D.53834 = D.53833 | 16;
  D.53835 = (unsigned char) D.53834;
  *code.8696 = D.53835;
  goto <D.28134>;
  <D.53830>:
  <D.53828>:
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  D.53808 = (unsigned int) D.53802;
  D.53809 = D.53808 + 128;
  if (D.53809 <= 255) goto <D.53836>; else goto <D.53837>;
  <D.53836>:
  code.8697 = code;
  code = code.8697 + 1;
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53832 = (signed char) D.53778;
  D.53833 = D.53832 & 7;
  D.53839 = D.53833 | 80;
  D.53840 = (unsigned char) D.53839;
  *code.8697 = D.53840;
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  D.53814 = (unsigned char) D.53802;
  *code = D.53814;
  code = code + 1;
  goto <D.53841>;
  <D.53837>:
  code.8698 = code;
  code = code.8698 + 1;
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53832 = (signed char) D.53778;
  D.53833 = D.53832 & 7;
  D.53843 = D.53833 | -112;
  D.53844 = (unsigned char) D.53843;
  *code.8698 = D.53844;
  {
    union x86_imm_buf imb;

    try
      {
        D.53769 = cfg->rgctx_var;
        D.53802 = D.53769->data.op[0].const_val;
        D.53818 = (int) D.53802;
        imb.val = D.53818;
        code.8699 = code;
        code = code.8699 + 1;
        D.53846 = imb.b[0];
        *code.8699 = D.53846;
        code.8700 = code;
        code = code.8700 + 1;
        D.53848 = imb.b[1];
        *code.8700 = D.53848;
        code.8701 = code;
        code = code.8701 + 1;
        D.53850 = imb.b[2];
        *code.8701 = D.53850;
        code.8702 = code;
        code = code.8702 + 1;
        D.53852 = imb.b[3];
        *code.8702 = D.53852;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53841>:
  <D.28134>:
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  D.53769 = cfg->rgctx_var;
  mono_add_var_location (cfg, D.53769, 1, 10, 0, 0, D.52991);
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.52991 = (int) D.52990;
  D.53769 = cfg->rgctx_var;
  D.53802 = D.53769->data.op[0].const_val;
  D.53818 = (int) D.53802;
  D.53769 = cfg->rgctx_var;
  D.53778 = D.53769->sreg1;
  D.53769 = cfg->rgctx_var;
  mono_add_var_location (cfg, D.53769, 0, D.53778, D.53818, D.52991, 0);
  <D.53771>:
  max_epilog_size = get_max_epilog_size (cfg);
  D.53853 = cfg->opt;
  D.53854 = D.53853 & 2;
  if (D.53854 != 0) goto <D.53855>; else goto <D.53856>;
  <D.53855>:
  bb = cfg->bb_entry;
  goto <D.28142>;
  <D.28141>:
  {
    struct MonoInst * ins;
    int max_length;

    max_length = 0;
    D.53857 = cfg->prof_options;
    D.53858 = D.53857 & 8192;
    if (D.53858 != 0) goto <D.53859>; else goto <D.53860>;
    <D.53859>:
    max_length = max_length + 6;
    <D.53860>:
    D.53853 = cfg->opt;
    D.53861 = D.53853 & 8192;
    if (D.53861 != 0) goto <D.53862>; else goto <D.53863>;
    <D.53862>:
    D.53864 = bb->loop_body_start;
    if (D.53864 != 0) goto <D.53865>; else goto <D.53866>;
    <D.53865>:
    D.53867 = bb->nesting;
    if (D.53867 != 0) goto <D.53868>; else goto <D.53869>;
    <D.53868>:
    max_length = max_length + 8;
    <D.53869>:
    <D.53866>:
    <D.53863>:
    ins = bb->code;
    goto <D.28139>;
    <D.28138>:
    D.53870 = ins->opcode;
    D.53871 = (int) D.53870;
    D.53872 = D.53871 + -313;
    D.53873 = amd64_desc_idx[D.53872];
    D.53874 = (sizetype) D.53873;
    D.53875 = D.53874 + 4;
    D.53876 = &amd64_desc + D.53875;
    D.53877 = *D.53876;
    D.53878 = (int) D.53877;
    max_length = D.53878 + max_length;
    ins = ins->next;
    <D.28139>:
    if (ins != 0B) goto <D.28138>; else goto <D.28140>;
    <D.28140>:
    D.53881 = cfg->bb_entry;
    if (D.53881 == bb) goto <D.53879>; else goto <D.53882>;
    <D.53882>:
    D.53883 = cfg->bb_exit;
    if (D.53883 == bb) goto <D.53879>; else goto <D.53880>;
    <D.53879>:
    max_length = max_length + max_epilog_size;
    <D.53880>:
    bb->max_length = max_length;
  }
  bb = bb->next_bb;
  <D.28142>:
  if (bb != 0B) goto <D.28141>; else goto <D.28143>;
  <D.28143>:
  <D.53856>:
  sig = mono_method_signature (method);
  pos = 0;
  cinfo = cfg->arch.cinfo;
  D.53884 = sig->ret;
  D.53885 = D.53884->type;
  if (D.53885 != 1) goto <D.53886>; else goto <D.53887>;
  <D.53886>:
  D.53888 = cfg->vret_addr;
  if (D.53888 != 0B) goto <D.53889>; else goto <D.53890>;
  <D.53889>:
  D.53888 = cfg->vret_addr;
  D.53891 = D.53888->opcode;
  if (D.53891 != 366) goto <D.53892>; else goto <D.53893>;
  <D.53892>:
  if (0 != 0) goto <D.53894>; else goto <D.53895>;
  <D.53894>:
  code.8703 = code;
  code = code.8703 + 1;
  *code.8703 = 102;
  <D.53895>:
  {
    unsigned char _amd64_rex_bits;

    D.53898 = cinfo->ret.reg;
    if (D.53898 > 7) goto <D.53899>; else goto <D.53900>;
    <D.53899>:
    iftmp.8704 = 12;
    goto <D.53901>;
    <D.53900>:
    iftmp.8704 = 8;
    <D.53901>:
    D.53888 = cfg->vret_addr;
    D.53902 = D.53888->sreg1;
    D.53903 = D.53902 > 7;
    D.53904 = (signed char) D.53903;
    D.53905 = iftmp.8704 | D.53904;
    _amd64_rex_bits = (unsigned char) D.53905;
    if (_amd64_rex_bits != 0) goto <D.53906>; else goto <D.53907>;
    <D.53906>:
    code.8705 = code;
    code = code.8705 + 1;
    D.53909 = _amd64_rex_bits | 64;
    *code.8705 = D.53909;
    <D.53907>:
  }
  switch (8) <default: <D.28150>, case 1: <D.28145>, case 2: <D.28147>, case 4: <D.28148>, case 8: <D.28149>>
  <D.28145>:
  code.8706 = code;
  code = code.8706 + 1;
  *code.8706 = 136;
  goto <D.28146>;
  <D.28147>:
  <D.28148>:
  <D.28149>:
  code.8707 = code;
  code = code.8707 + 1;
  *code.8707 = 137;
  goto <D.28146>;
  <D.28150>:
  __assert_fail ("0", "mini-amd64.c", 6970, &__PRETTY_FUNCTION__);
  <D.28146>:
  D.53888 = cfg->vret_addr;
  D.53902 = D.53888->sreg1;
  D.53912 = D.53902 & 7;
  if (D.53912 == 4) goto <D.53913>; else goto <D.53914>;
  <D.53913>:
  D.53888 = cfg->vret_addr;
  D.53915 = D.53888->data.op[0].const_val;
  if (D.53915 == 0) goto <D.53916>; else goto <D.53917>;
  <D.53916>:
  code.8708 = code;
  code = code.8708 + 1;
  D.53898 = cinfo->ret.reg;
  D.53919 = (int) D.53898;
  D.53920 = D.53919 & 7;
  D.53921 = D.53920 << 3;
  D.53922 = (signed char) D.53921;
  D.53923 = D.53922 | 4;
  D.53924 = (unsigned char) D.53923;
  *code.8708 = D.53924;
  code.8709 = code;
  code = code.8709 + 1;
  *code.8709 = 36;
  goto <D.53926>;
  <D.53917>:
  D.53888 = cfg->vret_addr;
  D.53915 = D.53888->data.op[0].const_val;
  D.53927 = (unsigned int) D.53915;
  D.53928 = D.53927 + 128;
  if (D.53928 <= 255) goto <D.53929>; else goto <D.53930>;
  <D.53929>:
  code.8710 = code;
  code = code.8710 + 1;
  D.53898 = cinfo->ret.reg;
  D.53919 = (int) D.53898;
  D.53920 = D.53919 & 7;
  D.53921 = D.53920 << 3;
  D.53922 = (signed char) D.53921;
  D.53932 = D.53922 | 68;
  D.53933 = (unsigned char) D.53932;
  *code.8710 = D.53933;
  code.8711 = code;
  code = code.8711 + 1;
  *code.8711 = 36;
  D.53888 = cfg->vret_addr;
  D.53915 = D.53888->data.op[0].const_val;
  D.53935 = (unsigned char) D.53915;
  *code = D.53935;
  code = code + 1;
  goto <D.53936>;
  <D.53930>:
  code.8712 = code;
  code = code.8712 + 1;
  D.53898 = cinfo->ret.reg;
  D.53919 = (int) D.53898;
  D.53920 = D.53919 & 7;
  D.53921 = D.53920 << 3;
  D.53922 = (signed char) D.53921;
  D.53938 = D.53922 | -124;
  D.53939 = (unsigned char) D.53938;
  *code.8712 = D.53939;
  code.8713 = code;
  code = code.8713 + 1;
  *code.8713 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.53888 = cfg->vret_addr;
        D.53915 = D.53888->data.op[0].const_val;
        D.53941 = (int) D.53915;
        imb.val = D.53941;
        code.8714 = code;
        code = code.8714 + 1;
        D.53943 = imb.b[0];
        *code.8714 = D.53943;
        code.8715 = code;
        code = code.8715 + 1;
        D.53945 = imb.b[1];
        *code.8715 = D.53945;
        code.8716 = code;
        code = code.8716 + 1;
        D.53947 = imb.b[2];
        *code.8716 = D.53947;
        code.8717 = code;
        code = code.8717 + 1;
        D.53949 = imb.b[3];
        *code.8717 = D.53949;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53936>:
  <D.53926>:
  goto <D.28152>;
  <D.53914>:
  D.53888 = cfg->vret_addr;
  D.53915 = D.53888->data.op[0].const_val;
  if (D.53915 == 0) goto <D.53950>; else goto <D.53951>;
  <D.53950>:
  D.53888 = cfg->vret_addr;
  D.53902 = D.53888->sreg1;
  D.53912 = D.53902 & 7;
  if (D.53912 != 5) goto <D.53952>; else goto <D.53953>;
  <D.53952>:
  code.8718 = code;
  code = code.8718 + 1;
  D.53898 = cinfo->ret.reg;
  D.53919 = (int) D.53898;
  D.53920 = D.53919 & 7;
  D.53921 = D.53920 << 3;
  D.53922 = (signed char) D.53921;
  D.53888 = cfg->vret_addr;
  D.53902 = D.53888->sreg1;
  D.53955 = (signed char) D.53902;
  D.53956 = D.53955 & 7;
  D.53957 = D.53922 | D.53956;
  D.53958 = (unsigned char) D.53957;
  *code.8718 = D.53958;
  goto <D.28152>;
  <D.53953>:
  <D.53951>:
  D.53888 = cfg->vret_addr;
  D.53915 = D.53888->data.op[0].const_val;
  D.53927 = (unsigned int) D.53915;
  D.53928 = D.53927 + 128;
  if (D.53928 <= 255) goto <D.53959>; else goto <D.53960>;
  <D.53959>:
  code.8719 = code;
  code = code.8719 + 1;
  D.53898 = cinfo->ret.reg;
  D.53919 = (int) D.53898;
  D.53920 = D.53919 & 7;
  D.53921 = D.53920 << 3;
  D.53922 = (signed char) D.53921;
  D.53962 = D.53922 | 64;
  D.53888 = cfg->vret_addr;
  D.53902 = D.53888->sreg1;
  D.53955 = (signed char) D.53902;
  D.53956 = D.53955 & 7;
  D.53963 = D.53962 | D.53956;
  D.53964 = (unsigned char) D.53963;
  *code.8719 = D.53964;
  D.53888 = cfg->vret_addr;
  D.53915 = D.53888->data.op[0].const_val;
  D.53935 = (unsigned char) D.53915;
  *code = D.53935;
  code = code + 1;
  goto <D.53965>;
  <D.53960>:
  code.8720 = code;
  code = code.8720 + 1;
  D.53898 = cinfo->ret.reg;
  D.53919 = (int) D.53898;
  D.53920 = D.53919 & 7;
  D.53921 = D.53920 << 3;
  D.53922 = (signed char) D.53921;
  D.53967 = D.53922 | -128;
  D.53888 = cfg->vret_addr;
  D.53902 = D.53888->sreg1;
  D.53955 = (signed char) D.53902;
  D.53956 = D.53955 & 7;
  D.53968 = D.53967 | D.53956;
  D.53969 = (unsigned char) D.53968;
  *code.8720 = D.53969;
  {
    union x86_imm_buf imb;

    try
      {
        D.53888 = cfg->vret_addr;
        D.53915 = D.53888->data.op[0].const_val;
        D.53941 = (int) D.53915;
        imb.val = D.53941;
        code.8721 = code;
        code = code.8721 + 1;
        D.53971 = imb.b[0];
        *code.8721 = D.53971;
        code.8722 = code;
        code = code.8722 + 1;
        D.53973 = imb.b[1];
        *code.8722 = D.53973;
        code.8723 = code;
        code = code.8723 + 1;
        D.53975 = imb.b[2];
        *code.8723 = D.53975;
        code.8724 = code;
        code = code.8724 + 1;
        D.53977 = imb.b[3];
        *code.8724 = D.53977;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.53965>:
  <D.28152>:
  <D.53893>:
  <D.53890>:
  <D.53887>:
  i = 0;
  goto <D.28276>;
  <D.28275>:
  {
    struct ArgInfo * ainfo;
    gint32 stack_offset;
    struct MonoType * arg_type;

    D.53978 = (sizetype) i;
    ainfo = &cinfo->args[D.53978];
    D.53979 = cfg->args;
    D.53980 = (long unsigned int) i;
    D.53981 = D.53980 * 8;
    D.53982 = D.53979 + D.53981;
    ins = *D.53982;
    D.53983 = ins->flags;
    D.53984 = (int) D.53983;
    D.53985 = D.53984 & 2;
    if (D.53985 != 0) goto <D.53986>; else goto <D.53987>;
    <D.53986>:
    if (trace == 0) goto <D.53988>; else goto <D.53989>;
    <D.53988>:
    // predicted unlikely by continue predictor.
    goto <D.28157>;
    <D.53989>:
    <D.53987>:
    D.53992 = BIT_FIELD_REF <*sig, 8, 112>;
    D.53993 = D.53992 & 64;
    if (D.53993 != 0) goto <D.53994>; else goto <D.53990>;
    <D.53994>:
    if (i == 0) goto <D.53995>; else goto <D.53990>;
    <D.53995>:
    D.53996 = mono_defaults.object_class;
    arg_type = &D.53996->byval_arg;
    goto <D.53991>;
    <D.53990>:
    D.53997 = sig->hasthis;
    D.53998 = (int) D.53997;
    D.53999 = i - D.53998;
    arg_type = sig->params[D.53999];
    <D.53991>:
    D.54000 = ainfo->offset;
    D.54001 = (int) D.54000;
    stack_offset = D.54001 + 16;
    D.54002 = BIT_FIELD_REF <*cfg, 8, 5608>;
    D.54003 = D.54002 & 16;
    if (D.54003 != 0) goto <D.54004>; else goto <D.54005>;
    <D.54004>:
    D.54006 = ainfo->storage;
    switch (D.54006) <default: <D.28189>, case 1: <D.28158>, case 4: <D.28161>>
    <D.28158>:
    code.8725 = code;
    code = code.8725 + 1;
    *code.8725 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.54009 = ainfo->reg;
      if (D.54009 > 7) goto <D.54010>; else goto <D.54011>;
      <D.54010>:
      iftmp.8726 = 4;
      goto <D.54012>;
      <D.54011>:
      iftmp.8726 = 0;
      <D.54012>:
      D.54009 = ainfo->reg;
      D.54013 = D.54009 > 7;
      D.54014 = (signed char) D.54013;
      D.54015 = iftmp.8726 | D.54014;
      _amd64_rex_bits = (unsigned char) D.54015;
      if (_amd64_rex_bits != 0) goto <D.54016>; else goto <D.54017>;
      <D.54016>:
      code.8727 = code;
      code = code.8727 + 1;
      D.54019 = _amd64_rex_bits | 64;
      *code.8727 = D.54019;
      <D.54017>:
    }
    code.8728 = code;
    code = code.8728 + 1;
    *code.8728 = 15;
    code.8729 = code;
    code = code.8729 + 1;
    *code.8729 = 90;
    code.8730 = code;
    code = code.8730 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54027 = D.54026 | -64;
    D.54009 = ainfo->reg;
    D.54028 = D.54009 & 7;
    D.54029 = D.54027 | D.54028;
    D.54030 = (unsigned char) D.54029;
    *code.8730 = D.54030;
    goto <D.28160>;
    <D.28161>:
    quad = 0;
    goto <D.28187>;
    <D.28186>:
    D.54031 = ainfo->pair_storage[quad];
    switch (D.54031) <default: <D.28185>, case 0: <D.28162>, case 1: <D.28174>, case 2: <D.28179>, case 6: <D.28184>>
    <D.28162>:
    if (0 != 0) goto <D.54032>; else goto <D.54033>;
    <D.54032>:
    code.8731 = code;
    code = code.8731 + 1;
    *code.8731 = 102;
    <D.54033>:
    {
      unsigned char _amd64_rex_bits;

      D.54036 = ainfo->pair_regs[quad];
      if (D.54036 > 7) goto <D.54037>; else goto <D.54038>;
      <D.54037>:
      iftmp.8732 = 12;
      goto <D.54039>;
      <D.54038>:
      iftmp.8732 = 8;
      <D.54039>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54043 = iftmp.8732 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54043;
      if (_amd64_rex_bits != 0) goto <D.54044>; else goto <D.54045>;
      <D.54044>:
      code.8733 = code;
      code = code.8733 + 1;
      D.54047 = _amd64_rex_bits | 64;
      *code.8733 = D.54047;
      <D.54045>:
    }
    switch (8) <default: <D.28169>, case 1: <D.28164>, case 2: <D.28166>, case 4: <D.28167>, case 8: <D.28168>>
    <D.28164>:
    code.8734 = code;
    code = code.8734 + 1;
    *code.8734 = 136;
    goto <D.28165>;
    <D.28166>:
    <D.28167>:
    <D.28168>:
    code.8735 = code;
    code = code.8735 + 1;
    *code.8735 = 137;
    goto <D.28165>;
    <D.28169>:
    __assert_fail ("0", "mini-amd64.c", 7002, &__PRETTY_FUNCTION__);
    <D.28165>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54051>; else goto <D.54052>;
    <D.54051>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54058>; else goto <D.54059>;
    <D.54058>:
    code.8736 = code;
    code = code.8736 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54065 = D.54064 | 4;
    D.54066 = (unsigned char) D.54065;
    *code.8736 = D.54066;
    code.8737 = code;
    code = code.8737 + 1;
    *code.8737 = 36;
    goto <D.54068>;
    <D.54059>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54076>; else goto <D.54069>;
    <D.54076>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54077>; else goto <D.54069>;
    <D.54077>:
    code.8738 = code;
    code = code.8738 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54079 = D.54064 | 68;
    D.54080 = (unsigned char) D.54079;
    *code.8738 = D.54080;
    code.8739 = code;
    code = code.8739 + 1;
    *code.8739 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54070>;
    <D.54069>:
    code.8740 = code;
    code = code.8740 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54087 = D.54064 | -124;
    D.54088 = (unsigned char) D.54087;
    *code.8740 = D.54088;
    code.8741 = code;
    code = code.8741 + 1;
    *code.8741 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8742 = code;
          code = code.8742 + 1;
          D.54091 = imb.b[0];
          *code.8742 = D.54091;
          code.8743 = code;
          code = code.8743 + 1;
          D.54093 = imb.b[1];
          *code.8743 = D.54093;
          code.8744 = code;
          code = code.8744 + 1;
          D.54095 = imb.b[2];
          *code.8744 = D.54095;
          code.8745 = code;
          code = code.8745 + 1;
          D.54097 = imb.b[3];
          *code.8745 = D.54097;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54070>:
    <D.54068>:
    goto <D.28171>;
    <D.54052>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54098>; else goto <D.54099>;
    <D.54098>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54100>; else goto <D.54101>;
    <D.54100>:
    code.8746 = code;
    code = code.8746 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54105 = D.54064 | D.54104;
    D.54106 = (unsigned char) D.54105;
    *code.8746 = D.54106;
    goto <D.28171>;
    <D.54101>:
    <D.54099>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54109>; else goto <D.54107>;
    <D.54109>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54110>; else goto <D.54107>;
    <D.54110>:
    code.8747 = code;
    code = code.8747 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54112 = D.54064 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54113 = D.54112 | D.54104;
    D.54114 = (unsigned char) D.54113;
    *code.8747 = D.54114;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54108>;
    <D.54107>:
    code.8748 = code;
    code = code.8748 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54116 = D.54064 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54117 = D.54116 | D.54104;
    D.54118 = (unsigned char) D.54117;
    *code.8748 = D.54118;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8749 = code;
          code = code.8749 + 1;
          D.54120 = imb.b[0];
          *code.8749 = D.54120;
          code.8750 = code;
          code = code.8750 + 1;
          D.54122 = imb.b[1];
          *code.8750 = D.54122;
          code.8751 = code;
          code = code.8751 + 1;
          D.54124 = imb.b[2];
          *code.8751 = D.54124;
          code.8752 = code;
          code = code.8752 + 1;
          D.54126 = imb.b[3];
          *code.8752 = D.54126;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54108>:
    <D.28171>:
    goto <D.28173>;
    <D.28174>:
    code.8753 = code;
    code = code.8753 + 1;
    *code.8753 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.54036 = ainfo->pair_regs[quad];
      if (D.54036 > 7) goto <D.54129>; else goto <D.54130>;
      <D.54129>:
      iftmp.8754 = 4;
      goto <D.54131>;
      <D.54130>:
      iftmp.8754 = 0;
      <D.54131>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54132 = iftmp.8754 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54132;
      if (_amd64_rex_bits != 0) goto <D.54133>; else goto <D.54134>;
      <D.54133>:
      code.8755 = code;
      code = code.8755 + 1;
      D.54136 = _amd64_rex_bits | 64;
      *code.8755 = D.54136;
      <D.54134>:
    }
    code.8756 = code;
    code = code.8756 + 1;
    *code.8756 = 15;
    code.8757 = code;
    code = code.8757 + 1;
    *code.8757 = 17;
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54139>; else goto <D.54140>;
    <D.54139>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54141>; else goto <D.54142>;
    <D.54141>:
    code.8758 = code;
    code = code.8758 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54065 = D.54064 | 4;
    D.54066 = (unsigned char) D.54065;
    *code.8758 = D.54066;
    code.8759 = code;
    code = code.8759 + 1;
    *code.8759 = 36;
    goto <D.54145>;
    <D.54142>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54148>; else goto <D.54146>;
    <D.54148>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54149>; else goto <D.54146>;
    <D.54149>:
    code.8760 = code;
    code = code.8760 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54079 = D.54064 | 68;
    D.54080 = (unsigned char) D.54079;
    *code.8760 = D.54080;
    code.8761 = code;
    code = code.8761 + 1;
    *code.8761 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54147>;
    <D.54146>:
    code.8762 = code;
    code = code.8762 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54087 = D.54064 | -124;
    D.54088 = (unsigned char) D.54087;
    *code.8762 = D.54088;
    code.8763 = code;
    code = code.8763 + 1;
    *code.8763 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8764 = code;
          code = code.8764 + 1;
          D.54155 = imb.b[0];
          *code.8764 = D.54155;
          code.8765 = code;
          code = code.8765 + 1;
          D.54157 = imb.b[1];
          *code.8765 = D.54157;
          code.8766 = code;
          code = code.8766 + 1;
          D.54159 = imb.b[2];
          *code.8766 = D.54159;
          code.8767 = code;
          code = code.8767 + 1;
          D.54161 = imb.b[3];
          *code.8767 = D.54161;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54147>:
    <D.54145>:
    goto <D.28177>;
    <D.54140>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54162>; else goto <D.54163>;
    <D.54162>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54164>; else goto <D.54165>;
    <D.54164>:
    code.8768 = code;
    code = code.8768 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54105 = D.54064 | D.54104;
    D.54106 = (unsigned char) D.54105;
    *code.8768 = D.54106;
    goto <D.28177>;
    <D.54165>:
    <D.54163>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54169>; else goto <D.54167>;
    <D.54169>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54170>; else goto <D.54167>;
    <D.54170>:
    code.8769 = code;
    code = code.8769 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54112 = D.54064 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54113 = D.54112 | D.54104;
    D.54114 = (unsigned char) D.54113;
    *code.8769 = D.54114;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54168>;
    <D.54167>:
    code.8770 = code;
    code = code.8770 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54116 = D.54064 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54117 = D.54116 | D.54104;
    D.54118 = (unsigned char) D.54117;
    *code.8770 = D.54118;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8771 = code;
          code = code.8771 + 1;
          D.54174 = imb.b[0];
          *code.8771 = D.54174;
          code.8772 = code;
          code = code.8772 + 1;
          D.54176 = imb.b[1];
          *code.8772 = D.54176;
          code.8773 = code;
          code = code.8773 + 1;
          D.54178 = imb.b[2];
          *code.8773 = D.54178;
          code.8774 = code;
          code = code.8774 + 1;
          D.54180 = imb.b[3];
          *code.8774 = D.54180;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54168>:
    <D.28177>:
    goto <D.28173>;
    <D.28179>:
    code.8775 = code;
    code = code.8775 + 1;
    *code.8775 = 242;
    {
      unsigned char _amd64_rex_bits;

      D.54036 = ainfo->pair_regs[quad];
      if (D.54036 > 7) goto <D.54183>; else goto <D.54184>;
      <D.54183>:
      iftmp.8776 = 4;
      goto <D.54185>;
      <D.54184>:
      iftmp.8776 = 0;
      <D.54185>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54186 = iftmp.8776 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54186;
      if (_amd64_rex_bits != 0) goto <D.54187>; else goto <D.54188>;
      <D.54187>:
      code.8777 = code;
      code = code.8777 + 1;
      D.54190 = _amd64_rex_bits | 64;
      *code.8777 = D.54190;
      <D.54188>:
    }
    code.8778 = code;
    code = code.8778 + 1;
    *code.8778 = 15;
    code.8779 = code;
    code = code.8779 + 1;
    *code.8779 = 17;
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54193>; else goto <D.54194>;
    <D.54193>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54195>; else goto <D.54196>;
    <D.54195>:
    code.8780 = code;
    code = code.8780 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54065 = D.54064 | 4;
    D.54066 = (unsigned char) D.54065;
    *code.8780 = D.54066;
    code.8781 = code;
    code = code.8781 + 1;
    *code.8781 = 36;
    goto <D.54199>;
    <D.54196>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54202>; else goto <D.54200>;
    <D.54202>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54203>; else goto <D.54200>;
    <D.54203>:
    code.8782 = code;
    code = code.8782 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54079 = D.54064 | 68;
    D.54080 = (unsigned char) D.54079;
    *code.8782 = D.54080;
    code.8783 = code;
    code = code.8783 + 1;
    *code.8783 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54201>;
    <D.54200>:
    code.8784 = code;
    code = code.8784 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54087 = D.54064 | -124;
    D.54088 = (unsigned char) D.54087;
    *code.8784 = D.54088;
    code.8785 = code;
    code = code.8785 + 1;
    *code.8785 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8786 = code;
          code = code.8786 + 1;
          D.54209 = imb.b[0];
          *code.8786 = D.54209;
          code.8787 = code;
          code = code.8787 + 1;
          D.54211 = imb.b[1];
          *code.8787 = D.54211;
          code.8788 = code;
          code = code.8788 + 1;
          D.54213 = imb.b[2];
          *code.8788 = D.54213;
          code.8789 = code;
          code = code.8789 + 1;
          D.54215 = imb.b[3];
          *code.8789 = D.54215;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54201>:
    <D.54199>:
    goto <D.28182>;
    <D.54194>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54216>; else goto <D.54217>;
    <D.54216>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54218>; else goto <D.54219>;
    <D.54218>:
    code.8790 = code;
    code = code.8790 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54105 = D.54064 | D.54104;
    D.54106 = (unsigned char) D.54105;
    *code.8790 = D.54106;
    goto <D.28182>;
    <D.54219>:
    <D.54217>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54223>; else goto <D.54221>;
    <D.54223>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54224>; else goto <D.54221>;
    <D.54224>:
    code.8791 = code;
    code = code.8791 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54112 = D.54064 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54113 = D.54112 | D.54104;
    D.54114 = (unsigned char) D.54113;
    *code.8791 = D.54114;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54222>;
    <D.54221>:
    code.8792 = code;
    code = code.8792 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54116 = D.54064 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54117 = D.54116 | D.54104;
    D.54118 = (unsigned char) D.54117;
    *code.8792 = D.54118;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8793 = code;
          code = code.8793 + 1;
          D.54228 = imb.b[0];
          *code.8793 = D.54228;
          code.8794 = code;
          code = code.8794 + 1;
          D.54230 = imb.b[1];
          *code.8794 = D.54230;
          code.8795 = code;
          code = code.8795 + 1;
          D.54232 = imb.b[2];
          *code.8795 = D.54232;
          code.8796 = code;
          code = code.8796 + 1;
          D.54234 = imb.b[3];
          *code.8796 = D.54234;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54222>:
    <D.28182>:
    goto <D.28173>;
    <D.28184>:
    goto <D.28173>;
    <D.28185>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7013);
    <D.28173>:
    quad = quad + 1;
    <D.28187>:
    if (quad <= 1) goto <D.28186>; else goto <D.28188>;
    <D.28188>:
    goto <D.28160>;
    <D.28189>:
    goto <D.28160>;
    <D.28160>:
    // predicted unlikely by continue predictor.
    goto <D.28157>;
    <D.54005>:
    D.54235 = ins->opcode;
    if (D.54235 != 366) goto <D.54236>; else goto <D.54237>;
    <D.54236>:
    D.54006 = ainfo->storage;
    switch (D.54006) <default: <D.28252>, case 0: <D.28190>, case 1: <D.28203>, case 2: <D.28208>, case 4: <D.28213>, case 5: <D.28241>>
    <D.28190>:
    {
      guint32 size;

      size = 8;
      if (size == 2) goto <D.54238>; else goto <D.54239>;
      <D.54238>:
      code.8797 = code;
      code = code.8797 + 1;
      *code.8797 = 102;
      <D.54239>:
      {
        unsigned char _amd64_rex_bits;

        if (size > 4) goto <D.54242>; else goto <D.54243>;
        <D.54242>:
        iftmp.8798 = 8;
        goto <D.54244>;
        <D.54243>:
        iftmp.8798 = 0;
        <D.54244>:
        D.54009 = ainfo->reg;
        if (D.54009 > 7) goto <D.54246>; else goto <D.54247>;
        <D.54246>:
        iftmp.8799 = 4;
        goto <D.54248>;
        <D.54247>:
        iftmp.8799 = 0;
        <D.54248>:
        D.54249 = iftmp.8798 | iftmp.8799;
        D.54040 = ins->sreg1;
        D.54041 = D.54040 > 7;
        D.54042 = (signed char) D.54041;
        D.54250 = D.54249 | D.54042;
        _amd64_rex_bits = (unsigned char) D.54250;
        D.54251 = _amd64_rex_bits != 0;
        D.54252 = size == 1;
        D.54253 = D.54251 | D.54252;
        if (D.54253 != 0) goto <D.54254>; else goto <D.54255>;
        <D.54254>:
        code.8800 = code;
        code = code.8800 + 1;
        D.54257 = _amd64_rex_bits | 64;
        *code.8800 = D.54257;
        <D.54255>:
      }
      switch (size) <default: <D.28198>, case 1: <D.28193>, case 2: <D.28195>, case 4: <D.28196>, case 8: <D.28197>>
      <D.28193>:
      code.8801 = code;
      code = code.8801 + 1;
      *code.8801 = 136;
      goto <D.28194>;
      <D.28195>:
      <D.28196>:
      <D.28197>:
      code.8802 = code;
      code = code.8802 + 1;
      *code.8802 = 137;
      goto <D.28194>;
      <D.28198>:
      __assert_fail ("0", "mini-amd64.c", 7041, &__PRETTY_FUNCTION__);
      <D.28194>:
      D.54040 = ins->sreg1;
      D.54050 = D.54040 & 7;
      if (D.54050 == 4) goto <D.54260>; else goto <D.54261>;
      <D.54260>:
      D.54053 = ins->data.op[0].const_val;
      if (D.54053 == 0) goto <D.54262>; else goto <D.54263>;
      <D.54262>:
      code.8803 = code;
      code = code.8803 + 1;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      D.54024 = D.54023 & 7;
      D.54025 = D.54024 << 3;
      D.54026 = (signed char) D.54025;
      D.54265 = D.54026 | 4;
      D.54266 = (unsigned char) D.54265;
      *code.8803 = D.54266;
      code.8804 = code;
      code = code.8804 + 1;
      *code.8804 = 36;
      goto <D.54268>;
      <D.54263>:
      D.54053 = ins->data.op[0].const_val;
      D.54269 = (unsigned int) D.54053;
      D.54270 = D.54269 + 128;
      if (D.54270 <= 255) goto <D.54271>; else goto <D.54272>;
      <D.54271>:
      code.8805 = code;
      code = code.8805 + 1;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      D.54024 = D.54023 & 7;
      D.54025 = D.54024 << 3;
      D.54026 = (signed char) D.54025;
      D.54274 = D.54026 | 68;
      D.54275 = (unsigned char) D.54274;
      *code.8805 = D.54275;
      code.8806 = code;
      code = code.8806 + 1;
      *code.8806 = 36;
      D.54053 = ins->data.op[0].const_val;
      D.54277 = (unsigned char) D.54053;
      *code = D.54277;
      code = code + 1;
      goto <D.54278>;
      <D.54272>:
      code.8807 = code;
      code = code.8807 + 1;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      D.54024 = D.54023 & 7;
      D.54025 = D.54024 << 3;
      D.54026 = (signed char) D.54025;
      D.54280 = D.54026 | -124;
      D.54281 = (unsigned char) D.54280;
      *code.8807 = D.54281;
      code.8808 = code;
      code = code.8808 + 1;
      *code.8808 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.54053 = ins->data.op[0].const_val;
            D.54283 = (int) D.54053;
            imb.val = D.54283;
            code.8809 = code;
            code = code.8809 + 1;
            D.54285 = imb.b[0];
            *code.8809 = D.54285;
            code.8810 = code;
            code = code.8810 + 1;
            D.54287 = imb.b[1];
            *code.8810 = D.54287;
            code.8811 = code;
            code = code.8811 + 1;
            D.54289 = imb.b[2];
            *code.8811 = D.54289;
            code.8812 = code;
            code = code.8812 + 1;
            D.54291 = imb.b[3];
            *code.8812 = D.54291;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.54278>:
      <D.54268>:
      goto <D.28200>;
      <D.54261>:
      D.54053 = ins->data.op[0].const_val;
      if (D.54053 == 0) goto <D.54292>; else goto <D.54293>;
      <D.54292>:
      D.54040 = ins->sreg1;
      D.54050 = D.54040 & 7;
      if (D.54050 != 5) goto <D.54294>; else goto <D.54295>;
      <D.54294>:
      code.8813 = code;
      code = code.8813 + 1;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      D.54024 = D.54023 & 7;
      D.54025 = D.54024 << 3;
      D.54026 = (signed char) D.54025;
      D.54040 = ins->sreg1;
      D.54103 = (signed char) D.54040;
      D.54104 = D.54103 & 7;
      D.54297 = D.54026 | D.54104;
      D.54298 = (unsigned char) D.54297;
      *code.8813 = D.54298;
      goto <D.28200>;
      <D.54295>:
      <D.54293>:
      D.54053 = ins->data.op[0].const_val;
      D.54269 = (unsigned int) D.54053;
      D.54270 = D.54269 + 128;
      if (D.54270 <= 255) goto <D.54299>; else goto <D.54300>;
      <D.54299>:
      code.8814 = code;
      code = code.8814 + 1;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      D.54024 = D.54023 & 7;
      D.54025 = D.54024 << 3;
      D.54026 = (signed char) D.54025;
      D.54302 = D.54026 | 64;
      D.54040 = ins->sreg1;
      D.54103 = (signed char) D.54040;
      D.54104 = D.54103 & 7;
      D.54303 = D.54302 | D.54104;
      D.54304 = (unsigned char) D.54303;
      *code.8814 = D.54304;
      D.54053 = ins->data.op[0].const_val;
      D.54277 = (unsigned char) D.54053;
      *code = D.54277;
      code = code + 1;
      goto <D.54305>;
      <D.54300>:
      code.8815 = code;
      code = code.8815 + 1;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      D.54024 = D.54023 & 7;
      D.54025 = D.54024 << 3;
      D.54026 = (signed char) D.54025;
      D.54307 = D.54026 | -128;
      D.54040 = ins->sreg1;
      D.54103 = (signed char) D.54040;
      D.54104 = D.54103 & 7;
      D.54308 = D.54307 | D.54104;
      D.54309 = (unsigned char) D.54308;
      *code.8815 = D.54309;
      {
        union x86_imm_buf imb;

        try
          {
            D.54053 = ins->data.op[0].const_val;
            D.54283 = (int) D.54053;
            imb.val = D.54283;
            code.8816 = code;
            code = code.8816 + 1;
            D.54311 = imb.b[0];
            *code.8816 = D.54311;
            code.8817 = code;
            code = code.8817 + 1;
            D.54313 = imb.b[1];
            *code.8817 = D.54313;
            code.8818 = code;
            code = code.8818 + 1;
            D.54315 = imb.b[2];
            *code.8818 = D.54315;
            code.8819 = code;
            code = code.8819 + 1;
            D.54317 = imb.b[3];
            *code.8819 = D.54317;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.54305>:
      <D.28200>:
      D.53979 = cfg->args;
      D.54318 = *D.53979;
      if (D.54318 == ins) goto <D.54319>; else goto <D.54320>;
      <D.54319>:
      code.8397 = (long int) code;
      D.52988 = cfg->native_code;
      D.52989 = (long int) D.52988;
      D.52990 = code.8397 - D.52989;
      D.52991 = (int) D.52990;
      D.54009 = ainfo->reg;
      D.54023 = (int) D.54009;
      mono_add_var_location (cfg, ins, 1, D.54023, 0, 0, D.52991);
      code.8397 = (long int) code;
      D.52988 = cfg->native_code;
      D.52989 = (long int) D.52988;
      D.52990 = code.8397 - D.52989;
      D.52991 = (int) D.52990;
      D.54053 = ins->data.op[0].const_val;
      D.54283 = (int) D.54053;
      D.54040 = ins->sreg1;
      mono_add_var_location (cfg, ins, 0, D.54040, D.54283, D.52991, 0);
      <D.54320>:
      goto <D.28202>;
    }
    <D.28203>:
    code.8820 = code;
    code = code.8820 + 1;
    *code.8820 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.54009 = ainfo->reg;
      if (D.54009 > 7) goto <D.54323>; else goto <D.54324>;
      <D.54323>:
      iftmp.8821 = 4;
      goto <D.54325>;
      <D.54324>:
      iftmp.8821 = 0;
      <D.54325>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54326 = iftmp.8821 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54326;
      if (_amd64_rex_bits != 0) goto <D.54327>; else goto <D.54328>;
      <D.54327>:
      code.8822 = code;
      code = code.8822 + 1;
      D.54330 = _amd64_rex_bits | 64;
      *code.8822 = D.54330;
      <D.54328>:
    }
    code.8823 = code;
    code = code.8823 + 1;
    *code.8823 = 15;
    code.8824 = code;
    code = code.8824 + 1;
    *code.8824 = 17;
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54333>; else goto <D.54334>;
    <D.54333>:
    D.54053 = ins->data.op[0].const_val;
    if (D.54053 == 0) goto <D.54335>; else goto <D.54336>;
    <D.54335>:
    code.8825 = code;
    code = code.8825 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54265 = D.54026 | 4;
    D.54266 = (unsigned char) D.54265;
    *code.8825 = D.54266;
    code.8826 = code;
    code = code.8826 + 1;
    *code.8826 = 36;
    goto <D.54339>;
    <D.54336>:
    D.54053 = ins->data.op[0].const_val;
    D.54269 = (unsigned int) D.54053;
    D.54270 = D.54269 + 128;
    if (D.54270 <= 255) goto <D.54340>; else goto <D.54341>;
    <D.54340>:
    code.8827 = code;
    code = code.8827 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54274 = D.54026 | 68;
    D.54275 = (unsigned char) D.54274;
    *code.8827 = D.54275;
    code.8828 = code;
    code = code.8828 + 1;
    *code.8828 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54277 = (unsigned char) D.54053;
    *code = D.54277;
    code = code + 1;
    goto <D.54344>;
    <D.54341>:
    code.8829 = code;
    code = code.8829 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54280 = D.54026 | -124;
    D.54281 = (unsigned char) D.54280;
    *code.8829 = D.54281;
    code.8830 = code;
    code = code.8830 + 1;
    *code.8830 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54283 = (int) D.54053;
          imb.val = D.54283;
          code.8831 = code;
          code = code.8831 + 1;
          D.54348 = imb.b[0];
          *code.8831 = D.54348;
          code.8832 = code;
          code = code.8832 + 1;
          D.54350 = imb.b[1];
          *code.8832 = D.54350;
          code.8833 = code;
          code = code.8833 + 1;
          D.54352 = imb.b[2];
          *code.8833 = D.54352;
          code.8834 = code;
          code = code.8834 + 1;
          D.54354 = imb.b[3];
          *code.8834 = D.54354;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54344>:
    <D.54339>:
    goto <D.28206>;
    <D.54334>:
    D.54053 = ins->data.op[0].const_val;
    if (D.54053 == 0) goto <D.54355>; else goto <D.54356>;
    <D.54355>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54357>; else goto <D.54358>;
    <D.54357>:
    code.8835 = code;
    code = code.8835 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54297 = D.54026 | D.54104;
    D.54298 = (unsigned char) D.54297;
    *code.8835 = D.54298;
    goto <D.28206>;
    <D.54358>:
    <D.54356>:
    D.54053 = ins->data.op[0].const_val;
    D.54269 = (unsigned int) D.54053;
    D.54270 = D.54269 + 128;
    if (D.54270 <= 255) goto <D.54360>; else goto <D.54361>;
    <D.54360>:
    code.8836 = code;
    code = code.8836 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54302 = D.54026 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54303 = D.54302 | D.54104;
    D.54304 = (unsigned char) D.54303;
    *code.8836 = D.54304;
    D.54053 = ins->data.op[0].const_val;
    D.54277 = (unsigned char) D.54053;
    *code = D.54277;
    code = code + 1;
    goto <D.54363>;
    <D.54361>:
    code.8837 = code;
    code = code.8837 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54307 = D.54026 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54308 = D.54307 | D.54104;
    D.54309 = (unsigned char) D.54308;
    *code.8837 = D.54309;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54283 = (int) D.54053;
          imb.val = D.54283;
          code.8838 = code;
          code = code.8838 + 1;
          D.54366 = imb.b[0];
          *code.8838 = D.54366;
          code.8839 = code;
          code = code.8839 + 1;
          D.54368 = imb.b[1];
          *code.8839 = D.54368;
          code.8840 = code;
          code = code.8840 + 1;
          D.54370 = imb.b[2];
          *code.8840 = D.54370;
          code.8841 = code;
          code = code.8841 + 1;
          D.54372 = imb.b[3];
          *code.8841 = D.54372;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54363>:
    <D.28206>:
    goto <D.28202>;
    <D.28208>:
    code.8842 = code;
    code = code.8842 + 1;
    *code.8842 = 242;
    {
      unsigned char _amd64_rex_bits;

      D.54009 = ainfo->reg;
      if (D.54009 > 7) goto <D.54375>; else goto <D.54376>;
      <D.54375>:
      iftmp.8843 = 4;
      goto <D.54377>;
      <D.54376>:
      iftmp.8843 = 0;
      <D.54377>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54378 = iftmp.8843 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54378;
      if (_amd64_rex_bits != 0) goto <D.54379>; else goto <D.54380>;
      <D.54379>:
      code.8844 = code;
      code = code.8844 + 1;
      D.54382 = _amd64_rex_bits | 64;
      *code.8844 = D.54382;
      <D.54380>:
    }
    code.8845 = code;
    code = code.8845 + 1;
    *code.8845 = 15;
    code.8846 = code;
    code = code.8846 + 1;
    *code.8846 = 17;
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54385>; else goto <D.54386>;
    <D.54385>:
    D.54053 = ins->data.op[0].const_val;
    if (D.54053 == 0) goto <D.54387>; else goto <D.54388>;
    <D.54387>:
    code.8847 = code;
    code = code.8847 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54265 = D.54026 | 4;
    D.54266 = (unsigned char) D.54265;
    *code.8847 = D.54266;
    code.8848 = code;
    code = code.8848 + 1;
    *code.8848 = 36;
    goto <D.54391>;
    <D.54388>:
    D.54053 = ins->data.op[0].const_val;
    D.54269 = (unsigned int) D.54053;
    D.54270 = D.54269 + 128;
    if (D.54270 <= 255) goto <D.54392>; else goto <D.54393>;
    <D.54392>:
    code.8849 = code;
    code = code.8849 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54274 = D.54026 | 68;
    D.54275 = (unsigned char) D.54274;
    *code.8849 = D.54275;
    code.8850 = code;
    code = code.8850 + 1;
    *code.8850 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54277 = (unsigned char) D.54053;
    *code = D.54277;
    code = code + 1;
    goto <D.54396>;
    <D.54393>:
    code.8851 = code;
    code = code.8851 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54280 = D.54026 | -124;
    D.54281 = (unsigned char) D.54280;
    *code.8851 = D.54281;
    code.8852 = code;
    code = code.8852 + 1;
    *code.8852 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54283 = (int) D.54053;
          imb.val = D.54283;
          code.8853 = code;
          code = code.8853 + 1;
          D.54400 = imb.b[0];
          *code.8853 = D.54400;
          code.8854 = code;
          code = code.8854 + 1;
          D.54402 = imb.b[1];
          *code.8854 = D.54402;
          code.8855 = code;
          code = code.8855 + 1;
          D.54404 = imb.b[2];
          *code.8855 = D.54404;
          code.8856 = code;
          code = code.8856 + 1;
          D.54406 = imb.b[3];
          *code.8856 = D.54406;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54396>:
    <D.54391>:
    goto <D.28211>;
    <D.54386>:
    D.54053 = ins->data.op[0].const_val;
    if (D.54053 == 0) goto <D.54407>; else goto <D.54408>;
    <D.54407>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54409>; else goto <D.54410>;
    <D.54409>:
    code.8857 = code;
    code = code.8857 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54297 = D.54026 | D.54104;
    D.54298 = (unsigned char) D.54297;
    *code.8857 = D.54298;
    goto <D.28211>;
    <D.54410>:
    <D.54408>:
    D.54053 = ins->data.op[0].const_val;
    D.54269 = (unsigned int) D.54053;
    D.54270 = D.54269 + 128;
    if (D.54270 <= 255) goto <D.54412>; else goto <D.54413>;
    <D.54412>:
    code.8858 = code;
    code = code.8858 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54302 = D.54026 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54303 = D.54302 | D.54104;
    D.54304 = (unsigned char) D.54303;
    *code.8858 = D.54304;
    D.54053 = ins->data.op[0].const_val;
    D.54277 = (unsigned char) D.54053;
    *code = D.54277;
    code = code + 1;
    goto <D.54415>;
    <D.54413>:
    code.8859 = code;
    code = code.8859 + 1;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    D.54024 = D.54023 & 7;
    D.54025 = D.54024 << 3;
    D.54026 = (signed char) D.54025;
    D.54307 = D.54026 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54308 = D.54307 | D.54104;
    D.54309 = (unsigned char) D.54308;
    *code.8859 = D.54309;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54283 = (int) D.54053;
          imb.val = D.54283;
          code.8860 = code;
          code = code.8860 + 1;
          D.54418 = imb.b[0];
          *code.8860 = D.54418;
          code.8861 = code;
          code = code.8861 + 1;
          D.54420 = imb.b[1];
          *code.8861 = D.54420;
          code.8862 = code;
          code = code.8862 + 1;
          D.54422 = imb.b[2];
          *code.8862 = D.54422;
          code.8863 = code;
          code = code.8863 + 1;
          D.54424 = imb.b[3];
          *code.8863 = D.54424;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54415>:
    <D.28211>:
    goto <D.28202>;
    <D.28213>:
    quad = 0;
    goto <D.28239>;
    <D.28238>:
    D.54031 = ainfo->pair_storage[quad];
    switch (D.54031) <default: <D.28237>, case 0: <D.28214>, case 1: <D.28226>, case 2: <D.28231>, case 6: <D.28236>>
    <D.28214>:
    if (0 != 0) goto <D.54425>; else goto <D.54426>;
    <D.54425>:
    code.8864 = code;
    code = code.8864 + 1;
    *code.8864 = 102;
    <D.54426>:
    {
      unsigned char _amd64_rex_bits;

      D.54036 = ainfo->pair_regs[quad];
      if (D.54036 > 7) goto <D.54429>; else goto <D.54430>;
      <D.54429>:
      iftmp.8865 = 12;
      goto <D.54431>;
      <D.54430>:
      iftmp.8865 = 8;
      <D.54431>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54432 = iftmp.8865 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54432;
      if (_amd64_rex_bits != 0) goto <D.54433>; else goto <D.54434>;
      <D.54433>:
      code.8866 = code;
      code = code.8866 + 1;
      D.54436 = _amd64_rex_bits | 64;
      *code.8866 = D.54436;
      <D.54434>:
    }
    switch (8) <default: <D.28221>, case 1: <D.28216>, case 2: <D.28218>, case 4: <D.28219>, case 8: <D.28220>>
    <D.28216>:
    code.8867 = code;
    code = code.8867 + 1;
    *code.8867 = 136;
    goto <D.28217>;
    <D.28218>:
    <D.28219>:
    <D.28220>:
    code.8868 = code;
    code = code.8868 + 1;
    *code.8868 = 137;
    goto <D.28217>;
    <D.28221>:
    __assert_fail ("0", "mini-amd64.c", 7064, &__PRETTY_FUNCTION__);
    <D.28217>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54439>; else goto <D.54440>;
    <D.54439>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54441>; else goto <D.54442>;
    <D.54441>:
    code.8869 = code;
    code = code.8869 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54065 = D.54064 | 4;
    D.54066 = (unsigned char) D.54065;
    *code.8869 = D.54066;
    code.8870 = code;
    code = code.8870 + 1;
    *code.8870 = 36;
    goto <D.54445>;
    <D.54442>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54448>; else goto <D.54446>;
    <D.54448>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54449>; else goto <D.54446>;
    <D.54449>:
    code.8871 = code;
    code = code.8871 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54079 = D.54064 | 68;
    D.54080 = (unsigned char) D.54079;
    *code.8871 = D.54080;
    code.8872 = code;
    code = code.8872 + 1;
    *code.8872 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54447>;
    <D.54446>:
    code.8873 = code;
    code = code.8873 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54087 = D.54064 | -124;
    D.54088 = (unsigned char) D.54087;
    *code.8873 = D.54088;
    code.8874 = code;
    code = code.8874 + 1;
    *code.8874 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8875 = code;
          code = code.8875 + 1;
          D.54455 = imb.b[0];
          *code.8875 = D.54455;
          code.8876 = code;
          code = code.8876 + 1;
          D.54457 = imb.b[1];
          *code.8876 = D.54457;
          code.8877 = code;
          code = code.8877 + 1;
          D.54459 = imb.b[2];
          *code.8877 = D.54459;
          code.8878 = code;
          code = code.8878 + 1;
          D.54461 = imb.b[3];
          *code.8878 = D.54461;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54447>:
    <D.54445>:
    goto <D.28223>;
    <D.54440>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54462>; else goto <D.54463>;
    <D.54462>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54464>; else goto <D.54465>;
    <D.54464>:
    code.8879 = code;
    code = code.8879 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54105 = D.54064 | D.54104;
    D.54106 = (unsigned char) D.54105;
    *code.8879 = D.54106;
    goto <D.28223>;
    <D.54465>:
    <D.54463>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54469>; else goto <D.54467>;
    <D.54469>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54470>; else goto <D.54467>;
    <D.54470>:
    code.8880 = code;
    code = code.8880 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54112 = D.54064 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54113 = D.54112 | D.54104;
    D.54114 = (unsigned char) D.54113;
    *code.8880 = D.54114;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54468>;
    <D.54467>:
    code.8881 = code;
    code = code.8881 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54116 = D.54064 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54117 = D.54116 | D.54104;
    D.54118 = (unsigned char) D.54117;
    *code.8881 = D.54118;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8882 = code;
          code = code.8882 + 1;
          D.54474 = imb.b[0];
          *code.8882 = D.54474;
          code.8883 = code;
          code = code.8883 + 1;
          D.54476 = imb.b[1];
          *code.8883 = D.54476;
          code.8884 = code;
          code = code.8884 + 1;
          D.54478 = imb.b[2];
          *code.8884 = D.54478;
          code.8885 = code;
          code = code.8885 + 1;
          D.54480 = imb.b[3];
          *code.8885 = D.54480;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54468>:
    <D.28223>:
    goto <D.28225>;
    <D.28226>:
    code.8886 = code;
    code = code.8886 + 1;
    *code.8886 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.54036 = ainfo->pair_regs[quad];
      if (D.54036 > 7) goto <D.54483>; else goto <D.54484>;
      <D.54483>:
      iftmp.8887 = 4;
      goto <D.54485>;
      <D.54484>:
      iftmp.8887 = 0;
      <D.54485>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54486 = iftmp.8887 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54486;
      if (_amd64_rex_bits != 0) goto <D.54487>; else goto <D.54488>;
      <D.54487>:
      code.8888 = code;
      code = code.8888 + 1;
      D.54490 = _amd64_rex_bits | 64;
      *code.8888 = D.54490;
      <D.54488>:
    }
    code.8889 = code;
    code = code.8889 + 1;
    *code.8889 = 15;
    code.8890 = code;
    code = code.8890 + 1;
    *code.8890 = 17;
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54493>; else goto <D.54494>;
    <D.54493>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54495>; else goto <D.54496>;
    <D.54495>:
    code.8891 = code;
    code = code.8891 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54065 = D.54064 | 4;
    D.54066 = (unsigned char) D.54065;
    *code.8891 = D.54066;
    code.8892 = code;
    code = code.8892 + 1;
    *code.8892 = 36;
    goto <D.54499>;
    <D.54496>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54502>; else goto <D.54500>;
    <D.54502>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54503>; else goto <D.54500>;
    <D.54503>:
    code.8893 = code;
    code = code.8893 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54079 = D.54064 | 68;
    D.54080 = (unsigned char) D.54079;
    *code.8893 = D.54080;
    code.8894 = code;
    code = code.8894 + 1;
    *code.8894 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54501>;
    <D.54500>:
    code.8895 = code;
    code = code.8895 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54087 = D.54064 | -124;
    D.54088 = (unsigned char) D.54087;
    *code.8895 = D.54088;
    code.8896 = code;
    code = code.8896 + 1;
    *code.8896 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8897 = code;
          code = code.8897 + 1;
          D.54509 = imb.b[0];
          *code.8897 = D.54509;
          code.8898 = code;
          code = code.8898 + 1;
          D.54511 = imb.b[1];
          *code.8898 = D.54511;
          code.8899 = code;
          code = code.8899 + 1;
          D.54513 = imb.b[2];
          *code.8899 = D.54513;
          code.8900 = code;
          code = code.8900 + 1;
          D.54515 = imb.b[3];
          *code.8900 = D.54515;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54501>:
    <D.54499>:
    goto <D.28229>;
    <D.54494>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54516>; else goto <D.54517>;
    <D.54516>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54518>; else goto <D.54519>;
    <D.54518>:
    code.8901 = code;
    code = code.8901 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54105 = D.54064 | D.54104;
    D.54106 = (unsigned char) D.54105;
    *code.8901 = D.54106;
    goto <D.28229>;
    <D.54519>:
    <D.54517>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54523>; else goto <D.54521>;
    <D.54523>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54524>; else goto <D.54521>;
    <D.54524>:
    code.8902 = code;
    code = code.8902 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54112 = D.54064 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54113 = D.54112 | D.54104;
    D.54114 = (unsigned char) D.54113;
    *code.8902 = D.54114;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54522>;
    <D.54521>:
    code.8903 = code;
    code = code.8903 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54116 = D.54064 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54117 = D.54116 | D.54104;
    D.54118 = (unsigned char) D.54117;
    *code.8903 = D.54118;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8904 = code;
          code = code.8904 + 1;
          D.54528 = imb.b[0];
          *code.8904 = D.54528;
          code.8905 = code;
          code = code.8905 + 1;
          D.54530 = imb.b[1];
          *code.8905 = D.54530;
          code.8906 = code;
          code = code.8906 + 1;
          D.54532 = imb.b[2];
          *code.8906 = D.54532;
          code.8907 = code;
          code = code.8907 + 1;
          D.54534 = imb.b[3];
          *code.8907 = D.54534;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54522>:
    <D.28229>:
    goto <D.28225>;
    <D.28231>:
    code.8908 = code;
    code = code.8908 + 1;
    *code.8908 = 242;
    {
      unsigned char _amd64_rex_bits;

      D.54036 = ainfo->pair_regs[quad];
      if (D.54036 > 7) goto <D.54537>; else goto <D.54538>;
      <D.54537>:
      iftmp.8909 = 4;
      goto <D.54539>;
      <D.54538>:
      iftmp.8909 = 0;
      <D.54539>:
      D.54040 = ins->sreg1;
      D.54041 = D.54040 > 7;
      D.54042 = (signed char) D.54041;
      D.54540 = iftmp.8909 | D.54042;
      _amd64_rex_bits = (unsigned char) D.54540;
      if (_amd64_rex_bits != 0) goto <D.54541>; else goto <D.54542>;
      <D.54541>:
      code.8910 = code;
      code = code.8910 + 1;
      D.54544 = _amd64_rex_bits | 64;
      *code.8910 = D.54544;
      <D.54542>:
    }
    code.8911 = code;
    code = code.8911 + 1;
    *code.8911 = 15;
    code.8912 = code;
    code = code.8912 + 1;
    *code.8912 = 17;
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.54547>; else goto <D.54548>;
    <D.54547>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54549>; else goto <D.54550>;
    <D.54549>:
    code.8913 = code;
    code = code.8913 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54065 = D.54064 | 4;
    D.54066 = (unsigned char) D.54065;
    *code.8913 = D.54066;
    code.8914 = code;
    code = code.8914 + 1;
    *code.8914 = 36;
    goto <D.54553>;
    <D.54550>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54556>; else goto <D.54554>;
    <D.54556>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54557>; else goto <D.54554>;
    <D.54557>:
    code.8915 = code;
    code = code.8915 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54079 = D.54064 | 68;
    D.54080 = (unsigned char) D.54079;
    *code.8915 = D.54080;
    code.8916 = code;
    code = code.8916 + 1;
    *code.8916 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54555>;
    <D.54554>:
    code.8917 = code;
    code = code.8917 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54087 = D.54064 | -124;
    D.54088 = (unsigned char) D.54087;
    *code.8917 = D.54088;
    code.8918 = code;
    code = code.8918 + 1;
    *code.8918 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8919 = code;
          code = code.8919 + 1;
          D.54563 = imb.b[0];
          *code.8919 = D.54563;
          code.8920 = code;
          code = code.8920 + 1;
          D.54565 = imb.b[1];
          *code.8920 = D.54565;
          code.8921 = code;
          code = code.8921 + 1;
          D.54567 = imb.b[2];
          *code.8921 = D.54567;
          code.8922 = code;
          code = code.8922 + 1;
          D.54569 = imb.b[3];
          *code.8922 = D.54569;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54555>:
    <D.54553>:
    goto <D.28234>;
    <D.54548>:
    D.54053 = ins->data.op[0].const_val;
    D.54054 = (long unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54056 = D.54055 * 8;
    D.54057 = D.54054 + D.54056;
    if (D.54057 == 0) goto <D.54570>; else goto <D.54571>;
    <D.54570>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.54572>; else goto <D.54573>;
    <D.54572>:
    code.8923 = code;
    code = code.8923 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54105 = D.54064 | D.54104;
    D.54106 = (unsigned char) D.54105;
    *code.8923 = D.54106;
    goto <D.28234>;
    <D.54573>:
    <D.54571>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 >= -128) goto <D.54577>; else goto <D.54575>;
    <D.54577>:
    D.54053 = ins->data.op[0].const_val;
    D.54071 = (unsigned int) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54072 = (unsigned int) D.54055;
    D.54073 = D.54072 * 8;
    D.54074 = D.54071 + D.54073;
    D.54075 = (int) D.54074;
    if (D.54075 <= 127) goto <D.54578>; else goto <D.54575>;
    <D.54578>:
    code.8924 = code;
    code = code.8924 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54112 = D.54064 | 64;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54113 = D.54112 | D.54104;
    D.54114 = (unsigned char) D.54113;
    *code.8924 = D.54114;
    D.54053 = ins->data.op[0].const_val;
    D.54082 = (unsigned char) D.54053;
    D.54055 = (long unsigned int) quad;
    D.54083 = (unsigned char) D.54055;
    D.54084 = D.54083 * 8;
    D.54085 = D.54082 + D.54084;
    *code = D.54085;
    code = code + 1;
    goto <D.54576>;
    <D.54575>:
    code.8925 = code;
    code = code.8925 + 1;
    D.54036 = ainfo->pair_regs[quad];
    D.54061 = (int) D.54036;
    D.54062 = D.54061 & 7;
    D.54063 = D.54062 << 3;
    D.54064 = (signed char) D.54063;
    D.54116 = D.54064 | -128;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.54117 = D.54116 | D.54104;
    D.54118 = (unsigned char) D.54117;
    *code.8925 = D.54118;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54071 = (unsigned int) D.54053;
          D.54055 = (long unsigned int) quad;
          D.54072 = (unsigned int) D.54055;
          D.54073 = D.54072 * 8;
          D.54074 = D.54071 + D.54073;
          D.54075 = (int) D.54074;
          imb.val = D.54075;
          code.8926 = code;
          code = code.8926 + 1;
          D.54582 = imb.b[0];
          *code.8926 = D.54582;
          code.8927 = code;
          code = code.8927 + 1;
          D.54584 = imb.b[1];
          *code.8927 = D.54584;
          code.8928 = code;
          code = code.8928 + 1;
          D.54586 = imb.b[2];
          *code.8928 = D.54586;
          code.8929 = code;
          code = code.8929 + 1;
          D.54588 = imb.b[3];
          *code.8929 = D.54588;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54576>:
    <D.28234>:
    goto <D.28225>;
    <D.28236>:
    goto <D.28225>;
    <D.28237>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7075);
    <D.28225>:
    quad = quad + 1;
    <D.28239>:
    if (quad <= 1) goto <D.28238>; else goto <D.28240>;
    <D.28240>:
    goto <D.28202>;
    <D.28241>:
    D.54589 = ainfo->pair_storage[0];
    if (D.54589 == 0) goto <D.54590>; else goto <D.54591>;
    <D.54590>:
    if (0 != 0) goto <D.54592>; else goto <D.54593>;
    <D.54592>:
    code.8930 = code;
    code = code.8930 + 1;
    *code.8930 = 102;
    <D.54593>:
    {
      unsigned char _amd64_rex_bits;

      D.54596 = ainfo->pair_regs[0];
      if (D.54596 > 7) goto <D.54597>; else goto <D.54598>;
      <D.54597>:
      iftmp.8931 = 12;
      goto <D.54599>;
      <D.54598>:
      iftmp.8931 = 8;
      <D.54599>:
      D.54600 = ins->data.op[0].src;
      D.54601 = D.54600->sreg1;
      D.54602 = D.54601 > 7;
      D.54603 = (signed char) D.54602;
      D.54604 = iftmp.8931 | D.54603;
      _amd64_rex_bits = (unsigned char) D.54604;
      if (_amd64_rex_bits != 0) goto <D.54605>; else goto <D.54606>;
      <D.54605>:
      code.8932 = code;
      code = code.8932 + 1;
      D.54608 = _amd64_rex_bits | 64;
      *code.8932 = D.54608;
      <D.54606>:
    }
    switch (8) <default: <D.28248>, case 1: <D.28243>, case 2: <D.28245>, case 4: <D.28246>, case 8: <D.28247>>
    <D.28243>:
    code.8933 = code;
    code = code.8933 + 1;
    *code.8933 = 136;
    goto <D.28244>;
    <D.28245>:
    <D.28246>:
    <D.28247>:
    code.8934 = code;
    code = code.8934 + 1;
    *code.8934 = 137;
    goto <D.28244>;
    <D.28248>:
    __assert_fail ("0", "mini-amd64.c", 7081, &__PRETTY_FUNCTION__);
    <D.28244>:
    D.54600 = ins->data.op[0].src;
    D.54601 = D.54600->sreg1;
    D.54611 = D.54601 & 7;
    if (D.54611 == 4) goto <D.54612>; else goto <D.54613>;
    <D.54612>:
    D.54600 = ins->data.op[0].src;
    D.54614 = D.54600->data.op[0].const_val;
    if (D.54614 == 0) goto <D.54615>; else goto <D.54616>;
    <D.54615>:
    code.8935 = code;
    code = code.8935 + 1;
    D.54596 = ainfo->pair_regs[0];
    D.54618 = (int) D.54596;
    D.54619 = D.54618 & 7;
    D.54620 = D.54619 << 3;
    D.54621 = (signed char) D.54620;
    D.54622 = D.54621 | 4;
    D.54623 = (unsigned char) D.54622;
    *code.8935 = D.54623;
    code.8936 = code;
    code = code.8936 + 1;
    *code.8936 = 36;
    goto <D.54625>;
    <D.54616>:
    D.54600 = ins->data.op[0].src;
    D.54614 = D.54600->data.op[0].const_val;
    D.54626 = (unsigned int) D.54614;
    D.54627 = D.54626 + 128;
    if (D.54627 <= 255) goto <D.54628>; else goto <D.54629>;
    <D.54628>:
    code.8937 = code;
    code = code.8937 + 1;
    D.54596 = ainfo->pair_regs[0];
    D.54618 = (int) D.54596;
    D.54619 = D.54618 & 7;
    D.54620 = D.54619 << 3;
    D.54621 = (signed char) D.54620;
    D.54631 = D.54621 | 68;
    D.54632 = (unsigned char) D.54631;
    *code.8937 = D.54632;
    code.8938 = code;
    code = code.8938 + 1;
    *code.8938 = 36;
    D.54600 = ins->data.op[0].src;
    D.54614 = D.54600->data.op[0].const_val;
    D.54634 = (unsigned char) D.54614;
    *code = D.54634;
    code = code + 1;
    goto <D.54635>;
    <D.54629>:
    code.8939 = code;
    code = code.8939 + 1;
    D.54596 = ainfo->pair_regs[0];
    D.54618 = (int) D.54596;
    D.54619 = D.54618 & 7;
    D.54620 = D.54619 << 3;
    D.54621 = (signed char) D.54620;
    D.54637 = D.54621 | -124;
    D.54638 = (unsigned char) D.54637;
    *code.8939 = D.54638;
    code.8940 = code;
    code = code.8940 + 1;
    *code.8940 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54600 = ins->data.op[0].src;
          D.54614 = D.54600->data.op[0].const_val;
          D.54640 = (int) D.54614;
          imb.val = D.54640;
          code.8941 = code;
          code = code.8941 + 1;
          D.54642 = imb.b[0];
          *code.8941 = D.54642;
          code.8942 = code;
          code = code.8942 + 1;
          D.54644 = imb.b[1];
          *code.8942 = D.54644;
          code.8943 = code;
          code = code.8943 + 1;
          D.54646 = imb.b[2];
          *code.8943 = D.54646;
          code.8944 = code;
          code = code.8944 + 1;
          D.54648 = imb.b[3];
          *code.8944 = D.54648;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54635>:
    <D.54625>:
    goto <D.28250>;
    <D.54613>:
    D.54600 = ins->data.op[0].src;
    D.54614 = D.54600->data.op[0].const_val;
    if (D.54614 == 0) goto <D.54649>; else goto <D.54650>;
    <D.54649>:
    D.54600 = ins->data.op[0].src;
    D.54601 = D.54600->sreg1;
    D.54611 = D.54601 & 7;
    if (D.54611 != 5) goto <D.54651>; else goto <D.54652>;
    <D.54651>:
    code.8945 = code;
    code = code.8945 + 1;
    D.54596 = ainfo->pair_regs[0];
    D.54618 = (int) D.54596;
    D.54619 = D.54618 & 7;
    D.54620 = D.54619 << 3;
    D.54621 = (signed char) D.54620;
    D.54600 = ins->data.op[0].src;
    D.54601 = D.54600->sreg1;
    D.54654 = (signed char) D.54601;
    D.54655 = D.54654 & 7;
    D.54656 = D.54621 | D.54655;
    D.54657 = (unsigned char) D.54656;
    *code.8945 = D.54657;
    goto <D.28250>;
    <D.54652>:
    <D.54650>:
    D.54600 = ins->data.op[0].src;
    D.54614 = D.54600->data.op[0].const_val;
    D.54626 = (unsigned int) D.54614;
    D.54627 = D.54626 + 128;
    if (D.54627 <= 255) goto <D.54658>; else goto <D.54659>;
    <D.54658>:
    code.8946 = code;
    code = code.8946 + 1;
    D.54596 = ainfo->pair_regs[0];
    D.54618 = (int) D.54596;
    D.54619 = D.54618 & 7;
    D.54620 = D.54619 << 3;
    D.54621 = (signed char) D.54620;
    D.54661 = D.54621 | 64;
    D.54600 = ins->data.op[0].src;
    D.54601 = D.54600->sreg1;
    D.54654 = (signed char) D.54601;
    D.54655 = D.54654 & 7;
    D.54662 = D.54661 | D.54655;
    D.54663 = (unsigned char) D.54662;
    *code.8946 = D.54663;
    D.54600 = ins->data.op[0].src;
    D.54614 = D.54600->data.op[0].const_val;
    D.54634 = (unsigned char) D.54614;
    *code = D.54634;
    code = code + 1;
    goto <D.54664>;
    <D.54659>:
    code.8947 = code;
    code = code.8947 + 1;
    D.54596 = ainfo->pair_regs[0];
    D.54618 = (int) D.54596;
    D.54619 = D.54618 & 7;
    D.54620 = D.54619 << 3;
    D.54621 = (signed char) D.54620;
    D.54666 = D.54621 | -128;
    D.54600 = ins->data.op[0].src;
    D.54601 = D.54600->sreg1;
    D.54654 = (signed char) D.54601;
    D.54655 = D.54654 & 7;
    D.54667 = D.54666 | D.54655;
    D.54668 = (unsigned char) D.54667;
    *code.8947 = D.54668;
    {
      union x86_imm_buf imb;

      try
        {
          D.54600 = ins->data.op[0].src;
          D.54614 = D.54600->data.op[0].const_val;
          D.54640 = (int) D.54614;
          imb.val = D.54640;
          code.8948 = code;
          code = code.8948 + 1;
          D.54670 = imb.b[0];
          *code.8948 = D.54670;
          code.8949 = code;
          code = code.8949 + 1;
          D.54672 = imb.b[1];
          *code.8949 = D.54672;
          code.8950 = code;
          code = code.8950 + 1;
          D.54674 = imb.b[2];
          *code.8950 = D.54674;
          code.8951 = code;
          code = code.8951 + 1;
          D.54676 = imb.b[3];
          *code.8951 = D.54676;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54664>:
    <D.28250>:
    <D.54591>:
    goto <D.28202>;
    <D.28252>:
    goto <D.28202>;
    <D.28202>:
    goto <D.54677>;
    <D.54237>:
    D.54006 = ainfo->storage;
    switch (D.54006) <default: <D.28274>, case 0: <D.28253>, case 3: <D.28262>>
    <D.28253>:
    if (0 != 0) goto <D.54678>; else goto <D.54679>;
    <D.54678>:
    code.8952 = code;
    code = code.8952 + 1;
    *code.8952 = 102;
    <D.54679>:
    {
      unsigned char _amd64_rex_bits;

      D.54682 = ins->dreg;
      if (D.54682 > 7) goto <D.54683>; else goto <D.54684>;
      <D.54683>:
      iftmp.8953 = 12;
      goto <D.54685>;
      <D.54684>:
      iftmp.8953 = 8;
      <D.54685>:
      D.54009 = ainfo->reg;
      D.54013 = D.54009 > 7;
      D.54014 = (signed char) D.54013;
      D.54686 = iftmp.8953 | D.54014;
      _amd64_rex_bits = (unsigned char) D.54686;
      if (_amd64_rex_bits != 0) goto <D.54687>; else goto <D.54688>;
      <D.54687>:
      code.8954 = code;
      code = code.8954 + 1;
      D.54690 = _amd64_rex_bits | 64;
      *code.8954 = D.54690;
      <D.54688>:
    }
    switch (8) <default: <D.28260>, case 1: <D.28255>, case 2: <D.28257>, case 4: <D.28258>, case 8: <D.28259>>
    <D.28255>:
    code.8955 = code;
    code = code.8955 + 1;
    *code.8955 = 138;
    goto <D.28256>;
    <D.28257>:
    <D.28258>:
    <D.28259>:
    code.8956 = code;
    code = code.8956 + 1;
    *code.8956 = 139;
    goto <D.28256>;
    <D.28260>:
    __assert_fail ("0", "mini-amd64.c", 7090, &__PRETTY_FUNCTION__);
    <D.28256>:
    code.8957 = code;
    code = code.8957 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54697 = D.54696 | -64;
    D.54009 = ainfo->reg;
    D.54028 = D.54009 & 7;
    D.54698 = D.54697 | D.54028;
    D.54699 = (unsigned char) D.54698;
    *code.8957 = D.54699;
    goto <D.28261>;
    <D.28262>:
    if (0 != 0) goto <D.54700>; else goto <D.54701>;
    <D.54700>:
    code.8958 = code;
    code = code.8958 + 1;
    *code.8958 = 102;
    <D.54701>:
    {
      unsigned char _amd64_rex_bits;

      D.54682 = ins->dreg;
      if (D.54682 > 7) goto <D.54704>; else goto <D.54705>;
      <D.54704>:
      iftmp.8959 = 12;
      goto <D.54706>;
      <D.54705>:
      iftmp.8959 = 8;
      <D.54706>:
      _amd64_rex_bits = iftmp.8959;
      if (_amd64_rex_bits != 0) goto <D.54707>; else goto <D.54708>;
      <D.54707>:
      code.8960 = code;
      code = code.8960 + 1;
      D.54710 = _amd64_rex_bits | 64;
      *code.8960 = D.54710;
      <D.54708>:
    }
    switch (8) <default: <D.28269>, case 1: <D.28264>, case 2: <D.28266>, case 4: <D.28267>, case 8: <D.28268>>
    <D.28264>:
    code.8961 = code;
    code = code.8961 + 1;
    *code.8961 = 138;
    goto <D.28265>;
    <D.28266>:
    <D.28267>:
    <D.28268>:
    code.8962 = code;
    code = code.8962 + 1;
    *code.8962 = 139;
    goto <D.28265>;
    <D.28269>:
    __assert_fail ("0", "mini-amd64.c", 7093, &__PRETTY_FUNCTION__);
    <D.28265>:
    if (0 != 0) goto <D.54713>; else goto <D.54714>;
    <D.54713>:
    code.8963 = code;
    code = code.8963 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54716 = D.54696 | 5;
    D.54717 = (unsigned char) D.54716;
    *code.8963 = D.54717;
    {
      union x86_imm_buf imb;

      try
        {
          D.54000 = ainfo->offset;
          D.54001 = (int) D.54000;
          D.54718 = D.54001 + 16;
          imb.val = D.54718;
          code.8964 = code;
          code = code.8964 + 1;
          D.54720 = imb.b[0];
          *code.8964 = D.54720;
          code.8965 = code;
          code = code.8965 + 1;
          D.54722 = imb.b[1];
          *code.8965 = D.54722;
          code.8966 = code;
          code = code.8966 + 1;
          D.54724 = imb.b[2];
          *code.8966 = D.54724;
          code.8967 = code;
          code = code.8967 + 1;
          D.54726 = imb.b[3];
          *code.8967 = D.54726;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.54727>;
    <D.54714>:
    if (0 != 0) goto <D.54728>; else goto <D.54729>;
    <D.54728>:
    D.54000 = ainfo->offset;
    if (D.54000 == -16) goto <D.54730>; else goto <D.54731>;
    <D.54730>:
    code.8968 = code;
    code = code.8968 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54733 = D.54696 | 4;
    D.54734 = (unsigned char) D.54733;
    *code.8968 = D.54734;
    code.8969 = code;
    code = code.8969 + 1;
    *code.8969 = 36;
    goto <D.54736>;
    <D.54731>:
    D.54000 = ainfo->offset;
    D.54737 = (unsigned short) D.54000;
    D.54738 = D.54737 + 144;
    if (D.54738 <= 255) goto <D.54739>; else goto <D.54740>;
    <D.54739>:
    code.8970 = code;
    code = code.8970 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54742 = D.54696 | 68;
    D.54743 = (unsigned char) D.54742;
    *code.8970 = D.54743;
    code.8971 = code;
    code = code.8971 + 1;
    *code.8971 = 36;
    D.54000 = ainfo->offset;
    D.54745 = (unsigned char) D.54000;
    D.54746 = D.54745 + 16;
    *code = D.54746;
    code = code + 1;
    goto <D.54747>;
    <D.54740>:
    code.8972 = code;
    code = code.8972 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54749 = D.54696 | -124;
    D.54750 = (unsigned char) D.54749;
    *code.8972 = D.54750;
    code.8973 = code;
    code = code.8973 + 1;
    *code.8973 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54000 = ainfo->offset;
          D.54001 = (int) D.54000;
          D.54718 = D.54001 + 16;
          imb.val = D.54718;
          code.8974 = code;
          code = code.8974 + 1;
          D.54753 = imb.b[0];
          *code.8974 = D.54753;
          code.8975 = code;
          code = code.8975 + 1;
          D.54755 = imb.b[1];
          *code.8975 = D.54755;
          code.8976 = code;
          code = code.8976 + 1;
          D.54757 = imb.b[2];
          *code.8976 = D.54757;
          code.8977 = code;
          code = code.8977 + 1;
          D.54759 = imb.b[3];
          *code.8977 = D.54759;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54747>:
    <D.54736>:
    goto <D.28272>;
    <D.54729>:
    if (0 != 0) goto <D.54760>; else goto <D.54761>;
    <D.54760>:
    code.8978 = code;
    code = code.8978 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54716 = D.54696 | 5;
    D.54717 = (unsigned char) D.54716;
    *code.8978 = D.54717;
    goto <D.28272>;
    <D.54761>:
    D.54000 = ainfo->offset;
    D.54737 = (unsigned short) D.54000;
    D.54738 = D.54737 + 144;
    if (D.54738 <= 255) goto <D.54763>; else goto <D.54764>;
    <D.54763>:
    code.8979 = code;
    code = code.8979 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54766 = D.54696 | 69;
    D.54767 = (unsigned char) D.54766;
    *code.8979 = D.54767;
    D.54000 = ainfo->offset;
    D.54745 = (unsigned char) D.54000;
    D.54746 = D.54745 + 16;
    *code = D.54746;
    code = code + 1;
    goto <D.54768>;
    <D.54764>:
    code.8980 = code;
    code = code.8980 + 1;
    D.54682 = ins->dreg;
    D.54694 = D.54682 & 7;
    D.54695 = D.54694 << 3;
    D.54696 = (signed char) D.54695;
    D.54770 = D.54696 | -123;
    D.54771 = (unsigned char) D.54770;
    *code.8980 = D.54771;
    {
      union x86_imm_buf imb;

      try
        {
          D.54000 = ainfo->offset;
          D.54001 = (int) D.54000;
          D.54718 = D.54001 + 16;
          imb.val = D.54718;
          code.8981 = code;
          code = code.8981 + 1;
          D.54773 = imb.b[0];
          *code.8981 = D.54773;
          code.8982 = code;
          code = code.8982 + 1;
          D.54775 = imb.b[1];
          *code.8982 = D.54775;
          code.8983 = code;
          code = code.8983 + 1;
          D.54777 = imb.b[2];
          *code.8983 = D.54777;
          code.8984 = code;
          code = code.8984 + 1;
          D.54779 = imb.b[3];
          *code.8984 = D.54779;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54768>:
    <D.28272>:
    <D.54727>:
    goto <D.28261>;
    <D.28274>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7096);
    <D.28261>:
    D.53979 = cfg->args;
    D.54318 = *D.53979;
    if (D.54318 == ins) goto <D.54780>; else goto <D.54781>;
    <D.54780>:
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    D.54009 = ainfo->reg;
    D.54023 = (int) D.54009;
    mono_add_var_location (cfg, ins, 1, D.54023, 0, 0, D.52991);
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    D.54682 = ins->dreg;
    mono_add_var_location (cfg, ins, 1, D.54682, 0, D.52991, 0);
    <D.54781>:
    <D.54677>:
  }
  <D.28157>:
  i = i + 1;
  <D.28276>:
  D.54782 = sig->param_count;
  D.54783 = (int) D.54782;
  D.53997 = sig->hasthis;
  D.53998 = (int) D.53997;
  D.54784 = D.54783 + D.53998;
  if (D.54784 > i) goto <D.28275>; else goto <D.28277>;
  <D.28277>:
  args_clobbered = 1;
  if (trace != 0) goto <D.54785>; else goto <D.54786>;
  <D.54785>:
  args_clobbered = 1;
  code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, 1);
  <D.54786>:
  D.53857 = cfg->prof_options;
  D.54787 = D.53857 & 4096;
  if (D.54787 != 0) goto <D.54788>; else goto <D.54789>;
  <D.54788>:
  args_clobbered = 1;
  <D.54789>:
  if (args_clobbered == 0) goto <D.54790>; else goto <D.54791>;
  <D.54790>:
  {
    struct MonoBasicBlock * first_bb;
    struct MonoInst * next;

    first_bb = cfg->bb_entry;
    next = first_bb->code;
    if (next == 0B) goto <D.54792>; else goto <D.54793>;
    <D.54792>:
    D.54794 = first_bb->next_bb;
    if (D.54794 != 0B) goto <D.54795>; else goto <D.54796>;
    <D.54795>:
    first_bb = first_bb->next_bb;
    next = first_bb->code;
    <D.54796>:
    <D.54793>:
    D.54797 = first_bb->in_count;
    if (D.54797 > 1) goto <D.54798>; else goto <D.54799>;
    <D.54798>:
    next = 0B;
    <D.54799>:
    i = 0;
    goto <D.28290>;
    <D.28289>:
    {
      struct ArgInfo * ainfo;
      gboolean match;

      D.53978 = (sizetype) i;
      ainfo = &cinfo->args[D.53978];
      match = 0;
      D.53979 = cfg->args;
      D.53980 = (long unsigned int) i;
      D.53981 = D.53980 * 8;
      D.53982 = D.53979 + D.53981;
      ins = *D.53982;
      D.54235 = ins->opcode;
      if (D.54235 != 366) goto <D.54800>; else goto <D.54801>;
      <D.54800>:
      D.54802 = ainfo->storage;
      switch (D.54802) <default: <D.28284>, case 0: <D.28282>>
      <D.28282>:
      D.54803 = next->opcode;
      D.54804 = D.54803 == 391;
      D.54805 = D.54803 == 396;
      D.54806 = D.54804 | D.54805;
      if (D.54806 != 0) goto <D.54807>; else goto <D.54808>;
      <D.54807>:
      D.54809 = next->sreg1;
      D.54040 = ins->sreg1;
      if (D.54809 == D.54040) goto <D.54810>; else goto <D.54811>;
      <D.54810>:
      D.54812 = next->data.op[0].const_val;
      D.54053 = ins->data.op[0].const_val;
      if (D.54812 == D.54053) goto <D.54813>; else goto <D.54814>;
      <D.54813>:
      D.54815 = next->dreg;
      D.54816 = ainfo->reg;
      D.54817 = (int) D.54816;
      if (D.54815 == D.54817) goto <D.54818>; else goto <D.54819>;
      <D.54818>:
      next->opcode = 316;
      next->dreg = -1;
      next->sreg3 = -1;
      D.54820 = next->sreg3;
      next->sreg2 = D.54820;
      D.54821 = next->sreg2;
      next->sreg1 = D.54821;
      match = 1;
      goto <D.54822>;
      <D.54819>:
      next->opcode = 428;
      D.54816 = ainfo->reg;
      D.54823 = (int) D.54816;
      next->sreg1 = D.54823;
      D.54815 = next->dreg;
      D.54816 = ainfo->reg;
      D.54817 = (int) D.54816;
      if (D.54815 == D.54817) goto <D.54824>; else goto <D.54826>;
      <D.54826>:
      D.54815 = next->dreg;
      if (D.54815 == 0) goto <D.54824>; else goto <D.54825>;
      <D.54824>:
      match = 1;
      <D.54825>:
      <D.54822>:
      <D.54814>:
      <D.54811>:
      <D.54808>:
      goto <D.28283>;
      <D.28284>:
      goto <D.28283>;
      <D.28283>:
      goto <D.54827>;
      <D.54801>:
      D.54802 = ainfo->storage;
      switch (D.54802) <default: <D.28287>, case 0: <D.28285>>
      <D.28285>:
      D.54828 = next->opcode;
      if (D.54828 == 428) goto <D.54829>; else goto <D.54830>;
      <D.54829>:
      D.54809 = next->sreg1;
      D.54682 = ins->dreg;
      if (D.54809 == D.54682) goto <D.54831>; else goto <D.54832>;
      <D.54831>:
      D.54815 = next->dreg;
      D.54816 = ainfo->reg;
      D.54817 = (int) D.54816;
      if (D.54815 == D.54817) goto <D.54833>; else goto <D.54834>;
      <D.54833>:
      next->opcode = 316;
      next->dreg = -1;
      next->sreg3 = -1;
      D.54820 = next->sreg3;
      next->sreg2 = D.54820;
      D.54821 = next->sreg2;
      next->sreg1 = D.54821;
      match = 1;
      <D.54834>:
      <D.54832>:
      <D.54830>:
      goto <D.28286>;
      <D.28287>:
      goto <D.28286>;
      <D.28286>:
      <D.54827>:
      if (match != 0) goto <D.54835>; else goto <D.54836>;
      <D.54835>:
      next = next->next;
      if (next == 0B) goto <D.28288>; else goto <D.54837>;
      <D.54837>:
      <D.54836>:
    }
    i = i + 1;
    <D.28290>:
    if (next != 0B) goto <D.54838>; else goto <D.28288>;
    <D.54838>:
    D.54782 = sig->param_count;
    D.54783 = (int) D.54782;
    D.53997 = sig->hasthis;
    D.53998 = (int) D.53997;
    D.54784 = D.54783 + D.53998;
    if (D.54784 > i) goto <D.28289>; else goto <D.28288>;
    <D.28288>:
  }
  <D.54791>:
  D.54839 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.54840 = D.54839 & 32;
  if (D.54840 != 0) goto <D.54841>; else goto <D.54842>;
  <D.54841>:
  {
    struct MonoInst * info_var;

    info_var = cfg->arch.seq_point_info_var;
    D.54843 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.54844 = D.54843 & 64;
    if (D.54844 != 0) goto <D.54845>; else goto <D.54846>;
    <D.54845>:
    D.52996 = cfg->method;
    code.8397 = (long int) code;
    D.52988 = cfg->native_code;
    D.52989 = (long int) D.52988;
    D.52990 = code.8397 - D.52989;
    D.52991 = (int) D.52990;
    mono_add_patch_info (cfg, D.52991, 40, D.52996);
    if (0 != 0) goto <D.54847>; else goto <D.54848>;
    <D.54847>:
    code.8985 = code;
    code = code.8985 + 1;
    *code.8985 = 102;
    <D.54848>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 13;
      if (_amd64_rex_bits != 0) goto <D.54850>; else goto <D.54851>;
      <D.54850>:
      code.8986 = code;
      code = code.8986 + 1;
      D.54853 = _amd64_rex_bits | 64;
      *code.8986 = D.54853;
      <D.54851>:
    }
    switch (8) <default: <D.28298>, case 1: <D.28293>, case 2: <D.28295>, case 4: <D.28296>, case 8: <D.28297>>
    <D.28293>:
    code.8987 = code;
    code = code.8987 + 1;
    *code.8987 = 138;
    goto <D.28294>;
    <D.28295>:
    <D.28296>:
    <D.28297>:
    code.8988 = code;
    code = code.8988 + 1;
    *code.8988 = 139;
    goto <D.28294>;
    <D.28298>:
    __assert_fail ("0", "mini-amd64.c", 7197, &__PRETTY_FUNCTION__);
    <D.28294>:
    if (1 != 0) goto <D.54856>; else goto <D.54857>;
    <D.54856>:
    code.8989 = code;
    code = code.8989 + 1;
    *code.8989 = 29;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.8990 = code;
          code = code.8990 + 1;
          D.54860 = imb.b[0];
          *code.8990 = D.54860;
          code.8991 = code;
          code = code.8991 + 1;
          D.54862 = imb.b[1];
          *code.8991 = D.54862;
          code.8992 = code;
          code = code.8992 + 1;
          D.54864 = imb.b[2];
          *code.8992 = D.54864;
          code.8993 = code;
          code = code.8993 + 1;
          D.54866 = imb.b[3];
          *code.8993 = D.54866;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.54867>;
    <D.54857>:
    if (0 != 0) goto <D.54868>; else goto <D.54869>;
    <D.54868>:
    if (1 != 0) goto <D.54870>; else goto <D.54871>;
    <D.54870>:
    code.8994 = code;
    code = code.8994 + 1;
    *code.8994 = 28;
    code.8995 = code;
    code = code.8995 + 1;
    *code.8995 = 36;
    goto <D.54874>;
    <D.54871>:
    if (1 != 0) goto <D.54875>; else goto <D.54876>;
    <D.54875>:
    code.8996 = code;
    code = code.8996 + 1;
    *code.8996 = 92;
    code.8997 = code;
    code = code.8997 + 1;
    *code.8997 = 36;
    *code = 0;
    code = code + 1;
    goto <D.54879>;
    <D.54876>:
    code.8998 = code;
    code = code.8998 + 1;
    *code.8998 = 156;
    code.8999 = code;
    code = code.8999 + 1;
    *code.8999 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9000 = code;
          code = code.9000 + 1;
          D.54883 = imb.b[0];
          *code.9000 = D.54883;
          code.9001 = code;
          code = code.9001 + 1;
          D.54885 = imb.b[1];
          *code.9001 = D.54885;
          code.9002 = code;
          code = code.9002 + 1;
          D.54887 = imb.b[2];
          *code.9002 = D.54887;
          code.9003 = code;
          code = code.9003 + 1;
          D.54889 = imb.b[3];
          *code.9003 = D.54889;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54879>:
    <D.54874>:
    goto <D.28301>;
    <D.54869>:
    if (1 != 0) goto <D.54890>; else goto <D.54891>;
    <D.54890>:
    code.9004 = code;
    code = code.9004 + 1;
    *code.9004 = 24;
    goto <D.28301>;
    <D.54891>:
    if (1 != 0) goto <D.54893>; else goto <D.54894>;
    <D.54893>:
    code.9005 = code;
    code = code.9005 + 1;
    *code.9005 = 88;
    *code = 0;
    code = code + 1;
    goto <D.54896>;
    <D.54894>:
    code.9006 = code;
    code = code.9006 + 1;
    *code.9006 = 152;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9007 = code;
          code = code.9007 + 1;
          D.54899 = imb.b[0];
          *code.9007 = D.54899;
          code.9008 = code;
          code = code.9008 + 1;
          D.54901 = imb.b[1];
          *code.9008 = D.54901;
          code.9009 = code;
          code = code.9009 + 1;
          D.54903 = imb.b[2];
          *code.9009 = D.54903;
          code.9010 = code;
          code = code.9010 + 1;
          D.54905 = imb.b[3];
          *code.9010 = D.54905;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54896>:
    <D.28301>:
    <D.54867>:
    D.54906 = info_var->opcode;
    D.54907 = D.54906 != 367;
    D.54908 = (long int) D.54907;
    D.54909 = __builtin_expect (D.54908, 0);
    if (D.54909 != 0) goto <D.54910>; else goto <D.54911>;
    <D.54910>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7198, "info_var->opcode == OP_REGOFFSET");
    <D.54911>:
    if (0 != 0) goto <D.54912>; else goto <D.54913>;
    <D.54912>:
    code.9011 = code;
    code = code.9011 + 1;
    *code.9011 = 102;
    <D.54913>:
    {
      unsigned char _amd64_rex_bits;

      D.54916 = info_var->sreg1;
      if (D.54916 > 7) goto <D.54917>; else goto <D.54918>;
      <D.54917>:
      iftmp.9012 = 13;
      goto <D.54919>;
      <D.54918>:
      iftmp.9012 = 12;
      <D.54919>:
      _amd64_rex_bits = iftmp.9012;
      if (_amd64_rex_bits != 0) goto <D.54920>; else goto <D.54921>;
      <D.54920>:
      code.9013 = code;
      code = code.9013 + 1;
      D.54923 = _amd64_rex_bits | 64;
      *code.9013 = D.54923;
      <D.54921>:
    }
    switch (8) <default: <D.28309>, case 1: <D.28304>, case 2: <D.28306>, case 4: <D.28307>, case 8: <D.28308>>
    <D.28304>:
    code.9014 = code;
    code = code.9014 + 1;
    *code.9014 = 136;
    goto <D.28305>;
    <D.28306>:
    <D.28307>:
    <D.28308>:
    code.9015 = code;
    code = code.9015 + 1;
    *code.9015 = 137;
    goto <D.28305>;
    <D.28309>:
    __assert_fail ("0", "mini-amd64.c", 7199, &__PRETTY_FUNCTION__);
    <D.28305>:
    D.54916 = info_var->sreg1;
    D.54926 = D.54916 & 7;
    if (D.54926 == 4) goto <D.54927>; else goto <D.54928>;
    <D.54927>:
    D.54929 = info_var->data.op[0].const_val;
    if (D.54929 == 0) goto <D.54930>; else goto <D.54931>;
    <D.54930>:
    code.9016 = code;
    code = code.9016 + 1;
    *code.9016 = 28;
    code.9017 = code;
    code = code.9017 + 1;
    *code.9017 = 36;
    goto <D.54934>;
    <D.54931>:
    D.54929 = info_var->data.op[0].const_val;
    D.54935 = (unsigned int) D.54929;
    D.54936 = D.54935 + 128;
    if (D.54936 <= 255) goto <D.54937>; else goto <D.54938>;
    <D.54937>:
    code.9018 = code;
    code = code.9018 + 1;
    *code.9018 = 92;
    code.9019 = code;
    code = code.9019 + 1;
    *code.9019 = 36;
    D.54929 = info_var->data.op[0].const_val;
    D.54941 = (unsigned char) D.54929;
    *code = D.54941;
    code = code + 1;
    goto <D.54942>;
    <D.54938>:
    code.9020 = code;
    code = code.9020 + 1;
    *code.9020 = 156;
    code.9021 = code;
    code = code.9021 + 1;
    *code.9021 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54929 = info_var->data.op[0].const_val;
          D.54945 = (int) D.54929;
          imb.val = D.54945;
          code.9022 = code;
          code = code.9022 + 1;
          D.54947 = imb.b[0];
          *code.9022 = D.54947;
          code.9023 = code;
          code = code.9023 + 1;
          D.54949 = imb.b[1];
          *code.9023 = D.54949;
          code.9024 = code;
          code = code.9024 + 1;
          D.54951 = imb.b[2];
          *code.9024 = D.54951;
          code.9025 = code;
          code = code.9025 + 1;
          D.54953 = imb.b[3];
          *code.9025 = D.54953;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54942>:
    <D.54934>:
    goto <D.28311>;
    <D.54928>:
    D.54929 = info_var->data.op[0].const_val;
    if (D.54929 == 0) goto <D.54954>; else goto <D.54955>;
    <D.54954>:
    D.54916 = info_var->sreg1;
    D.54926 = D.54916 & 7;
    if (D.54926 != 5) goto <D.54956>; else goto <D.54957>;
    <D.54956>:
    code.9026 = code;
    code = code.9026 + 1;
    D.54916 = info_var->sreg1;
    D.54959 = (signed char) D.54916;
    D.54960 = D.54959 & 7;
    D.54961 = D.54960 | 24;
    D.54962 = (unsigned char) D.54961;
    *code.9026 = D.54962;
    goto <D.28311>;
    <D.54957>:
    <D.54955>:
    D.54929 = info_var->data.op[0].const_val;
    D.54935 = (unsigned int) D.54929;
    D.54936 = D.54935 + 128;
    if (D.54936 <= 255) goto <D.54963>; else goto <D.54964>;
    <D.54963>:
    code.9027 = code;
    code = code.9027 + 1;
    D.54916 = info_var->sreg1;
    D.54959 = (signed char) D.54916;
    D.54960 = D.54959 & 7;
    D.54966 = D.54960 | 88;
    D.54967 = (unsigned char) D.54966;
    *code.9027 = D.54967;
    D.54929 = info_var->data.op[0].const_val;
    D.54941 = (unsigned char) D.54929;
    *code = D.54941;
    code = code + 1;
    goto <D.54968>;
    <D.54964>:
    code.9028 = code;
    code = code.9028 + 1;
    D.54916 = info_var->sreg1;
    D.54959 = (signed char) D.54916;
    D.54960 = D.54959 & 7;
    D.54970 = D.54960 | -104;
    D.54971 = (unsigned char) D.54970;
    *code.9028 = D.54971;
    {
      union x86_imm_buf imb;

      try
        {
          D.54929 = info_var->data.op[0].const_val;
          D.54945 = (int) D.54929;
          imb.val = D.54945;
          code.9029 = code;
          code = code.9029 + 1;
          D.54973 = imb.b[0];
          *code.9029 = D.54973;
          code.9030 = code;
          code = code.9030 + 1;
          D.54975 = imb.b[1];
          *code.9030 = D.54975;
          code.9031 = code;
          code = code.9031 + 1;
          D.54977 = imb.b[2];
          *code.9031 = D.54977;
          code.9032 = code;
          code = code.9032 + 1;
          D.54979 = imb.b[3];
          *code.9032 = D.54979;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.54968>:
    <D.28311>:
    <D.54846>:
    ins = cfg->arch.ss_trigger_page_var;
    D.54235 = ins->opcode;
    D.54980 = D.54235 != 367;
    D.54981 = (long int) D.54980;
    D.54982 = __builtin_expect (D.54981, 0);
    if (D.54982 != 0) goto <D.54983>; else goto <D.54984>;
    <D.54983>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7205, "ins->opcode == OP_REGOFFSET");
    <D.54984>:
    D.54843 = BIT_FIELD_REF <*cfg, 8, 5600>;
    D.54844 = D.54843 & 64;
    if (D.54844 != 0) goto <D.54985>; else goto <D.54986>;
    <D.54985>:
    if (0 != 0) goto <D.54987>; else goto <D.54988>;
    <D.54987>:
    code.9033 = code;
    code = code.9033 + 1;
    *code.9033 = 102;
    <D.54988>:
    {
      unsigned char _amd64_rex_bits;

      D.54916 = info_var->sreg1;
      if (D.54916 > 7) goto <D.54991>; else goto <D.54992>;
      <D.54991>:
      iftmp.9034 = 13;
      goto <D.54993>;
      <D.54992>:
      iftmp.9034 = 12;
      <D.54993>:
      _amd64_rex_bits = iftmp.9034;
      if (_amd64_rex_bits != 0) goto <D.54994>; else goto <D.54995>;
      <D.54994>:
      code.9035 = code;
      code = code.9035 + 1;
      D.54997 = _amd64_rex_bits | 64;
      *code.9035 = D.54997;
      <D.54995>:
    }
    switch (8) <default: <D.28319>, case 1: <D.28314>, case 2: <D.28316>, case 4: <D.28317>, case 8: <D.28318>>
    <D.28314>:
    code.9036 = code;
    code = code.9036 + 1;
    *code.9036 = 138;
    goto <D.28315>;
    <D.28316>:
    <D.28317>:
    <D.28318>:
    code.9037 = code;
    code = code.9037 + 1;
    *code.9037 = 139;
    goto <D.28315>;
    <D.28319>:
    __assert_fail ("0", "mini-amd64.c", 7208, &__PRETTY_FUNCTION__);
    <D.28315>:
    D.54916 = info_var->sreg1;
    if (D.54916 == 16) goto <D.55000>; else goto <D.55001>;
    <D.55000>:
    code.9038 = code;
    code = code.9038 + 1;
    *code.9038 = 29;
    {
      union x86_imm_buf imb;

      try
        {
          D.54929 = info_var->data.op[0].const_val;
          D.54945 = (int) D.54929;
          imb.val = D.54945;
          code.9039 = code;
          code = code.9039 + 1;
          D.55004 = imb.b[0];
          *code.9039 = D.55004;
          code.9040 = code;
          code = code.9040 + 1;
          D.55006 = imb.b[1];
          *code.9040 = D.55006;
          code.9041 = code;
          code = code.9041 + 1;
          D.55008 = imb.b[2];
          *code.9041 = D.55008;
          code.9042 = code;
          code = code.9042 + 1;
          D.55010 = imb.b[3];
          *code.9042 = D.55010;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.55011>;
    <D.55001>:
    D.54916 = info_var->sreg1;
    D.54926 = D.54916 & 7;
    if (D.54926 == 4) goto <D.55012>; else goto <D.55013>;
    <D.55012>:
    D.54929 = info_var->data.op[0].const_val;
    if (D.54929 == 0) goto <D.55014>; else goto <D.55015>;
    <D.55014>:
    code.9043 = code;
    code = code.9043 + 1;
    *code.9043 = 28;
    code.9044 = code;
    code = code.9044 + 1;
    *code.9044 = 36;
    goto <D.55018>;
    <D.55015>:
    D.54929 = info_var->data.op[0].const_val;
    D.54935 = (unsigned int) D.54929;
    D.54936 = D.54935 + 128;
    if (D.54936 <= 255) goto <D.55019>; else goto <D.55020>;
    <D.55019>:
    code.9045 = code;
    code = code.9045 + 1;
    *code.9045 = 92;
    code.9046 = code;
    code = code.9046 + 1;
    *code.9046 = 36;
    D.54929 = info_var->data.op[0].const_val;
    D.54941 = (unsigned char) D.54929;
    *code = D.54941;
    code = code + 1;
    goto <D.55023>;
    <D.55020>:
    code.9047 = code;
    code = code.9047 + 1;
    *code.9047 = 156;
    code.9048 = code;
    code = code.9048 + 1;
    *code.9048 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54929 = info_var->data.op[0].const_val;
          D.54945 = (int) D.54929;
          imb.val = D.54945;
          code.9049 = code;
          code = code.9049 + 1;
          D.55027 = imb.b[0];
          *code.9049 = D.55027;
          code.9050 = code;
          code = code.9050 + 1;
          D.55029 = imb.b[1];
          *code.9050 = D.55029;
          code.9051 = code;
          code = code.9051 + 1;
          D.55031 = imb.b[2];
          *code.9051 = D.55031;
          code.9052 = code;
          code = code.9052 + 1;
          D.55033 = imb.b[3];
          *code.9052 = D.55033;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55023>:
    <D.55018>:
    goto <D.28322>;
    <D.55013>:
    D.54929 = info_var->data.op[0].const_val;
    if (D.54929 == 0) goto <D.55034>; else goto <D.55035>;
    <D.55034>:
    D.54916 = info_var->sreg1;
    D.54926 = D.54916 & 7;
    if (D.54926 != 5) goto <D.55036>; else goto <D.55037>;
    <D.55036>:
    code.9053 = code;
    code = code.9053 + 1;
    D.54916 = info_var->sreg1;
    D.54959 = (signed char) D.54916;
    D.54960 = D.54959 & 7;
    D.54961 = D.54960 | 24;
    D.54962 = (unsigned char) D.54961;
    *code.9053 = D.54962;
    goto <D.28322>;
    <D.55037>:
    <D.55035>:
    D.54929 = info_var->data.op[0].const_val;
    D.54935 = (unsigned int) D.54929;
    D.54936 = D.54935 + 128;
    if (D.54936 <= 255) goto <D.55039>; else goto <D.55040>;
    <D.55039>:
    code.9054 = code;
    code = code.9054 + 1;
    D.54916 = info_var->sreg1;
    D.54959 = (signed char) D.54916;
    D.54960 = D.54959 & 7;
    D.54966 = D.54960 | 88;
    D.54967 = (unsigned char) D.54966;
    *code.9054 = D.54967;
    D.54929 = info_var->data.op[0].const_val;
    D.54941 = (unsigned char) D.54929;
    *code = D.54941;
    code = code + 1;
    goto <D.55042>;
    <D.55040>:
    code.9055 = code;
    code = code.9055 + 1;
    D.54916 = info_var->sreg1;
    D.54959 = (signed char) D.54916;
    D.54960 = D.54959 & 7;
    D.54970 = D.54960 | -104;
    D.54971 = (unsigned char) D.54970;
    *code.9055 = D.54971;
    {
      union x86_imm_buf imb;

      try
        {
          D.54929 = info_var->data.op[0].const_val;
          D.54945 = (int) D.54929;
          imb.val = D.54945;
          code.9056 = code;
          code = code.9056 + 1;
          D.55045 = imb.b[0];
          *code.9056 = D.55045;
          code.9057 = code;
          code = code.9057 + 1;
          D.55047 = imb.b[1];
          *code.9057 = D.55047;
          code.9058 = code;
          code = code.9058 + 1;
          D.55049 = imb.b[2];
          *code.9058 = D.55049;
          code.9059 = code;
          code = code.9059 + 1;
          D.55051 = imb.b[3];
          *code.9059 = D.55051;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55042>:
    <D.28322>:
    <D.55011>:
    if (0 != 0) goto <D.55052>; else goto <D.55053>;
    <D.55052>:
    code.9060 = code;
    code = code.9060 + 1;
    *code.9060 = 102;
    <D.55053>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 13;
      if (_amd64_rex_bits != 0) goto <D.55055>; else goto <D.55056>;
      <D.55055>:
      code.9061 = code;
      code = code.9061 + 1;
      D.55058 = _amd64_rex_bits | 64;
      *code.9061 = D.55058;
      <D.55056>:
    }
    switch (8) <default: <D.28330>, case 1: <D.28325>, case 2: <D.28327>, case 4: <D.28328>, case 8: <D.28329>>
    <D.28325>:
    code.9062 = code;
    code = code.9062 + 1;
    *code.9062 = 138;
    goto <D.28326>;
    <D.28327>:
    <D.28328>:
    <D.28329>:
    code.9063 = code;
    code = code.9063 + 1;
    *code.9063 = 139;
    goto <D.28326>;
    <D.28330>:
    __assert_fail ("0", "mini-amd64.c", 7209, &__PRETTY_FUNCTION__);
    <D.28326>:
    if (0 != 0) goto <D.55061>; else goto <D.55062>;
    <D.55061>:
    code.9064 = code;
    code = code.9064 + 1;
    *code.9064 = 29;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9065 = code;
          code = code.9065 + 1;
          D.55065 = imb.b[0];
          *code.9065 = D.55065;
          code.9066 = code;
          code = code.9066 + 1;
          D.55067 = imb.b[1];
          *code.9066 = D.55067;
          code.9067 = code;
          code = code.9067 + 1;
          D.55069 = imb.b[2];
          *code.9067 = D.55069;
          code.9068 = code;
          code = code.9068 + 1;
          D.55071 = imb.b[3];
          *code.9068 = D.55071;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.55072>;
    <D.55062>:
    if (0 != 0) goto <D.55073>; else goto <D.55074>;
    <D.55073>:
    if (1 != 0) goto <D.55075>; else goto <D.55076>;
    <D.55075>:
    code.9069 = code;
    code = code.9069 + 1;
    *code.9069 = 28;
    code.9070 = code;
    code = code.9070 + 1;
    *code.9070 = 36;
    goto <D.55079>;
    <D.55076>:
    if (1 != 0) goto <D.55080>; else goto <D.55081>;
    <D.55080>:
    code.9071 = code;
    code = code.9071 + 1;
    *code.9071 = 92;
    code.9072 = code;
    code = code.9072 + 1;
    *code.9072 = 36;
    *code = 0;
    code = code + 1;
    goto <D.55084>;
    <D.55081>:
    code.9073 = code;
    code = code.9073 + 1;
    *code.9073 = 156;
    code.9074 = code;
    code = code.9074 + 1;
    *code.9074 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9075 = code;
          code = code.9075 + 1;
          D.55088 = imb.b[0];
          *code.9075 = D.55088;
          code.9076 = code;
          code = code.9076 + 1;
          D.55090 = imb.b[1];
          *code.9076 = D.55090;
          code.9077 = code;
          code = code.9077 + 1;
          D.55092 = imb.b[2];
          *code.9077 = D.55092;
          code.9078 = code;
          code = code.9078 + 1;
          D.55094 = imb.b[3];
          *code.9078 = D.55094;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55084>:
    <D.55079>:
    goto <D.28333>;
    <D.55074>:
    if (1 != 0) goto <D.55095>; else goto <D.55096>;
    <D.55095>:
    code.9079 = code;
    code = code.9079 + 1;
    *code.9079 = 27;
    goto <D.28333>;
    <D.55096>:
    if (1 != 0) goto <D.55098>; else goto <D.55099>;
    <D.55098>:
    code.9080 = code;
    code = code.9080 + 1;
    *code.9080 = 91;
    *code = 0;
    code = code + 1;
    goto <D.55101>;
    <D.55099>:
    code.9081 = code;
    code = code.9081 + 1;
    *code.9081 = 155;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9082 = code;
          code = code.9082 + 1;
          D.55104 = imb.b[0];
          *code.9082 = D.55104;
          code.9083 = code;
          code = code.9083 + 1;
          D.55106 = imb.b[1];
          *code.9083 = D.55106;
          code.9084 = code;
          code = code.9084 + 1;
          D.55108 = imb.b[2];
          *code.9084 = D.55108;
          code.9085 = code;
          code = code.9085 + 1;
          D.55110 = imb.b[3];
          *code.9085 = D.55110;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55101>:
    <D.28333>:
    <D.55072>:
    goto <D.55111>;
    <D.54986>:
    {
      int _amd64_width_temp;

      ss_trigger_page.9086 = ss_trigger_page;
      ss_trigger_page.9087 = (long unsigned int) ss_trigger_page.9086;
      ss_trigger_page.9086 = ss_trigger_page;
      ss_trigger_page.9088 = (long int) ss_trigger_page.9086;
      D.55115 = (int) ss_trigger_page.9088;
      D.55116 = (long unsigned int) D.55115;
      D.55117 = ss_trigger_page.9087 == D.55116;
      _amd64_width_temp = (int) D.55117;
      {
        unsigned char _amd64_rex_bits;

        if (_amd64_width_temp == 0) goto <D.55119>; else goto <D.55120>;
        <D.55119>:
        iftmp.9089 = 9;
        goto <D.55121>;
        <D.55120>:
        iftmp.9089 = 1;
        <D.55121>:
        _amd64_rex_bits = iftmp.9089;
        if (_amd64_rex_bits != 0) goto <D.55122>; else goto <D.55123>;
        <D.55122>:
        code.9090 = code;
        code = code.9090 + 1;
        D.55125 = _amd64_rex_bits | 64;
        *code.9090 = D.55125;
        <D.55123>:
      }
      code.9091 = code;
      code = code.9091 + 1;
      *code.9091 = 187;
      if (_amd64_width_temp == 0) goto <D.55127>; else goto <D.55128>;
      <D.55127>:
      {
        union amd64_imm_buf imb;

        try
          {
            ss_trigger_page.9086 = ss_trigger_page;
            ss_trigger_page.9087 = (long unsigned int) ss_trigger_page.9086;
            imb.val = ss_trigger_page.9087;
            code.9092 = code;
            code = code.9092 + 1;
            D.55130 = imb.b[0];
            *code.9092 = D.55130;
            code.9093 = code;
            code = code.9093 + 1;
            D.55132 = imb.b[1];
            *code.9093 = D.55132;
            code.9094 = code;
            code = code.9094 + 1;
            D.55134 = imb.b[2];
            *code.9094 = D.55134;
            code.9095 = code;
            code = code.9095 + 1;
            D.55136 = imb.b[3];
            *code.9095 = D.55136;
            code.9096 = code;
            code = code.9096 + 1;
            D.55138 = imb.b[4];
            *code.9096 = D.55138;
            code.9097 = code;
            code = code.9097 + 1;
            D.55140 = imb.b[5];
            *code.9097 = D.55140;
            code.9098 = code;
            code = code.9098 + 1;
            D.55142 = imb.b[6];
            *code.9098 = D.55142;
            code.9099 = code;
            code = code.9099 + 1;
            D.55144 = imb.b[7];
            *code.9099 = D.55144;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.55145>;
      <D.55128>:
      {
        union x86_imm_buf imb;

        try
          {
            ss_trigger_page.9086 = ss_trigger_page;
            ss_trigger_page.9088 = (long int) ss_trigger_page.9086;
            D.55115 = (int) ss_trigger_page.9088;
            imb.val = D.55115;
            code.9100 = code;
            code = code.9100 + 1;
            D.55147 = imb.b[0];
            *code.9100 = D.55147;
            code.9101 = code;
            code = code.9101 + 1;
            D.55149 = imb.b[1];
            *code.9101 = D.55149;
            code.9102 = code;
            code = code.9102 + 1;
            D.55151 = imb.b[2];
            *code.9102 = D.55151;
            code.9103 = code;
            code = code.9103 + 1;
            D.55153 = imb.b[3];
            *code.9103 = D.55153;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.55145>:
    }
    <D.55111>:
    if (0 != 0) goto <D.55154>; else goto <D.55155>;
    <D.55154>:
    code.9104 = code;
    code = code.9104 + 1;
    *code.9104 = 102;
    <D.55155>:
    {
      unsigned char _amd64_rex_bits;

      D.54040 = ins->sreg1;
      if (D.54040 > 7) goto <D.55158>; else goto <D.55159>;
      <D.55158>:
      iftmp.9105 = 13;
      goto <D.55160>;
      <D.55159>:
      iftmp.9105 = 12;
      <D.55160>:
      _amd64_rex_bits = iftmp.9105;
      if (_amd64_rex_bits != 0) goto <D.55161>; else goto <D.55162>;
      <D.55161>:
      code.9106 = code;
      code = code.9106 + 1;
      D.55164 = _amd64_rex_bits | 64;
      *code.9106 = D.55164;
      <D.55162>:
    }
    switch (8) <default: <D.28345>, case 1: <D.28340>, case 2: <D.28342>, case 4: <D.28343>, case 8: <D.28344>>
    <D.28340>:
    code.9107 = code;
    code = code.9107 + 1;
    *code.9107 = 136;
    goto <D.28341>;
    <D.28342>:
    <D.28343>:
    <D.28344>:
    code.9108 = code;
    code = code.9108 + 1;
    *code.9108 = 137;
    goto <D.28341>;
    <D.28345>:
    __assert_fail ("0", "mini-amd64.c", 7213, &__PRETTY_FUNCTION__);
    <D.28341>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 == 4) goto <D.55167>; else goto <D.55168>;
    <D.55167>:
    D.54053 = ins->data.op[0].const_val;
    if (D.54053 == 0) goto <D.55169>; else goto <D.55170>;
    <D.55169>:
    code.9109 = code;
    code = code.9109 + 1;
    *code.9109 = 28;
    code.9110 = code;
    code = code.9110 + 1;
    *code.9110 = 36;
    goto <D.55173>;
    <D.55170>:
    D.54053 = ins->data.op[0].const_val;
    D.54269 = (unsigned int) D.54053;
    D.54270 = D.54269 + 128;
    if (D.54270 <= 255) goto <D.55174>; else goto <D.55175>;
    <D.55174>:
    code.9111 = code;
    code = code.9111 + 1;
    *code.9111 = 92;
    code.9112 = code;
    code = code.9112 + 1;
    *code.9112 = 36;
    D.54053 = ins->data.op[0].const_val;
    D.54277 = (unsigned char) D.54053;
    *code = D.54277;
    code = code + 1;
    goto <D.55178>;
    <D.55175>:
    code.9113 = code;
    code = code.9113 + 1;
    *code.9113 = 156;
    code.9114 = code;
    code = code.9114 + 1;
    *code.9114 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54283 = (int) D.54053;
          imb.val = D.54283;
          code.9115 = code;
          code = code.9115 + 1;
          D.55182 = imb.b[0];
          *code.9115 = D.55182;
          code.9116 = code;
          code = code.9116 + 1;
          D.55184 = imb.b[1];
          *code.9116 = D.55184;
          code.9117 = code;
          code = code.9117 + 1;
          D.55186 = imb.b[2];
          *code.9117 = D.55186;
          code.9118 = code;
          code = code.9118 + 1;
          D.55188 = imb.b[3];
          *code.9118 = D.55188;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55178>:
    <D.55173>:
    goto <D.28347>;
    <D.55168>:
    D.54053 = ins->data.op[0].const_val;
    if (D.54053 == 0) goto <D.55189>; else goto <D.55190>;
    <D.55189>:
    D.54040 = ins->sreg1;
    D.54050 = D.54040 & 7;
    if (D.54050 != 5) goto <D.55191>; else goto <D.55192>;
    <D.55191>:
    code.9119 = code;
    code = code.9119 + 1;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.55194 = D.54104 | 24;
    D.55195 = (unsigned char) D.55194;
    *code.9119 = D.55195;
    goto <D.28347>;
    <D.55192>:
    <D.55190>:
    D.54053 = ins->data.op[0].const_val;
    D.54269 = (unsigned int) D.54053;
    D.54270 = D.54269 + 128;
    if (D.54270 <= 255) goto <D.55196>; else goto <D.55197>;
    <D.55196>:
    code.9120 = code;
    code = code.9120 + 1;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.55199 = D.54104 | 88;
    D.55200 = (unsigned char) D.55199;
    *code.9120 = D.55200;
    D.54053 = ins->data.op[0].const_val;
    D.54277 = (unsigned char) D.54053;
    *code = D.54277;
    code = code + 1;
    goto <D.55201>;
    <D.55197>:
    code.9121 = code;
    code = code.9121 + 1;
    D.54040 = ins->sreg1;
    D.54103 = (signed char) D.54040;
    D.54104 = D.54103 & 7;
    D.55203 = D.54104 | -104;
    D.55204 = (unsigned char) D.55203;
    *code.9121 = D.55204;
    {
      union x86_imm_buf imb;

      try
        {
          D.54053 = ins->data.op[0].const_val;
          D.54283 = (int) D.54053;
          imb.val = D.54283;
          code.9122 = code;
          code = code.9122 + 1;
          D.55206 = imb.b[0];
          *code.9122 = D.55206;
          code.9123 = code;
          code = code.9123 + 1;
          D.55208 = imb.b[1];
          *code.9123 = D.55208;
          code.9124 = code;
          code = code.9124 + 1;
          D.55210 = imb.b[2];
          *code.9124 = D.55210;
          code.9125 = code;
          code = code.9125 + 1;
          D.55212 = imb.b[3];
          *code.9125 = D.55212;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55201>:
    <D.28347>:
  }
  <D.54842>:
  code.8397 = (long int) code;
  D.52988 = cfg->native_code;
  D.52989 = (long int) D.52988;
  D.52990 = code.8397 - D.52989;
  D.55213 = (unsigned int) D.52990;
  cfg->code_len = D.55213;
  D.55214 = cfg->code_len;
  D.52978 = cfg->code_size;
  D.55215 = D.55214 >= D.52978;
  D.55216 = (long int) D.55215;
  D.55217 = __builtin_expect (D.55216, 0);
  if (D.55217 != 0) goto <D.55218>; else goto <D.55219>;
  <D.55218>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7218, "cfg->code_len < cfg->code_size");
  <D.55219>:
  D.55220 = code;
  return D.55220;
}


emit_setup_lmf (struct MonoCompile * cfg, guint8 * code, gint32 lmf_offset, int cfa_offset)
{
  guint8 * code.9126;
  unsigned char iftmp.9127;
  unsigned int D.55237;
  guint8 * code.9128;
  unsigned char D.55244;
  guint8 * code.9129;
  guint8 * code.9130;
  unsigned int D.55247;
  long unsigned int D.55250;
  guint8 * code.9131;
  guint8 * code.9132;
  unsigned int lmf_offset.9133;
  unsigned int D.55259;
  int D.55260;
  guint8 * code.9134;
  guint8 * code.9135;
  unsigned char D.55265;
  unsigned char D.55266;
  guint8 * code.9136;
  guint8 * code.9137;
  guint8 * code.9138;
  unsigned char D.55270;
  guint8 * code.9139;
  unsigned char D.55272;
  guint8 * code.9140;
  unsigned char D.55274;
  guint8 * code.9141;
  unsigned char D.55276;
  guint8 * code.9142;
  unsigned char D.55282;
  unsigned char D.55283;
  unsigned char D.55284;
  guint8 * code.9143;
  unsigned char D.55290;
  guint8 * code.9144;
  unsigned char D.55292;
  guint8 * code.9145;
  unsigned char D.55294;
  guint8 * code.9146;
  unsigned char D.55296;
  guint8 * code.9147;
  unsigned char D.55298;
  guint8 * code.9148;
  unsigned char D.55300;
  guint8 * code.9149;
  signed char iftmp.9150;
  _Bool D.55310;
  signed char D.55311;
  signed char D.55312;
  guint8 * code.9151;
  unsigned char D.55316;
  guint8 * code.9152;
  guint8 * code.9153;
  int D.55321;
  guint8 * code.9154;
  int D.55325;
  int D.55326;
  signed char D.55327;
  signed char D.55328;
  unsigned char D.55329;
  guint8 * code.9155;
  unsigned int D.55332;
  unsigned int D.55333;
  guint8 * code.9156;
  signed char D.55337;
  unsigned char D.55338;
  guint8 * code.9157;
  unsigned char D.55340;
  unsigned char D.55341;
  unsigned char D.55342;
  guint8 * code.9158;
  signed char D.55345;
  unsigned char D.55346;
  guint8 * code.9159;
  guint8 * code.9160;
  unsigned char D.55349;
  guint8 * code.9161;
  unsigned char D.55351;
  guint8 * code.9162;
  unsigned char D.55353;
  guint8 * code.9163;
  unsigned char D.55355;
  guint8 * code.9164;
  unsigned char D.55361;
  unsigned char D.55362;
  unsigned char D.55363;
  unsigned char D.55364;
  guint8 * code.9165;
  unsigned char D.55368;
  guint8 * code.9166;
  unsigned char D.55371;
  guint8 * code.9167;
  unsigned char D.55373;
  guint8 * code.9168;
  unsigned char D.55375;
  guint8 * code.9169;
  unsigned char D.55377;
  guint8 * code.9170;
  unsigned char D.55379;
  int D.55382;
  int D.55386;
  long int code.9171;
  unsigned char * D.55388;
  long int D.55389;
  long int D.55390;
  int D.55391;
  unsigned int D.55392;
  int D.55393;
  unsigned int D.55394;
  int D.55395;
  unsigned int D.55396;
  int D.55397;
  unsigned int D.55398;
  int D.55399;
  unsigned int D.55400;
  int D.55401;
  unsigned int D.55402;
  int D.55403;
  unsigned int D.55404;
  int D.55405;
  guint8 * D.55406;
  int i;
  static const char __PRETTY_FUNCTION__[15] = "emit_setup_lmf";

  if (0 != 0) goto <D.55233>; else goto <D.55234>;
  <D.55233>:
  code.9126 = code;
  code = code.9126 + 1;
  *code.9126 = 102;
  <D.55234>:
  {
    unsigned char _amd64_rex_bits;

    D.55237 = cfg->frame_reg;
    if (D.55237 > 7) goto <D.55238>; else goto <D.55239>;
    <D.55238>:
    iftmp.9127 = 9;
    goto <D.55240>;
    <D.55239>:
    iftmp.9127 = 8;
    <D.55240>:
    _amd64_rex_bits = iftmp.9127;
    if (_amd64_rex_bits != 0) goto <D.55241>; else goto <D.55242>;
    <D.55241>:
    code.9128 = code;
    code = code.9128 + 1;
    D.55244 = _amd64_rex_bits | 64;
    *code.9128 = D.55244;
    <D.55242>:
  }
  switch (8) <default: <D.25125>, case 1: <D.25120>, case 2: <D.25122>, case 4: <D.25123>, case 8: <D.25124>>
  <D.25120>:
  code.9129 = code;
  code = code.9129 + 1;
  *code.9129 = 136;
  goto <D.25121>;
  <D.25122>:
  <D.25123>:
  <D.25124>:
  code.9130 = code;
  code = code.9130 + 1;
  *code.9130 = 137;
  goto <D.25121>;
  <D.25125>:
  __assert_fail ("0", "mini-amd64.c", 3766, &__PRETTY_FUNCTION__);
  <D.25121>:
  D.55237 = cfg->frame_reg;
  D.55247 = D.55237 & 7;
  if (D.55247 == 4) goto <D.55248>; else goto <D.55249>;
  <D.55248>:
  D.55250 = (long unsigned int) lmf_offset;
  if (D.55250 == 18446744073709551584) goto <D.55251>; else goto <D.55252>;
  <D.55251>:
  code.9131 = code;
  code = code.9131 + 1;
  *code.9131 = 36;
  code.9132 = code;
  code = code.9132 + 1;
  *code.9132 = 36;
  goto <D.55255>;
  <D.55252>:
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55259 = lmf_offset.9133 + 32;
  D.55260 = (int) D.55259;
  if (D.55260 >= -128) goto <D.55261>; else goto <D.55256>;
  <D.55261>:
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55259 = lmf_offset.9133 + 32;
  D.55260 = (int) D.55259;
  if (D.55260 <= 127) goto <D.55262>; else goto <D.55256>;
  <D.55262>:
  code.9134 = code;
  code = code.9134 + 1;
  *code.9134 = 100;
  code.9135 = code;
  code = code.9135 + 1;
  *code.9135 = 36;
  D.55265 = (unsigned char) lmf_offset;
  D.55266 = D.55265 + 32;
  *code = D.55266;
  code = code + 1;
  goto <D.55257>;
  <D.55256>:
  code.9136 = code;
  code = code.9136 + 1;
  *code.9136 = 164;
  code.9137 = code;
  code = code.9137 + 1;
  *code.9137 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9133 = (unsigned int) lmf_offset;
        D.55259 = lmf_offset.9133 + 32;
        D.55260 = (int) D.55259;
        imb.val = D.55260;
        code.9138 = code;
        code = code.9138 + 1;
        D.55270 = imb.b[0];
        *code.9138 = D.55270;
        code.9139 = code;
        code = code.9139 + 1;
        D.55272 = imb.b[1];
        *code.9139 = D.55272;
        code.9140 = code;
        code = code.9140 + 1;
        D.55274 = imb.b[2];
        *code.9140 = D.55274;
        code.9141 = code;
        code = code.9141 + 1;
        D.55276 = imb.b[3];
        *code.9141 = D.55276;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55257>:
  <D.55255>:
  goto <D.25128>;
  <D.55249>:
  D.55250 = (long unsigned int) lmf_offset;
  if (D.55250 == 18446744073709551584) goto <D.55277>; else goto <D.55278>;
  <D.55277>:
  D.55237 = cfg->frame_reg;
  D.55247 = D.55237 & 7;
  if (D.55247 != 5) goto <D.55279>; else goto <D.55280>;
  <D.55279>:
  code.9142 = code;
  code = code.9142 + 1;
  D.55237 = cfg->frame_reg;
  D.55282 = (unsigned char) D.55237;
  D.55283 = D.55282 & 7;
  D.55284 = D.55283 | 32;
  *code.9142 = D.55284;
  goto <D.25128>;
  <D.55280>:
  <D.55278>:
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55259 = lmf_offset.9133 + 32;
  D.55260 = (int) D.55259;
  if (D.55260 >= -128) goto <D.55287>; else goto <D.55285>;
  <D.55287>:
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55259 = lmf_offset.9133 + 32;
  D.55260 = (int) D.55259;
  if (D.55260 <= 127) goto <D.55288>; else goto <D.55285>;
  <D.55288>:
  code.9143 = code;
  code = code.9143 + 1;
  D.55237 = cfg->frame_reg;
  D.55282 = (unsigned char) D.55237;
  D.55283 = D.55282 & 7;
  D.55290 = D.55283 | 96;
  *code.9143 = D.55290;
  D.55265 = (unsigned char) lmf_offset;
  D.55266 = D.55265 + 32;
  *code = D.55266;
  code = code + 1;
  goto <D.55286>;
  <D.55285>:
  code.9144 = code;
  code = code.9144 + 1;
  D.55237 = cfg->frame_reg;
  D.55282 = (unsigned char) D.55237;
  D.55283 = D.55282 & 7;
  D.55292 = D.55283 | 160;
  *code.9144 = D.55292;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9133 = (unsigned int) lmf_offset;
        D.55259 = lmf_offset.9133 + 32;
        D.55260 = (int) D.55259;
        imb.val = D.55260;
        code.9145 = code;
        code = code.9145 + 1;
        D.55294 = imb.b[0];
        *code.9145 = D.55294;
        code.9146 = code;
        code = code.9146 + 1;
        D.55296 = imb.b[1];
        *code.9146 = D.55296;
        code.9147 = code;
        code = code.9147 + 1;
        D.55298 = imb.b[2];
        *code.9147 = D.55298;
        code.9148 = code;
        code = code.9148 + 1;
        D.55300 = imb.b[3];
        *code.9148 = D.55300;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55286>:
  <D.25128>:
  i = 0;
  goto <D.25150>;
  <D.25149>:
  {
    int offset;

    switch (i) <default: <D.25138>, case 3: <D.25131>, case 5: <D.25133>, case 12: <D.25134>, case 13: <D.25135>, case 14: <D.25136>, case 15: <D.25137>>
    <D.25131>:
    offset = 16;
    goto <D.25132>;
    <D.25133>:
    offset = 24;
    goto <D.25132>;
    <D.25134>:
    offset = 40;
    goto <D.25132>;
    <D.25135>:
    offset = 48;
    goto <D.25132>;
    <D.25136>:
    offset = 56;
    goto <D.25132>;
    <D.25137>:
    offset = 64;
    goto <D.25132>;
    <D.25138>:
    offset = -1;
    goto <D.25132>;
    <D.25132>:
    if (offset != -1) goto <D.55301>; else goto <D.55302>;
    <D.55301>:
    if (0 != 0) goto <D.55303>; else goto <D.55304>;
    <D.55303>:
    code.9149 = code;
    code = code.9149 + 1;
    *code.9149 = 102;
    <D.55304>:
    {
      unsigned char _amd64_rex_bits;

      if (i > 7) goto <D.55307>; else goto <D.55308>;
      <D.55307>:
      iftmp.9150 = 12;
      goto <D.55309>;
      <D.55308>:
      iftmp.9150 = 8;
      <D.55309>:
      D.55237 = cfg->frame_reg;
      D.55310 = D.55237 > 7;
      D.55311 = (signed char) D.55310;
      D.55312 = iftmp.9150 | D.55311;
      _amd64_rex_bits = (unsigned char) D.55312;
      if (_amd64_rex_bits != 0) goto <D.55313>; else goto <D.55314>;
      <D.55313>:
      code.9151 = code;
      code = code.9151 + 1;
      D.55316 = _amd64_rex_bits | 64;
      *code.9151 = D.55316;
      <D.55314>:
    }
    switch (8) <default: <D.25145>, case 1: <D.25140>, case 2: <D.25142>, case 4: <D.25143>, case 8: <D.25144>>
    <D.25140>:
    code.9152 = code;
    code = code.9152 + 1;
    *code.9152 = 136;
    goto <D.25141>;
    <D.25142>:
    <D.25143>:
    <D.25144>:
    code.9153 = code;
    code = code.9153 + 1;
    *code.9153 = 137;
    goto <D.25141>;
    <D.25145>:
    __assert_fail ("0", "mini-amd64.c", 3791, &__PRETTY_FUNCTION__);
    <D.25141>:
    D.55237 = cfg->frame_reg;
    D.55247 = D.55237 & 7;
    if (D.55247 == 4) goto <D.55319>; else goto <D.55320>;
    <D.55319>:
    D.55321 = lmf_offset + offset;
    if (D.55321 == 0) goto <D.55322>; else goto <D.55323>;
    <D.55322>:
    code.9154 = code;
    code = code.9154 + 1;
    D.55325 = i & 7;
    D.55326 = D.55325 << 3;
    D.55327 = (signed char) D.55326;
    D.55328 = D.55327 | 4;
    D.55329 = (unsigned char) D.55328;
    *code.9154 = D.55329;
    code.9155 = code;
    code = code.9155 + 1;
    *code.9155 = 36;
    goto <D.55331>;
    <D.55323>:
    D.55321 = lmf_offset + offset;
    D.55332 = (unsigned int) D.55321;
    D.55333 = D.55332 + 128;
    if (D.55333 <= 255) goto <D.55334>; else goto <D.55335>;
    <D.55334>:
    code.9156 = code;
    code = code.9156 + 1;
    D.55325 = i & 7;
    D.55326 = D.55325 << 3;
    D.55327 = (signed char) D.55326;
    D.55337 = D.55327 | 68;
    D.55338 = (unsigned char) D.55337;
    *code.9156 = D.55338;
    code.9157 = code;
    code = code.9157 + 1;
    *code.9157 = 36;
    D.55340 = (unsigned char) lmf_offset;
    D.55341 = (unsigned char) offset;
    D.55342 = D.55340 + D.55341;
    *code = D.55342;
    code = code + 1;
    goto <D.55343>;
    <D.55335>:
    code.9158 = code;
    code = code.9158 + 1;
    D.55325 = i & 7;
    D.55326 = D.55325 << 3;
    D.55327 = (signed char) D.55326;
    D.55345 = D.55327 | -124;
    D.55346 = (unsigned char) D.55345;
    *code.9158 = D.55346;
    code.9159 = code;
    code = code.9159 + 1;
    *code.9159 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.55321 = lmf_offset + offset;
          imb.val = D.55321;
          code.9160 = code;
          code = code.9160 + 1;
          D.55349 = imb.b[0];
          *code.9160 = D.55349;
          code.9161 = code;
          code = code.9161 + 1;
          D.55351 = imb.b[1];
          *code.9161 = D.55351;
          code.9162 = code;
          code = code.9162 + 1;
          D.55353 = imb.b[2];
          *code.9162 = D.55353;
          code.9163 = code;
          code = code.9163 + 1;
          D.55355 = imb.b[3];
          *code.9163 = D.55355;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55343>:
    <D.55331>:
    goto <D.25147>;
    <D.55320>:
    D.55321 = lmf_offset + offset;
    if (D.55321 == 0) goto <D.55356>; else goto <D.55357>;
    <D.55356>:
    D.55237 = cfg->frame_reg;
    D.55247 = D.55237 & 7;
    if (D.55247 != 5) goto <D.55358>; else goto <D.55359>;
    <D.55358>:
    code.9164 = code;
    code = code.9164 + 1;
    D.55361 = (unsigned char) i;
    D.55362 = D.55361 & 7;
    D.55363 = D.55362 << 3;
    D.55237 = cfg->frame_reg;
    D.55282 = (unsigned char) D.55237;
    D.55283 = D.55282 & 7;
    D.55364 = D.55363 | D.55283;
    *code.9164 = D.55364;
    goto <D.25147>;
    <D.55359>:
    <D.55357>:
    D.55321 = lmf_offset + offset;
    D.55332 = (unsigned int) D.55321;
    D.55333 = D.55332 + 128;
    if (D.55333 <= 255) goto <D.55365>; else goto <D.55366>;
    <D.55365>:
    code.9165 = code;
    code = code.9165 + 1;
    D.55361 = (unsigned char) i;
    D.55362 = D.55361 & 7;
    D.55363 = D.55362 << 3;
    D.55237 = cfg->frame_reg;
    D.55282 = (unsigned char) D.55237;
    D.55283 = D.55282 & 7;
    D.55364 = D.55363 | D.55283;
    D.55368 = D.55364 | 64;
    *code.9165 = D.55368;
    D.55340 = (unsigned char) lmf_offset;
    D.55341 = (unsigned char) offset;
    D.55342 = D.55340 + D.55341;
    *code = D.55342;
    code = code + 1;
    goto <D.55369>;
    <D.55366>:
    code.9166 = code;
    code = code.9166 + 1;
    D.55361 = (unsigned char) i;
    D.55362 = D.55361 & 7;
    D.55363 = D.55362 << 3;
    D.55237 = cfg->frame_reg;
    D.55282 = (unsigned char) D.55237;
    D.55283 = D.55282 & 7;
    D.55364 = D.55363 | D.55283;
    D.55371 = D.55364 | 128;
    *code.9166 = D.55371;
    {
      union x86_imm_buf imb;

      try
        {
          D.55321 = lmf_offset + offset;
          imb.val = D.55321;
          code.9167 = code;
          code = code.9167 + 1;
          D.55373 = imb.b[0];
          *code.9167 = D.55373;
          code.9168 = code;
          code = code.9168 + 1;
          D.55375 = imb.b[1];
          *code.9168 = D.55375;
          code.9169 = code;
          code = code.9169 + 1;
          D.55377 = imb.b[2];
          *code.9169 = D.55377;
          code.9170 = code;
          code = code.9170 + 1;
          D.55379 = imb.b[3];
          *code.9170 = D.55379;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55369>:
    <D.25147>:
    D.55382 = cfg->arch.omit_fp;
    if (D.55382 != 0) goto <D.55380>; else goto <D.55383>;
    <D.55383>:
    if (i != 5) goto <D.55380>; else goto <D.55381>;
    <D.55380>:
    if (cfa_offset != -1) goto <D.55384>; else goto <D.55385>;
    <D.55384>:
    D.55321 = lmf_offset + offset;
    D.55386 = D.55321 - cfa_offset;
    code.9171 = (long int) code;
    D.55388 = cfg->native_code;
    D.55389 = (long int) D.55388;
    D.55390 = code.9171 - D.55389;
    D.55391 = (int) D.55390;
    mono_emit_unwind_op (cfg, D.55391, 128, i, D.55386);
    <D.55385>:
    <D.55381>:
    <D.55302>:
  }
  i = i + 1;
  <D.25150>:
  if (i <= 15) goto <D.25149>; else goto <D.25151>;
  <D.25151>:
  mini_gc_set_slot_type_from_fp (cfg, lmf_offset, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55392 = lmf_offset.9133 + 8;
  D.55393 = (int) D.55392;
  mini_gc_set_slot_type_from_fp (cfg, D.55393, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55259 = lmf_offset.9133 + 32;
  D.55260 = (int) D.55259;
  mini_gc_set_slot_type_from_fp (cfg, D.55260, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55394 = lmf_offset.9133 + 16;
  D.55395 = (int) D.55394;
  mini_gc_set_slot_type_from_fp (cfg, D.55395, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55396 = lmf_offset.9133 + 24;
  D.55397 = (int) D.55396;
  mini_gc_set_slot_type_from_fp (cfg, D.55397, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55398 = lmf_offset.9133 + 40;
  D.55399 = (int) D.55398;
  mini_gc_set_slot_type_from_fp (cfg, D.55399, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55400 = lmf_offset.9133 + 48;
  D.55401 = (int) D.55400;
  mini_gc_set_slot_type_from_fp (cfg, D.55401, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55402 = lmf_offset.9133 + 56;
  D.55403 = (int) D.55402;
  mini_gc_set_slot_type_from_fp (cfg, D.55403, 0);
  lmf_offset.9133 = (unsigned int) lmf_offset;
  D.55404 = lmf_offset.9133 + 64;
  D.55405 = (int) D.55404;
  mini_gc_set_slot_type_from_fp (cfg, D.55405, 0);
  D.55406 = code;
  return D.55406;
}


get_max_epilog_size (struct MonoCompile * cfg)
{
  struct MonoMethod * D.55408;
  unsigned char D.55409;
  unsigned char D.55410;
  struct MonoTraceSpec * mono_jit_trace_calls.9172;
  unsigned int D.55416;
  unsigned int D.55417;
  int D.55420;
  int max_epilog_size;

  max_epilog_size = 16;
  D.55408 = cfg->method;
  D.55409 = BIT_FIELD_REF <*D.55408, 8, 264>;
  D.55410 = D.55409 & 1;
  if (D.55410 != 0) goto <D.55411>; else goto <D.55412>;
  <D.55411>:
  max_epilog_size = max_epilog_size + 256;
  <D.55412>:
  mono_jit_trace_calls.9172 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.9172 != 0B) goto <D.55414>; else goto <D.55415>;
  <D.55414>:
  max_epilog_size = max_epilog_size + 50;
  <D.55415>:
  D.55416 = cfg->prof_options;
  D.55417 = D.55416 & 4096;
  if (D.55417 != 0) goto <D.55418>; else goto <D.55419>;
  <D.55418>:
  max_epilog_size = max_epilog_size + 50;
  <D.55419>:
  max_epilog_size = max_epilog_size + 34;
  D.55420 = max_epilog_size;
  return D.55420;
}


mono_arch_emit_epilog (struct MonoCompile * cfg)
{
  gint32 iftmp.9173;
  struct MonoInst * D.55423;
  long int D.55426;
  unsigned int D.55428;
  unsigned int D.55429;
  void * D.55430;
  int D.55431;
  int D.55432;
  unsigned int D.55433;
  unsigned int max_epilog_size.9174;
  unsigned int D.55435;
  unsigned int D.55436;
  unsigned char * D.55437;
  sizetype D.55438;
  struct MonoTraceSpec * mono_jit_trace_calls.9175;
  int D.55442;
  unsigned char D.55445;
  unsigned char D.55446;
  int D.55449;
  int D.55452;
  guint8 * code.9176;
  guint8 * code.9177;
  unsigned char D.55459;
  guint8 * code.9178;
  guint8 * code.9179;
  guint8 * code.9180;
  guint8 * code.9181;
  unsigned char D.55466;
  guint8 * code.9182;
  unsigned char D.55468;
  guint8 * code.9183;
  unsigned char D.55470;
  guint8 * code.9184;
  unsigned char D.55472;
  guint8 * code.9185;
  guint8 * code.9186;
  guint8 * code.9187;
  guint8 * code.9188;
  guint8 * code.9189;
  guint8 * code.9190;
  guint8 * code.9191;
  unsigned char D.55489;
  guint8 * code.9192;
  unsigned char D.55491;
  guint8 * code.9193;
  unsigned char D.55493;
  guint8 * code.9194;
  unsigned char D.55495;
  guint8 * code.9195;
  guint8 * code.9196;
  guint8 * code.9197;
  guint8 * code.9198;
  unsigned char D.55505;
  guint8 * code.9199;
  unsigned char D.55507;
  guint8 * code.9200;
  unsigned char D.55509;
  guint8 * code.9201;
  unsigned char D.55511;
  guint8 * code.9202;
  guint8 * code.9203;
  unsigned char D.55516;
  guint8 * code.9204;
  unsigned char D.55518;
  guint8 * code.9205;
  unsigned char D.55520;
  guint8 * code.9206;
  unsigned char D.55522;
  guint8 * code.9207;
  guint8 * code.9208;
  guint8 * code.9209;
  guint8 * code.9210;
  guint8 * code.9211;
  unsigned char D.55531;
  guint8 * code.9212;
  unsigned char D.55533;
  guint8 * code.9213;
  unsigned char D.55535;
  guint8 * code.9214;
  unsigned char D.55537;
  guint8 * code.9215;
  unsigned char D.55541;
  guint8 * code.9216;
  unsigned char D.55544;
  guint8 * code.9217;
  guint8 * code.9218;
  unsigned char D.55547;
  int D.55548;
  unsigned char D.55549;
  unsigned char D.55550;
  long int code.9219;
  long int pos.9220;
  long int D.55555;
  int D.55558;
  unsigned char * pos.9221;
  unsigned char D.55560;
  unsigned char * pos.9222;
  unsigned char D.55562;
  unsigned char * pos.9223;
  unsigned char D.55564;
  unsigned char * pos.9224;
  unsigned char D.55566;
  unsigned int disp.9225;
  unsigned int D.55569;
  unsigned char D.55572;
  unsigned char D.55573;
  long unsigned int D.55576;
  long unsigned int D.55577;
  guint8 * code.9226;
  unsigned char iftmp.9227;
  unsigned int D.55584;
  guint8 * code.9228;
  unsigned char D.55591;
  guint8 * code.9229;
  guint8 * code.9230;
  guint8 * code.9231;
  unsigned int lmf_offset.9232;
  unsigned int D.55598;
  int D.55599;
  guint8 * code.9233;
  unsigned char D.55601;
  guint8 * code.9234;
  unsigned char D.55603;
  guint8 * code.9235;
  unsigned char D.55605;
  guint8 * code.9236;
  unsigned char D.55607;
  unsigned int D.55609;
  long unsigned int D.55612;
  guint8 * code.9237;
  guint8 * code.9238;
  guint8 * code.9239;
  guint8 * code.9240;
  unsigned char D.55624;
  unsigned char D.55625;
  guint8 * code.9241;
  guint8 * code.9242;
  guint8 * code.9243;
  unsigned char D.55629;
  guint8 * code.9244;
  unsigned char D.55631;
  guint8 * code.9245;
  unsigned char D.55633;
  guint8 * code.9246;
  unsigned char D.55635;
  guint8 * code.9247;
  unsigned char D.55641;
  unsigned char D.55642;
  unsigned char D.55643;
  guint8 * code.9248;
  unsigned char D.55649;
  guint8 * code.9249;
  unsigned char D.55651;
  guint8 * code.9250;
  unsigned char D.55653;
  guint8 * code.9251;
  unsigned char D.55655;
  guint8 * code.9252;
  unsigned char D.55657;
  guint8 * code.9253;
  unsigned char D.55659;
  long unsigned int D.55660;
  guint8 * code.9254;
  unsigned char iftmp.9255;
  guint8 * code.9256;
  unsigned char D.55673;
  guint8 * code.9257;
  guint8 * code.9258;
  guint8 * code.9259;
  unsigned int D.55679;
  int D.55680;
  guint8 * code.9260;
  unsigned char D.55682;
  guint8 * code.9261;
  unsigned char D.55684;
  guint8 * code.9262;
  unsigned char D.55686;
  guint8 * code.9263;
  unsigned char D.55688;
  guint8 * code.9264;
  guint8 * code.9265;
  guint8 * code.9266;
  guint8 * code.9267;
  unsigned char D.55703;
  guint8 * code.9268;
  guint8 * code.9269;
  guint8 * code.9270;
  unsigned char D.55707;
  guint8 * code.9271;
  unsigned char D.55709;
  guint8 * code.9272;
  unsigned char D.55711;
  guint8 * code.9273;
  unsigned char D.55713;
  guint8 * code.9274;
  unsigned char D.55719;
  guint8 * code.9275;
  unsigned char D.55725;
  guint8 * code.9276;
  unsigned char D.55727;
  guint8 * code.9277;
  unsigned char D.55729;
  guint8 * code.9278;
  unsigned char D.55731;
  guint8 * code.9279;
  unsigned char D.55733;
  guint8 * code.9280;
  unsigned char D.55735;
  long unsigned int D.55736;
  guint8 * code.9281;
  unsigned char iftmp.9282;
  guint8 * code.9283;
  unsigned char D.55749;
  guint8 * code.9284;
  guint8 * code.9285;
  guint8 * code.9286;
  unsigned int D.55755;
  int D.55756;
  guint8 * code.9287;
  unsigned char D.55758;
  guint8 * code.9288;
  unsigned char D.55760;
  guint8 * code.9289;
  unsigned char D.55762;
  guint8 * code.9290;
  unsigned char D.55764;
  guint8 * code.9291;
  guint8 * code.9292;
  guint8 * code.9293;
  guint8 * code.9294;
  unsigned char D.55779;
  guint8 * code.9295;
  guint8 * code.9296;
  guint8 * code.9297;
  unsigned char D.55783;
  guint8 * code.9298;
  unsigned char D.55785;
  guint8 * code.9299;
  unsigned char D.55787;
  guint8 * code.9300;
  unsigned char D.55789;
  guint8 * code.9301;
  unsigned char D.55795;
  guint8 * code.9302;
  unsigned char D.55801;
  guint8 * code.9303;
  unsigned char D.55803;
  guint8 * code.9304;
  unsigned char D.55805;
  guint8 * code.9305;
  unsigned char D.55807;
  guint8 * code.9306;
  unsigned char D.55809;
  guint8 * code.9307;
  unsigned char D.55811;
  long unsigned int D.55812;
  guint8 * code.9308;
  unsigned char iftmp.9309;
  guint8 * code.9310;
  unsigned char D.55825;
  guint8 * code.9311;
  guint8 * code.9312;
  guint8 * code.9313;
  unsigned int D.55831;
  int D.55832;
  guint8 * code.9314;
  unsigned char D.55834;
  guint8 * code.9315;
  unsigned char D.55836;
  guint8 * code.9316;
  unsigned char D.55838;
  guint8 * code.9317;
  unsigned char D.55840;
  guint8 * code.9318;
  guint8 * code.9319;
  guint8 * code.9320;
  guint8 * code.9321;
  unsigned char D.55855;
  guint8 * code.9322;
  guint8 * code.9323;
  guint8 * code.9324;
  unsigned char D.55859;
  guint8 * code.9325;
  unsigned char D.55861;
  guint8 * code.9326;
  unsigned char D.55863;
  guint8 * code.9327;
  unsigned char D.55865;
  guint8 * code.9328;
  guint8 * code.9329;
  guint8 * code.9330;
  guint8 * code.9331;
  unsigned char D.55878;
  guint8 * code.9332;
  unsigned char D.55880;
  guint8 * code.9333;
  unsigned char D.55882;
  guint8 * code.9334;
  unsigned char D.55884;
  long unsigned int D.55885;
  guint8 * code.9335;
  unsigned char iftmp.9336;
  guint8 * code.9337;
  unsigned char D.55898;
  guint8 * code.9338;
  guint8 * code.9339;
  guint8 * code.9340;
  unsigned int D.55904;
  int D.55905;
  guint8 * code.9341;
  unsigned char D.55907;
  guint8 * code.9342;
  unsigned char D.55909;
  guint8 * code.9343;
  unsigned char D.55911;
  guint8 * code.9344;
  unsigned char D.55913;
  guint8 * code.9345;
  guint8 * code.9346;
  guint8 * code.9347;
  guint8 * code.9348;
  unsigned char D.55928;
  guint8 * code.9349;
  guint8 * code.9350;
  guint8 * code.9351;
  unsigned char D.55932;
  guint8 * code.9352;
  unsigned char D.55934;
  guint8 * code.9353;
  unsigned char D.55936;
  guint8 * code.9354;
  unsigned char D.55938;
  guint8 * code.9355;
  unsigned char D.55944;
  guint8 * code.9356;
  unsigned char D.55950;
  guint8 * code.9357;
  unsigned char D.55952;
  guint8 * code.9358;
  unsigned char D.55954;
  guint8 * code.9359;
  unsigned char D.55956;
  guint8 * code.9360;
  unsigned char D.55958;
  guint8 * code.9361;
  unsigned char D.55960;
  long unsigned int D.55961;
  guint8 * code.9362;
  unsigned char iftmp.9363;
  guint8 * code.9364;
  unsigned char D.55974;
  guint8 * code.9365;
  guint8 * code.9366;
  guint8 * code.9367;
  unsigned int D.55980;
  int D.55981;
  guint8 * code.9368;
  unsigned char D.55983;
  guint8 * code.9369;
  unsigned char D.55985;
  guint8 * code.9370;
  unsigned char D.55987;
  guint8 * code.9371;
  unsigned char D.55989;
  guint8 * code.9372;
  guint8 * code.9373;
  guint8 * code.9374;
  guint8 * code.9375;
  unsigned char D.56004;
  guint8 * code.9376;
  guint8 * code.9377;
  guint8 * code.9378;
  unsigned char D.56008;
  guint8 * code.9379;
  unsigned char D.56010;
  guint8 * code.9380;
  unsigned char D.56012;
  guint8 * code.9381;
  unsigned char D.56014;
  guint8 * code.9382;
  unsigned char D.56020;
  guint8 * code.9383;
  unsigned char D.56026;
  guint8 * code.9384;
  unsigned char D.56028;
  guint8 * code.9385;
  unsigned char D.56030;
  guint8 * code.9386;
  unsigned char D.56032;
  guint8 * code.9387;
  unsigned char D.56034;
  guint8 * code.9388;
  unsigned char D.56036;
  int D.56038;
  int D.56039;
  int D.56042;
  long unsigned int D.56043;
  long unsigned int D.56044;
  guint8 * code.9389;
  signed char iftmp.9390;
  _Bool D.56054;
  signed char D.56055;
  signed char D.56056;
  guint8 * code.9391;
  unsigned char D.56060;
  guint8 * code.9392;
  guint8 * code.9393;
  guint8 * code.9394;
  int D.56066;
  int D.56067;
  signed char D.56068;
  signed char D.56069;
  unsigned char D.56070;
  guint8 * code.9395;
  unsigned char D.56072;
  guint8 * code.9396;
  unsigned char D.56074;
  guint8 * code.9397;
  unsigned char D.56076;
  guint8 * code.9398;
  unsigned char D.56078;
  guint8 * code.9399;
  signed char D.56085;
  unsigned char D.56086;
  guint8 * code.9400;
  unsigned int save_area_offset.9401;
  unsigned int D.56090;
  guint8 * code.9402;
  signed char D.56094;
  unsigned char D.56095;
  guint8 * code.9403;
  unsigned char D.56097;
  guint8 * code.9404;
  signed char D.56100;
  unsigned char D.56101;
  guint8 * code.9405;
  guint8 * code.9406;
  unsigned char D.56104;
  guint8 * code.9407;
  unsigned char D.56106;
  guint8 * code.9408;
  unsigned char D.56108;
  guint8 * code.9409;
  unsigned char D.56110;
  guint8 * code.9410;
  unsigned char D.56116;
  unsigned char D.56117;
  unsigned char D.56118;
  unsigned char D.56119;
  guint8 * code.9411;
  unsigned char D.56123;
  guint8 * code.9412;
  unsigned char D.56126;
  guint8 * code.9413;
  unsigned char D.56128;
  guint8 * code.9414;
  unsigned char D.56130;
  guint8 * code.9415;
  unsigned char D.56132;
  guint8 * code.9416;
  unsigned char D.56134;
  <unnamed type> D.56135;
  <unnamed type> D.56138;
  guint8 * code.9417;
  signed char iftmp.9418;
  signed char D.56143;
  int D.56147;
  _Bool D.56148;
  signed char D.56149;
  signed char D.56150;
  guint8 * code.9419;
  unsigned char D.56154;
  guint8 * code.9420;
  guint8 * code.9421;
  guint8 * code.9422;
  int D.56160;
  int D.56161;
  int D.56162;
  signed char D.56163;
  signed char D.56164;
  unsigned char D.56165;
  long int D.56166;
  unsigned int D.56167;
  long unsigned int D.56168;
  unsigned int D.56169;
  unsigned int D.56170;
  unsigned int D.56171;
  int D.56172;
  guint8 * code.9423;
  unsigned char D.56174;
  guint8 * code.9424;
  unsigned char D.56176;
  guint8 * code.9425;
  unsigned char D.56178;
  guint8 * code.9426;
  unsigned char D.56180;
  int D.56182;
  long unsigned int D.56185;
  long unsigned int D.56186;
  long unsigned int D.56187;
  guint8 * code.9427;
  signed char D.56191;
  unsigned char D.56192;
  guint8 * code.9428;
  guint8 * code.9429;
  signed char D.56200;
  unsigned char D.56201;
  guint8 * code.9430;
  unsigned char D.56203;
  unsigned char D.56204;
  unsigned char D.56205;
  unsigned char D.56206;
  guint8 * code.9431;
  signed char D.56208;
  unsigned char D.56209;
  guint8 * code.9432;
  guint8 * code.9433;
  unsigned char D.56212;
  guint8 * code.9434;
  unsigned char D.56214;
  guint8 * code.9435;
  unsigned char D.56216;
  guint8 * code.9436;
  unsigned char D.56218;
  guint8 * code.9437;
  signed char D.56224;
  signed char D.56225;
  signed char D.56226;
  unsigned char D.56227;
  guint8 * code.9438;
  signed char D.56233;
  signed char D.56234;
  unsigned char D.56235;
  guint8 * code.9439;
  signed char D.56237;
  signed char D.56238;
  unsigned char D.56239;
  guint8 * code.9440;
  unsigned char D.56241;
  guint8 * code.9441;
  unsigned char D.56243;
  guint8 * code.9442;
  unsigned char D.56245;
  guint8 * code.9443;
  unsigned char D.56247;
  guint8 * code.9444;
  signed char iftmp.9445;
  signed char D.56253;
  guint8 * code.9446;
  unsigned char D.56257;
  guint8 * code.9447;
  guint8 * code.9448;
  guint8 * code.9449;
  guint8 * code.9450;
  guint8 * code.9451;
  guint8 * code.9452;
  guint8 * code.9453;
  guint8 * code.9454;
  guint8 * code.9455;
  unsigned char D.56276;
  guint8 * code.9456;
  unsigned char D.56278;
  guint8 * code.9457;
  unsigned char D.56280;
  guint8 * code.9458;
  unsigned char D.56282;
  guint8 * code.9459;
  guint8 * code.9460;
  guint8 * code.9461;
  guint8 * code.9462;
  unsigned char D.56295;
  guint8 * code.9463;
  unsigned char D.56297;
  guint8 * code.9464;
  unsigned char D.56299;
  guint8 * code.9465;
  unsigned char D.56301;
  guint8 * code.9466;
  signed char iftmp.9467;
  signed char D.56307;
  guint8 * code.9468;
  unsigned char D.56311;
  guint8 * code.9469;
  guint8 * code.9470;
  guint8 * code.9471;
  guint8 * code.9472;
  guint8 * code.9473;
  guint8 * code.9474;
  guint8 * code.9475;
  guint8 * code.9476;
  guint8 * code.9477;
  unsigned char D.56330;
  guint8 * code.9478;
  unsigned char D.56332;
  guint8 * code.9479;
  unsigned char D.56334;
  guint8 * code.9480;
  unsigned char D.56336;
  guint8 * code.9481;
  guint8 * code.9482;
  guint8 * code.9483;
  guint8 * code.9484;
  unsigned char D.56349;
  guint8 * code.9485;
  unsigned char D.56351;
  guint8 * code.9486;
  unsigned char D.56353;
  guint8 * code.9487;
  unsigned char D.56355;
  int D.56356;
  int D.56359;
  unsigned int D.56362;
  unsigned int D.56363;
  guint8 * code.9488;
  unsigned char D.56369;
  guint8 * code.9489;
  guint8 * code.9490;
  unsigned char D.56372;
  guint8 * code.9491;
  unsigned char D.56379;
  guint8 * code.9492;
  guint8 * code.9493;
  unsigned char D.56382;
  guint8 * code.9494;
  unsigned char D.56384;
  guint8 * code.9495;
  unsigned char D.56386;
  guint8 * code.9496;
  unsigned char D.56388;
  guint8 * code.9497;
  unsigned char D.56393;
  guint8 * code.9498;
  guint8 * code.9499;
  guint8 * code.9500;
  unsigned char D.56397;
  guint8 * code.9501;
  unsigned char D.56399;
  guint8 * code.9502;
  unsigned char D.56401;
  guint8 * code.9503;
  unsigned char D.56403;
  guint8 * code.9504;
  struct MonoMethodDesc * mono_inject_async_exc_method.9505;
  struct MonoMethod * D.56409;
  int D.56410;
  int D.56413;
  int mono_inject_async_exc_pos.9506;
  guint8 * code.9507;
  guint8 * code.9508;
  unsigned char D.56423;
  guint8 * code.9509;
  guint8 * code.9510;
  guint8 * code.9511;
  guint8 * code.9512;
  guint8 * code.9513;
  unsigned char D.56429;
  guint8 * code.9514;
  unsigned char D.56431;
  guint8 * code.9515;
  unsigned char D.56433;
  guint8 * code.9516;
  unsigned char D.56435;
  int D.56436;
  guint8 * code.9517;
  long int D.56438;
  long int D.56439;
  unsigned int D.56440;
  _Bool D.56441;
  long int D.56442;
  long int D.56443;
  struct MonoMethod * method;
  int quad;
  int pos;
  int i;
  guint8 * code;
  int max_epilog_size;
  struct CallInfo * cinfo;
  gint32 lmf_offset;
  static const char __PRETTY_FUNCTION__[22] = "mono_arch_emit_epilog";

  method = cfg->method;
  D.55423 = cfg->lmf_var;
  if (D.55423 != 0B) goto <D.55424>; else goto <D.55425>;
  <D.55424>:
  D.55423 = cfg->lmf_var;
  D.55426 = D.55423->data.op[0].const_val;
  iftmp.9173 = (gint32) D.55426;
  goto <D.55427>;
  <D.55425>:
  iftmp.9173 = -1;
  <D.55427>:
  lmf_offset = iftmp.9173;
  max_epilog_size = get_max_epilog_size (cfg);
  goto <D.28361>;
  <D.28360>:
  D.55428 = cfg->code_size;
  D.55429 = D.55428 * 2;
  cfg->code_size = D.55429;
  D.55430 = mono_realloc_native_code (cfg);
  cfg->native_code = D.55430;
  D.55431 = cfg->stat_code_reallocs;
  D.55432 = D.55431 + 1;
  cfg->stat_code_reallocs = D.55432;
  <D.28361>:
  D.55433 = cfg->code_len;
  max_epilog_size.9174 = (unsigned int) max_epilog_size;
  D.55435 = D.55433 + max_epilog_size.9174;
  D.55428 = cfg->code_size;
  D.55436 = D.55428 + 4294967280;
  if (D.55435 > D.55436) goto <D.28360>; else goto <D.28362>;
  <D.28362>:
  D.55437 = cfg->native_code;
  D.55433 = cfg->code_len;
  D.55438 = (sizetype) D.55433;
  code = D.55437 + D.55438;
  mono_jit_trace_calls.9175 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.9175 != 0B) goto <D.55440>; else goto <D.55441>;
  <D.55440>:
  D.55442 = mono_trace_eval (method);
  if (D.55442 != 0) goto <D.55443>; else goto <D.55444>;
  <D.55443>:
  code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, 1);
  <D.55444>:
  <D.55441>:
  pos = 0;
  D.55445 = BIT_FIELD_REF <*method, 8, 264>;
  D.55446 = D.55445 & 1;
  if (D.55446 != 0) goto <D.55447>; else goto <D.55448>;
  <D.55447>:
  D.55449 = mono_get_jit_tls_offset ();
  if (D.55449 != -1) goto <D.55450>; else goto <D.55451>;
  <D.55450>:
  {
    guint8 * patch;

    D.55452 = mono_get_jit_tls_offset ();
    code = mono_amd64_emit_tls_get (code, 1, D.55452);
    if (0 != 0) goto <D.55453>; else goto <D.55454>;
    <D.55453>:
    code.9176 = code;
    code = code.9176 + 1;
    *code.9176 = 102;
    <D.55454>:
    {
      unsigned char _amd64_rex_bits;

      _amd64_rex_bits = 8;
      if (_amd64_rex_bits != 0) goto <D.55456>; else goto <D.55457>;
      <D.55456>:
      code.9177 = code;
      code = code.9177 + 1;
      D.55459 = _amd64_rex_bits | 64;
      *code.9177 = D.55459;
      <D.55457>:
    }
    switch (8) <default: <D.28370>, case 1: <D.28365>, case 2: <D.28367>, case 4: <D.28368>, case 8: <D.28369>>
    <D.28365>:
    code.9178 = code;
    code = code.9178 + 1;
    *code.9178 = 138;
    goto <D.28366>;
    <D.28367>:
    <D.28368>:
    <D.28369>:
    code.9179 = code;
    code = code.9179 + 1;
    *code.9179 = 139;
    goto <D.28366>;
    <D.28370>:
    __assert_fail ("0", "mini-amd64.c", 7261, &__PRETTY_FUNCTION__);
    <D.28366>:
    if (0 != 0) goto <D.55462>; else goto <D.55463>;
    <D.55462>:
    code.9180 = code;
    code = code.9180 + 1;
    *code.9180 = 13;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 24;
          code.9181 = code;
          code = code.9181 + 1;
          D.55466 = imb.b[0];
          *code.9181 = D.55466;
          code.9182 = code;
          code = code.9182 + 1;
          D.55468 = imb.b[1];
          *code.9182 = D.55468;
          code.9183 = code;
          code = code.9183 + 1;
          D.55470 = imb.b[2];
          *code.9183 = D.55470;
          code.9184 = code;
          code = code.9184 + 1;
          D.55472 = imb.b[3];
          *code.9184 = D.55472;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.55473>;
    <D.55463>:
    if (0 != 0) goto <D.55474>; else goto <D.55475>;
    <D.55474>:
    if (0 != 0) goto <D.55476>; else goto <D.55477>;
    <D.55476>:
    code.9185 = code;
    code = code.9185 + 1;
    *code.9185 = 12;
    code.9186 = code;
    code = code.9186 + 1;
    *code.9186 = 36;
    goto <D.55480>;
    <D.55477>:
    if (1 != 0) goto <D.55481>; else goto <D.55482>;
    <D.55481>:
    code.9187 = code;
    code = code.9187 + 1;
    *code.9187 = 76;
    code.9188 = code;
    code = code.9188 + 1;
    *code.9188 = 36;
    *code = 24;
    code = code + 1;
    goto <D.55485>;
    <D.55482>:
    code.9189 = code;
    code = code.9189 + 1;
    *code.9189 = 140;
    code.9190 = code;
    code = code.9190 + 1;
    *code.9190 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 24;
          code.9191 = code;
          code = code.9191 + 1;
          D.55489 = imb.b[0];
          *code.9191 = D.55489;
          code.9192 = code;
          code = code.9192 + 1;
          D.55491 = imb.b[1];
          *code.9192 = D.55491;
          code.9193 = code;
          code = code.9193 + 1;
          D.55493 = imb.b[2];
          *code.9193 = D.55493;
          code.9194 = code;
          code = code.9194 + 1;
          D.55495 = imb.b[3];
          *code.9194 = D.55495;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55485>:
    <D.55480>:
    goto <D.28374>;
    <D.55475>:
    if (0 != 0) goto <D.55496>; else goto <D.55497>;
    <D.55496>:
    code.9195 = code;
    code = code.9195 + 1;
    *code.9195 = 9;
    goto <D.28374>;
    <D.55497>:
    if (1 != 0) goto <D.55499>; else goto <D.55500>;
    <D.55499>:
    code.9196 = code;
    code = code.9196 + 1;
    *code.9196 = 73;
    *code = 24;
    code = code + 1;
    goto <D.55502>;
    <D.55500>:
    code.9197 = code;
    code = code.9197 + 1;
    *code.9197 = 137;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 24;
          code.9198 = code;
          code = code.9198 + 1;
          D.55505 = imb.b[0];
          *code.9198 = D.55505;
          code.9199 = code;
          code = code.9199 + 1;
          D.55507 = imb.b[1];
          *code.9199 = D.55507;
          code.9200 = code;
          code = code.9200 + 1;
          D.55509 = imb.b[2];
          *code.9200 = D.55509;
          code.9201 = code;
          code = code.9201 + 1;
          D.55511 = imb.b[3];
          *code.9201 = D.55511;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55502>:
    <D.28374>:
    <D.55473>:
    if (0 != 0) goto <D.55512>; else goto <D.55513>;
    <D.55512>:
    code.9202 = code;
    code = code.9202 + 1;
    *code.9202 = 61;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9203 = code;
          code = code.9203 + 1;
          D.55516 = imb.b[0];
          *code.9203 = D.55516;
          code.9204 = code;
          code = code.9204 + 1;
          D.55518 = imb.b[1];
          *code.9204 = D.55518;
          code.9205 = code;
          code = code.9205 + 1;
          D.55520 = imb.b[2];
          *code.9205 = D.55520;
          code.9206 = code;
          code = code.9206 + 1;
          D.55522 = imb.b[3];
          *code.9206 = D.55522;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.28377>;
    <D.55513>:
    if (1 != 0) goto <D.55523>; else goto <D.55524>;
    <D.55523>:
    code.9207 = code;
    code = code.9207 + 1;
    *code.9207 = 131;
    code.9208 = code;
    code = code.9208 + 1;
    *code.9208 = 249;
    *code = 0;
    code = code + 1;
    goto <D.55527>;
    <D.55524>:
    code.9209 = code;
    code = code.9209 + 1;
    *code.9209 = 129;
    code.9210 = code;
    code = code.9210 + 1;
    *code.9210 = 249;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9211 = code;
          code = code.9211 + 1;
          D.55531 = imb.b[0];
          *code.9211 = D.55531;
          code.9212 = code;
          code = code.9212 + 1;
          D.55533 = imb.b[1];
          *code.9212 = D.55533;
          code.9213 = code;
          code = code.9213 + 1;
          D.55535 = imb.b[2];
          *code.9213 = D.55535;
          code.9214 = code;
          code = code.9214 + 1;
          D.55537 = imb.b[3];
          *code.9214 = D.55537;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.55527>:
    <D.28377>:
    patch = code;
    if (0 != 0) goto <D.55538>; else goto <D.55539>;
    <D.55538>:
    code.9215 = code;
    code = code.9215 + 1;
    D.55541 = 116;
    *code.9215 = D.55541;
    goto <D.55542>;
    <D.55539>:
    code.9216 = code;
    code = code.9216 + 1;
    D.55544 = 116;
    *code.9216 = D.55544;
    <D.55542>:
    *code = 0;
    code = code + 1;
    code.9217 = code;
    code = code.9217 + 1;
    *code.9217 = 255;
    code.9218 = code;
    code = code.9218 + 1;
    *code.9218 = 209;
    {
      unsigned char * pos;
      int disp;
      int size;

      pos = patch + 1;
      size = 0;
      D.55547 = MEM[(unsigned char *)patch];
      D.55548 = (int) D.55547;
      switch (D.55548) <default: <D.28406>, case 15: <D.28385>, case 112: <D.28390>, case 113: <D.28391>, case 114: <D.28392>, case 115: <D.28393>, case 116: <D.28394>, case 117: <D.28395>, case 118: <D.28396>, case 119: <D.28397>, case 120: <D.28398>, case 121: <D.28399>, case 122: <D.28400>, case 123: <D.28401>, case 124: <D.28402>, case 125: <D.28403>, case 126: <D.28404>, case 127: <D.28405>, case 224: <D.28386>, case 225: <D.28387>, case 226: <D.28388>, case 232: <D.28382>, case 233: <D.28383>, case 235: <D.28389>>
      <D.28382>:
      <D.28383>:
      size = size + 1;
      goto <D.28384>;
      <D.28385>:
      D.55549 = *pos;
      D.55550 = D.55549 + 144;
      if (D.55550 > 31) goto <D.55551>; else goto <D.55552>;
      <D.55551>:
      __assert_fail ("0", "mini-amd64.c", 7267, &__PRETTY_FUNCTION__);
      <D.55552>:
      size = size + 1;
      pos = pos + 1;
      goto <D.28384>;
      <D.28386>:
      <D.28387>:
      <D.28388>:
      <D.28389>:
      <D.28390>:
      <D.28391>:
      <D.28392>:
      <D.28393>:
      <D.28394>:
      <D.28395>:
      <D.28396>:
      <D.28397>:
      <D.28398>:
      <D.28399>:
      <D.28400>:
      <D.28401>:
      <D.28402>:
      <D.28403>:
      <D.28404>:
      <D.28405>:
      goto <D.28384>;
      <D.28406>:
      __assert_fail ("0", "mini-amd64.c", 7267, &__PRETTY_FUNCTION__);
      <D.28384>:
      code.9219 = (long int) code;
      pos.9220 = (long int) pos;
      D.55555 = code.9219 - pos.9220;
      disp = (int) D.55555;
      if (size != 0) goto <D.55556>; else goto <D.55557>;
      <D.55556>:
      {
        union x86_imm_buf imb;

        try
          {
            D.55558 = disp + -4;
            imb.val = D.55558;
            pos.9221 = pos;
            pos = pos.9221 + 1;
            D.55560 = imb.b[0];
            *pos.9221 = D.55560;
            pos.9222 = pos;
            pos = pos.9222 + 1;
            D.55562 = imb.b[1];
            *pos.9222 = D.55562;
            pos.9223 = pos;
            pos = pos.9223 + 1;
            D.55564 = imb.b[2];
            *pos.9223 = D.55564;
            pos.9224 = pos;
            pos = pos.9224 + 1;
            D.55566 = imb.b[3];
            *pos.9224 = D.55566;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.55567>;
      <D.55557>:
      disp.9225 = (unsigned int) disp;
      D.55569 = disp.9225 + 127;
      if (D.55569 <= 255) goto <D.55570>; else goto <D.55571>;
      <D.55570>:
      D.55572 = (unsigned char) disp;
      D.55573 = D.55572 + 255;
      *pos = D.55573;
      pos = pos + 1;
      goto <D.55574>;
      <D.55571>:
      __assert_fail ("0", "mini-amd64.c", 7267, &__PRETTY_FUNCTION__);
      <D.55574>:
      <D.55567>:
    }
  }
  goto <D.55575>;
  <D.55451>:
  <D.55575>:
  D.55576 = cfg->used_int_regs;
  D.55577 = D.55576 & 32;
  if (D.55577 != 0) goto <D.55578>; else goto <D.55579>;
  <D.55578>:
  if (0 != 0) goto <D.55580>; else goto <D.55581>;
  <D.55580>:
  code.9226 = code;
  code = code.9226 + 1;
  *code.9226 = 102;
  <D.55581>:
  {
    unsigned char _amd64_rex_bits;

    D.55584 = cfg->frame_reg;
    if (D.55584 > 7) goto <D.55585>; else goto <D.55586>;
    <D.55585>:
    iftmp.9227 = 9;
    goto <D.55587>;
    <D.55586>:
    iftmp.9227 = 8;
    <D.55587>:
    _amd64_rex_bits = iftmp.9227;
    if (_amd64_rex_bits != 0) goto <D.55588>; else goto <D.55589>;
    <D.55588>:
    code.9228 = code;
    code = code.9228 + 1;
    D.55591 = _amd64_rex_bits | 64;
    *code.9228 = D.55591;
    <D.55589>:
  }
  switch (8) <default: <D.28414>, case 1: <D.28409>, case 2: <D.28411>, case 4: <D.28412>, case 8: <D.28413>>
  <D.28409>:
  code.9229 = code;
  code = code.9229 + 1;
  *code.9229 = 138;
  goto <D.28410>;
  <D.28411>:
  <D.28412>:
  <D.28413>:
  code.9230 = code;
  code = code.9230 + 1;
  *code.9230 = 139;
  goto <D.28410>;
  <D.28414>:
  __assert_fail ("0", "mini-amd64.c", 7274, &__PRETTY_FUNCTION__);
  <D.28410>:
  D.55584 = cfg->frame_reg;
  if (D.55584 == 16) goto <D.55594>; else goto <D.55595>;
  <D.55594>:
  code.9231 = code;
  code = code.9231 + 1;
  *code.9231 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55598 = lmf_offset.9232 + 24;
        D.55599 = (int) D.55598;
        imb.val = D.55599;
        code.9233 = code;
        code = code.9233 + 1;
        D.55601 = imb.b[0];
        *code.9233 = D.55601;
        code.9234 = code;
        code = code.9234 + 1;
        D.55603 = imb.b[1];
        *code.9234 = D.55603;
        code.9235 = code;
        code = code.9235 + 1;
        D.55605 = imb.b[2];
        *code.9235 = D.55605;
        code.9236 = code;
        code = code.9236 + 1;
        D.55607 = imb.b[3];
        *code.9236 = D.55607;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.55608>;
  <D.55595>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 == 4) goto <D.55610>; else goto <D.55611>;
  <D.55610>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551592) goto <D.55613>; else goto <D.55614>;
  <D.55613>:
  code.9237 = code;
  code = code.9237 + 1;
  *code.9237 = 44;
  code.9238 = code;
  code = code.9238 + 1;
  *code.9238 = 36;
  goto <D.55617>;
  <D.55614>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55598 = lmf_offset.9232 + 24;
  D.55599 = (int) D.55598;
  if (D.55599 >= -128) goto <D.55620>; else goto <D.55618>;
  <D.55620>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55598 = lmf_offset.9232 + 24;
  D.55599 = (int) D.55598;
  if (D.55599 <= 127) goto <D.55621>; else goto <D.55618>;
  <D.55621>:
  code.9239 = code;
  code = code.9239 + 1;
  *code.9239 = 108;
  code.9240 = code;
  code = code.9240 + 1;
  *code.9240 = 36;
  D.55624 = (unsigned char) lmf_offset;
  D.55625 = D.55624 + 24;
  *code = D.55625;
  code = code + 1;
  goto <D.55619>;
  <D.55618>:
  code.9241 = code;
  code = code.9241 + 1;
  *code.9241 = 172;
  code.9242 = code;
  code = code.9242 + 1;
  *code.9242 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55598 = lmf_offset.9232 + 24;
        D.55599 = (int) D.55598;
        imb.val = D.55599;
        code.9243 = code;
        code = code.9243 + 1;
        D.55629 = imb.b[0];
        *code.9243 = D.55629;
        code.9244 = code;
        code = code.9244 + 1;
        D.55631 = imb.b[1];
        *code.9244 = D.55631;
        code.9245 = code;
        code = code.9245 + 1;
        D.55633 = imb.b[2];
        *code.9245 = D.55633;
        code.9246 = code;
        code = code.9246 + 1;
        D.55635 = imb.b[3];
        *code.9246 = D.55635;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55619>:
  <D.55617>:
  goto <D.28417>;
  <D.55611>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551592) goto <D.55636>; else goto <D.55637>;
  <D.55636>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 != 5) goto <D.55638>; else goto <D.55639>;
  <D.55638>:
  code.9247 = code;
  code = code.9247 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55643 = D.55642 | 40;
  *code.9247 = D.55643;
  goto <D.28417>;
  <D.55639>:
  <D.55637>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55598 = lmf_offset.9232 + 24;
  D.55599 = (int) D.55598;
  if (D.55599 >= -128) goto <D.55646>; else goto <D.55644>;
  <D.55646>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55598 = lmf_offset.9232 + 24;
  D.55599 = (int) D.55598;
  if (D.55599 <= 127) goto <D.55647>; else goto <D.55644>;
  <D.55647>:
  code.9248 = code;
  code = code.9248 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55649 = D.55642 | 104;
  *code.9248 = D.55649;
  D.55624 = (unsigned char) lmf_offset;
  D.55625 = D.55624 + 24;
  *code = D.55625;
  code = code + 1;
  goto <D.55645>;
  <D.55644>:
  code.9249 = code;
  code = code.9249 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55651 = D.55642 | 168;
  *code.9249 = D.55651;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55598 = lmf_offset.9232 + 24;
        D.55599 = (int) D.55598;
        imb.val = D.55599;
        code.9250 = code;
        code = code.9250 + 1;
        D.55653 = imb.b[0];
        *code.9250 = D.55653;
        code.9251 = code;
        code = code.9251 + 1;
        D.55655 = imb.b[1];
        *code.9251 = D.55655;
        code.9252 = code;
        code = code.9252 + 1;
        D.55657 = imb.b[2];
        *code.9252 = D.55657;
        code.9253 = code;
        code = code.9253 + 1;
        D.55659 = imb.b[3];
        *code.9253 = D.55659;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55645>:
  <D.28417>:
  <D.55608>:
  <D.55579>:
  D.55576 = cfg->used_int_regs;
  D.55660 = D.55576 & 8;
  if (D.55660 != 0) goto <D.55661>; else goto <D.55662>;
  <D.55661>:
  if (0 != 0) goto <D.55663>; else goto <D.55664>;
  <D.55663>:
  code.9254 = code;
  code = code.9254 + 1;
  *code.9254 = 102;
  <D.55664>:
  {
    unsigned char _amd64_rex_bits;

    D.55584 = cfg->frame_reg;
    if (D.55584 > 7) goto <D.55667>; else goto <D.55668>;
    <D.55667>:
    iftmp.9255 = 9;
    goto <D.55669>;
    <D.55668>:
    iftmp.9255 = 8;
    <D.55669>:
    _amd64_rex_bits = iftmp.9255;
    if (_amd64_rex_bits != 0) goto <D.55670>; else goto <D.55671>;
    <D.55670>:
    code.9256 = code;
    code = code.9256 + 1;
    D.55673 = _amd64_rex_bits | 64;
    *code.9256 = D.55673;
    <D.55671>:
  }
  switch (8) <default: <D.28425>, case 1: <D.28420>, case 2: <D.28422>, case 4: <D.28423>, case 8: <D.28424>>
  <D.28420>:
  code.9257 = code;
  code = code.9257 + 1;
  *code.9257 = 138;
  goto <D.28421>;
  <D.28422>:
  <D.28423>:
  <D.28424>:
  code.9258 = code;
  code = code.9258 + 1;
  *code.9258 = 139;
  goto <D.28421>;
  <D.28425>:
  __assert_fail ("0", "mini-amd64.c", 7277, &__PRETTY_FUNCTION__);
  <D.28421>:
  D.55584 = cfg->frame_reg;
  if (D.55584 == 16) goto <D.55676>; else goto <D.55677>;
  <D.55676>:
  code.9259 = code;
  code = code.9259 + 1;
  *code.9259 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55679 = lmf_offset.9232 + 16;
        D.55680 = (int) D.55679;
        imb.val = D.55680;
        code.9260 = code;
        code = code.9260 + 1;
        D.55682 = imb.b[0];
        *code.9260 = D.55682;
        code.9261 = code;
        code = code.9261 + 1;
        D.55684 = imb.b[1];
        *code.9261 = D.55684;
        code.9262 = code;
        code = code.9262 + 1;
        D.55686 = imb.b[2];
        *code.9262 = D.55686;
        code.9263 = code;
        code = code.9263 + 1;
        D.55688 = imb.b[3];
        *code.9263 = D.55688;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.55689>;
  <D.55677>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 == 4) goto <D.55690>; else goto <D.55691>;
  <D.55690>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551600) goto <D.55692>; else goto <D.55693>;
  <D.55692>:
  code.9264 = code;
  code = code.9264 + 1;
  *code.9264 = 28;
  code.9265 = code;
  code = code.9265 + 1;
  *code.9265 = 36;
  goto <D.55696>;
  <D.55693>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55679 = lmf_offset.9232 + 16;
  D.55680 = (int) D.55679;
  if (D.55680 >= -128) goto <D.55699>; else goto <D.55697>;
  <D.55699>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55679 = lmf_offset.9232 + 16;
  D.55680 = (int) D.55679;
  if (D.55680 <= 127) goto <D.55700>; else goto <D.55697>;
  <D.55700>:
  code.9266 = code;
  code = code.9266 + 1;
  *code.9266 = 92;
  code.9267 = code;
  code = code.9267 + 1;
  *code.9267 = 36;
  D.55624 = (unsigned char) lmf_offset;
  D.55703 = D.55624 + 16;
  *code = D.55703;
  code = code + 1;
  goto <D.55698>;
  <D.55697>:
  code.9268 = code;
  code = code.9268 + 1;
  *code.9268 = 156;
  code.9269 = code;
  code = code.9269 + 1;
  *code.9269 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55679 = lmf_offset.9232 + 16;
        D.55680 = (int) D.55679;
        imb.val = D.55680;
        code.9270 = code;
        code = code.9270 + 1;
        D.55707 = imb.b[0];
        *code.9270 = D.55707;
        code.9271 = code;
        code = code.9271 + 1;
        D.55709 = imb.b[1];
        *code.9271 = D.55709;
        code.9272 = code;
        code = code.9272 + 1;
        D.55711 = imb.b[2];
        *code.9272 = D.55711;
        code.9273 = code;
        code = code.9273 + 1;
        D.55713 = imb.b[3];
        *code.9273 = D.55713;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55698>:
  <D.55696>:
  goto <D.28428>;
  <D.55691>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551600) goto <D.55714>; else goto <D.55715>;
  <D.55714>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 != 5) goto <D.55716>; else goto <D.55717>;
  <D.55716>:
  code.9274 = code;
  code = code.9274 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55719 = D.55642 | 24;
  *code.9274 = D.55719;
  goto <D.28428>;
  <D.55717>:
  <D.55715>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55679 = lmf_offset.9232 + 16;
  D.55680 = (int) D.55679;
  if (D.55680 >= -128) goto <D.55722>; else goto <D.55720>;
  <D.55722>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55679 = lmf_offset.9232 + 16;
  D.55680 = (int) D.55679;
  if (D.55680 <= 127) goto <D.55723>; else goto <D.55720>;
  <D.55723>:
  code.9275 = code;
  code = code.9275 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55725 = D.55642 | 88;
  *code.9275 = D.55725;
  D.55624 = (unsigned char) lmf_offset;
  D.55703 = D.55624 + 16;
  *code = D.55703;
  code = code + 1;
  goto <D.55721>;
  <D.55720>:
  code.9276 = code;
  code = code.9276 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55727 = D.55642 | 152;
  *code.9276 = D.55727;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55679 = lmf_offset.9232 + 16;
        D.55680 = (int) D.55679;
        imb.val = D.55680;
        code.9277 = code;
        code = code.9277 + 1;
        D.55729 = imb.b[0];
        *code.9277 = D.55729;
        code.9278 = code;
        code = code.9278 + 1;
        D.55731 = imb.b[1];
        *code.9278 = D.55731;
        code.9279 = code;
        code = code.9279 + 1;
        D.55733 = imb.b[2];
        *code.9279 = D.55733;
        code.9280 = code;
        code = code.9280 + 1;
        D.55735 = imb.b[3];
        *code.9280 = D.55735;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55721>:
  <D.28428>:
  <D.55689>:
  <D.55662>:
  D.55576 = cfg->used_int_regs;
  D.55736 = D.55576 & 4096;
  if (D.55736 != 0) goto <D.55737>; else goto <D.55738>;
  <D.55737>:
  if (0 != 0) goto <D.55739>; else goto <D.55740>;
  <D.55739>:
  code.9281 = code;
  code = code.9281 + 1;
  *code.9281 = 102;
  <D.55740>:
  {
    unsigned char _amd64_rex_bits;

    D.55584 = cfg->frame_reg;
    if (D.55584 > 7) goto <D.55743>; else goto <D.55744>;
    <D.55743>:
    iftmp.9282 = 13;
    goto <D.55745>;
    <D.55744>:
    iftmp.9282 = 12;
    <D.55745>:
    _amd64_rex_bits = iftmp.9282;
    if (_amd64_rex_bits != 0) goto <D.55746>; else goto <D.55747>;
    <D.55746>:
    code.9283 = code;
    code = code.9283 + 1;
    D.55749 = _amd64_rex_bits | 64;
    *code.9283 = D.55749;
    <D.55747>:
  }
  switch (8) <default: <D.28436>, case 1: <D.28431>, case 2: <D.28433>, case 4: <D.28434>, case 8: <D.28435>>
  <D.28431>:
  code.9284 = code;
  code = code.9284 + 1;
  *code.9284 = 138;
  goto <D.28432>;
  <D.28433>:
  <D.28434>:
  <D.28435>:
  code.9285 = code;
  code = code.9285 + 1;
  *code.9285 = 139;
  goto <D.28432>;
  <D.28436>:
  __assert_fail ("0", "mini-amd64.c", 7280, &__PRETTY_FUNCTION__);
  <D.28432>:
  D.55584 = cfg->frame_reg;
  if (D.55584 == 16) goto <D.55752>; else goto <D.55753>;
  <D.55752>:
  code.9286 = code;
  code = code.9286 + 1;
  *code.9286 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55755 = lmf_offset.9232 + 40;
        D.55756 = (int) D.55755;
        imb.val = D.55756;
        code.9287 = code;
        code = code.9287 + 1;
        D.55758 = imb.b[0];
        *code.9287 = D.55758;
        code.9288 = code;
        code = code.9288 + 1;
        D.55760 = imb.b[1];
        *code.9288 = D.55760;
        code.9289 = code;
        code = code.9289 + 1;
        D.55762 = imb.b[2];
        *code.9289 = D.55762;
        code.9290 = code;
        code = code.9290 + 1;
        D.55764 = imb.b[3];
        *code.9290 = D.55764;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.55765>;
  <D.55753>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 == 4) goto <D.55766>; else goto <D.55767>;
  <D.55766>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551576) goto <D.55768>; else goto <D.55769>;
  <D.55768>:
  code.9291 = code;
  code = code.9291 + 1;
  *code.9291 = 36;
  code.9292 = code;
  code = code.9292 + 1;
  *code.9292 = 36;
  goto <D.55772>;
  <D.55769>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55755 = lmf_offset.9232 + 40;
  D.55756 = (int) D.55755;
  if (D.55756 >= -128) goto <D.55775>; else goto <D.55773>;
  <D.55775>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55755 = lmf_offset.9232 + 40;
  D.55756 = (int) D.55755;
  if (D.55756 <= 127) goto <D.55776>; else goto <D.55773>;
  <D.55776>:
  code.9293 = code;
  code = code.9293 + 1;
  *code.9293 = 100;
  code.9294 = code;
  code = code.9294 + 1;
  *code.9294 = 36;
  D.55624 = (unsigned char) lmf_offset;
  D.55779 = D.55624 + 40;
  *code = D.55779;
  code = code + 1;
  goto <D.55774>;
  <D.55773>:
  code.9295 = code;
  code = code.9295 + 1;
  *code.9295 = 164;
  code.9296 = code;
  code = code.9296 + 1;
  *code.9296 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55755 = lmf_offset.9232 + 40;
        D.55756 = (int) D.55755;
        imb.val = D.55756;
        code.9297 = code;
        code = code.9297 + 1;
        D.55783 = imb.b[0];
        *code.9297 = D.55783;
        code.9298 = code;
        code = code.9298 + 1;
        D.55785 = imb.b[1];
        *code.9298 = D.55785;
        code.9299 = code;
        code = code.9299 + 1;
        D.55787 = imb.b[2];
        *code.9299 = D.55787;
        code.9300 = code;
        code = code.9300 + 1;
        D.55789 = imb.b[3];
        *code.9300 = D.55789;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55774>:
  <D.55772>:
  goto <D.28439>;
  <D.55767>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551576) goto <D.55790>; else goto <D.55791>;
  <D.55790>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 != 5) goto <D.55792>; else goto <D.55793>;
  <D.55792>:
  code.9301 = code;
  code = code.9301 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55795 = D.55642 | 32;
  *code.9301 = D.55795;
  goto <D.28439>;
  <D.55793>:
  <D.55791>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55755 = lmf_offset.9232 + 40;
  D.55756 = (int) D.55755;
  if (D.55756 >= -128) goto <D.55798>; else goto <D.55796>;
  <D.55798>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55755 = lmf_offset.9232 + 40;
  D.55756 = (int) D.55755;
  if (D.55756 <= 127) goto <D.55799>; else goto <D.55796>;
  <D.55799>:
  code.9302 = code;
  code = code.9302 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55801 = D.55642 | 96;
  *code.9302 = D.55801;
  D.55624 = (unsigned char) lmf_offset;
  D.55779 = D.55624 + 40;
  *code = D.55779;
  code = code + 1;
  goto <D.55797>;
  <D.55796>:
  code.9303 = code;
  code = code.9303 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55803 = D.55642 | 160;
  *code.9303 = D.55803;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55755 = lmf_offset.9232 + 40;
        D.55756 = (int) D.55755;
        imb.val = D.55756;
        code.9304 = code;
        code = code.9304 + 1;
        D.55805 = imb.b[0];
        *code.9304 = D.55805;
        code.9305 = code;
        code = code.9305 + 1;
        D.55807 = imb.b[1];
        *code.9305 = D.55807;
        code.9306 = code;
        code = code.9306 + 1;
        D.55809 = imb.b[2];
        *code.9306 = D.55809;
        code.9307 = code;
        code = code.9307 + 1;
        D.55811 = imb.b[3];
        *code.9307 = D.55811;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55797>:
  <D.28439>:
  <D.55765>:
  <D.55738>:
  D.55576 = cfg->used_int_regs;
  D.55812 = D.55576 & 8192;
  if (D.55812 != 0) goto <D.55813>; else goto <D.55814>;
  <D.55813>:
  if (0 != 0) goto <D.55815>; else goto <D.55816>;
  <D.55815>:
  code.9308 = code;
  code = code.9308 + 1;
  *code.9308 = 102;
  <D.55816>:
  {
    unsigned char _amd64_rex_bits;

    D.55584 = cfg->frame_reg;
    if (D.55584 > 7) goto <D.55819>; else goto <D.55820>;
    <D.55819>:
    iftmp.9309 = 13;
    goto <D.55821>;
    <D.55820>:
    iftmp.9309 = 12;
    <D.55821>:
    _amd64_rex_bits = iftmp.9309;
    if (_amd64_rex_bits != 0) goto <D.55822>; else goto <D.55823>;
    <D.55822>:
    code.9310 = code;
    code = code.9310 + 1;
    D.55825 = _amd64_rex_bits | 64;
    *code.9310 = D.55825;
    <D.55823>:
  }
  switch (8) <default: <D.28447>, case 1: <D.28442>, case 2: <D.28444>, case 4: <D.28445>, case 8: <D.28446>>
  <D.28442>:
  code.9311 = code;
  code = code.9311 + 1;
  *code.9311 = 138;
  goto <D.28443>;
  <D.28444>:
  <D.28445>:
  <D.28446>:
  code.9312 = code;
  code = code.9312 + 1;
  *code.9312 = 139;
  goto <D.28443>;
  <D.28447>:
  __assert_fail ("0", "mini-amd64.c", 7283, &__PRETTY_FUNCTION__);
  <D.28443>:
  D.55584 = cfg->frame_reg;
  if (D.55584 == 16) goto <D.55828>; else goto <D.55829>;
  <D.55828>:
  code.9313 = code;
  code = code.9313 + 1;
  *code.9313 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55831 = lmf_offset.9232 + 48;
        D.55832 = (int) D.55831;
        imb.val = D.55832;
        code.9314 = code;
        code = code.9314 + 1;
        D.55834 = imb.b[0];
        *code.9314 = D.55834;
        code.9315 = code;
        code = code.9315 + 1;
        D.55836 = imb.b[1];
        *code.9315 = D.55836;
        code.9316 = code;
        code = code.9316 + 1;
        D.55838 = imb.b[2];
        *code.9316 = D.55838;
        code.9317 = code;
        code = code.9317 + 1;
        D.55840 = imb.b[3];
        *code.9317 = D.55840;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.55841>;
  <D.55829>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 == 4) goto <D.55842>; else goto <D.55843>;
  <D.55842>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551568) goto <D.55844>; else goto <D.55845>;
  <D.55844>:
  code.9318 = code;
  code = code.9318 + 1;
  *code.9318 = 44;
  code.9319 = code;
  code = code.9319 + 1;
  *code.9319 = 36;
  goto <D.55848>;
  <D.55845>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55831 = lmf_offset.9232 + 48;
  D.55832 = (int) D.55831;
  if (D.55832 >= -128) goto <D.55851>; else goto <D.55849>;
  <D.55851>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55831 = lmf_offset.9232 + 48;
  D.55832 = (int) D.55831;
  if (D.55832 <= 127) goto <D.55852>; else goto <D.55849>;
  <D.55852>:
  code.9320 = code;
  code = code.9320 + 1;
  *code.9320 = 108;
  code.9321 = code;
  code = code.9321 + 1;
  *code.9321 = 36;
  D.55624 = (unsigned char) lmf_offset;
  D.55855 = D.55624 + 48;
  *code = D.55855;
  code = code + 1;
  goto <D.55850>;
  <D.55849>:
  code.9322 = code;
  code = code.9322 + 1;
  *code.9322 = 172;
  code.9323 = code;
  code = code.9323 + 1;
  *code.9323 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55831 = lmf_offset.9232 + 48;
        D.55832 = (int) D.55831;
        imb.val = D.55832;
        code.9324 = code;
        code = code.9324 + 1;
        D.55859 = imb.b[0];
        *code.9324 = D.55859;
        code.9325 = code;
        code = code.9325 + 1;
        D.55861 = imb.b[1];
        *code.9325 = D.55861;
        code.9326 = code;
        code = code.9326 + 1;
        D.55863 = imb.b[2];
        *code.9326 = D.55863;
        code.9327 = code;
        code = code.9327 + 1;
        D.55865 = imb.b[3];
        *code.9327 = D.55865;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55850>:
  <D.55848>:
  goto <D.28450>;
  <D.55843>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551568) goto <D.55866>; else goto <D.55867>;
  <D.55866>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 != 5) goto <D.55868>; else goto <D.55869>;
  <D.55868>:
  code.9328 = code;
  code = code.9328 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55643 = D.55642 | 40;
  *code.9328 = D.55643;
  goto <D.28450>;
  <D.55869>:
  <D.55867>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55831 = lmf_offset.9232 + 48;
  D.55832 = (int) D.55831;
  if (D.55832 >= -128) goto <D.55873>; else goto <D.55871>;
  <D.55873>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55831 = lmf_offset.9232 + 48;
  D.55832 = (int) D.55831;
  if (D.55832 <= 127) goto <D.55874>; else goto <D.55871>;
  <D.55874>:
  code.9329 = code;
  code = code.9329 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55649 = D.55642 | 104;
  *code.9329 = D.55649;
  D.55624 = (unsigned char) lmf_offset;
  D.55855 = D.55624 + 48;
  *code = D.55855;
  code = code + 1;
  goto <D.55872>;
  <D.55871>:
  code.9330 = code;
  code = code.9330 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55651 = D.55642 | 168;
  *code.9330 = D.55651;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55831 = lmf_offset.9232 + 48;
        D.55832 = (int) D.55831;
        imb.val = D.55832;
        code.9331 = code;
        code = code.9331 + 1;
        D.55878 = imb.b[0];
        *code.9331 = D.55878;
        code.9332 = code;
        code = code.9332 + 1;
        D.55880 = imb.b[1];
        *code.9332 = D.55880;
        code.9333 = code;
        code = code.9333 + 1;
        D.55882 = imb.b[2];
        *code.9333 = D.55882;
        code.9334 = code;
        code = code.9334 + 1;
        D.55884 = imb.b[3];
        *code.9334 = D.55884;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55872>:
  <D.28450>:
  <D.55841>:
  <D.55814>:
  D.55576 = cfg->used_int_regs;
  D.55885 = D.55576 & 16384;
  if (D.55885 != 0) goto <D.55886>; else goto <D.55887>;
  <D.55886>:
  if (0 != 0) goto <D.55888>; else goto <D.55889>;
  <D.55888>:
  code.9335 = code;
  code = code.9335 + 1;
  *code.9335 = 102;
  <D.55889>:
  {
    unsigned char _amd64_rex_bits;

    D.55584 = cfg->frame_reg;
    if (D.55584 > 7) goto <D.55892>; else goto <D.55893>;
    <D.55892>:
    iftmp.9336 = 13;
    goto <D.55894>;
    <D.55893>:
    iftmp.9336 = 12;
    <D.55894>:
    _amd64_rex_bits = iftmp.9336;
    if (_amd64_rex_bits != 0) goto <D.55895>; else goto <D.55896>;
    <D.55895>:
    code.9337 = code;
    code = code.9337 + 1;
    D.55898 = _amd64_rex_bits | 64;
    *code.9337 = D.55898;
    <D.55896>:
  }
  switch (8) <default: <D.28458>, case 1: <D.28453>, case 2: <D.28455>, case 4: <D.28456>, case 8: <D.28457>>
  <D.28453>:
  code.9338 = code;
  code = code.9338 + 1;
  *code.9338 = 138;
  goto <D.28454>;
  <D.28455>:
  <D.28456>:
  <D.28457>:
  code.9339 = code;
  code = code.9339 + 1;
  *code.9339 = 139;
  goto <D.28454>;
  <D.28458>:
  __assert_fail ("0", "mini-amd64.c", 7286, &__PRETTY_FUNCTION__);
  <D.28454>:
  D.55584 = cfg->frame_reg;
  if (D.55584 == 16) goto <D.55901>; else goto <D.55902>;
  <D.55901>:
  code.9340 = code;
  code = code.9340 + 1;
  *code.9340 = 53;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55904 = lmf_offset.9232 + 56;
        D.55905 = (int) D.55904;
        imb.val = D.55905;
        code.9341 = code;
        code = code.9341 + 1;
        D.55907 = imb.b[0];
        *code.9341 = D.55907;
        code.9342 = code;
        code = code.9342 + 1;
        D.55909 = imb.b[1];
        *code.9342 = D.55909;
        code.9343 = code;
        code = code.9343 + 1;
        D.55911 = imb.b[2];
        *code.9343 = D.55911;
        code.9344 = code;
        code = code.9344 + 1;
        D.55913 = imb.b[3];
        *code.9344 = D.55913;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.55914>;
  <D.55902>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 == 4) goto <D.55915>; else goto <D.55916>;
  <D.55915>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551560) goto <D.55917>; else goto <D.55918>;
  <D.55917>:
  code.9345 = code;
  code = code.9345 + 1;
  *code.9345 = 52;
  code.9346 = code;
  code = code.9346 + 1;
  *code.9346 = 36;
  goto <D.55921>;
  <D.55918>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55904 = lmf_offset.9232 + 56;
  D.55905 = (int) D.55904;
  if (D.55905 >= -128) goto <D.55924>; else goto <D.55922>;
  <D.55924>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55904 = lmf_offset.9232 + 56;
  D.55905 = (int) D.55904;
  if (D.55905 <= 127) goto <D.55925>; else goto <D.55922>;
  <D.55925>:
  code.9347 = code;
  code = code.9347 + 1;
  *code.9347 = 116;
  code.9348 = code;
  code = code.9348 + 1;
  *code.9348 = 36;
  D.55624 = (unsigned char) lmf_offset;
  D.55928 = D.55624 + 56;
  *code = D.55928;
  code = code + 1;
  goto <D.55923>;
  <D.55922>:
  code.9349 = code;
  code = code.9349 + 1;
  *code.9349 = 180;
  code.9350 = code;
  code = code.9350 + 1;
  *code.9350 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55904 = lmf_offset.9232 + 56;
        D.55905 = (int) D.55904;
        imb.val = D.55905;
        code.9351 = code;
        code = code.9351 + 1;
        D.55932 = imb.b[0];
        *code.9351 = D.55932;
        code.9352 = code;
        code = code.9352 + 1;
        D.55934 = imb.b[1];
        *code.9352 = D.55934;
        code.9353 = code;
        code = code.9353 + 1;
        D.55936 = imb.b[2];
        *code.9353 = D.55936;
        code.9354 = code;
        code = code.9354 + 1;
        D.55938 = imb.b[3];
        *code.9354 = D.55938;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55923>:
  <D.55921>:
  goto <D.28461>;
  <D.55916>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551560) goto <D.55939>; else goto <D.55940>;
  <D.55939>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 != 5) goto <D.55941>; else goto <D.55942>;
  <D.55941>:
  code.9355 = code;
  code = code.9355 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55944 = D.55642 | 48;
  *code.9355 = D.55944;
  goto <D.28461>;
  <D.55942>:
  <D.55940>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55904 = lmf_offset.9232 + 56;
  D.55905 = (int) D.55904;
  if (D.55905 >= -128) goto <D.55947>; else goto <D.55945>;
  <D.55947>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55904 = lmf_offset.9232 + 56;
  D.55905 = (int) D.55904;
  if (D.55905 <= 127) goto <D.55948>; else goto <D.55945>;
  <D.55948>:
  code.9356 = code;
  code = code.9356 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55950 = D.55642 | 112;
  *code.9356 = D.55950;
  D.55624 = (unsigned char) lmf_offset;
  D.55928 = D.55624 + 56;
  *code = D.55928;
  code = code + 1;
  goto <D.55946>;
  <D.55945>:
  code.9357 = code;
  code = code.9357 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.55952 = D.55642 | 176;
  *code.9357 = D.55952;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55904 = lmf_offset.9232 + 56;
        D.55905 = (int) D.55904;
        imb.val = D.55905;
        code.9358 = code;
        code = code.9358 + 1;
        D.55954 = imb.b[0];
        *code.9358 = D.55954;
        code.9359 = code;
        code = code.9359 + 1;
        D.55956 = imb.b[1];
        *code.9359 = D.55956;
        code.9360 = code;
        code = code.9360 + 1;
        D.55958 = imb.b[2];
        *code.9360 = D.55958;
        code.9361 = code;
        code = code.9361 + 1;
        D.55960 = imb.b[3];
        *code.9361 = D.55960;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55946>:
  <D.28461>:
  <D.55914>:
  <D.55887>:
  D.55576 = cfg->used_int_regs;
  D.55961 = D.55576 & 32768;
  if (D.55961 != 0) goto <D.55962>; else goto <D.55963>;
  <D.55962>:
  if (0 != 0) goto <D.55964>; else goto <D.55965>;
  <D.55964>:
  code.9362 = code;
  code = code.9362 + 1;
  *code.9362 = 102;
  <D.55965>:
  {
    unsigned char _amd64_rex_bits;

    D.55584 = cfg->frame_reg;
    if (D.55584 > 7) goto <D.55968>; else goto <D.55969>;
    <D.55968>:
    iftmp.9363 = 13;
    goto <D.55970>;
    <D.55969>:
    iftmp.9363 = 12;
    <D.55970>:
    _amd64_rex_bits = iftmp.9363;
    if (_amd64_rex_bits != 0) goto <D.55971>; else goto <D.55972>;
    <D.55971>:
    code.9364 = code;
    code = code.9364 + 1;
    D.55974 = _amd64_rex_bits | 64;
    *code.9364 = D.55974;
    <D.55972>:
  }
  switch (8) <default: <D.28469>, case 1: <D.28464>, case 2: <D.28466>, case 4: <D.28467>, case 8: <D.28468>>
  <D.28464>:
  code.9365 = code;
  code = code.9365 + 1;
  *code.9365 = 138;
  goto <D.28465>;
  <D.28466>:
  <D.28467>:
  <D.28468>:
  code.9366 = code;
  code = code.9366 + 1;
  *code.9366 = 139;
  goto <D.28465>;
  <D.28469>:
  __assert_fail ("0", "mini-amd64.c", 7290, &__PRETTY_FUNCTION__);
  <D.28465>:
  D.55584 = cfg->frame_reg;
  if (D.55584 == 16) goto <D.55977>; else goto <D.55978>;
  <D.55977>:
  code.9367 = code;
  code = code.9367 + 1;
  *code.9367 = 61;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55980 = lmf_offset.9232 + 64;
        D.55981 = (int) D.55980;
        imb.val = D.55981;
        code.9368 = code;
        code = code.9368 + 1;
        D.55983 = imb.b[0];
        *code.9368 = D.55983;
        code.9369 = code;
        code = code.9369 + 1;
        D.55985 = imb.b[1];
        *code.9369 = D.55985;
        code.9370 = code;
        code = code.9370 + 1;
        D.55987 = imb.b[2];
        *code.9370 = D.55987;
        code.9371 = code;
        code = code.9371 + 1;
        D.55989 = imb.b[3];
        *code.9371 = D.55989;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.55990>;
  <D.55978>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 == 4) goto <D.55991>; else goto <D.55992>;
  <D.55991>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551552) goto <D.55993>; else goto <D.55994>;
  <D.55993>:
  code.9372 = code;
  code = code.9372 + 1;
  *code.9372 = 60;
  code.9373 = code;
  code = code.9373 + 1;
  *code.9373 = 36;
  goto <D.55997>;
  <D.55994>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55980 = lmf_offset.9232 + 64;
  D.55981 = (int) D.55980;
  if (D.55981 >= -128) goto <D.56000>; else goto <D.55998>;
  <D.56000>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55980 = lmf_offset.9232 + 64;
  D.55981 = (int) D.55980;
  if (D.55981 <= 127) goto <D.56001>; else goto <D.55998>;
  <D.56001>:
  code.9374 = code;
  code = code.9374 + 1;
  *code.9374 = 124;
  code.9375 = code;
  code = code.9375 + 1;
  *code.9375 = 36;
  D.55624 = (unsigned char) lmf_offset;
  D.56004 = D.55624 + 64;
  *code = D.56004;
  code = code + 1;
  goto <D.55999>;
  <D.55998>:
  code.9376 = code;
  code = code.9376 + 1;
  *code.9376 = 188;
  code.9377 = code;
  code = code.9377 + 1;
  *code.9377 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55980 = lmf_offset.9232 + 64;
        D.55981 = (int) D.55980;
        imb.val = D.55981;
        code.9378 = code;
        code = code.9378 + 1;
        D.56008 = imb.b[0];
        *code.9378 = D.56008;
        code.9379 = code;
        code = code.9379 + 1;
        D.56010 = imb.b[1];
        *code.9379 = D.56010;
        code.9380 = code;
        code = code.9380 + 1;
        D.56012 = imb.b[2];
        *code.9380 = D.56012;
        code.9381 = code;
        code = code.9381 + 1;
        D.56014 = imb.b[3];
        *code.9381 = D.56014;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.55999>:
  <D.55997>:
  goto <D.28472>;
  <D.55992>:
  D.55612 = (long unsigned int) lmf_offset;
  if (D.55612 == 18446744073709551552) goto <D.56015>; else goto <D.56016>;
  <D.56015>:
  D.55584 = cfg->frame_reg;
  D.55609 = D.55584 & 7;
  if (D.55609 != 5) goto <D.56017>; else goto <D.56018>;
  <D.56017>:
  code.9382 = code;
  code = code.9382 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.56020 = D.55642 | 56;
  *code.9382 = D.56020;
  goto <D.28472>;
  <D.56018>:
  <D.56016>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55980 = lmf_offset.9232 + 64;
  D.55981 = (int) D.55980;
  if (D.55981 >= -128) goto <D.56023>; else goto <D.56021>;
  <D.56023>:
  lmf_offset.9232 = (unsigned int) lmf_offset;
  D.55980 = lmf_offset.9232 + 64;
  D.55981 = (int) D.55980;
  if (D.55981 <= 127) goto <D.56024>; else goto <D.56021>;
  <D.56024>:
  code.9383 = code;
  code = code.9383 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.56026 = D.55642 | 120;
  *code.9383 = D.56026;
  D.55624 = (unsigned char) lmf_offset;
  D.56004 = D.55624 + 64;
  *code = D.56004;
  code = code + 1;
  goto <D.56022>;
  <D.56021>:
  code.9384 = code;
  code = code.9384 + 1;
  D.55584 = cfg->frame_reg;
  D.55641 = (unsigned char) D.55584;
  D.55642 = D.55641 & 7;
  D.56028 = D.55642 | 184;
  *code.9384 = D.56028;
  {
    union x86_imm_buf imb;

    try
      {
        lmf_offset.9232 = (unsigned int) lmf_offset;
        D.55980 = lmf_offset.9232 + 64;
        D.55981 = (int) D.55980;
        imb.val = D.55981;
        code.9385 = code;
        code = code.9385 + 1;
        D.56030 = imb.b[0];
        *code.9385 = D.56030;
        code.9386 = code;
        code = code.9386 + 1;
        D.56032 = imb.b[1];
        *code.9386 = D.56032;
        code.9387 = code;
        code = code.9387 + 1;
        D.56034 = imb.b[2];
        *code.9387 = D.56034;
        code.9388 = code;
        code = code.9388 + 1;
        D.56036 = imb.b[3];
        *code.9388 = D.56036;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56022>:
  <D.28472>:
  <D.55990>:
  <D.55963>:
  goto <D.56037>;
  <D.55448>:
  {
    gint32 save_area_offset;

    save_area_offset = cfg->arch.reg_save_area_offset;
    i = 0;
    goto <D.28487>;
    <D.28486>:
    D.56038 = 61480 >> i;
    D.56039 = D.56038 & 1;
    if (D.56039 != 0) goto <D.56040>; else goto <D.56041>;
    <D.56040>:
    D.55576 = cfg->used_int_regs;
    D.56042 = 1 << i;
    D.56043 = (long unsigned int) D.56042;
    D.56044 = D.55576 & D.56043;
    if (D.56044 != 0) goto <D.56045>; else goto <D.56046>;
    <D.56045>:
    if (0 != 0) goto <D.56047>; else goto <D.56048>;
    <D.56047>:
    code.9389 = code;
    code = code.9389 + 1;
    *code.9389 = 102;
    <D.56048>:
    {
      unsigned char _amd64_rex_bits;

      if (i > 7) goto <D.56051>; else goto <D.56052>;
      <D.56051>:
      iftmp.9390 = 12;
      goto <D.56053>;
      <D.56052>:
      iftmp.9390 = 8;
      <D.56053>:
      D.55584 = cfg->frame_reg;
      D.56054 = D.55584 > 7;
      D.56055 = (signed char) D.56054;
      D.56056 = iftmp.9390 | D.56055;
      _amd64_rex_bits = (unsigned char) D.56056;
      if (_amd64_rex_bits != 0) goto <D.56057>; else goto <D.56058>;
      <D.56057>:
      code.9391 = code;
      code = code.9391 + 1;
      D.56060 = _amd64_rex_bits | 64;
      *code.9391 = D.56060;
      <D.56058>:
    }
    switch (8) <default: <D.28481>, case 1: <D.28476>, case 2: <D.28478>, case 4: <D.28479>, case 8: <D.28480>>
    <D.28476>:
    code.9392 = code;
    code = code.9392 + 1;
    *code.9392 = 138;
    goto <D.28477>;
    <D.28478>:
    <D.28479>:
    <D.28480>:
    code.9393 = code;
    code = code.9393 + 1;
    *code.9393 = 139;
    goto <D.28477>;
    <D.28481>:
    __assert_fail ("0", "mini-amd64.c", 7308, &__PRETTY_FUNCTION__);
    <D.28477>:
    D.55584 = cfg->frame_reg;
    if (D.55584 == 16) goto <D.56063>; else goto <D.56064>;
    <D.56063>:
    code.9394 = code;
    code = code.9394 + 1;
    D.56066 = i & 7;
    D.56067 = D.56066 << 3;
    D.56068 = (signed char) D.56067;
    D.56069 = D.56068 | 5;
    D.56070 = (unsigned char) D.56069;
    *code.9394 = D.56070;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.9395 = code;
          code = code.9395 + 1;
          D.56072 = imb.b[0];
          *code.9395 = D.56072;
          code.9396 = code;
          code = code.9396 + 1;
          D.56074 = imb.b[1];
          *code.9396 = D.56074;
          code.9397 = code;
          code = code.9397 + 1;
          D.56076 = imb.b[2];
          *code.9397 = D.56076;
          code.9398 = code;
          code = code.9398 + 1;
          D.56078 = imb.b[3];
          *code.9398 = D.56078;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.56079>;
    <D.56064>:
    D.55584 = cfg->frame_reg;
    D.55609 = D.55584 & 7;
    if (D.55609 == 4) goto <D.56080>; else goto <D.56081>;
    <D.56080>:
    if (save_area_offset == 0) goto <D.56082>; else goto <D.56083>;
    <D.56082>:
    code.9399 = code;
    code = code.9399 + 1;
    D.56066 = i & 7;
    D.56067 = D.56066 << 3;
    D.56068 = (signed char) D.56067;
    D.56085 = D.56068 | 4;
    D.56086 = (unsigned char) D.56085;
    *code.9399 = D.56086;
    code.9400 = code;
    code = code.9400 + 1;
    *code.9400 = 36;
    goto <D.56088>;
    <D.56083>:
    save_area_offset.9401 = (unsigned int) save_area_offset;
    D.56090 = save_area_offset.9401 + 128;
    if (D.56090 <= 255) goto <D.56091>; else goto <D.56092>;
    <D.56091>:
    code.9402 = code;
    code = code.9402 + 1;
    D.56066 = i & 7;
    D.56067 = D.56066 << 3;
    D.56068 = (signed char) D.56067;
    D.56094 = D.56068 | 68;
    D.56095 = (unsigned char) D.56094;
    *code.9402 = D.56095;
    code.9403 = code;
    code = code.9403 + 1;
    *code.9403 = 36;
    D.56097 = (unsigned char) save_area_offset;
    *code = D.56097;
    code = code + 1;
    goto <D.56098>;
    <D.56092>:
    code.9404 = code;
    code = code.9404 + 1;
    D.56066 = i & 7;
    D.56067 = D.56066 << 3;
    D.56068 = (signed char) D.56067;
    D.56100 = D.56068 | -124;
    D.56101 = (unsigned char) D.56100;
    *code.9404 = D.56101;
    code.9405 = code;
    code = code.9405 + 1;
    *code.9405 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.9406 = code;
          code = code.9406 + 1;
          D.56104 = imb.b[0];
          *code.9406 = D.56104;
          code.9407 = code;
          code = code.9407 + 1;
          D.56106 = imb.b[1];
          *code.9407 = D.56106;
          code.9408 = code;
          code = code.9408 + 1;
          D.56108 = imb.b[2];
          *code.9408 = D.56108;
          code.9409 = code;
          code = code.9409 + 1;
          D.56110 = imb.b[3];
          *code.9409 = D.56110;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56098>:
    <D.56088>:
    goto <D.28484>;
    <D.56081>:
    if (save_area_offset == 0) goto <D.56111>; else goto <D.56112>;
    <D.56111>:
    D.55584 = cfg->frame_reg;
    D.55609 = D.55584 & 7;
    if (D.55609 != 5) goto <D.56113>; else goto <D.56114>;
    <D.56113>:
    code.9410 = code;
    code = code.9410 + 1;
    D.56116 = (unsigned char) i;
    D.56117 = D.56116 & 7;
    D.56118 = D.56117 << 3;
    D.55584 = cfg->frame_reg;
    D.55641 = (unsigned char) D.55584;
    D.55642 = D.55641 & 7;
    D.56119 = D.56118 | D.55642;
    *code.9410 = D.56119;
    goto <D.28484>;
    <D.56114>:
    <D.56112>:
    save_area_offset.9401 = (unsigned int) save_area_offset;
    D.56090 = save_area_offset.9401 + 128;
    if (D.56090 <= 255) goto <D.56120>; else goto <D.56121>;
    <D.56120>:
    code.9411 = code;
    code = code.9411 + 1;
    D.56116 = (unsigned char) i;
    D.56117 = D.56116 & 7;
    D.56118 = D.56117 << 3;
    D.55584 = cfg->frame_reg;
    D.55641 = (unsigned char) D.55584;
    D.55642 = D.55641 & 7;
    D.56119 = D.56118 | D.55642;
    D.56123 = D.56119 | 64;
    *code.9411 = D.56123;
    D.56097 = (unsigned char) save_area_offset;
    *code = D.56097;
    code = code + 1;
    goto <D.56124>;
    <D.56121>:
    code.9412 = code;
    code = code.9412 + 1;
    D.56116 = (unsigned char) i;
    D.56117 = D.56116 & 7;
    D.56118 = D.56117 << 3;
    D.55584 = cfg->frame_reg;
    D.55641 = (unsigned char) D.55584;
    D.55642 = D.55641 & 7;
    D.56119 = D.56118 | D.55642;
    D.56126 = D.56119 | 128;
    *code.9412 = D.56126;
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = save_area_offset;
          code.9413 = code;
          code = code.9413 + 1;
          D.56128 = imb.b[0];
          *code.9413 = D.56128;
          code.9414 = code;
          code = code.9414 + 1;
          D.56130 = imb.b[1];
          *code.9414 = D.56130;
          code.9415 = code;
          code = code.9415 + 1;
          D.56132 = imb.b[2];
          *code.9415 = D.56132;
          code.9416 = code;
          code = code.9416 + 1;
          D.56134 = imb.b[3];
          *code.9416 = D.56134;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56124>:
    <D.28484>:
    <D.56079>:
    save_area_offset = save_area_offset + 8;
    <D.56046>:
    <D.56041>:
    i = i + 1;
    <D.28487>:
    if (i <= 16) goto <D.28486>; else goto <D.28488>;
    <D.28488>:
  }
  <D.56037>:
  cinfo = cfg->arch.cinfo;
  D.56135 = cinfo->ret.storage;
  if (D.56135 == 4) goto <D.56136>; else goto <D.56137>;
  <D.56136>:
  {
    struct ArgInfo * ainfo;
    struct MonoInst * inst;

    ainfo = &cinfo->ret;
    inst = cfg->ret;
    quad = 0;
    goto <D.28517>;
    <D.28516>:
    D.56138 = ainfo->pair_storage[quad];
    switch (D.56138) <default: <D.28515>, case 0: <D.28491>, case 1: <D.28504>, case 2: <D.28509>, case 6: <D.28514>>
    <D.28491>:
    if (0 != 0) goto <D.56139>; else goto <D.56140>;
    <D.56139>:
    code.9417 = code;
    code = code.9417 + 1;
    *code.9417 = 102;
    <D.56140>:
    {
      unsigned char _amd64_rex_bits;

      D.56143 = ainfo->pair_regs[quad];
      if (D.56143 > 7) goto <D.56144>; else goto <D.56145>;
      <D.56144>:
      iftmp.9418 = 12;
      goto <D.56146>;
      <D.56145>:
      iftmp.9418 = 8;
      <D.56146>:
      D.56147 = inst->sreg1;
      D.56148 = D.56147 > 7;
      D.56149 = (signed char) D.56148;
      D.56150 = iftmp.9418 | D.56149;
      _amd64_rex_bits = (unsigned char) D.56150;
      if (_amd64_rex_bits != 0) goto <D.56151>; else goto <D.56152>;
      <D.56151>:
      code.9419 = code;
      code = code.9419 + 1;
      D.56154 = _amd64_rex_bits | 64;
      *code.9419 = D.56154;
      <D.56152>:
    }
    switch (8) <default: <D.28498>, case 1: <D.28493>, case 2: <D.28495>, case 4: <D.28496>, case 8: <D.28497>>
    <D.28493>:
    code.9420 = code;
    code = code.9420 + 1;
    *code.9420 = 138;
    goto <D.28494>;
    <D.28495>:
    <D.28496>:
    <D.28497>:
    code.9421 = code;
    code = code.9421 + 1;
    *code.9421 = 139;
    goto <D.28494>;
    <D.28498>:
    __assert_fail ("0", "mini-amd64.c", 7322, &__PRETTY_FUNCTION__);
    <D.28494>:
    D.56147 = inst->sreg1;
    if (D.56147 == 16) goto <D.56157>; else goto <D.56158>;
    <D.56157>:
    code.9422 = code;
    code = code.9422 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56164 = D.56163 | 5;
    D.56165 = (unsigned char) D.56164;
    *code.9422 = D.56165;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9423 = code;
          code = code.9423 + 1;
          D.56174 = imb.b[0];
          *code.9423 = D.56174;
          code.9424 = code;
          code = code.9424 + 1;
          D.56176 = imb.b[1];
          *code.9424 = D.56176;
          code.9425 = code;
          code = code.9425 + 1;
          D.56178 = imb.b[2];
          *code.9425 = D.56178;
          code.9426 = code;
          code = code.9426 + 1;
          D.56180 = imb.b[3];
          *code.9426 = D.56180;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.56181>;
    <D.56158>:
    D.56147 = inst->sreg1;
    D.56182 = D.56147 & 7;
    if (D.56182 == 4) goto <D.56183>; else goto <D.56184>;
    <D.56183>:
    D.56166 = inst->data.op[0].const_val;
    D.56185 = (long unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56186 = D.56168 * 8;
    D.56187 = D.56185 + D.56186;
    if (D.56187 == 0) goto <D.56188>; else goto <D.56189>;
    <D.56188>:
    code.9427 = code;
    code = code.9427 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56191 = D.56163 | 4;
    D.56192 = (unsigned char) D.56191;
    *code.9427 = D.56192;
    code.9428 = code;
    code = code.9428 + 1;
    *code.9428 = 36;
    goto <D.56194>;
    <D.56189>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 >= -128) goto <D.56197>; else goto <D.56195>;
    <D.56197>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 <= 127) goto <D.56198>; else goto <D.56195>;
    <D.56198>:
    code.9429 = code;
    code = code.9429 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56200 = D.56163 | 68;
    D.56201 = (unsigned char) D.56200;
    *code.9429 = D.56201;
    code.9430 = code;
    code = code.9430 + 1;
    *code.9430 = 36;
    D.56166 = inst->data.op[0].const_val;
    D.56203 = (unsigned char) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56204 = (unsigned char) D.56168;
    D.56205 = D.56204 * 8;
    D.56206 = D.56203 + D.56205;
    *code = D.56206;
    code = code + 1;
    goto <D.56196>;
    <D.56195>:
    code.9431 = code;
    code = code.9431 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56208 = D.56163 | -124;
    D.56209 = (unsigned char) D.56208;
    *code.9431 = D.56209;
    code.9432 = code;
    code = code.9432 + 1;
    *code.9432 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9433 = code;
          code = code.9433 + 1;
          D.56212 = imb.b[0];
          *code.9433 = D.56212;
          code.9434 = code;
          code = code.9434 + 1;
          D.56214 = imb.b[1];
          *code.9434 = D.56214;
          code.9435 = code;
          code = code.9435 + 1;
          D.56216 = imb.b[2];
          *code.9435 = D.56216;
          code.9436 = code;
          code = code.9436 + 1;
          D.56218 = imb.b[3];
          *code.9436 = D.56218;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56196>:
    <D.56194>:
    goto <D.28501>;
    <D.56184>:
    D.56166 = inst->data.op[0].const_val;
    D.56185 = (long unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56186 = D.56168 * 8;
    D.56187 = D.56185 + D.56186;
    if (D.56187 == 0) goto <D.56219>; else goto <D.56220>;
    <D.56219>:
    D.56147 = inst->sreg1;
    D.56182 = D.56147 & 7;
    if (D.56182 != 5) goto <D.56221>; else goto <D.56222>;
    <D.56221>:
    code.9437 = code;
    code = code.9437 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56226 = D.56163 | D.56225;
    D.56227 = (unsigned char) D.56226;
    *code.9437 = D.56227;
    goto <D.28501>;
    <D.56222>:
    <D.56220>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 >= -128) goto <D.56230>; else goto <D.56228>;
    <D.56230>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 <= 127) goto <D.56231>; else goto <D.56228>;
    <D.56231>:
    code.9438 = code;
    code = code.9438 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56233 = D.56163 | 64;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56234 = D.56233 | D.56225;
    D.56235 = (unsigned char) D.56234;
    *code.9438 = D.56235;
    D.56166 = inst->data.op[0].const_val;
    D.56203 = (unsigned char) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56204 = (unsigned char) D.56168;
    D.56205 = D.56204 * 8;
    D.56206 = D.56203 + D.56205;
    *code = D.56206;
    code = code + 1;
    goto <D.56229>;
    <D.56228>:
    code.9439 = code;
    code = code.9439 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56237 = D.56163 | -128;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56238 = D.56237 | D.56225;
    D.56239 = (unsigned char) D.56238;
    *code.9439 = D.56239;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9440 = code;
          code = code.9440 + 1;
          D.56241 = imb.b[0];
          *code.9440 = D.56241;
          code.9441 = code;
          code = code.9441 + 1;
          D.56243 = imb.b[1];
          *code.9441 = D.56243;
          code.9442 = code;
          code = code.9442 + 1;
          D.56245 = imb.b[2];
          *code.9442 = D.56245;
          code.9443 = code;
          code = code.9443 + 1;
          D.56247 = imb.b[3];
          *code.9443 = D.56247;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56229>:
    <D.28501>:
    <D.56181>:
    goto <D.28503>;
    <D.28504>:
    code.9444 = code;
    code = code.9444 + 1;
    *code.9444 = 243;
    {
      unsigned char _amd64_rex_bits;

      D.56143 = ainfo->pair_regs[quad];
      if (D.56143 > 7) goto <D.56250>; else goto <D.56251>;
      <D.56250>:
      iftmp.9445 = 4;
      goto <D.56252>;
      <D.56251>:
      iftmp.9445 = 0;
      <D.56252>:
      D.56147 = inst->sreg1;
      D.56148 = D.56147 > 7;
      D.56149 = (signed char) D.56148;
      D.56253 = iftmp.9445 | D.56149;
      _amd64_rex_bits = (unsigned char) D.56253;
      if (_amd64_rex_bits != 0) goto <D.56254>; else goto <D.56255>;
      <D.56254>:
      code.9446 = code;
      code = code.9446 + 1;
      D.56257 = _amd64_rex_bits | 64;
      *code.9446 = D.56257;
      <D.56255>:
    }
    code.9447 = code;
    code = code.9447 + 1;
    *code.9447 = 15;
    code.9448 = code;
    code = code.9448 + 1;
    *code.9448 = 16;
    D.56147 = inst->sreg1;
    D.56182 = D.56147 & 7;
    if (D.56182 == 4) goto <D.56260>; else goto <D.56261>;
    <D.56260>:
    D.56166 = inst->data.op[0].const_val;
    D.56185 = (long unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56186 = D.56168 * 8;
    D.56187 = D.56185 + D.56186;
    if (D.56187 == 0) goto <D.56262>; else goto <D.56263>;
    <D.56262>:
    code.9449 = code;
    code = code.9449 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56191 = D.56163 | 4;
    D.56192 = (unsigned char) D.56191;
    *code.9449 = D.56192;
    code.9450 = code;
    code = code.9450 + 1;
    *code.9450 = 36;
    goto <D.56266>;
    <D.56263>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 >= -128) goto <D.56269>; else goto <D.56267>;
    <D.56269>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 <= 127) goto <D.56270>; else goto <D.56267>;
    <D.56270>:
    code.9451 = code;
    code = code.9451 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56200 = D.56163 | 68;
    D.56201 = (unsigned char) D.56200;
    *code.9451 = D.56201;
    code.9452 = code;
    code = code.9452 + 1;
    *code.9452 = 36;
    D.56166 = inst->data.op[0].const_val;
    D.56203 = (unsigned char) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56204 = (unsigned char) D.56168;
    D.56205 = D.56204 * 8;
    D.56206 = D.56203 + D.56205;
    *code = D.56206;
    code = code + 1;
    goto <D.56268>;
    <D.56267>:
    code.9453 = code;
    code = code.9453 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56208 = D.56163 | -124;
    D.56209 = (unsigned char) D.56208;
    *code.9453 = D.56209;
    code.9454 = code;
    code = code.9454 + 1;
    *code.9454 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9455 = code;
          code = code.9455 + 1;
          D.56276 = imb.b[0];
          *code.9455 = D.56276;
          code.9456 = code;
          code = code.9456 + 1;
          D.56278 = imb.b[1];
          *code.9456 = D.56278;
          code.9457 = code;
          code = code.9457 + 1;
          D.56280 = imb.b[2];
          *code.9457 = D.56280;
          code.9458 = code;
          code = code.9458 + 1;
          D.56282 = imb.b[3];
          *code.9458 = D.56282;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56268>:
    <D.56266>:
    goto <D.28507>;
    <D.56261>:
    D.56166 = inst->data.op[0].const_val;
    D.56185 = (long unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56186 = D.56168 * 8;
    D.56187 = D.56185 + D.56186;
    if (D.56187 == 0) goto <D.56283>; else goto <D.56284>;
    <D.56283>:
    D.56147 = inst->sreg1;
    D.56182 = D.56147 & 7;
    if (D.56182 != 5) goto <D.56285>; else goto <D.56286>;
    <D.56285>:
    code.9459 = code;
    code = code.9459 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56226 = D.56163 | D.56225;
    D.56227 = (unsigned char) D.56226;
    *code.9459 = D.56227;
    goto <D.28507>;
    <D.56286>:
    <D.56284>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 >= -128) goto <D.56290>; else goto <D.56288>;
    <D.56290>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 <= 127) goto <D.56291>; else goto <D.56288>;
    <D.56291>:
    code.9460 = code;
    code = code.9460 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56233 = D.56163 | 64;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56234 = D.56233 | D.56225;
    D.56235 = (unsigned char) D.56234;
    *code.9460 = D.56235;
    D.56166 = inst->data.op[0].const_val;
    D.56203 = (unsigned char) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56204 = (unsigned char) D.56168;
    D.56205 = D.56204 * 8;
    D.56206 = D.56203 + D.56205;
    *code = D.56206;
    code = code + 1;
    goto <D.56289>;
    <D.56288>:
    code.9461 = code;
    code = code.9461 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56237 = D.56163 | -128;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56238 = D.56237 | D.56225;
    D.56239 = (unsigned char) D.56238;
    *code.9461 = D.56239;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9462 = code;
          code = code.9462 + 1;
          D.56295 = imb.b[0];
          *code.9462 = D.56295;
          code.9463 = code;
          code = code.9463 + 1;
          D.56297 = imb.b[1];
          *code.9463 = D.56297;
          code.9464 = code;
          code = code.9464 + 1;
          D.56299 = imb.b[2];
          *code.9464 = D.56299;
          code.9465 = code;
          code = code.9465 + 1;
          D.56301 = imb.b[3];
          *code.9465 = D.56301;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56289>:
    <D.28507>:
    goto <D.28503>;
    <D.28509>:
    code.9466 = code;
    code = code.9466 + 1;
    *code.9466 = 242;
    {
      unsigned char _amd64_rex_bits;

      D.56143 = ainfo->pair_regs[quad];
      if (D.56143 > 7) goto <D.56304>; else goto <D.56305>;
      <D.56304>:
      iftmp.9467 = 4;
      goto <D.56306>;
      <D.56305>:
      iftmp.9467 = 0;
      <D.56306>:
      D.56147 = inst->sreg1;
      D.56148 = D.56147 > 7;
      D.56149 = (signed char) D.56148;
      D.56307 = iftmp.9467 | D.56149;
      _amd64_rex_bits = (unsigned char) D.56307;
      if (_amd64_rex_bits != 0) goto <D.56308>; else goto <D.56309>;
      <D.56308>:
      code.9468 = code;
      code = code.9468 + 1;
      D.56311 = _amd64_rex_bits | 64;
      *code.9468 = D.56311;
      <D.56309>:
    }
    code.9469 = code;
    code = code.9469 + 1;
    *code.9469 = 15;
    code.9470 = code;
    code = code.9470 + 1;
    *code.9470 = 16;
    D.56147 = inst->sreg1;
    D.56182 = D.56147 & 7;
    if (D.56182 == 4) goto <D.56314>; else goto <D.56315>;
    <D.56314>:
    D.56166 = inst->data.op[0].const_val;
    D.56185 = (long unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56186 = D.56168 * 8;
    D.56187 = D.56185 + D.56186;
    if (D.56187 == 0) goto <D.56316>; else goto <D.56317>;
    <D.56316>:
    code.9471 = code;
    code = code.9471 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56191 = D.56163 | 4;
    D.56192 = (unsigned char) D.56191;
    *code.9471 = D.56192;
    code.9472 = code;
    code = code.9472 + 1;
    *code.9472 = 36;
    goto <D.56320>;
    <D.56317>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 >= -128) goto <D.56323>; else goto <D.56321>;
    <D.56323>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 <= 127) goto <D.56324>; else goto <D.56321>;
    <D.56324>:
    code.9473 = code;
    code = code.9473 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56200 = D.56163 | 68;
    D.56201 = (unsigned char) D.56200;
    *code.9473 = D.56201;
    code.9474 = code;
    code = code.9474 + 1;
    *code.9474 = 36;
    D.56166 = inst->data.op[0].const_val;
    D.56203 = (unsigned char) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56204 = (unsigned char) D.56168;
    D.56205 = D.56204 * 8;
    D.56206 = D.56203 + D.56205;
    *code = D.56206;
    code = code + 1;
    goto <D.56322>;
    <D.56321>:
    code.9475 = code;
    code = code.9475 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56208 = D.56163 | -124;
    D.56209 = (unsigned char) D.56208;
    *code.9475 = D.56209;
    code.9476 = code;
    code = code.9476 + 1;
    *code.9476 = 36;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9477 = code;
          code = code.9477 + 1;
          D.56330 = imb.b[0];
          *code.9477 = D.56330;
          code.9478 = code;
          code = code.9478 + 1;
          D.56332 = imb.b[1];
          *code.9478 = D.56332;
          code.9479 = code;
          code = code.9479 + 1;
          D.56334 = imb.b[2];
          *code.9479 = D.56334;
          code.9480 = code;
          code = code.9480 + 1;
          D.56336 = imb.b[3];
          *code.9480 = D.56336;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56322>:
    <D.56320>:
    goto <D.28512>;
    <D.56315>:
    D.56166 = inst->data.op[0].const_val;
    D.56185 = (long unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56186 = D.56168 * 8;
    D.56187 = D.56185 + D.56186;
    if (D.56187 == 0) goto <D.56337>; else goto <D.56338>;
    <D.56337>:
    D.56147 = inst->sreg1;
    D.56182 = D.56147 & 7;
    if (D.56182 != 5) goto <D.56339>; else goto <D.56340>;
    <D.56339>:
    code.9481 = code;
    code = code.9481 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56226 = D.56163 | D.56225;
    D.56227 = (unsigned char) D.56226;
    *code.9481 = D.56227;
    goto <D.28512>;
    <D.56340>:
    <D.56338>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 >= -128) goto <D.56344>; else goto <D.56342>;
    <D.56344>:
    D.56166 = inst->data.op[0].const_val;
    D.56167 = (unsigned int) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56169 = (unsigned int) D.56168;
    D.56170 = D.56169 * 8;
    D.56171 = D.56167 + D.56170;
    D.56172 = (int) D.56171;
    if (D.56172 <= 127) goto <D.56345>; else goto <D.56342>;
    <D.56345>:
    code.9482 = code;
    code = code.9482 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56233 = D.56163 | 64;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56234 = D.56233 | D.56225;
    D.56235 = (unsigned char) D.56234;
    *code.9482 = D.56235;
    D.56166 = inst->data.op[0].const_val;
    D.56203 = (unsigned char) D.56166;
    D.56168 = (long unsigned int) quad;
    D.56204 = (unsigned char) D.56168;
    D.56205 = D.56204 * 8;
    D.56206 = D.56203 + D.56205;
    *code = D.56206;
    code = code + 1;
    goto <D.56343>;
    <D.56342>:
    code.9483 = code;
    code = code.9483 + 1;
    D.56143 = ainfo->pair_regs[quad];
    D.56160 = (int) D.56143;
    D.56161 = D.56160 & 7;
    D.56162 = D.56161 << 3;
    D.56163 = (signed char) D.56162;
    D.56237 = D.56163 | -128;
    D.56147 = inst->sreg1;
    D.56224 = (signed char) D.56147;
    D.56225 = D.56224 & 7;
    D.56238 = D.56237 | D.56225;
    D.56239 = (unsigned char) D.56238;
    *code.9483 = D.56239;
    {
      union x86_imm_buf imb;

      try
        {
          D.56166 = inst->data.op[0].const_val;
          D.56167 = (unsigned int) D.56166;
          D.56168 = (long unsigned int) quad;
          D.56169 = (unsigned int) D.56168;
          D.56170 = D.56169 * 8;
          D.56171 = D.56167 + D.56170;
          D.56172 = (int) D.56171;
          imb.val = D.56172;
          code.9484 = code;
          code = code.9484 + 1;
          D.56349 = imb.b[0];
          *code.9484 = D.56349;
          code.9485 = code;
          code = code.9485 + 1;
          D.56351 = imb.b[1];
          *code.9485 = D.56351;
          code.9486 = code;
          code = code.9486 + 1;
          D.56353 = imb.b[2];
          *code.9486 = D.56353;
          code.9487 = code;
          code = code.9487 + 1;
          D.56355 = imb.b[3];
          *code.9487 = D.56355;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.56343>:
    <D.28512>:
    goto <D.28503>;
    <D.28514>:
    goto <D.28503>;
    <D.28515>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7333);
    <D.28503>:
    quad = quad + 1;
    <D.28517>:
    if (quad <= 1) goto <D.28516>; else goto <D.28518>;
    <D.28518>:
  }
  <D.56137>:
  D.56356 = cfg->arch.omit_fp;
  if (D.56356 != 0) goto <D.56357>; else goto <D.56358>;
  <D.56357>:
  D.56359 = cfg->arch.stack_alloc_size;
  if (D.56359 != 0) goto <D.56360>; else goto <D.56361>;
  <D.56360>:
  D.56359 = cfg->arch.stack_alloc_size;
  D.56362 = (unsigned int) D.56359;
  D.56363 = D.56362 + 128;
  if (D.56363 <= 255) goto <D.56364>; else goto <D.56365>;
  <D.56364>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.56366>; else goto <D.56367>;
    <D.56366>:
    code.9488 = code;
    code = code.9488 + 1;
    D.56369 = _amd64_rex_bits | 64;
    *code.9488 = D.56369;
    <D.56367>:
  }
  code.9489 = code;
  code = code.9489 + 1;
  *code.9489 = 131;
  code.9490 = code;
  code = code.9490 + 1;
  *code.9490 = 196;
  D.56359 = cfg->arch.stack_alloc_size;
  D.56372 = (unsigned char) D.56359;
  *code = D.56372;
  code = code + 1;
  goto <D.56373>;
  <D.56365>:
  if (0 != 0) goto <D.56374>; else goto <D.56375>;
  <D.56374>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.56376>; else goto <D.56377>;
    <D.56376>:
    code.9491 = code;
    code = code.9491 + 1;
    D.56379 = _amd64_rex_bits | 64;
    *code.9491 = D.56379;
    <D.56377>:
  }
  code.9492 = code;
  code = code.9492 + 1;
  *code.9492 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        D.56359 = cfg->arch.stack_alloc_size;
        imb.val = D.56359;
        code.9493 = code;
        code = code.9493 + 1;
        D.56382 = imb.b[0];
        *code.9493 = D.56382;
        code.9494 = code;
        code = code.9494 + 1;
        D.56384 = imb.b[1];
        *code.9494 = D.56384;
        code.9495 = code;
        code = code.9495 + 1;
        D.56386 = imb.b[2];
        *code.9495 = D.56386;
        code.9496 = code;
        code = code.9496 + 1;
        D.56388 = imb.b[3];
        *code.9496 = D.56388;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.56389>;
  <D.56375>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.56390>; else goto <D.56391>;
    <D.56390>:
    code.9497 = code;
    code = code.9497 + 1;
    D.56393 = _amd64_rex_bits | 64;
    *code.9497 = D.56393;
    <D.56391>:
  }
  code.9498 = code;
  code = code.9498 + 1;
  *code.9498 = 129;
  code.9499 = code;
  code = code.9499 + 1;
  *code.9499 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        D.56359 = cfg->arch.stack_alloc_size;
        imb.val = D.56359;
        code.9500 = code;
        code = code.9500 + 1;
        D.56397 = imb.b[0];
        *code.9500 = D.56397;
        code.9501 = code;
        code = code.9501 + 1;
        D.56399 = imb.b[1];
        *code.9501 = D.56399;
        code.9502 = code;
        code = code.9502 + 1;
        D.56401 = imb.b[2];
        *code.9502 = D.56401;
        code.9503 = code;
        code = code.9503 + 1;
        D.56403 = imb.b[3];
        *code.9503 = D.56403;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56389>:
  <D.56373>:
  <D.56361>:
  goto <D.56404>;
  <D.56358>:
  code.9504 = code;
  code = code.9504 + 1;
  *code.9504 = 201;
  <D.56404>:
  mono_inject_async_exc_method.9505 = mono_inject_async_exc_method;
  if (mono_inject_async_exc_method.9505 != 0B) goto <D.56407>; else goto <D.56408>;
  <D.56407>:
  D.56409 = cfg->method;
  mono_inject_async_exc_method.9505 = mono_inject_async_exc_method;
  D.56410 = mono_method_desc_full_match (mono_inject_async_exc_method.9505, D.56409);
  if (D.56410 != 0) goto <D.56411>; else goto <D.56412>;
  <D.56411>:
  D.56413 = cfg->arch.async_point_count;
  mono_inject_async_exc_pos.9506 = mono_inject_async_exc_pos;
  if (D.56413 == mono_inject_async_exc_pos.9506) goto <D.56415>; else goto <D.56416>;
  <D.56415>:
  if (0 != 0) goto <D.56417>; else goto <D.56418>;
  <D.56417>:
  code.9507 = code;
  code = code.9507 + 1;
  *code.9507 = 102;
  <D.56418>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.56420>; else goto <D.56421>;
    <D.56420>:
    code.9508 = code;
    code = code.9508 + 1;
    D.56423 = _amd64_rex_bits | 64;
    *code.9508 = D.56423;
    <D.56421>:
  }
  switch (4) <default: <D.28530>, case 1: <D.28525>, case 2: <D.28527>, case 4: <D.28528>, case 8: <D.28529>>
  <D.28525>:
  code.9509 = code;
  code = code.9509 + 1;
  *code.9509 = 138;
  goto <D.28526>;
  <D.28527>:
  <D.28528>:
  <D.28529>:
  code.9510 = code;
  code = code.9510 + 1;
  *code.9510 = 139;
  goto <D.28526>;
  <D.28530>:
  __assert_fail ("0", "mini-amd64.c", 7344, &__PRETTY_FUNCTION__);
  <D.28526>:
  code.9511 = code;
  code = code.9511 + 1;
  *code.9511 = 4;
  code.9512 = code;
  code = code.9512 + 1;
  *code.9512 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9513 = code;
        code = code.9513 + 1;
        D.56429 = imb.b[0];
        *code.9513 = D.56429;
        code.9514 = code;
        code = code.9514 + 1;
        D.56431 = imb.b[1];
        *code.9514 = D.56431;
        code.9515 = code;
        code = code.9515 + 1;
        D.56433 = imb.b[2];
        *code.9515 = D.56433;
        code.9516 = code;
        code = code.9516 + 1;
        D.56435 = imb.b[3];
        *code.9516 = D.56435;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56416>:
  D.56413 = cfg->arch.async_point_count;
  D.56436 = D.56413 + 1;
  cfg->arch.async_point_count = D.56436;
  <D.56412>:
  <D.56408>:
  code.9517 = code;
  code = code.9517 + 1;
  *code.9517 = 195;
  code.9219 = (long int) code;
  D.55437 = cfg->native_code;
  D.56438 = (long int) D.55437;
  D.56439 = code.9219 - D.56438;
  D.56440 = (unsigned int) D.56439;
  cfg->code_len = D.56440;
  D.55433 = cfg->code_len;
  D.55428 = cfg->code_size;
  D.56441 = D.55433 >= D.55428;
  D.56442 = (long int) D.56441;
  D.56443 = __builtin_expect (D.56442, 0);
  if (D.56443 != 0) goto <D.56444>; else goto <D.56445>;
  <D.56444>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7349, "cfg->code_len < cfg->code_size");
  <D.56445>:
}


mono_arch_emit_exceptions (struct MonoCompile * cfg)
{
  <unnamed type> D.56449;
  unsigned int D.56458;
  unsigned int D.56459;
  void * D.56460;
  int D.56461;
  int D.56462;
  unsigned int D.56463;
  unsigned int D.56464;
  unsigned int D.56465;
  unsigned char * D.56466;
  sizetype D.56467;
  int D.56468;
  sizetype D.56469;
  unsigned char * D.56470;
  const char * D.56471;
  struct MonoImage * D.56472;
  _Bool D.56473;
  long int D.56474;
  long int D.56475;
  struct MonoClass * D.56478;
  guint8 * D.56482;
  long int D.56483;
  long int D.56484;
  long int D.56485;
  long int D.56486;
  long int D.56487;
  long unsigned int D.56488;
  unsigned int D.56489;
  unsigned int D.56490;
  int D.56491;
  long unsigned int D.56492;
  _Bool D.56493;
  unsigned char iftmp.9518;
  guint8 * code.9519;
  unsigned char D.56501;
  guint8 * code.9520;
  guint8 * code.9521;
  unsigned char D.56506;
  guint8 * code.9522;
  unsigned char D.56508;
  guint8 * code.9523;
  unsigned char D.56510;
  guint8 * code.9524;
  unsigned char D.56512;
  guint8 * code.9525;
  unsigned char D.56514;
  guint8 * code.9526;
  unsigned char D.56516;
  guint8 * code.9527;
  unsigned char D.56518;
  guint8 * code.9528;
  unsigned char D.56520;
  guint8 * code.9529;
  unsigned char D.56523;
  guint8 * code.9530;
  unsigned char D.56525;
  guint8 * code.9531;
  unsigned char D.56527;
  guint8 * code.9532;
  unsigned char D.56529;
  guint8 * D.56530;
  long int D.56531;
  long int code.9533;
  long int D.56533;
  unsigned int D.56534;
  unsigned int D.56535;
  unsigned int t.9534;
  unsigned int D.56537;
  guint8 * code.9535;
  unsigned char D.56541;
  unsigned int D.56543;
  guint8 * code.9536;
  guint8 * code.9537;
  unsigned char D.56546;
  guint8 * code.9538;
  unsigned char D.56548;
  guint8 * code.9539;
  unsigned char D.56550;
  guint8 * code.9540;
  unsigned char D.56552;
  guint8 * code.9541;
  unsigned char D.56557;
  guint8 * code.9542;
  guint8 * code.9543;
  unsigned char D.56562;
  guint8 * code.9544;
  unsigned char D.56564;
  guint8 * code.9545;
  unsigned char D.56566;
  guint8 * code.9546;
  unsigned char D.56568;
  guint8 * code.9547;
  unsigned char D.56570;
  guint8 * code.9548;
  unsigned char D.56572;
  guint8 * code.9549;
  unsigned char D.56574;
  guint8 * code.9550;
  unsigned char D.56576;
  guint8 * code.9551;
  unsigned char D.56579;
  guint8 * code.9552;
  unsigned char D.56581;
  guint8 * code.9553;
  unsigned char D.56583;
  guint8 * code.9554;
  unsigned char D.56585;
  unsigned int D.56588;
  unsigned int D.56589;
  long unsigned int D.56590;
  int D.56591;
  long unsigned int D.56592;
  _Bool D.56593;
  unsigned char iftmp.9555;
  guint8 * code.9556;
  unsigned char D.56601;
  guint8 * code.9557;
  guint8 * code.9558;
  unsigned char D.56606;
  guint8 * code.9559;
  unsigned char D.56608;
  guint8 * code.9560;
  unsigned char D.56610;
  guint8 * code.9561;
  unsigned char D.56612;
  guint8 * code.9562;
  unsigned char D.56614;
  guint8 * code.9563;
  unsigned char D.56616;
  guint8 * code.9564;
  unsigned char D.56618;
  guint8 * code.9565;
  unsigned char D.56620;
  guint8 * code.9566;
  unsigned char D.56623;
  guint8 * code.9567;
  unsigned char D.56625;
  guint8 * code.9568;
  unsigned char D.56627;
  guint8 * code.9569;
  unsigned char D.56629;
  long int D.56630;
  long int D.56631;
  long unsigned int D.56632;
  unsigned int D.56633;
  unsigned int D.56634;
  int D.56635;
  long unsigned int D.56636;
  _Bool D.56637;
  unsigned char iftmp.9570;
  guint8 * buf.9571;
  unsigned char D.56645;
  guint8 * buf.9572;
  guint8 * buf.9573;
  unsigned char D.56650;
  guint8 * buf.9574;
  unsigned char D.56652;
  guint8 * buf.9575;
  unsigned char D.56654;
  guint8 * buf.9576;
  unsigned char D.56656;
  guint8 * buf.9577;
  unsigned char D.56658;
  guint8 * buf.9578;
  unsigned char D.56660;
  guint8 * buf.9579;
  unsigned char D.56662;
  guint8 * buf.9580;
  unsigned char D.56664;
  guint8 * buf.9581;
  unsigned char D.56667;
  guint8 * buf.9582;
  unsigned char D.56669;
  guint8 * buf.9583;
  unsigned char D.56671;
  guint8 * buf.9584;
  unsigned char D.56673;
  guint8 * buf.9585;
  sizetype D.56677;
  unsigned char * D.56678;
  _Bool D.56679;
  long int D.56680;
  long int D.56681;
  long unsigned int code.9586;
  long unsigned int D.56685;
  long unsigned int D.56686;
  guint8 * D.56687;
  unsigned char D.56688;
  unsigned char D.56689;
  long int pos.9587;
  long int D.56693;
  unsigned int D.56694;
  const void * D.56698;
  double D.56699;
  float D.56701;
  unsigned char D.56702;
  unsigned char D.56703;
  long unsigned int D.56706;
  long unsigned int D.56707;
  long int orig_code.9588;
  long int D.56709;
  long unsigned int D.56710;
  guint8 * D.56711;
  unsigned char D.56712;
  unsigned char D.56713;
  guint32 * D.56716;
  long int pos.9589;
  long int D.56718;
  unsigned int D.56719;
  unsigned int D.56720;
  guint32 * D.56722;
  unsigned int D.56723;
  struct MonoJumpInfo * D.56726;
  struct MonoJumpInfo * D.56729;
  struct MonoJumpInfo * D.56731;
  unsigned int D.56734;
  _Bool D.56735;
  long int D.56736;
  long int D.56737;
  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;

  try
    {
      code_size = 0;
      patch_info = cfg->patch_info;
      goto <D.28544>;
      <D.28543>:
      D.56449 = patch_info->type;
      if (D.56449 == 9) goto <D.56450>; else goto <D.56451>;
      <D.56450>:
      code_size = code_size + 40;
      <D.56451>:
      D.56449 = patch_info->type;
      if (D.56449 == 21) goto <D.56452>; else goto <D.56453>;
      <D.56452>:
      code_size = code_size + 23;
      <D.56453>:
      D.56449 = patch_info->type;
      if (D.56449 == 20) goto <D.56454>; else goto <D.56455>;
      <D.56454>:
      code_size = code_size + 19;
      <D.56455>:
      D.56449 = patch_info->type;
      if (D.56449 == 42) goto <D.56456>; else goto <D.56457>;
      <D.56456>:
      code_size = code_size + 15;
      <D.56457>:
      patch_info = patch_info->next;
      <D.28544>:
      if (patch_info != 0B) goto <D.28543>; else goto <D.28545>;
      <D.28545>:
      goto <D.28547>;
      <D.28546>:
      D.56458 = cfg->code_size;
      D.56459 = D.56458 * 2;
      cfg->code_size = D.56459;
      D.56460 = mono_realloc_native_code (cfg);
      cfg->native_code = D.56460;
      D.56461 = cfg->stat_code_reallocs;
      D.56462 = D.56461 + 1;
      cfg->stat_code_reallocs = D.56462;
      <D.28547>:
      D.56463 = cfg->code_len;
      D.56464 = D.56463 + code_size;
      D.56458 = cfg->code_size;
      D.56465 = D.56458 + 4294967280;
      if (D.56464 > D.56465) goto <D.28546>; else goto <D.28548>;
      <D.28548>:
      D.56466 = cfg->native_code;
      D.56463 = cfg->code_len;
      D.56467 = (sizetype) D.56463;
      code = D.56466 + D.56467;
      nthrows = 0;
      patch_info = cfg->patch_info;
      goto <D.28580>;
      <D.28579>:
      D.56449 = patch_info->type;
      switch (D.56449) <default: <D.28578>, case 9: <D.28549>>
      <D.28549>:
      {
        struct MonoClass * exc_class;
        guint8 * buf;
        guint8 * buf2;
        guint32 throw_ip;

        D.56466 = cfg->native_code;
        D.56468 = patch_info->ip.i;
        D.56469 = (sizetype) D.56468;
        D.56470 = D.56466 + D.56469;
        amd64_patch (D.56470, code);
        D.56471 = patch_info->data.name;
        D.56472 = mono_defaults.corlib;
        exc_class = mono_class_from_name (D.56472, "System", D.56471);
        D.56473 = exc_class == 0B;
        D.56474 = (long int) D.56473;
        D.56475 = __builtin_expect (D.56474, 0);
        if (D.56475 != 0) goto <D.56476>; else goto <D.56477>;
        <D.56476>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7401, "exc_class");
        <D.56477>:
        D.56468 = patch_info->ip.i;
        throw_ip = (guint32) D.56468;
        i = 0;
        goto <D.28556>;
        <D.28555>:
        D.56478 = exc_classes[i];
        if (D.56478 == exc_class) goto <D.28554>; else goto <D.56479>;
        <D.56479>:
        i = i + 1;
        <D.28556>:
        if (i < nthrows) goto <D.28555>; else goto <D.28554>;
        <D.28554>:
        if (i < nthrows) goto <D.56480>; else goto <D.56481>;
        <D.56480>:
        {
          int _amd64_width_temp;

          D.56482 = exc_throw_end[i];
          D.56483 = (long int) D.56482;
          D.56466 = cfg->native_code;
          D.56484 = (long int) D.56466;
          D.56485 = D.56483 - D.56484;
          D.56486 = (long int) throw_ip;
          D.56487 = D.56485 - D.56486;
          D.56488 = (long unsigned int) D.56487;
          D.56482 = exc_throw_end[i];
          D.56483 = (long int) D.56482;
          D.56466 = cfg->native_code;
          D.56484 = (long int) D.56466;
          D.56485 = D.56483 - D.56484;
          D.56489 = (unsigned int) D.56485;
          D.56490 = D.56489 - throw_ip;
          D.56491 = (int) D.56490;
          D.56492 = (long unsigned int) D.56491;
          D.56493 = D.56488 == D.56492;
          _amd64_width_temp = (int) D.56493;
          {
            unsigned char _amd64_rex_bits;

            if (_amd64_width_temp == 0) goto <D.56495>; else goto <D.56496>;
            <D.56495>:
            iftmp.9518 = 8;
            goto <D.56497>;
            <D.56496>:
            iftmp.9518 = 0;
            <D.56497>:
            _amd64_rex_bits = iftmp.9518;
            if (_amd64_rex_bits != 0) goto <D.56498>; else goto <D.56499>;
            <D.56498>:
            code.9519 = code;
            code = code.9519 + 1;
            D.56501 = _amd64_rex_bits | 64;
            *code.9519 = D.56501;
            <D.56499>:
          }
          code.9520 = code;
          code = code.9520 + 1;
          *code.9520 = 190;
          if (_amd64_width_temp == 0) goto <D.56503>; else goto <D.56504>;
          <D.56503>:
          {
            union amd64_imm_buf imb;

            try
              {
                D.56482 = exc_throw_end[i];
                D.56483 = (long int) D.56482;
                D.56466 = cfg->native_code;
                D.56484 = (long int) D.56466;
                D.56485 = D.56483 - D.56484;
                D.56486 = (long int) throw_ip;
                D.56487 = D.56485 - D.56486;
                D.56488 = (long unsigned int) D.56487;
                imb.val = D.56488;
                code.9521 = code;
                code = code.9521 + 1;
                D.56506 = imb.b[0];
                *code.9521 = D.56506;
                code.9522 = code;
                code = code.9522 + 1;
                D.56508 = imb.b[1];
                *code.9522 = D.56508;
                code.9523 = code;
                code = code.9523 + 1;
                D.56510 = imb.b[2];
                *code.9523 = D.56510;
                code.9524 = code;
                code = code.9524 + 1;
                D.56512 = imb.b[3];
                *code.9524 = D.56512;
                code.9525 = code;
                code = code.9525 + 1;
                D.56514 = imb.b[4];
                *code.9525 = D.56514;
                code.9526 = code;
                code = code.9526 + 1;
                D.56516 = imb.b[5];
                *code.9526 = D.56516;
                code.9527 = code;
                code = code.9527 + 1;
                D.56518 = imb.b[6];
                *code.9527 = D.56518;
                code.9528 = code;
                code = code.9528 + 1;
                D.56520 = imb.b[7];
                *code.9528 = D.56520;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.56521>;
          <D.56504>:
          {
            union x86_imm_buf imb;

            try
              {
                D.56482 = exc_throw_end[i];
                D.56483 = (long int) D.56482;
                D.56466 = cfg->native_code;
                D.56484 = (long int) D.56466;
                D.56485 = D.56483 - D.56484;
                D.56489 = (unsigned int) D.56485;
                D.56490 = D.56489 - throw_ip;
                D.56491 = (int) D.56490;
                imb.val = D.56491;
                code.9529 = code;
                code = code.9529 + 1;
                D.56523 = imb.b[0];
                *code.9529 = D.56523;
                code.9530 = code;
                code = code.9530 + 1;
                D.56525 = imb.b[1];
                *code.9530 = D.56525;
                code.9531 = code;
                code = code.9531 + 1;
                D.56527 = imb.b[2];
                *code.9531 = D.56527;
                code.9532 = code;
                code = code.9532 + 1;
                D.56529 = imb.b[3];
                *code.9532 = D.56529;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.56521>:
        }
        {
          int t;

          D.56530 = exc_throw_start[i];
          D.56531 = (long int) D.56530;
          code.9533 = (long int) code;
          D.56533 = D.56531 - code.9533;
          D.56534 = (unsigned int) D.56533;
          D.56535 = D.56534 + 4294967294;
          t = (int) D.56535;
          t.9534 = (unsigned int) t;
          D.56537 = t.9534 + 128;
          if (D.56537 <= 255) goto <D.56538>; else goto <D.56539>;
          <D.56538>:
          code.9535 = code;
          code = code.9535 + 1;
          *code.9535 = 235;
          D.56541 = (unsigned char) t;
          *code = D.56541;
          code = code + 1;
          goto <D.56542>;
          <D.56539>:
          D.56530 = exc_throw_start[i];
          D.56531 = (long int) D.56530;
          code.9533 = (long int) code;
          D.56533 = D.56531 - code.9533;
          D.56534 = (unsigned int) D.56533;
          D.56543 = D.56534 + 4294967291;
          t = (int) D.56543;
          code.9536 = code;
          code = code.9536 + 1;
          *code.9536 = 233;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = t;
                code.9537 = code;
                code = code.9537 + 1;
                D.56546 = imb.b[0];
                *code.9537 = D.56546;
                code.9538 = code;
                code = code.9538 + 1;
                D.56548 = imb.b[1];
                *code.9538 = D.56548;
                code.9539 = code;
                code = code.9539 + 1;
                D.56550 = imb.b[2];
                *code.9539 = D.56550;
                code.9540 = code;
                code = code.9540 + 1;
                D.56552 = imb.b[3];
                *code.9540 = D.56552;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.56542>:
        }
        patch_info->type = 51;
        goto <D.56553>;
        <D.56481>:
        buf = code;
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 0;
          if (_amd64_rex_bits != 0) goto <D.56554>; else goto <D.56555>;
          <D.56554>:
          code.9541 = code;
          code = code.9541 + 1;
          D.56557 = _amd64_rex_bits | 64;
          *code.9541 = D.56557;
          <D.56555>:
        }
        code.9542 = code;
        code = code.9542 + 1;
        *code.9542 = 190;
        if (0 != 0) goto <D.56559>; else goto <D.56560>;
        <D.56559>:
        {
          union amd64_imm_buf imb;

          try
            {
              imb.val = 4042322160;
              code.9543 = code;
              code = code.9543 + 1;
              D.56562 = imb.b[0];
              *code.9543 = D.56562;
              code.9544 = code;
              code = code.9544 + 1;
              D.56564 = imb.b[1];
              *code.9544 = D.56564;
              code.9545 = code;
              code = code.9545 + 1;
              D.56566 = imb.b[2];
              *code.9545 = D.56566;
              code.9546 = code;
              code = code.9546 + 1;
              D.56568 = imb.b[3];
              *code.9546 = D.56568;
              code.9547 = code;
              code = code.9547 + 1;
              D.56570 = imb.b[4];
              *code.9547 = D.56570;
              code.9548 = code;
              code = code.9548 + 1;
              D.56572 = imb.b[5];
              *code.9548 = D.56572;
              code.9549 = code;
              code = code.9549 + 1;
              D.56574 = imb.b[6];
              *code.9549 = D.56574;
              code.9550 = code;
              code = code.9550 + 1;
              D.56576 = imb.b[7];
              *code.9550 = D.56576;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.56577>;
        <D.56560>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = -252645136;
              code.9551 = code;
              code = code.9551 + 1;
              D.56579 = imb.b[0];
              *code.9551 = D.56579;
              code.9552 = code;
              code = code.9552 + 1;
              D.56581 = imb.b[1];
              *code.9552 = D.56581;
              code.9553 = code;
              code = code.9553 + 1;
              D.56583 = imb.b[2];
              *code.9553 = D.56583;
              code.9554 = code;
              code = code.9554 + 1;
              D.56585 = imb.b[3];
              *code.9554 = D.56585;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.56577>:
        buf2 = code;
        if (nthrows <= 15) goto <D.56586>; else goto <D.56587>;
        <D.56586>:
        exc_classes[nthrows] = exc_class;
        exc_throw_start[nthrows] = code;
        <D.56587>:
        {
          int _amd64_width_temp;

          D.56588 = exc_class->type_token;
          D.56589 = D.56588 + 4261412864;
          D.56590 = (long unsigned int) D.56589;
          D.56588 = exc_class->type_token;
          D.56589 = D.56588 + 4261412864;
          D.56591 = (int) D.56589;
          D.56592 = (long unsigned int) D.56591;
          D.56593 = D.56590 == D.56592;
          _amd64_width_temp = (int) D.56593;
          {
            unsigned char _amd64_rex_bits;

            if (_amd64_width_temp == 0) goto <D.56595>; else goto <D.56596>;
            <D.56595>:
            iftmp.9555 = 8;
            goto <D.56597>;
            <D.56596>:
            iftmp.9555 = 0;
            <D.56597>:
            _amd64_rex_bits = iftmp.9555;
            if (_amd64_rex_bits != 0) goto <D.56598>; else goto <D.56599>;
            <D.56598>:
            code.9556 = code;
            code = code.9556 + 1;
            D.56601 = _amd64_rex_bits | 64;
            *code.9556 = D.56601;
            <D.56599>:
          }
          code.9557 = code;
          code = code.9557 + 1;
          *code.9557 = 191;
          if (_amd64_width_temp == 0) goto <D.56603>; else goto <D.56604>;
          <D.56603>:
          {
            union amd64_imm_buf imb;

            try
              {
                D.56588 = exc_class->type_token;
                D.56589 = D.56588 + 4261412864;
                D.56590 = (long unsigned int) D.56589;
                imb.val = D.56590;
                code.9558 = code;
                code = code.9558 + 1;
                D.56606 = imb.b[0];
                *code.9558 = D.56606;
                code.9559 = code;
                code = code.9559 + 1;
                D.56608 = imb.b[1];
                *code.9559 = D.56608;
                code.9560 = code;
                code = code.9560 + 1;
                D.56610 = imb.b[2];
                *code.9560 = D.56610;
                code.9561 = code;
                code = code.9561 + 1;
                D.56612 = imb.b[3];
                *code.9561 = D.56612;
                code.9562 = code;
                code = code.9562 + 1;
                D.56614 = imb.b[4];
                *code.9562 = D.56614;
                code.9563 = code;
                code = code.9563 + 1;
                D.56616 = imb.b[5];
                *code.9563 = D.56616;
                code.9564 = code;
                code = code.9564 + 1;
                D.56618 = imb.b[6];
                *code.9564 = D.56618;
                code.9565 = code;
                code = code.9565 + 1;
                D.56620 = imb.b[7];
                *code.9565 = D.56620;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.56621>;
          <D.56604>:
          {
            union x86_imm_buf imb;

            try
              {
                D.56588 = exc_class->type_token;
                D.56589 = D.56588 + 4261412864;
                D.56591 = (int) D.56589;
                imb.val = D.56591;
                code.9566 = code;
                code = code.9566 + 1;
                D.56623 = imb.b[0];
                *code.9566 = D.56623;
                code.9567 = code;
                code = code.9567 + 1;
                D.56625 = imb.b[1];
                *code.9567 = D.56625;
                code.9568 = code;
                code = code.9568 + 1;
                D.56627 = imb.b[2];
                *code.9568 = D.56627;
                code.9569 = code;
                code = code.9569 + 1;
                D.56629 = imb.b[3];
                *code.9569 = D.56629;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.56621>:
        }
        patch_info->type = 51;
        code = emit_call_body (cfg, code, 7, "mono_arch_throw_corlib_exception");
        {
          int _amd64_width_temp;

          code.9533 = (long int) code;
          D.56466 = cfg->native_code;
          D.56484 = (long int) D.56466;
          D.56630 = code.9533 - D.56484;
          D.56486 = (long int) throw_ip;
          D.56631 = D.56630 - D.56486;
          D.56632 = (long unsigned int) D.56631;
          code.9533 = (long int) code;
          D.56466 = cfg->native_code;
          D.56484 = (long int) D.56466;
          D.56630 = code.9533 - D.56484;
          D.56633 = (unsigned int) D.56630;
          D.56634 = D.56633 - throw_ip;
          D.56635 = (int) D.56634;
          D.56636 = (long unsigned int) D.56635;
          D.56637 = D.56632 == D.56636;
          _amd64_width_temp = (int) D.56637;
          {
            unsigned char _amd64_rex_bits;

            if (_amd64_width_temp == 0) goto <D.56639>; else goto <D.56640>;
            <D.56639>:
            iftmp.9570 = 8;
            goto <D.56641>;
            <D.56640>:
            iftmp.9570 = 0;
            <D.56641>:
            _amd64_rex_bits = iftmp.9570;
            if (_amd64_rex_bits != 0) goto <D.56642>; else goto <D.56643>;
            <D.56642>:
            buf.9571 = buf;
            buf = buf.9571 + 1;
            D.56645 = _amd64_rex_bits | 64;
            *buf.9571 = D.56645;
            <D.56643>:
          }
          buf.9572 = buf;
          buf = buf.9572 + 1;
          *buf.9572 = 190;
          if (_amd64_width_temp == 0) goto <D.56647>; else goto <D.56648>;
          <D.56647>:
          {
            union amd64_imm_buf imb;

            try
              {
                code.9533 = (long int) code;
                D.56466 = cfg->native_code;
                D.56484 = (long int) D.56466;
                D.56630 = code.9533 - D.56484;
                D.56486 = (long int) throw_ip;
                D.56631 = D.56630 - D.56486;
                D.56632 = (long unsigned int) D.56631;
                imb.val = D.56632;
                buf.9573 = buf;
                buf = buf.9573 + 1;
                D.56650 = imb.b[0];
                *buf.9573 = D.56650;
                buf.9574 = buf;
                buf = buf.9574 + 1;
                D.56652 = imb.b[1];
                *buf.9574 = D.56652;
                buf.9575 = buf;
                buf = buf.9575 + 1;
                D.56654 = imb.b[2];
                *buf.9575 = D.56654;
                buf.9576 = buf;
                buf = buf.9576 + 1;
                D.56656 = imb.b[3];
                *buf.9576 = D.56656;
                buf.9577 = buf;
                buf = buf.9577 + 1;
                D.56658 = imb.b[4];
                *buf.9577 = D.56658;
                buf.9578 = buf;
                buf = buf.9578 + 1;
                D.56660 = imb.b[5];
                *buf.9578 = D.56660;
                buf.9579 = buf;
                buf = buf.9579 + 1;
                D.56662 = imb.b[6];
                *buf.9579 = D.56662;
                buf.9580 = buf;
                buf = buf.9580 + 1;
                D.56664 = imb.b[7];
                *buf.9580 = D.56664;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.56665>;
          <D.56648>:
          {
            union x86_imm_buf imb;

            try
              {
                code.9533 = (long int) code;
                D.56466 = cfg->native_code;
                D.56484 = (long int) D.56466;
                D.56630 = code.9533 - D.56484;
                D.56633 = (unsigned int) D.56630;
                D.56634 = D.56633 - throw_ip;
                D.56635 = (int) D.56634;
                imb.val = D.56635;
                buf.9581 = buf;
                buf = buf.9581 + 1;
                D.56667 = imb.b[0];
                *buf.9581 = D.56667;
                buf.9582 = buf;
                buf = buf.9582 + 1;
                D.56669 = imb.b[1];
                *buf.9582 = D.56669;
                buf.9583 = buf;
                buf = buf.9583 + 1;
                D.56671 = imb.b[2];
                *buf.9583 = D.56671;
                buf.9584 = buf;
                buf = buf.9584 + 1;
                D.56673 = imb.b[3];
                *buf.9584 = D.56673;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.56665>:
        }
        goto <D.28575>;
        <D.28574>:
        buf.9585 = buf;
        buf = buf.9585 + 1;
        *buf.9585 = 144;
        <D.28575>:
        if (buf < buf2) goto <D.28574>; else goto <D.28576>;
        <D.28576>:
        if (nthrows <= 15) goto <D.56675>; else goto <D.56676>;
        <D.56675>:
        exc_throw_end[nthrows] = code;
        nthrows = nthrows + 1;
        <D.56676>:
        <D.56553>:
        goto <D.28577>;
      }
      <D.28578>:
      goto <D.28577>;
      <D.28577>:
      D.56466 = cfg->native_code;
      D.56458 = cfg->code_size;
      D.56677 = (sizetype) D.56458;
      D.56678 = D.56466 + D.56677;
      D.56679 = D.56678 <= code;
      D.56680 = (long int) D.56679;
      D.56681 = __builtin_expect (D.56680, 0);
      if (D.56681 != 0) goto <D.56682>; else goto <D.56683>;
      <D.56682>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7444, "code < cfg->native_code + cfg->code_size");
      <D.56683>:
      patch_info = patch_info->next;
      <D.28580>:
      if (patch_info != 0B) goto <D.28579>; else goto <D.28581>;
      <D.28581>:
      patch_info = cfg->patch_info;
      goto <D.28599>;
      <D.28598>:
      {
        gboolean remove;
        guint8 * orig_code;

        remove = 0;
        orig_code = code;
        D.56449 = patch_info->type;
        switch (D.56449) <default: <D.28593>, case 20: <D.28585>, case 21: <D.28584>, case 42: <D.28590>>
        <D.28584>:
        <D.28585>:
        {
          guint8 * pos;
          guint8 * patch_pos;
          guint32 target_pos;

          code.9586 = (long unsigned int) code;
          D.56685 = code.9586 + 15;
          D.56686 = D.56685 & 18446744073709551600;
          code = (guint8 *) D.56686;
          D.56466 = cfg->native_code;
          D.56468 = patch_info->ip.i;
          D.56469 = (sizetype) D.56468;
          pos = D.56466 + D.56469;
          D.56687 = pos + 1;
          D.56688 = *D.56687;
          D.56689 = D.56688 + 192;
          if (D.56689 <= 15) goto <D.56690>; else goto <D.56691>;
          <D.56690>:
          patch_pos = pos + 5;
          code.9533 = (long int) code;
          pos.9587 = (long int) pos;
          D.56693 = code.9533 - pos.9587;
          D.56694 = (unsigned int) D.56693;
          target_pos = D.56694 + 4294967287;
          goto <D.56695>;
          <D.56691>:
          patch_pos = pos + 4;
          code.9533 = (long int) code;
          pos.9587 = (long int) pos;
          D.56693 = code.9533 - pos.9587;
          D.56694 = (unsigned int) D.56693;
          target_pos = D.56694 + 4294967288;
          <D.56695>:
          D.56449 = patch_info->type;
          if (D.56449 == 21) goto <D.56696>; else goto <D.56697>;
          <D.56696>:
          D.56698 = patch_info->data.target;
          D.56699 = MEM[(double *)D.56698];
          MEM[(double *)code] = D.56699;
          code = code + 8;
          goto <D.56700>;
          <D.56697>:
          D.56698 = patch_info->data.target;
          D.56701 = MEM[(float *)D.56698];
          MEM[(float *)code] = D.56701;
          code = code + 4;
          <D.56700>:
          MEM[(guint32 *)patch_pos] = target_pos;
          remove = 1;
          goto <D.28589>;
        }
        <D.28590>:
        {
          guint8 * pos;

          D.56702 = BIT_FIELD_REF <*cfg, 8, 5600>;
          D.56703 = D.56702 & 64;
          if (D.56703 != 0) goto <D.56704>; else goto <D.56705>;
          <D.56704>:
          // predicted unlikely by continue predictor.
          goto <D.28592>;
          <D.56705>:
          code.9586 = (long unsigned int) code;
          D.56706 = code.9586 + 7;
          D.56707 = D.56706 & 18446744073709551608;
          code = (guint8 *) D.56707;
          code.9533 = (long int) code;
          orig_code.9588 = (long int) orig_code;
          D.56709 = code.9533 - orig_code.9588;
          D.56710 = (long unsigned int) D.56709;
          memset (orig_code, 0, D.56710);
          D.56466 = cfg->native_code;
          D.56468 = patch_info->ip.i;
          D.56469 = (sizetype) D.56468;
          pos = D.56466 + D.56469;
          D.56711 = pos + 1;
          D.56712 = *D.56711;
          D.56713 = D.56712 + 192;
          if (D.56713 <= 15) goto <D.56714>; else goto <D.56715>;
          <D.56714>:
          D.56716 = pos + 4;
          code.9533 = (long int) code;
          pos.9589 = (long int) pos;
          D.56718 = code.9533 - pos.9589;
          D.56719 = (unsigned int) D.56718;
          D.56720 = D.56719 + 4294967288;
          *D.56716 = D.56720;
          goto <D.56721>;
          <D.56715>:
          D.56722 = pos + 3;
          code.9533 = (long int) code;
          pos.9589 = (long int) pos;
          D.56718 = code.9533 - pos.9589;
          D.56719 = (unsigned int) D.56718;
          D.56723 = D.56719 + 4294967289;
          *D.56722 = D.56723;
          <D.56721>:
          D.56698 = patch_info->data.target;
          MEM[(void * *)code] = D.56698;
          code = code + 8;
          remove = 1;
          goto <D.28589>;
        }
        <D.28593>:
        goto <D.28589>;
        <D.28589>:
        if (remove != 0) goto <D.56724>; else goto <D.56725>;
        <D.56724>:
        D.56726 = cfg->patch_info;
        if (D.56726 == patch_info) goto <D.56727>; else goto <D.56728>;
        <D.56727>:
        D.56729 = patch_info->next;
        cfg->patch_info = D.56729;
        goto <D.56730>;
        <D.56728>:
        {
          struct MonoJumpInfo * tmp;

          tmp = cfg->patch_info;
          goto <D.28596>;
          <D.28595>:
          tmp = tmp->next;
          <D.28596>:
          D.56731 = tmp->next;
          if (D.56731 != patch_info) goto <D.28595>; else goto <D.28597>;
          <D.28597>:
          D.56729 = patch_info->next;
          tmp->next = D.56729;
        }
        <D.56730>:
        <D.56725>:
        D.56466 = cfg->native_code;
        D.56458 = cfg->code_size;
        D.56677 = (sizetype) D.56458;
        D.56678 = D.56466 + D.56677;
        D.56679 = D.56678 <= code;
        D.56680 = (long int) D.56679;
        D.56681 = __builtin_expect (D.56680, 0);
        if (D.56681 != 0) goto <D.56732>; else goto <D.56733>;
        <D.56732>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7561, "code < cfg->native_code + cfg->code_size");
        <D.56733>:
      }
      <D.28592>:
      patch_info = patch_info->next;
      <D.28599>:
      if (patch_info != 0B) goto <D.28598>; else goto <D.28600>;
      <D.28600>:
      code.9533 = (long int) code;
      D.56466 = cfg->native_code;
      D.56484 = (long int) D.56466;
      D.56630 = code.9533 - D.56484;
      D.56734 = (unsigned int) D.56630;
      cfg->code_len = D.56734;
      D.56463 = cfg->code_len;
      D.56458 = cfg->code_size;
      D.56735 = D.56463 >= D.56458;
      D.56736 = (long int) D.56735;
      D.56737 = __builtin_expect (D.56736, 0);
      if (D.56737 != 0) goto <D.56738>; else goto <D.56739>;
      <D.56738>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7566, "cfg->code_len < cfg->code_size");
      <D.56739>:
    }
  finally
    {
      exc_classes = {CLOBBER};
      exc_throw_start = {CLOBBER};
      exc_throw_end = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.56744;
  int D.56749;
  void * D.56751;
  long unsigned int D.56752;

  D.56744 = __builtin_constant_p (__len);
  if (D.56744 != 0) goto <D.56745>; else goto <D.56746>;
  <D.56745>:
  if (__len == 0) goto <D.56747>; else goto <D.56748>;
  <D.56747>:
  D.56749 = __builtin_constant_p (__ch);
  if (D.56749 == 0) goto <D.56742>; else goto <D.56750>;
  <D.56750>:
  if (__ch != 0) goto <D.56742>; else goto <D.56743>;
  <D.56742>:
  __warn_memset_zero_len ();
  D.56751 = __dest;
  return D.56751;
  <D.56743>:
  <D.56748>:
  <D.56746>:
  D.56752 = __builtin_object_size (__dest, 0);
  D.56751 = __builtin___memset_chk (__dest, __ch, __len, D.56752);
  return D.56751;
}


mono_arch_instrument_prolog (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments)
{
  struct MonoMethod * D.56756;
  struct MonoMemPool * D.56757;
  struct MonoGenericSharingContext * D.56758;
  short unsigned int D.56759;
  int D.56760;
  <unnamed-unsigned:1> D.56761;
  int D.56762;
  long unsigned int D.56763;
  unsigned int D.56764;
  unsigned int D.56765;
  unsigned int D.56766;
  int D.56767;
  unsigned int stack_area.9590;
  unsigned int D.56769;
  guchar * code.9591;
  unsigned char D.56775;
  guchar * code.9592;
  guchar * code.9593;
  unsigned char D.56778;
  guchar * code.9594;
  unsigned char D.56785;
  guchar * code.9595;
  guchar * code.9596;
  unsigned char D.56788;
  guchar * code.9597;
  unsigned char D.56790;
  guchar * code.9598;
  unsigned char D.56792;
  guchar * code.9599;
  unsigned char D.56794;
  guchar * code.9600;
  unsigned char D.56799;
  guchar * code.9601;
  guchar * code.9602;
  guchar * code.9603;
  unsigned char D.56803;
  guchar * code.9604;
  unsigned char D.56805;
  guchar * code.9605;
  unsigned char D.56807;
  guchar * code.9606;
  unsigned char D.56809;
  struct MonoInst * * D.56810;
  long unsigned int D.56811;
  long unsigned int D.56812;
  struct MonoInst * * D.56813;
  short unsigned int D.56814;
  guchar * code.9607;
  unsigned char iftmp.9608;
  int D.56821;
  guchar * code.9609;
  unsigned char D.56828;
  guchar * code.9610;
  guchar * code.9611;
  guchar * code.9612;
  int D.56836;
  int D.56837;
  signed char D.56838;
  signed char D.56839;
  unsigned char D.56840;
  guchar * code.9613;
  int D.56843;
  unsigned int D.56844;
  unsigned int D.56845;
  guchar * code.9614;
  signed char D.56849;
  unsigned char D.56850;
  guchar * code.9615;
  unsigned char D.56852;
  unsigned char D.56853;
  guchar * code.9616;
  signed char D.56856;
  unsigned char D.56857;
  guchar * code.9617;
  guchar * code.9618;
  unsigned char D.56860;
  guchar * code.9619;
  unsigned char D.56862;
  guchar * code.9620;
  unsigned char D.56864;
  guchar * code.9621;
  unsigned char D.56866;
  guchar * code.9622;
  guchar * code.9623;
  guchar * code.9624;
  guchar * code.9625;
  unsigned char D.56876;
  guchar * code.9626;
  unsigned char D.56878;
  guchar * code.9627;
  unsigned char D.56880;
  guchar * code.9628;
  unsigned char D.56882;
  guchar * code.9629;
  unsigned char iftmp.9630;
  int D.56888;
  guchar * code.9631;
  unsigned char D.56895;
  guchar * code.9632;
  guchar * code.9633;
  guchar * code.9634;
  long int D.56901;
  int D.56902;
  guchar * code.9635;
  unsigned char D.56904;
  guchar * code.9636;
  unsigned char D.56906;
  guchar * code.9637;
  unsigned char D.56908;
  guchar * code.9638;
  unsigned char D.56910;
  int D.56912;
  guchar * code.9639;
  guchar * code.9640;
  unsigned int D.56920;
  unsigned int D.56921;
  guchar * code.9641;
  guchar * code.9642;
  unsigned char D.56926;
  guchar * code.9643;
  guchar * code.9644;
  guchar * code.9645;
  unsigned char D.56931;
  guchar * code.9646;
  unsigned char D.56933;
  guchar * code.9647;
  unsigned char D.56935;
  guchar * code.9648;
  unsigned char D.56937;
  guchar * code.9649;
  signed char D.56943;
  signed char D.56944;
  signed char D.56945;
  unsigned char D.56946;
  guchar * code.9650;
  signed char D.56950;
  unsigned char D.56951;
  guchar * code.9651;
  signed char D.56954;
  unsigned char D.56955;
  guchar * code.9652;
  unsigned char D.56957;
  guchar * code.9653;
  unsigned char D.56959;
  guchar * code.9654;
  unsigned char D.56961;
  guchar * code.9655;
  unsigned char D.56963;
  guchar * code.9656;
  guchar * code.9657;
  unsigned char D.56970;
  guchar * code.9658;
  guchar * code.9659;
  guchar * code.9660;
  guchar * code.9661;
  guchar * code.9662;
  guchar * code.9663;
  guchar * code.9664;
  guchar * code.9665;
  guchar * code.9666;
  unsigned char D.56988;
  guchar * code.9667;
  unsigned char D.56990;
  guchar * code.9668;
  unsigned char D.56992;
  guchar * code.9669;
  unsigned char D.56994;
  guchar * code.9670;
  guchar * code.9671;
  guchar * code.9672;
  guchar * code.9673;
  unsigned char D.57004;
  guchar * code.9674;
  unsigned char D.57006;
  guchar * code.9675;
  unsigned char D.57008;
  guchar * code.9676;
  unsigned char D.57010;
  long int code.9677;
  unsigned char * D.57012;
  long int D.57013;
  long int D.57014;
  int D.57015;
  guchar * code.9678;
  unsigned char D.57019;
  guchar * code.9679;
  guchar * code.9680;
  unsigned char D.57024;
  guchar * code.9681;
  unsigned char D.57026;
  guchar * code.9682;
  unsigned char D.57028;
  guchar * code.9683;
  unsigned char D.57030;
  guchar * code.9684;
  unsigned char D.57032;
  guchar * code.9685;
  unsigned char D.57034;
  guchar * code.9686;
  unsigned char D.57036;
  guchar * code.9687;
  unsigned char D.57038;
  guchar * code.9688;
  unsigned char D.57041;
  guchar * code.9689;
  unsigned char D.57043;
  guchar * code.9690;
  unsigned char D.57045;
  guchar * code.9691;
  unsigned char D.57047;
  guchar * code.9692;
  guchar * code.9693;
  unsigned char D.57054;
  guchar * code.9694;
  guchar * code.9695;
  guchar * code.9696;
  guchar * code.9697;
  unsigned char D.57065;
  guchar * code.9698;
  guchar * code.9699;
  guchar * code.9700;
  unsigned char D.57074;
  guchar * code.9701;
  guchar * code.9702;
  unsigned char D.57077;
  guchar * code.9703;
  unsigned char D.57079;
  guchar * code.9704;
  unsigned char D.57081;
  guchar * code.9705;
  unsigned char D.57083;
  guchar * code.9706;
  unsigned char D.57088;
  guchar * code.9707;
  guchar * code.9708;
  guchar * code.9709;
  unsigned char D.57092;
  guchar * code.9710;
  unsigned char D.57094;
  guchar * code.9711;
  unsigned char D.57096;
  guchar * code.9712;
  unsigned char D.57098;
  void * D.57099;
  guchar * code;
  struct CallInfo * cinfo;
  struct MonoMethodSignature * sig;
  struct MonoInst * inst;
  int i;
  int n;
  int stack_area;
  static const char __PRETTY_FUNCTION__[28] = "mono_arch_instrument_prolog";

  code = p;
  cinfo = 0B;
  stack_area = 0;
  if (enable_arguments != 0) goto <D.56754>; else goto <D.56755>;
  <D.56754>:
  D.56756 = cfg->method;
  sig = mono_method_signature (D.56756);
  D.56757 = cfg->mempool;
  D.56758 = cfg->generic_sharing_context;
  cinfo = get_call_info (D.56758, D.56757, sig);
  D.56759 = sig->param_count;
  D.56760 = (int) D.56759;
  D.56761 = sig->hasthis;
  D.56762 = (int) D.56761;
  n = D.56760 + D.56762;
  D.56763 = (long unsigned int) n;
  D.56764 = (unsigned int) D.56763;
  D.56765 = D.56764 * 8;
  D.56766 = D.56765 + 15;
  D.56767 = (int) D.56766;
  stack_area = D.56767 & -16;
  stack_area.9590 = (unsigned int) stack_area;
  D.56769 = stack_area.9590 + 128;
  if (D.56769 <= 255) goto <D.56770>; else goto <D.56771>;
  <D.56770>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.56772>; else goto <D.56773>;
    <D.56772>:
    code.9591 = code;
    code = code.9591 + 1;
    D.56775 = _amd64_rex_bits | 64;
    *code.9591 = D.56775;
    <D.56773>:
  }
  code.9592 = code;
  code = code.9592 + 1;
  *code.9592 = 131;
  code.9593 = code;
  code = code.9593 + 1;
  *code.9593 = 236;
  D.56778 = (unsigned char) stack_area;
  *code = D.56778;
  code = code + 1;
  goto <D.56779>;
  <D.56771>:
  if (0 != 0) goto <D.56780>; else goto <D.56781>;
  <D.56780>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.56782>; else goto <D.56783>;
    <D.56782>:
    code.9594 = code;
    code = code.9594 + 1;
    D.56785 = _amd64_rex_bits | 64;
    *code.9594 = D.56785;
    <D.56783>:
  }
  code.9595 = code;
  code = code.9595 + 1;
  *code.9595 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = stack_area;
        code.9596 = code;
        code = code.9596 + 1;
        D.56788 = imb.b[0];
        *code.9596 = D.56788;
        code.9597 = code;
        code = code.9597 + 1;
        D.56790 = imb.b[1];
        *code.9597 = D.56790;
        code.9598 = code;
        code = code.9598 + 1;
        D.56792 = imb.b[2];
        *code.9598 = D.56792;
        code.9599 = code;
        code = code.9599 + 1;
        D.56794 = imb.b[3];
        *code.9599 = D.56794;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.56795>;
  <D.56781>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.56796>; else goto <D.56797>;
    <D.56796>:
    code.9600 = code;
    code = code.9600 + 1;
    D.56799 = _amd64_rex_bits | 64;
    *code.9600 = D.56799;
    <D.56797>:
  }
  code.9601 = code;
  code = code.9601 + 1;
  *code.9601 = 129;
  code.9602 = code;
  code = code.9602 + 1;
  *code.9602 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = stack_area;
        code.9603 = code;
        code = code.9603 + 1;
        D.56803 = imb.b[0];
        *code.9603 = D.56803;
        code.9604 = code;
        code = code.9604 + 1;
        D.56805 = imb.b[1];
        *code.9604 = D.56805;
        code.9605 = code;
        code = code.9605 + 1;
        D.56807 = imb.b[2];
        *code.9605 = D.56807;
        code.9606 = code;
        code = code.9606 + 1;
        D.56809 = imb.b[3];
        *code.9606 = D.56809;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56795>:
  <D.56779>:
  i = 0;
  goto <D.28652>;
  <D.28651>:
  D.56810 = cfg->args;
  D.56811 = (long unsigned int) i;
  D.56812 = D.56811 * 8;
  D.56813 = D.56810 + D.56812;
  inst = *D.56813;
  D.56814 = inst->opcode;
  if (D.56814 == 366) goto <D.56815>; else goto <D.56816>;
  <D.56815>:
  if (0 != 0) goto <D.56817>; else goto <D.56818>;
  <D.56817>:
  code.9607 = code;
  code = code.9607 + 1;
  *code.9607 = 102;
  <D.56818>:
  {
    unsigned char _amd64_rex_bits;

    D.56821 = inst->dreg;
    if (D.56821 > 7) goto <D.56822>; else goto <D.56823>;
    <D.56822>:
    iftmp.9608 = 12;
    goto <D.56824>;
    <D.56823>:
    iftmp.9608 = 8;
    <D.56824>:
    _amd64_rex_bits = iftmp.9608;
    if (_amd64_rex_bits != 0) goto <D.56825>; else goto <D.56826>;
    <D.56825>:
    code.9609 = code;
    code = code.9609 + 1;
    D.56828 = _amd64_rex_bits | 64;
    *code.9609 = D.56828;
    <D.56826>:
  }
  switch (8) <default: <D.28625>, case 1: <D.28620>, case 2: <D.28622>, case 4: <D.28623>, case 8: <D.28624>>
  <D.28620>:
  code.9610 = code;
  code = code.9610 + 1;
  *code.9610 = 136;
  goto <D.28621>;
  <D.28622>:
  <D.28623>:
  <D.28624>:
  code.9611 = code;
  code = code.9611 + 1;
  *code.9611 = 137;
  goto <D.28621>;
  <D.28625>:
  __assert_fail ("0", "mini-amd64.c", 7599, &__PRETTY_FUNCTION__);
  <D.28621>:
  if (1 != 0) goto <D.56831>; else goto <D.56832>;
  <D.56831>:
  if (i == 0) goto <D.56833>; else goto <D.56834>;
  <D.56833>:
  code.9612 = code;
  code = code.9612 + 1;
  D.56821 = inst->dreg;
  D.56836 = D.56821 & 7;
  D.56837 = D.56836 << 3;
  D.56838 = (signed char) D.56837;
  D.56839 = D.56838 | 4;
  D.56840 = (unsigned char) D.56839;
  *code.9612 = D.56840;
  code.9613 = code;
  code = code.9613 + 1;
  *code.9613 = 36;
  goto <D.56842>;
  <D.56834>:
  D.56843 = i * 8;
  D.56844 = (unsigned int) D.56843;
  D.56845 = D.56844 + 128;
  if (D.56845 <= 255) goto <D.56846>; else goto <D.56847>;
  <D.56846>:
  code.9614 = code;
  code = code.9614 + 1;
  D.56821 = inst->dreg;
  D.56836 = D.56821 & 7;
  D.56837 = D.56836 << 3;
  D.56838 = (signed char) D.56837;
  D.56849 = D.56838 | 68;
  D.56850 = (unsigned char) D.56849;
  *code.9614 = D.56850;
  code.9615 = code;
  code = code.9615 + 1;
  *code.9615 = 36;
  D.56852 = (unsigned char) i;
  D.56853 = D.56852 * 8;
  *code = D.56853;
  code = code + 1;
  goto <D.56854>;
  <D.56847>:
  code.9616 = code;
  code = code.9616 + 1;
  D.56821 = inst->dreg;
  D.56836 = D.56821 & 7;
  D.56837 = D.56836 << 3;
  D.56838 = (signed char) D.56837;
  D.56856 = D.56838 | -124;
  D.56857 = (unsigned char) D.56856;
  *code.9616 = D.56857;
  code.9617 = code;
  code = code.9617 + 1;
  *code.9617 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.56843 = i * 8;
        imb.val = D.56843;
        code.9618 = code;
        code = code.9618 + 1;
        D.56860 = imb.b[0];
        *code.9618 = D.56860;
        code.9619 = code;
        code = code.9619 + 1;
        D.56862 = imb.b[1];
        *code.9619 = D.56862;
        code.9620 = code;
        code = code.9620 + 1;
        D.56864 = imb.b[2];
        *code.9620 = D.56864;
        code.9621 = code;
        code = code.9621 + 1;
        D.56866 = imb.b[3];
        *code.9621 = D.56866;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56854>:
  <D.56842>:
  goto <D.28628>;
  <D.56832>:
  if (i == 0) goto <D.56867>; else goto <D.56868>;
  <D.56867>:
  code.9622 = code;
  code = code.9622 + 1;
  D.56821 = inst->dreg;
  D.56836 = D.56821 & 7;
  D.56837 = D.56836 << 3;
  D.56838 = (signed char) D.56837;
  D.56839 = D.56838 | 4;
  D.56840 = (unsigned char) D.56839;
  *code.9622 = D.56840;
  goto <D.28628>;
  <D.56868>:
  D.56843 = i * 8;
  D.56844 = (unsigned int) D.56843;
  D.56845 = D.56844 + 128;
  if (D.56845 <= 255) goto <D.56870>; else goto <D.56871>;
  <D.56870>:
  code.9623 = code;
  code = code.9623 + 1;
  D.56821 = inst->dreg;
  D.56836 = D.56821 & 7;
  D.56837 = D.56836 << 3;
  D.56838 = (signed char) D.56837;
  D.56849 = D.56838 | 68;
  D.56850 = (unsigned char) D.56849;
  *code.9623 = D.56850;
  D.56852 = (unsigned char) i;
  D.56853 = D.56852 * 8;
  *code = D.56853;
  code = code + 1;
  goto <D.56873>;
  <D.56871>:
  code.9624 = code;
  code = code.9624 + 1;
  D.56821 = inst->dreg;
  D.56836 = D.56821 & 7;
  D.56837 = D.56836 << 3;
  D.56838 = (signed char) D.56837;
  D.56856 = D.56838 | -124;
  D.56857 = (unsigned char) D.56856;
  *code.9624 = D.56857;
  {
    union x86_imm_buf imb;

    try
      {
        D.56843 = i * 8;
        imb.val = D.56843;
        code.9625 = code;
        code = code.9625 + 1;
        D.56876 = imb.b[0];
        *code.9625 = D.56876;
        code.9626 = code;
        code = code.9626 + 1;
        D.56878 = imb.b[1];
        *code.9626 = D.56878;
        code.9627 = code;
        code = code.9627 + 1;
        D.56880 = imb.b[2];
        *code.9627 = D.56880;
        code.9628 = code;
        code = code.9628 + 1;
        D.56882 = imb.b[3];
        *code.9628 = D.56882;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56873>:
  <D.28628>:
  goto <D.56883>;
  <D.56816>:
  if (0 != 0) goto <D.56884>; else goto <D.56885>;
  <D.56884>:
  code.9629 = code;
  code = code.9629 + 1;
  *code.9629 = 102;
  <D.56885>:
  {
    unsigned char _amd64_rex_bits;

    D.56888 = inst->sreg1;
    if (D.56888 > 7) goto <D.56889>; else goto <D.56890>;
    <D.56889>:
    iftmp.9630 = 13;
    goto <D.56891>;
    <D.56890>:
    iftmp.9630 = 12;
    <D.56891>:
    _amd64_rex_bits = iftmp.9630;
    if (_amd64_rex_bits != 0) goto <D.56892>; else goto <D.56893>;
    <D.56892>:
    code.9631 = code;
    code = code.9631 + 1;
    D.56895 = _amd64_rex_bits | 64;
    *code.9631 = D.56895;
    <D.56893>:
  }
  switch (8) <default: <D.28636>, case 1: <D.28631>, case 2: <D.28633>, case 4: <D.28634>, case 8: <D.28635>>
  <D.28631>:
  code.9632 = code;
  code = code.9632 + 1;
  *code.9632 = 138;
  goto <D.28632>;
  <D.28633>:
  <D.28634>:
  <D.28635>:
  code.9633 = code;
  code = code.9633 + 1;
  *code.9633 = 139;
  goto <D.28632>;
  <D.28636>:
  __assert_fail ("0", "mini-amd64.c", 7601, &__PRETTY_FUNCTION__);
  <D.28632>:
  D.56888 = inst->sreg1;
  if (D.56888 == 16) goto <D.56898>; else goto <D.56899>;
  <D.56898>:
  code.9634 = code;
  code = code.9634 + 1;
  *code.9634 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        D.56901 = inst->data.op[0].const_val;
        D.56902 = (int) D.56901;
        imb.val = D.56902;
        code.9635 = code;
        code = code.9635 + 1;
        D.56904 = imb.b[0];
        *code.9635 = D.56904;
        code.9636 = code;
        code = code.9636 + 1;
        D.56906 = imb.b[1];
        *code.9636 = D.56906;
        code.9637 = code;
        code = code.9637 + 1;
        D.56908 = imb.b[2];
        *code.9637 = D.56908;
        code.9638 = code;
        code = code.9638 + 1;
        D.56910 = imb.b[3];
        *code.9638 = D.56910;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.56911>;
  <D.56899>:
  D.56888 = inst->sreg1;
  D.56912 = D.56888 & 7;
  if (D.56912 == 4) goto <D.56913>; else goto <D.56914>;
  <D.56913>:
  D.56901 = inst->data.op[0].const_val;
  if (D.56901 == 0) goto <D.56915>; else goto <D.56916>;
  <D.56915>:
  code.9639 = code;
  code = code.9639 + 1;
  *code.9639 = 28;
  code.9640 = code;
  code = code.9640 + 1;
  *code.9640 = 36;
  goto <D.56919>;
  <D.56916>:
  D.56901 = inst->data.op[0].const_val;
  D.56920 = (unsigned int) D.56901;
  D.56921 = D.56920 + 128;
  if (D.56921 <= 255) goto <D.56922>; else goto <D.56923>;
  <D.56922>:
  code.9641 = code;
  code = code.9641 + 1;
  *code.9641 = 92;
  code.9642 = code;
  code = code.9642 + 1;
  *code.9642 = 36;
  D.56901 = inst->data.op[0].const_val;
  D.56926 = (unsigned char) D.56901;
  *code = D.56926;
  code = code + 1;
  goto <D.56927>;
  <D.56923>:
  code.9643 = code;
  code = code.9643 + 1;
  *code.9643 = 156;
  code.9644 = code;
  code = code.9644 + 1;
  *code.9644 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.56901 = inst->data.op[0].const_val;
        D.56902 = (int) D.56901;
        imb.val = D.56902;
        code.9645 = code;
        code = code.9645 + 1;
        D.56931 = imb.b[0];
        *code.9645 = D.56931;
        code.9646 = code;
        code = code.9646 + 1;
        D.56933 = imb.b[1];
        *code.9646 = D.56933;
        code.9647 = code;
        code = code.9647 + 1;
        D.56935 = imb.b[2];
        *code.9647 = D.56935;
        code.9648 = code;
        code = code.9648 + 1;
        D.56937 = imb.b[3];
        *code.9648 = D.56937;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56927>:
  <D.56919>:
  goto <D.28639>;
  <D.56914>:
  D.56901 = inst->data.op[0].const_val;
  if (D.56901 == 0) goto <D.56938>; else goto <D.56939>;
  <D.56938>:
  D.56888 = inst->sreg1;
  D.56912 = D.56888 & 7;
  if (D.56912 != 5) goto <D.56940>; else goto <D.56941>;
  <D.56940>:
  code.9649 = code;
  code = code.9649 + 1;
  D.56888 = inst->sreg1;
  D.56943 = (signed char) D.56888;
  D.56944 = D.56943 & 7;
  D.56945 = D.56944 | 24;
  D.56946 = (unsigned char) D.56945;
  *code.9649 = D.56946;
  goto <D.28639>;
  <D.56941>:
  <D.56939>:
  D.56901 = inst->data.op[0].const_val;
  D.56920 = (unsigned int) D.56901;
  D.56921 = D.56920 + 128;
  if (D.56921 <= 255) goto <D.56947>; else goto <D.56948>;
  <D.56947>:
  code.9650 = code;
  code = code.9650 + 1;
  D.56888 = inst->sreg1;
  D.56943 = (signed char) D.56888;
  D.56944 = D.56943 & 7;
  D.56950 = D.56944 | 88;
  D.56951 = (unsigned char) D.56950;
  *code.9650 = D.56951;
  D.56901 = inst->data.op[0].const_val;
  D.56926 = (unsigned char) D.56901;
  *code = D.56926;
  code = code + 1;
  goto <D.56952>;
  <D.56948>:
  code.9651 = code;
  code = code.9651 + 1;
  D.56888 = inst->sreg1;
  D.56943 = (signed char) D.56888;
  D.56944 = D.56943 & 7;
  D.56954 = D.56944 | -104;
  D.56955 = (unsigned char) D.56954;
  *code.9651 = D.56955;
  {
    union x86_imm_buf imb;

    try
      {
        D.56901 = inst->data.op[0].const_val;
        D.56902 = (int) D.56901;
        imb.val = D.56902;
        code.9652 = code;
        code = code.9652 + 1;
        D.56957 = imb.b[0];
        *code.9652 = D.56957;
        code.9653 = code;
        code = code.9653 + 1;
        D.56959 = imb.b[1];
        *code.9653 = D.56959;
        code.9654 = code;
        code = code.9654 + 1;
        D.56961 = imb.b[2];
        *code.9654 = D.56961;
        code.9655 = code;
        code = code.9655 + 1;
        D.56963 = imb.b[3];
        *code.9655 = D.56963;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56952>:
  <D.28639>:
  <D.56911>:
  if (0 != 0) goto <D.56964>; else goto <D.56965>;
  <D.56964>:
  code.9656 = code;
  code = code.9656 + 1;
  *code.9656 = 102;
  <D.56965>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 12;
    if (_amd64_rex_bits != 0) goto <D.56967>; else goto <D.56968>;
    <D.56967>:
    code.9657 = code;
    code = code.9657 + 1;
    D.56970 = _amd64_rex_bits | 64;
    *code.9657 = D.56970;
    <D.56968>:
  }
  switch (8) <default: <D.28647>, case 1: <D.28642>, case 2: <D.28644>, case 4: <D.28645>, case 8: <D.28646>>
  <D.28642>:
  code.9658 = code;
  code = code.9658 + 1;
  *code.9658 = 136;
  goto <D.28643>;
  <D.28644>:
  <D.28645>:
  <D.28646>:
  code.9659 = code;
  code = code.9659 + 1;
  *code.9659 = 137;
  goto <D.28643>;
  <D.28647>:
  __assert_fail ("0", "mini-amd64.c", 7602, &__PRETTY_FUNCTION__);
  <D.28643>:
  if (1 != 0) goto <D.56973>; else goto <D.56974>;
  <D.56973>:
  if (i == 0) goto <D.56975>; else goto <D.56976>;
  <D.56975>:
  code.9660 = code;
  code = code.9660 + 1;
  *code.9660 = 28;
  code.9661 = code;
  code = code.9661 + 1;
  *code.9661 = 36;
  goto <D.56979>;
  <D.56976>:
  D.56843 = i * 8;
  D.56844 = (unsigned int) D.56843;
  D.56845 = D.56844 + 128;
  if (D.56845 <= 255) goto <D.56980>; else goto <D.56981>;
  <D.56980>:
  code.9662 = code;
  code = code.9662 + 1;
  *code.9662 = 92;
  code.9663 = code;
  code = code.9663 + 1;
  *code.9663 = 36;
  D.56852 = (unsigned char) i;
  D.56853 = D.56852 * 8;
  *code = D.56853;
  code = code + 1;
  goto <D.56984>;
  <D.56981>:
  code.9664 = code;
  code = code.9664 + 1;
  *code.9664 = 156;
  code.9665 = code;
  code = code.9665 + 1;
  *code.9665 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        D.56843 = i * 8;
        imb.val = D.56843;
        code.9666 = code;
        code = code.9666 + 1;
        D.56988 = imb.b[0];
        *code.9666 = D.56988;
        code.9667 = code;
        code = code.9667 + 1;
        D.56990 = imb.b[1];
        *code.9667 = D.56990;
        code.9668 = code;
        code = code.9668 + 1;
        D.56992 = imb.b[2];
        *code.9668 = D.56992;
        code.9669 = code;
        code = code.9669 + 1;
        D.56994 = imb.b[3];
        *code.9669 = D.56994;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.56984>:
  <D.56979>:
  goto <D.28649>;
  <D.56974>:
  if (i == 0) goto <D.56995>; else goto <D.56996>;
  <D.56995>:
  code.9670 = code;
  code = code.9670 + 1;
  *code.9670 = 28;
  goto <D.28649>;
  <D.56996>:
  D.56843 = i * 8;
  D.56844 = (unsigned int) D.56843;
  D.56845 = D.56844 + 128;
  if (D.56845 <= 255) goto <D.56998>; else goto <D.56999>;
  <D.56998>:
  code.9671 = code;
  code = code.9671 + 1;
  *code.9671 = 92;
  D.56852 = (unsigned char) i;
  D.56853 = D.56852 * 8;
  *code = D.56853;
  code = code + 1;
  goto <D.57001>;
  <D.56999>:
  code.9672 = code;
  code = code.9672 + 1;
  *code.9672 = 156;
  {
    union x86_imm_buf imb;

    try
      {
        D.56843 = i * 8;
        imb.val = D.56843;
        code.9673 = code;
        code = code.9673 + 1;
        D.57004 = imb.b[0];
        *code.9673 = D.57004;
        code.9674 = code;
        code = code.9674 + 1;
        D.57006 = imb.b[1];
        *code.9674 = D.57006;
        code.9675 = code;
        code = code.9675 + 1;
        D.57008 = imb.b[2];
        *code.9675 = D.57008;
        code.9676 = code;
        code = code.9676 + 1;
        D.57010 = imb.b[3];
        *code.9676 = D.57010;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57001>:
  <D.28649>:
  <D.56883>:
  i = i + 1;
  <D.28652>:
  if (i < n) goto <D.28651>; else goto <D.28653>;
  <D.28653>:
  <D.56755>:
  D.56756 = cfg->method;
  code.9677 = (long int) code;
  D.57012 = cfg->native_code;
  D.57013 = (long int) D.57012;
  D.57014 = code.9677 - D.57013;
  D.57015 = (int) D.57014;
  mono_add_patch_info (cfg, D.57015, 6, D.56756);
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57016>; else goto <D.57017>;
    <D.57016>:
    code.9678 = code;
    code = code.9678 + 1;
    D.57019 = _amd64_rex_bits | 64;
    *code.9678 = D.57019;
    <D.57017>:
  }
  code.9679 = code;
  code = code.9679 + 1;
  *code.9679 = 191;
  if (1 != 0) goto <D.57021>; else goto <D.57022>;
  <D.57021>:
  {
    union amd64_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9680 = code;
        code = code.9680 + 1;
        D.57024 = imb.b[0];
        *code.9680 = D.57024;
        code.9681 = code;
        code = code.9681 + 1;
        D.57026 = imb.b[1];
        *code.9681 = D.57026;
        code.9682 = code;
        code = code.9682 + 1;
        D.57028 = imb.b[2];
        *code.9682 = D.57028;
        code.9683 = code;
        code = code.9683 + 1;
        D.57030 = imb.b[3];
        *code.9683 = D.57030;
        code.9684 = code;
        code = code.9684 + 1;
        D.57032 = imb.b[4];
        *code.9684 = D.57032;
        code.9685 = code;
        code = code.9685 + 1;
        D.57034 = imb.b[5];
        *code.9685 = D.57034;
        code.9686 = code;
        code = code.9686 + 1;
        D.57036 = imb.b[6];
        *code.9686 = D.57036;
        code.9687 = code;
        code = code.9687 + 1;
        D.57038 = imb.b[7];
        *code.9687 = D.57038;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57039>;
  <D.57022>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9688 = code;
        code = code.9688 + 1;
        D.57041 = imb.b[0];
        *code.9688 = D.57041;
        code.9689 = code;
        code = code.9689 + 1;
        D.57043 = imb.b[1];
        *code.9689 = D.57043;
        code.9690 = code;
        code = code.9690 + 1;
        D.57045 = imb.b[2];
        *code.9690 = D.57045;
        code.9691 = code;
        code = code.9691 + 1;
        D.57047 = imb.b[3];
        *code.9691 = D.57047;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57039>:
  if (0 != 0) goto <D.57048>; else goto <D.57049>;
  <D.57048>:
  code.9692 = code;
  code = code.9692 + 1;
  *code.9692 = 102;
  <D.57049>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57051>; else goto <D.57052>;
    <D.57051>:
    code.9693 = code;
    code = code.9693 + 1;
    D.57054 = _amd64_rex_bits | 64;
    *code.9693 = D.57054;
    <D.57052>:
  }
  switch (8) <default: <D.28663>, case 1: <D.28658>, case 2: <D.28660>, case 4: <D.28661>, case 8: <D.28662>>
  <D.28658>:
  code.9694 = code;
  code = code.9694 + 1;
  *code.9694 = 138;
  goto <D.28659>;
  <D.28660>:
  <D.28661>:
  <D.28662>:
  code.9695 = code;
  code = code.9695 + 1;
  *code.9695 = 139;
  goto <D.28659>;
  <D.28663>:
  __assert_fail ("0", "mini-amd64.c", 7609, &__PRETTY_FUNCTION__);
  <D.28659>:
  code.9696 = code;
  code = code.9696 + 1;
  *code.9696 = 244;
  code = emit_call (cfg, code, 1, func, 1);
  if (enable_arguments != 0) goto <D.57058>; else goto <D.57059>;
  <D.57058>:
  stack_area.9590 = (unsigned int) stack_area;
  D.56769 = stack_area.9590 + 128;
  if (D.56769 <= 255) goto <D.57060>; else goto <D.57061>;
  <D.57060>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57062>; else goto <D.57063>;
    <D.57062>:
    code.9697 = code;
    code = code.9697 + 1;
    D.57065 = _amd64_rex_bits | 64;
    *code.9697 = D.57065;
    <D.57063>:
  }
  code.9698 = code;
  code = code.9698 + 1;
  *code.9698 = 131;
  code.9699 = code;
  code = code.9699 + 1;
  *code.9699 = 196;
  D.56778 = (unsigned char) stack_area;
  *code = D.56778;
  code = code + 1;
  goto <D.57068>;
  <D.57061>:
  if (0 != 0) goto <D.57069>; else goto <D.57070>;
  <D.57069>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57071>; else goto <D.57072>;
    <D.57071>:
    code.9700 = code;
    code = code.9700 + 1;
    D.57074 = _amd64_rex_bits | 64;
    *code.9700 = D.57074;
    <D.57072>:
  }
  code.9701 = code;
  code = code.9701 + 1;
  *code.9701 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = stack_area;
        code.9702 = code;
        code = code.9702 + 1;
        D.57077 = imb.b[0];
        *code.9702 = D.57077;
        code.9703 = code;
        code = code.9703 + 1;
        D.57079 = imb.b[1];
        *code.9703 = D.57079;
        code.9704 = code;
        code = code.9704 + 1;
        D.57081 = imb.b[2];
        *code.9704 = D.57081;
        code.9705 = code;
        code = code.9705 + 1;
        D.57083 = imb.b[3];
        *code.9705 = D.57083;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57084>;
  <D.57070>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57085>; else goto <D.57086>;
    <D.57085>:
    code.9706 = code;
    code = code.9706 + 1;
    D.57088 = _amd64_rex_bits | 64;
    *code.9706 = D.57088;
    <D.57086>:
  }
  code.9707 = code;
  code = code.9707 + 1;
  *code.9707 = 129;
  code.9708 = code;
  code = code.9708 + 1;
  *code.9708 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = stack_area;
        code.9709 = code;
        code = code.9709 + 1;
        D.57092 = imb.b[0];
        *code.9709 = D.57092;
        code.9710 = code;
        code = code.9710 + 1;
        D.57094 = imb.b[1];
        *code.9710 = D.57094;
        code.9711 = code;
        code = code.9711 + 1;
        D.57096 = imb.b[2];
        *code.9711 = D.57096;
        code.9712 = code;
        code = code.9712 + 1;
        D.57098 = imb.b[3];
        *code.9712 = D.57098;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57084>:
  <D.57068>:
  <D.57059>:
  D.57099 = code;
  return D.57099;
}


mono_arch_instrument_epilog_full (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments, gboolean preserve_argument_registers)
{
  struct MonoMethodSignature * D.57101;
  struct MonoType * D.57102;
  unsigned char D.57103;
  int D.57104;
  int D.28696;
  int iftmp.9713;
  int D.28692;
  const char[6] * D.57110;
  unsigned char D.57111;
  int D.57112;
  unsigned char D.57113;
  int D.57114;
  _Bool D.57115;
  _Bool D.57116;
  _Bool D.57117;
  const unsigned char * D.57120;
  unsigned char D.57121;
  int D.57122;
  const unsigned char * D.57123;
  unsigned char D.57124;
  int D.57125;
  _Bool D.57126;
  _Bool D.57127;
  const unsigned char * D.57130;
  unsigned char D.57131;
  int D.57132;
  const unsigned char * D.57133;
  unsigned char D.57134;
  int D.57135;
  _Bool D.57136;
  _Bool D.57137;
  const unsigned char * D.57140;
  unsigned char D.57141;
  int D.57142;
  const unsigned char * D.57143;
  unsigned char D.57144;
  int D.57145;
  const char * D.57147;
  struct MonoClass * D.57149;
  struct MonoClass * D.57150;
  int D.57152;
  guchar * code.9714;
  unsigned char D.57158;
  guchar * code.9715;
  guchar * code.9716;
  unsigned char D.57165;
  guchar * code.9717;
  guchar * code.9718;
  guchar * code.9719;
  unsigned char D.57174;
  guchar * code.9720;
  guchar * code.9721;
  unsigned char D.57177;
  guchar * code.9722;
  unsigned char D.57179;
  guchar * code.9723;
  unsigned char D.57181;
  guchar * code.9724;
  unsigned char D.57183;
  guchar * code.9725;
  unsigned char D.57188;
  guchar * code.9726;
  guchar * code.9727;
  guchar * code.9728;
  unsigned char D.57192;
  guchar * code.9729;
  unsigned char D.57194;
  guchar * code.9730;
  unsigned char D.57196;
  guchar * code.9731;
  unsigned char D.57198;
  guchar * code.9732;
  guchar * code.9733;
  unsigned char D.57207;
  guchar * code.9734;
  guchar * code.9735;
  guchar * code.9736;
  unsigned char iftmp.9737;
  guchar * code.9738;
  unsigned char D.57220;
  guchar * code.9739;
  guchar * code.9740;
  unsigned char D.57225;
  guchar * code.9741;
  unsigned char D.57227;
  guchar * code.9742;
  unsigned char D.57229;
  guchar * code.9743;
  unsigned char D.57231;
  guchar * code.9744;
  unsigned char D.57233;
  guchar * code.9745;
  unsigned char D.57235;
  guchar * code.9746;
  unsigned char D.57237;
  guchar * code.9747;
  unsigned char D.57239;
  guchar * code.9748;
  unsigned char D.57242;
  guchar * code.9749;
  unsigned char D.57244;
  guchar * code.9750;
  unsigned char D.57246;
  guchar * code.9751;
  unsigned char D.57248;
  guchar * code.9752;
  unsigned char D.57254;
  guchar * code.9753;
  guchar * code.9754;
  guchar * code.9755;
  unsigned char D.57263;
  guchar * code.9756;
  guchar * code.9757;
  unsigned char D.57266;
  guchar * code.9758;
  unsigned char D.57268;
  guchar * code.9759;
  unsigned char D.57270;
  guchar * code.9760;
  unsigned char D.57272;
  guchar * code.9761;
  unsigned char D.57277;
  guchar * code.9762;
  guchar * code.9763;
  guchar * code.9764;
  unsigned char D.57281;
  guchar * code.9765;
  unsigned char D.57283;
  guchar * code.9766;
  unsigned char D.57285;
  guchar * code.9767;
  unsigned char D.57287;
  guchar * code.9768;
  guchar * code.9769;
  unsigned char D.57292;
  guchar * code.9770;
  guchar * code.9771;
  guchar * code.9772;
  guchar * code.9773;
  guchar * code.9774;
  guchar * code.9775;
  guchar * code.9776;
  guchar * code.9777;
  guchar * code.9778;
  unsigned char D.57310;
  guchar * code.9779;
  unsigned char D.57312;
  guchar * code.9780;
  unsigned char D.57314;
  guchar * code.9781;
  unsigned char D.57316;
  guchar * code.9782;
  guchar * code.9783;
  guchar * code.9784;
  guchar * code.9785;
  unsigned char D.57326;
  guchar * code.9786;
  unsigned char D.57328;
  guchar * code.9787;
  unsigned char D.57330;
  guchar * code.9788;
  unsigned char D.57332;
  guchar * code.9789;
  unsigned char D.57338;
  guchar * code.9790;
  guchar * code.9791;
  guchar * code.9792;
  unsigned char D.57347;
  guchar * code.9793;
  guchar * code.9794;
  unsigned char D.57350;
  guchar * code.9795;
  unsigned char D.57352;
  guchar * code.9796;
  unsigned char D.57354;
  guchar * code.9797;
  unsigned char D.57356;
  guchar * code.9798;
  unsigned char D.57361;
  guchar * code.9799;
  guchar * code.9800;
  guchar * code.9801;
  unsigned char D.57365;
  guchar * code.9802;
  unsigned char D.57367;
  guchar * code.9803;
  unsigned char D.57369;
  guchar * code.9804;
  unsigned char D.57371;
  unsigned char iftmp.9805;
  guchar * code.9806;
  unsigned char D.57381;
  guchar * code.9807;
  guchar * code.9808;
  unsigned char D.57386;
  guchar * code.9809;
  unsigned char D.57388;
  guchar * code.9810;
  unsigned char D.57390;
  guchar * code.9811;
  unsigned char D.57392;
  guchar * code.9812;
  unsigned char D.57394;
  guchar * code.9813;
  unsigned char D.57396;
  guchar * code.9814;
  unsigned char D.57398;
  guchar * code.9815;
  unsigned char D.57400;
  guchar * code.9816;
  unsigned char D.57403;
  guchar * code.9817;
  unsigned char D.57405;
  guchar * code.9818;
  unsigned char D.57407;
  guchar * code.9819;
  unsigned char D.57409;
  unsigned char iftmp.9820;
  guchar * code.9821;
  unsigned char D.57418;
  guchar * code.9822;
  guchar * code.9823;
  unsigned char D.57423;
  guchar * code.9824;
  unsigned char D.57425;
  guchar * code.9825;
  unsigned char D.57427;
  guchar * code.9826;
  unsigned char D.57429;
  guchar * code.9827;
  unsigned char D.57431;
  guchar * code.9828;
  unsigned char D.57433;
  guchar * code.9829;
  unsigned char D.57435;
  guchar * code.9830;
  unsigned char D.57437;
  guchar * code.9831;
  unsigned char D.57440;
  guchar * code.9832;
  unsigned char D.57442;
  guchar * code.9833;
  unsigned char D.57444;
  guchar * code.9834;
  unsigned char D.57446;
  <unnamed type> D.57449;
  _Bool D.57450;
  guchar * code.9835;
  unsigned char D.57454;
  guchar * code.9836;
  unsigned char D.57456;
  unsigned char D.57457;
  unsigned char D.57458;
  long int code.9837;
  unsigned char * D.57460;
  long int D.57461;
  long int D.57462;
  int D.57463;
  guchar * code.9838;
  unsigned char D.57467;
  guchar * code.9839;
  guchar * code.9840;
  unsigned char D.57472;
  guchar * code.9841;
  unsigned char D.57474;
  guchar * code.9842;
  unsigned char D.57476;
  guchar * code.9843;
  unsigned char D.57478;
  guchar * code.9844;
  unsigned char D.57480;
  guchar * code.9845;
  unsigned char D.57482;
  guchar * code.9846;
  unsigned char D.57484;
  guchar * code.9847;
  unsigned char D.57486;
  guchar * code.9848;
  unsigned char D.57489;
  guchar * code.9849;
  unsigned char D.57491;
  guchar * code.9850;
  unsigned char D.57493;
  guchar * code.9851;
  unsigned char D.57495;
  guchar * code.9852;
  unsigned char D.57501;
  guchar * code.9853;
  unsigned char D.57503;
  guchar * code.9854;
  unsigned char D.57509;
  guchar * code.9855;
  guchar * code.9856;
  guchar * code.9857;
  unsigned char D.57518;
  guchar * code.9858;
  guchar * code.9859;
  unsigned char D.57521;
  guchar * code.9860;
  unsigned char D.57523;
  guchar * code.9861;
  unsigned char D.57525;
  guchar * code.9862;
  unsigned char D.57527;
  guchar * code.9863;
  unsigned char D.57532;
  guchar * code.9864;
  guchar * code.9865;
  guchar * code.9866;
  unsigned char D.57536;
  guchar * code.9867;
  unsigned char D.57538;
  guchar * code.9868;
  unsigned char D.57540;
  guchar * code.9869;
  unsigned char D.57542;
  guchar * code.9870;
  unsigned char D.57546;
  guchar * code.9871;
  guchar * code.9872;
  unsigned char D.57553;
  guchar * code.9873;
  guchar * code.9874;
  guchar * code.9875;
  unsigned char D.57562;
  guchar * code.9876;
  guchar * code.9877;
  unsigned char D.57565;
  guchar * code.9878;
  unsigned char D.57567;
  guchar * code.9879;
  unsigned char D.57569;
  guchar * code.9880;
  unsigned char D.57571;
  guchar * code.9881;
  unsigned char D.57576;
  guchar * code.9882;
  guchar * code.9883;
  guchar * code.9884;
  unsigned char D.57580;
  guchar * code.9885;
  unsigned char D.57582;
  guchar * code.9886;
  unsigned char D.57584;
  guchar * code.9887;
  unsigned char D.57586;
  guchar * code.9888;
  guchar * code.9889;
  unsigned char D.57591;
  guchar * code.9890;
  guchar * code.9891;
  guchar * code.9892;
  guchar * code.9893;
  guchar * code.9894;
  guchar * code.9895;
  guchar * code.9896;
  guchar * code.9897;
  guchar * code.9898;
  unsigned char D.57609;
  guchar * code.9899;
  unsigned char D.57611;
  guchar * code.9900;
  unsigned char D.57613;
  guchar * code.9901;
  unsigned char D.57615;
  guchar * code.9902;
  guchar * code.9903;
  guchar * code.9904;
  guchar * code.9905;
  unsigned char D.57625;
  guchar * code.9906;
  unsigned char D.57627;
  guchar * code.9907;
  unsigned char D.57629;
  guchar * code.9908;
  unsigned char D.57631;
  guchar * code.9909;
  unsigned char D.57637;
  guchar * code.9910;
  guchar * code.9911;
  guchar * code.9912;
  unsigned char D.57646;
  guchar * code.9913;
  guchar * code.9914;
  unsigned char D.57649;
  guchar * code.9915;
  unsigned char D.57651;
  guchar * code.9916;
  unsigned char D.57653;
  guchar * code.9917;
  unsigned char D.57655;
  guchar * code.9918;
  unsigned char D.57660;
  guchar * code.9919;
  guchar * code.9920;
  guchar * code.9921;
  unsigned char D.57664;
  guchar * code.9922;
  unsigned char D.57666;
  guchar * code.9923;
  unsigned char D.57668;
  guchar * code.9924;
  unsigned char D.57670;
  void * D.57671;
  guchar * code;
  int save_mode;
  struct MonoMethod * method;
  struct MonoType * ret_type;
  int i;
  static const char __PRETTY_FUNCTION__[33] = "mono_arch_instrument_epilog_full";

  code = p;
  save_mode = 0;
  method = cfg->method;
  D.57101 = mono_method_signature (method);
  D.57102 = D.57101->ret;
  ret_type = mini_replace_type (D.57102);
  D.57103 = ret_type->type;
  D.57104 = (int) D.57103;
  switch (D.57104) <default: <D.28704>, case 1: <D.28687>, case 10: <D.28698>, case 11: <D.28699>, case 12: <D.28700>, case 13: <D.28701>, case 17: <D.28703>, case 21: <D.28702>>
  <D.28687>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.57110 = ".ctor";
      D.57111 = MEM[(const unsigned char *)D.57110];
      D.57112 = (int) D.57111;
      D.57113 = *__s2;
      D.57114 = (int) D.57113;
      __result = D.57112 - D.57114;
      {
        D.57115 = __s1_len != 0;
        D.57116 = __result == 0;
        D.57117 = D.57115 & D.57116;
        if (D.57117 != 0) goto <D.57118>; else goto <D.57119>;
        <D.57118>:
        D.57120 = &MEM[(void *)".ctor" + 1B];
        D.57121 = *D.57120;
        D.57122 = (int) D.57121;
        D.57123 = __s2 + 1;
        D.57124 = *D.57123;
        D.57125 = (int) D.57124;
        __result = D.57122 - D.57125;
        D.57126 = __s1_len > 1;
        D.57116 = __result == 0;
        D.57127 = D.57126 & D.57116;
        if (D.57127 != 0) goto <D.57128>; else goto <D.57129>;
        <D.57128>:
        D.57130 = &MEM[(void *)".ctor" + 2B];
        D.57131 = *D.57130;
        D.57132 = (int) D.57131;
        D.57133 = __s2 + 2;
        D.57134 = *D.57133;
        D.57135 = (int) D.57134;
        __result = D.57132 - D.57135;
        D.57136 = __s1_len > 2;
        D.57116 = __result == 0;
        D.57137 = D.57136 & D.57116;
        if (D.57137 != 0) goto <D.57138>; else goto <D.57139>;
        <D.57138>:
        D.57140 = &MEM[(void *)".ctor" + 3B];
        D.57141 = *D.57140;
        D.57142 = (int) D.57141;
        D.57143 = __s2 + 3;
        D.57144 = *D.57143;
        D.57145 = (int) D.57144;
        __result = D.57142 - D.57145;
        <D.57139>:
        <D.57129>:
        <D.57119>:
      }
      D.28692 = __result;
    }
    iftmp.9713 = D.28692;
    goto <D.57146>;
    <D.57109>:
    D.57147 = method->name;
    iftmp.9713 = __builtin_strcmp (".ctor", D.57147);
    <D.57146>:
    D.28696 = iftmp.9713;
  }
  if (D.28696 != 0) goto <D.57148>; else goto <D.57105>;
  <D.57148>:
  D.57149 = method->klass;
  D.57150 = mono_defaults.string_class;
  if (D.57149 == D.57150) goto <D.57151>; else goto <D.57105>;
  <D.57151>:
  save_mode = 2;
  goto <D.57106>;
  <D.57105>:
  save_mode = 0;
  <D.57106>:
  goto <D.28697>;
  <D.28698>:
  <D.28699>:
  save_mode = 2;
  goto <D.28697>;
  <D.28700>:
  <D.28701>:
  save_mode = 4;
  goto <D.28697>;
  <D.28702>:
  D.57152 = mono_type_generic_inst_is_valuetype (ret_type);
  if (D.57152 == 0) goto <D.57153>; else goto <D.57154>;
  <D.57153>:
  save_mode = 2;
  goto <D.28697>;
  <D.57154>:
  <D.28703>:
  save_mode = 1;
  goto <D.28697>;
  <D.28704>:
  save_mode = 2;
  goto <D.28697>;
  <D.28697>:
  switch (save_mode) <default: <D.28742>, case 0: <D.28741>, case 1: <D.28721>, case 2: <D.28705>, case 4: <D.28726>>
  <D.28705>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.57155>; else goto <D.57156>;
    <D.57155>:
    code.9714 = code;
    code = code.9714 + 1;
    D.57158 = _amd64_rex_bits | 64;
    *code.9714 = D.57158;
    <D.57156>:
  }
  code.9715 = code;
  code = code.9715 + 1;
  *code.9715 = 80;
  if (1 != 0) goto <D.57160>; else goto <D.57161>;
  <D.57160>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57162>; else goto <D.57163>;
    <D.57162>:
    code.9716 = code;
    code = code.9716 + 1;
    D.57165 = _amd64_rex_bits | 64;
    *code.9716 = D.57165;
    <D.57163>:
  }
  code.9717 = code;
  code = code.9717 + 1;
  *code.9717 = 131;
  code.9718 = code;
  code = code.9718 + 1;
  *code.9718 = 236;
  *code = 8;
  code = code + 1;
  goto <D.57168>;
  <D.57161>:
  if (0 != 0) goto <D.57169>; else goto <D.57170>;
  <D.57169>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57171>; else goto <D.57172>;
    <D.57171>:
    code.9719 = code;
    code = code.9719 + 1;
    D.57174 = _amd64_rex_bits | 64;
    *code.9719 = D.57174;
    <D.57172>:
  }
  code.9720 = code;
  code = code.9720 + 1;
  *code.9720 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9721 = code;
        code = code.9721 + 1;
        D.57177 = imb.b[0];
        *code.9721 = D.57177;
        code.9722 = code;
        code = code.9722 + 1;
        D.57179 = imb.b[1];
        *code.9722 = D.57179;
        code.9723 = code;
        code = code.9723 + 1;
        D.57181 = imb.b[2];
        *code.9723 = D.57181;
        code.9724 = code;
        code = code.9724 + 1;
        D.57183 = imb.b[3];
        *code.9724 = D.57183;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57184>;
  <D.57170>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57185>; else goto <D.57186>;
    <D.57185>:
    code.9725 = code;
    code = code.9725 + 1;
    D.57188 = _amd64_rex_bits | 64;
    *code.9725 = D.57188;
    <D.57186>:
  }
  code.9726 = code;
  code = code.9726 + 1;
  *code.9726 = 129;
  code.9727 = code;
  code = code.9727 + 1;
  *code.9727 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9728 = code;
        code = code.9728 + 1;
        D.57192 = imb.b[0];
        *code.9728 = D.57192;
        code.9729 = code;
        code = code.9729 + 1;
        D.57194 = imb.b[1];
        *code.9729 = D.57194;
        code.9730 = code;
        code = code.9730 + 1;
        D.57196 = imb.b[2];
        *code.9730 = D.57196;
        code.9731 = code;
        code = code.9731 + 1;
        D.57198 = imb.b[3];
        *code.9731 = D.57198;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57184>:
  <D.57168>:
  if (enable_arguments != 0) goto <D.57199>; else goto <D.57200>;
  <D.57199>:
  if (0 != 0) goto <D.57201>; else goto <D.57202>;
  <D.57201>:
  code.9732 = code;
  code = code.9732 + 1;
  *code.9732 = 102;
  <D.57202>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57204>; else goto <D.57205>;
    <D.57204>:
    code.9733 = code;
    code = code.9733 + 1;
    D.57207 = _amd64_rex_bits | 64;
    *code.9733 = D.57207;
    <D.57205>:
  }
  switch (8) <default: <D.28718>, case 1: <D.28713>, case 2: <D.28715>, case 4: <D.28716>, case 8: <D.28717>>
  <D.28713>:
  code.9734 = code;
  code = code.9734 + 1;
  *code.9734 = 138;
  goto <D.28714>;
  <D.28715>:
  <D.28716>:
  <D.28717>:
  code.9735 = code;
  code = code.9735 + 1;
  *code.9735 = 139;
  goto <D.28714>;
  <D.28718>:
  __assert_fail ("0", "mini-amd64.c", 7672, &__PRETTY_FUNCTION__);
  <D.28714>:
  code.9736 = code;
  code = code.9736 + 1;
  *code.9736 = 240;
  <D.57200>:
  goto <D.28720>;
  <D.28721>:
  if (enable_arguments != 0) goto <D.57211>; else goto <D.57212>;
  <D.57211>:
  {
    int _amd64_width_temp;

    _amd64_width_temp = 1;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.57214>; else goto <D.57215>;
      <D.57214>:
      iftmp.9737 = 8;
      goto <D.57216>;
      <D.57215>:
      iftmp.9737 = 0;
      <D.57216>:
      _amd64_rex_bits = iftmp.9737;
      if (_amd64_rex_bits != 0) goto <D.57217>; else goto <D.57218>;
      <D.57217>:
      code.9738 = code;
      code = code.9738 + 1;
      D.57220 = _amd64_rex_bits | 64;
      *code.9738 = D.57220;
      <D.57218>:
    }
    code.9739 = code;
    code = code.9739 + 1;
    *code.9739 = 190;
    if (_amd64_width_temp == 0) goto <D.57222>; else goto <D.57223>;
    <D.57222>:
    {
      union amd64_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9740 = code;
          code = code.9740 + 1;
          D.57225 = imb.b[0];
          *code.9740 = D.57225;
          code.9741 = code;
          code = code.9741 + 1;
          D.57227 = imb.b[1];
          *code.9741 = D.57227;
          code.9742 = code;
          code = code.9742 + 1;
          D.57229 = imb.b[2];
          *code.9742 = D.57229;
          code.9743 = code;
          code = code.9743 + 1;
          D.57231 = imb.b[3];
          *code.9743 = D.57231;
          code.9744 = code;
          code = code.9744 + 1;
          D.57233 = imb.b[4];
          *code.9744 = D.57233;
          code.9745 = code;
          code = code.9745 + 1;
          D.57235 = imb.b[5];
          *code.9745 = D.57235;
          code.9746 = code;
          code = code.9746 + 1;
          D.57237 = imb.b[6];
          *code.9746 = D.57237;
          code.9747 = code;
          code = code.9747 + 1;
          D.57239 = imb.b[7];
          *code.9747 = D.57239;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.57240>;
    <D.57223>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9748 = code;
          code = code.9748 + 1;
          D.57242 = imb.b[0];
          *code.9748 = D.57242;
          code.9749 = code;
          code = code.9749 + 1;
          D.57244 = imb.b[1];
          *code.9749 = D.57244;
          code.9750 = code;
          code = code.9750 + 1;
          D.57246 = imb.b[2];
          *code.9750 = D.57246;
          code.9751 = code;
          code = code.9751 + 1;
          D.57248 = imb.b[3];
          *code.9751 = D.57248;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.57240>:
  }
  <D.57212>:
  goto <D.28720>;
  <D.28726>:
  if (1 != 0) goto <D.57249>; else goto <D.57250>;
  <D.57249>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57251>; else goto <D.57252>;
    <D.57251>:
    code.9752 = code;
    code = code.9752 + 1;
    D.57254 = _amd64_rex_bits | 64;
    *code.9752 = D.57254;
    <D.57252>:
  }
  code.9753 = code;
  code = code.9753 + 1;
  *code.9753 = 131;
  code.9754 = code;
  code = code.9754 + 1;
  *code.9754 = 236;
  *code = 8;
  code = code + 1;
  goto <D.57257>;
  <D.57250>:
  if (0 != 0) goto <D.57258>; else goto <D.57259>;
  <D.57258>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57260>; else goto <D.57261>;
    <D.57260>:
    code.9755 = code;
    code = code.9755 + 1;
    D.57263 = _amd64_rex_bits | 64;
    *code.9755 = D.57263;
    <D.57261>:
  }
  code.9756 = code;
  code = code.9756 + 1;
  *code.9756 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9757 = code;
        code = code.9757 + 1;
        D.57266 = imb.b[0];
        *code.9757 = D.57266;
        code.9758 = code;
        code = code.9758 + 1;
        D.57268 = imb.b[1];
        *code.9758 = D.57268;
        code.9759 = code;
        code = code.9759 + 1;
        D.57270 = imb.b[2];
        *code.9759 = D.57270;
        code.9760 = code;
        code = code.9760 + 1;
        D.57272 = imb.b[3];
        *code.9760 = D.57272;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57273>;
  <D.57259>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57274>; else goto <D.57275>;
    <D.57274>:
    code.9761 = code;
    code = code.9761 + 1;
    D.57277 = _amd64_rex_bits | 64;
    *code.9761 = D.57277;
    <D.57275>:
  }
  code.9762 = code;
  code = code.9762 + 1;
  *code.9762 = 129;
  code.9763 = code;
  code = code.9763 + 1;
  *code.9763 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9764 = code;
        code = code.9764 + 1;
        D.57281 = imb.b[0];
        *code.9764 = D.57281;
        code.9765 = code;
        code = code.9765 + 1;
        D.57283 = imb.b[1];
        *code.9765 = D.57283;
        code.9766 = code;
        code = code.9766 + 1;
        D.57285 = imb.b[2];
        *code.9766 = D.57285;
        code.9767 = code;
        code = code.9767 + 1;
        D.57287 = imb.b[3];
        *code.9767 = D.57287;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57273>:
  <D.57257>:
  code.9768 = code;
  code = code.9768 + 1;
  *code.9768 = 242;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.57289>; else goto <D.57290>;
    <D.57289>:
    code.9769 = code;
    code = code.9769 + 1;
    D.57292 = _amd64_rex_bits | 64;
    *code.9769 = D.57292;
    <D.57290>:
  }
  code.9770 = code;
  code = code.9770 + 1;
  *code.9770 = 15;
  code.9771 = code;
  code = code.9771 + 1;
  *code.9771 = 17;
  if (1 != 0) goto <D.57295>; else goto <D.57296>;
  <D.57295>:
  if (1 != 0) goto <D.57297>; else goto <D.57298>;
  <D.57297>:
  code.9772 = code;
  code = code.9772 + 1;
  *code.9772 = 4;
  code.9773 = code;
  code = code.9773 + 1;
  *code.9773 = 36;
  goto <D.57301>;
  <D.57298>:
  if (1 != 0) goto <D.57302>; else goto <D.57303>;
  <D.57302>:
  code.9774 = code;
  code = code.9774 + 1;
  *code.9774 = 68;
  code.9775 = code;
  code = code.9775 + 1;
  *code.9775 = 36;
  *code = 0;
  code = code + 1;
  goto <D.57306>;
  <D.57303>:
  code.9776 = code;
  code = code.9776 + 1;
  *code.9776 = 132;
  code.9777 = code;
  code = code.9777 + 1;
  *code.9777 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9778 = code;
        code = code.9778 + 1;
        D.57310 = imb.b[0];
        *code.9778 = D.57310;
        code.9779 = code;
        code = code.9779 + 1;
        D.57312 = imb.b[1];
        *code.9779 = D.57312;
        code.9780 = code;
        code = code.9780 + 1;
        D.57314 = imb.b[2];
        *code.9780 = D.57314;
        code.9781 = code;
        code = code.9781 + 1;
        D.57316 = imb.b[3];
        *code.9781 = D.57316;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57306>:
  <D.57301>:
  goto <D.28734>;
  <D.57296>:
  if (1 != 0) goto <D.57317>; else goto <D.57318>;
  <D.57317>:
  code.9782 = code;
  code = code.9782 + 1;
  *code.9782 = 4;
  goto <D.28734>;
  <D.57318>:
  if (1 != 0) goto <D.57320>; else goto <D.57321>;
  <D.57320>:
  code.9783 = code;
  code = code.9783 + 1;
  *code.9783 = 68;
  *code = 0;
  code = code + 1;
  goto <D.57323>;
  <D.57321>:
  code.9784 = code;
  code = code.9784 + 1;
  *code.9784 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9785 = code;
        code = code.9785 + 1;
        D.57326 = imb.b[0];
        *code.9785 = D.57326;
        code.9786 = code;
        code = code.9786 + 1;
        D.57328 = imb.b[1];
        *code.9786 = D.57328;
        code.9787 = code;
        code = code.9787 + 1;
        D.57330 = imb.b[2];
        *code.9787 = D.57330;
        code.9788 = code;
        code = code.9788 + 1;
        D.57332 = imb.b[3];
        *code.9788 = D.57332;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57323>:
  <D.28734>:
  if (1 != 0) goto <D.57333>; else goto <D.57334>;
  <D.57333>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57335>; else goto <D.57336>;
    <D.57335>:
    code.9789 = code;
    code = code.9789 + 1;
    D.57338 = _amd64_rex_bits | 64;
    *code.9789 = D.57338;
    <D.57336>:
  }
  code.9790 = code;
  code = code.9790 + 1;
  *code.9790 = 131;
  code.9791 = code;
  code = code.9791 + 1;
  *code.9791 = 236;
  *code = 8;
  code = code + 1;
  goto <D.57341>;
  <D.57334>:
  if (0 != 0) goto <D.57342>; else goto <D.57343>;
  <D.57342>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57344>; else goto <D.57345>;
    <D.57344>:
    code.9792 = code;
    code = code.9792 + 1;
    D.57347 = _amd64_rex_bits | 64;
    *code.9792 = D.57347;
    <D.57345>:
  }
  code.9793 = code;
  code = code.9793 + 1;
  *code.9793 = 45;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9794 = code;
        code = code.9794 + 1;
        D.57350 = imb.b[0];
        *code.9794 = D.57350;
        code.9795 = code;
        code = code.9795 + 1;
        D.57352 = imb.b[1];
        *code.9795 = D.57352;
        code.9796 = code;
        code = code.9796 + 1;
        D.57354 = imb.b[2];
        *code.9796 = D.57354;
        code.9797 = code;
        code = code.9797 + 1;
        D.57356 = imb.b[3];
        *code.9797 = D.57356;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57357>;
  <D.57343>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57358>; else goto <D.57359>;
    <D.57358>:
    code.9798 = code;
    code = code.9798 + 1;
    D.57361 = _amd64_rex_bits | 64;
    *code.9798 = D.57361;
    <D.57359>:
  }
  code.9799 = code;
  code = code.9799 + 1;
  *code.9799 = 129;
  code.9800 = code;
  code = code.9800 + 1;
  *code.9800 = 236;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9801 = code;
        code = code.9801 + 1;
        D.57365 = imb.b[0];
        *code.9801 = D.57365;
        code.9802 = code;
        code = code.9802 + 1;
        D.57367 = imb.b[1];
        *code.9802 = D.57367;
        code.9803 = code;
        code = code.9803 + 1;
        D.57369 = imb.b[2];
        *code.9803 = D.57369;
        code.9804 = code;
        code = code.9804 + 1;
        D.57371 = imb.b[3];
        *code.9804 = D.57371;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57357>:
  <D.57341>:
  goto <D.28720>;
  <D.28741>:
  goto <D.28720>;
  <D.28742>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7692);
  <D.28720>:
  if (save_mode == 4) goto <D.57372>; else goto <D.57373>;
  <D.57372>:
  {
    int _amd64_width_temp;

    _amd64_width_temp = 1;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.57375>; else goto <D.57376>;
      <D.57375>:
      iftmp.9805 = 8;
      goto <D.57377>;
      <D.57376>:
      iftmp.9805 = 0;
      <D.57377>:
      _amd64_rex_bits = iftmp.9805;
      if (_amd64_rex_bits != 0) goto <D.57378>; else goto <D.57379>;
      <D.57378>:
      code.9806 = code;
      code = code.9806 + 1;
      D.57381 = _amd64_rex_bits | 64;
      *code.9806 = D.57381;
      <D.57379>:
    }
    code.9807 = code;
    code = code.9807 + 1;
    *code.9807 = 184;
    if (_amd64_width_temp == 0) goto <D.57383>; else goto <D.57384>;
    <D.57383>:
    {
      union amd64_imm_buf imb;

      try
        {
          imb.val = 1;
          code.9808 = code;
          code = code.9808 + 1;
          D.57386 = imb.b[0];
          *code.9808 = D.57386;
          code.9809 = code;
          code = code.9809 + 1;
          D.57388 = imb.b[1];
          *code.9809 = D.57388;
          code.9810 = code;
          code = code.9810 + 1;
          D.57390 = imb.b[2];
          *code.9810 = D.57390;
          code.9811 = code;
          code = code.9811 + 1;
          D.57392 = imb.b[3];
          *code.9811 = D.57392;
          code.9812 = code;
          code = code.9812 + 1;
          D.57394 = imb.b[4];
          *code.9812 = D.57394;
          code.9813 = code;
          code = code.9813 + 1;
          D.57396 = imb.b[5];
          *code.9813 = D.57396;
          code.9814 = code;
          code = code.9814 + 1;
          D.57398 = imb.b[6];
          *code.9814 = D.57398;
          code.9815 = code;
          code = code.9815 + 1;
          D.57400 = imb.b[7];
          *code.9815 = D.57400;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.57401>;
    <D.57384>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 1;
          code.9816 = code;
          code = code.9816 + 1;
          D.57403 = imb.b[0];
          *code.9816 = D.57403;
          code.9817 = code;
          code = code.9817 + 1;
          D.57405 = imb.b[1];
          *code.9817 = D.57405;
          code.9818 = code;
          code = code.9818 + 1;
          D.57407 = imb.b[2];
          *code.9818 = D.57407;
          code.9819 = code;
          code = code.9819 + 1;
          D.57409 = imb.b[3];
          *code.9819 = D.57409;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.57401>:
  }
  goto <D.57410>;
  <D.57373>:
  {
    int _amd64_width_temp;

    _amd64_width_temp = 1;
    {
      unsigned char _amd64_rex_bits;

      if (_amd64_width_temp == 0) goto <D.57412>; else goto <D.57413>;
      <D.57412>:
      iftmp.9820 = 8;
      goto <D.57414>;
      <D.57413>:
      iftmp.9820 = 0;
      <D.57414>:
      _amd64_rex_bits = iftmp.9820;
      if (_amd64_rex_bits != 0) goto <D.57415>; else goto <D.57416>;
      <D.57415>:
      code.9821 = code;
      code = code.9821 + 1;
      D.57418 = _amd64_rex_bits | 64;
      *code.9821 = D.57418;
      <D.57416>:
    }
    code.9822 = code;
    code = code.9822 + 1;
    *code.9822 = 184;
    if (_amd64_width_temp == 0) goto <D.57420>; else goto <D.57421>;
    <D.57420>:
    {
      union amd64_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9823 = code;
          code = code.9823 + 1;
          D.57423 = imb.b[0];
          *code.9823 = D.57423;
          code.9824 = code;
          code = code.9824 + 1;
          D.57425 = imb.b[1];
          *code.9824 = D.57425;
          code.9825 = code;
          code = code.9825 + 1;
          D.57427 = imb.b[2];
          *code.9825 = D.57427;
          code.9826 = code;
          code = code.9826 + 1;
          D.57429 = imb.b[3];
          *code.9826 = D.57429;
          code.9827 = code;
          code = code.9827 + 1;
          D.57431 = imb.b[4];
          *code.9827 = D.57431;
          code.9828 = code;
          code = code.9828 + 1;
          D.57433 = imb.b[5];
          *code.9828 = D.57433;
          code.9829 = code;
          code = code.9829 + 1;
          D.57435 = imb.b[6];
          *code.9829 = D.57435;
          code.9830 = code;
          code = code.9830 + 1;
          D.57437 = imb.b[7];
          *code.9830 = D.57437;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    goto <D.57438>;
    <D.57421>:
    {
      union x86_imm_buf imb;

      try
        {
          imb.val = 0;
          code.9831 = code;
          code = code.9831 + 1;
          D.57440 = imb.b[0];
          *code.9831 = D.57440;
          code.9832 = code;
          code = code.9832 + 1;
          D.57442 = imb.b[1];
          *code.9832 = D.57442;
          code.9833 = code;
          code = code.9833 + 1;
          D.57444 = imb.b[2];
          *code.9833 = D.57444;
          code.9834 = code;
          code = code.9834 + 1;
          D.57446 = imb.b[3];
          *code.9834 = D.57446;
        }
      finally
        {
          imb = {CLOBBER};
        }
    }
    <D.57438>:
  }
  <D.57410>:
  if (preserve_argument_registers != 0) goto <D.57447>; else goto <D.57448>;
  <D.57447>:
  i = 0;
  goto <D.28753>;
  <D.28752>:
  {
    unsigned char _amd64_rex_bits;

    D.57449 = param_regs[i];
    D.57450 = D.57449 > 7;
    _amd64_rex_bits = (unsigned char) D.57450;
    if (_amd64_rex_bits != 0) goto <D.57451>; else goto <D.57452>;
    <D.57451>:
    code.9835 = code;
    code = code.9835 + 1;
    D.57454 = _amd64_rex_bits | 64;
    *code.9835 = D.57454;
    <D.57452>:
  }
  code.9836 = code;
  code = code.9836 + 1;
  D.57449 = param_regs[i];
  D.57456 = (unsigned char) D.57449;
  D.57457 = D.57456 & 7;
  D.57458 = D.57457 + 80;
  *code.9836 = D.57458;
  i = i + 1;
  <D.28753>:
  if (i <= 5) goto <D.28752>; else goto <D.28754>;
  <D.28754>:
  <D.57448>:
  code.9837 = (long int) code;
  D.57460 = cfg->native_code;
  D.57461 = (long int) D.57460;
  D.57462 = code.9837 - D.57461;
  D.57463 = (int) D.57462;
  mono_add_patch_info (cfg, D.57463, 6, method);
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57464>; else goto <D.57465>;
    <D.57464>:
    code.9838 = code;
    code = code.9838 + 1;
    D.57467 = _amd64_rex_bits | 64;
    *code.9838 = D.57467;
    <D.57465>:
  }
  code.9839 = code;
  code = code.9839 + 1;
  *code.9839 = 191;
  if (1 != 0) goto <D.57469>; else goto <D.57470>;
  <D.57469>:
  {
    union amd64_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9840 = code;
        code = code.9840 + 1;
        D.57472 = imb.b[0];
        *code.9840 = D.57472;
        code.9841 = code;
        code = code.9841 + 1;
        D.57474 = imb.b[1];
        *code.9841 = D.57474;
        code.9842 = code;
        code = code.9842 + 1;
        D.57476 = imb.b[2];
        *code.9842 = D.57476;
        code.9843 = code;
        code = code.9843 + 1;
        D.57478 = imb.b[3];
        *code.9843 = D.57478;
        code.9844 = code;
        code = code.9844 + 1;
        D.57480 = imb.b[4];
        *code.9844 = D.57480;
        code.9845 = code;
        code = code.9845 + 1;
        D.57482 = imb.b[5];
        *code.9845 = D.57482;
        code.9846 = code;
        code = code.9846 + 1;
        D.57484 = imb.b[6];
        *code.9846 = D.57484;
        code.9847 = code;
        code = code.9847 + 1;
        D.57486 = imb.b[7];
        *code.9847 = D.57486;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57487>;
  <D.57470>:
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9848 = code;
        code = code.9848 + 1;
        D.57489 = imb.b[0];
        *code.9848 = D.57489;
        code.9849 = code;
        code = code.9849 + 1;
        D.57491 = imb.b[1];
        *code.9849 = D.57491;
        code.9850 = code;
        code = code.9850 + 1;
        D.57493 = imb.b[2];
        *code.9850 = D.57493;
        code.9851 = code;
        code = code.9851 + 1;
        D.57495 = imb.b[3];
        *code.9851 = D.57495;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57487>:
  code = emit_call (cfg, code, 1, func, 1);
  if (preserve_argument_registers != 0) goto <D.57496>; else goto <D.57497>;
  <D.57496>:
  i = 5;
  goto <D.28760>;
  <D.28759>:
  {
    unsigned char _amd64_rex_bits;

    D.57449 = param_regs[i];
    D.57450 = D.57449 > 7;
    _amd64_rex_bits = (unsigned char) D.57450;
    if (_amd64_rex_bits != 0) goto <D.57498>; else goto <D.57499>;
    <D.57498>:
    code.9852 = code;
    code = code.9852 + 1;
    D.57501 = _amd64_rex_bits | 64;
    *code.9852 = D.57501;
    <D.57499>:
  }
  code.9853 = code;
  code = code.9853 + 1;
  D.57449 = param_regs[i];
  D.57456 = (unsigned char) D.57449;
  D.57457 = D.57456 & 7;
  D.57503 = D.57457 + 88;
  *code.9853 = D.57503;
  i = i + -1;
  <D.28760>:
  if (i >= 0) goto <D.28759>; else goto <D.28761>;
  <D.28761>:
  <D.57497>:
  switch (save_mode) <default: <D.28787>, case 0: <D.28786>, case 1: <D.28770>, case 2: <D.28762>, case 4: <D.28771>>
  <D.28762>:
  if (1 != 0) goto <D.57504>; else goto <D.57505>;
  <D.57504>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57506>; else goto <D.57507>;
    <D.57506>:
    code.9854 = code;
    code = code.9854 + 1;
    D.57509 = _amd64_rex_bits | 64;
    *code.9854 = D.57509;
    <D.57507>:
  }
  code.9855 = code;
  code = code.9855 + 1;
  *code.9855 = 131;
  code.9856 = code;
  code = code.9856 + 1;
  *code.9856 = 196;
  *code = 8;
  code = code + 1;
  goto <D.57512>;
  <D.57505>:
  if (0 != 0) goto <D.57513>; else goto <D.57514>;
  <D.57513>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57515>; else goto <D.57516>;
    <D.57515>:
    code.9857 = code;
    code = code.9857 + 1;
    D.57518 = _amd64_rex_bits | 64;
    *code.9857 = D.57518;
    <D.57516>:
  }
  code.9858 = code;
  code = code.9858 + 1;
  *code.9858 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9859 = code;
        code = code.9859 + 1;
        D.57521 = imb.b[0];
        *code.9859 = D.57521;
        code.9860 = code;
        code = code.9860 + 1;
        D.57523 = imb.b[1];
        *code.9860 = D.57523;
        code.9861 = code;
        code = code.9861 + 1;
        D.57525 = imb.b[2];
        *code.9861 = D.57525;
        code.9862 = code;
        code = code.9862 + 1;
        D.57527 = imb.b[3];
        *code.9862 = D.57527;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57528>;
  <D.57514>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57529>; else goto <D.57530>;
    <D.57529>:
    code.9863 = code;
    code = code.9863 + 1;
    D.57532 = _amd64_rex_bits | 64;
    *code.9863 = D.57532;
    <D.57530>:
  }
  code.9864 = code;
  code = code.9864 + 1;
  *code.9864 = 129;
  code.9865 = code;
  code = code.9865 + 1;
  *code.9865 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9866 = code;
        code = code.9866 + 1;
        D.57536 = imb.b[0];
        *code.9866 = D.57536;
        code.9867 = code;
        code = code.9867 + 1;
        D.57538 = imb.b[1];
        *code.9867 = D.57538;
        code.9868 = code;
        code = code.9868 + 1;
        D.57540 = imb.b[2];
        *code.9868 = D.57540;
        code.9869 = code;
        code = code.9869 + 1;
        D.57542 = imb.b[3];
        *code.9869 = D.57542;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57528>:
  <D.57512>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.57543>; else goto <D.57544>;
    <D.57543>:
    code.9870 = code;
    code = code.9870 + 1;
    D.57546 = _amd64_rex_bits | 64;
    *code.9870 = D.57546;
    <D.57544>:
  }
  code.9871 = code;
  code = code.9871 + 1;
  *code.9871 = 88;
  goto <D.28769>;
  <D.28770>:
  goto <D.28769>;
  <D.28771>:
  if (1 != 0) goto <D.57548>; else goto <D.57549>;
  <D.57548>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57550>; else goto <D.57551>;
    <D.57550>:
    code.9872 = code;
    code = code.9872 + 1;
    D.57553 = _amd64_rex_bits | 64;
    *code.9872 = D.57553;
    <D.57551>:
  }
  code.9873 = code;
  code = code.9873 + 1;
  *code.9873 = 131;
  code.9874 = code;
  code = code.9874 + 1;
  *code.9874 = 196;
  *code = 8;
  code = code + 1;
  goto <D.57556>;
  <D.57549>:
  if (0 != 0) goto <D.57557>; else goto <D.57558>;
  <D.57557>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57559>; else goto <D.57560>;
    <D.57559>:
    code.9875 = code;
    code = code.9875 + 1;
    D.57562 = _amd64_rex_bits | 64;
    *code.9875 = D.57562;
    <D.57560>:
  }
  code.9876 = code;
  code = code.9876 + 1;
  *code.9876 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9877 = code;
        code = code.9877 + 1;
        D.57565 = imb.b[0];
        *code.9877 = D.57565;
        code.9878 = code;
        code = code.9878 + 1;
        D.57567 = imb.b[1];
        *code.9878 = D.57567;
        code.9879 = code;
        code = code.9879 + 1;
        D.57569 = imb.b[2];
        *code.9879 = D.57569;
        code.9880 = code;
        code = code.9880 + 1;
        D.57571 = imb.b[3];
        *code.9880 = D.57571;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57572>;
  <D.57558>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57573>; else goto <D.57574>;
    <D.57573>:
    code.9881 = code;
    code = code.9881 + 1;
    D.57576 = _amd64_rex_bits | 64;
    *code.9881 = D.57576;
    <D.57574>:
  }
  code.9882 = code;
  code = code.9882 + 1;
  *code.9882 = 129;
  code.9883 = code;
  code = code.9883 + 1;
  *code.9883 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9884 = code;
        code = code.9884 + 1;
        D.57580 = imb.b[0];
        *code.9884 = D.57580;
        code.9885 = code;
        code = code.9885 + 1;
        D.57582 = imb.b[1];
        *code.9885 = D.57582;
        code.9886 = code;
        code = code.9886 + 1;
        D.57584 = imb.b[2];
        *code.9886 = D.57584;
        code.9887 = code;
        code = code.9887 + 1;
        D.57586 = imb.b[3];
        *code.9887 = D.57586;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57572>:
  <D.57556>:
  code.9888 = code;
  code = code.9888 + 1;
  *code.9888 = 242;
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 0;
    if (_amd64_rex_bits != 0) goto <D.57588>; else goto <D.57589>;
    <D.57588>:
    code.9889 = code;
    code = code.9889 + 1;
    D.57591 = _amd64_rex_bits | 64;
    *code.9889 = D.57591;
    <D.57589>:
  }
  code.9890 = code;
  code = code.9890 + 1;
  *code.9890 = 15;
  code.9891 = code;
  code = code.9891 + 1;
  *code.9891 = 16;
  if (1 != 0) goto <D.57594>; else goto <D.57595>;
  <D.57594>:
  if (1 != 0) goto <D.57596>; else goto <D.57597>;
  <D.57596>:
  code.9892 = code;
  code = code.9892 + 1;
  *code.9892 = 4;
  code.9893 = code;
  code = code.9893 + 1;
  *code.9893 = 36;
  goto <D.57600>;
  <D.57597>:
  if (1 != 0) goto <D.57601>; else goto <D.57602>;
  <D.57601>:
  code.9894 = code;
  code = code.9894 + 1;
  *code.9894 = 68;
  code.9895 = code;
  code = code.9895 + 1;
  *code.9895 = 36;
  *code = 0;
  code = code + 1;
  goto <D.57605>;
  <D.57602>:
  code.9896 = code;
  code = code.9896 + 1;
  *code.9896 = 132;
  code.9897 = code;
  code = code.9897 + 1;
  *code.9897 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9898 = code;
        code = code.9898 + 1;
        D.57609 = imb.b[0];
        *code.9898 = D.57609;
        code.9899 = code;
        code = code.9899 + 1;
        D.57611 = imb.b[1];
        *code.9899 = D.57611;
        code.9900 = code;
        code = code.9900 + 1;
        D.57613 = imb.b[2];
        *code.9900 = D.57613;
        code.9901 = code;
        code = code.9901 + 1;
        D.57615 = imb.b[3];
        *code.9901 = D.57615;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57605>:
  <D.57600>:
  goto <D.28779>;
  <D.57595>:
  if (1 != 0) goto <D.57616>; else goto <D.57617>;
  <D.57616>:
  code.9902 = code;
  code = code.9902 + 1;
  *code.9902 = 4;
  goto <D.28779>;
  <D.57617>:
  if (1 != 0) goto <D.57619>; else goto <D.57620>;
  <D.57619>:
  code.9903 = code;
  code = code.9903 + 1;
  *code.9903 = 68;
  *code = 0;
  code = code + 1;
  goto <D.57622>;
  <D.57620>:
  code.9904 = code;
  code = code.9904 + 1;
  *code.9904 = 132;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.9905 = code;
        code = code.9905 + 1;
        D.57625 = imb.b[0];
        *code.9905 = D.57625;
        code.9906 = code;
        code = code.9906 + 1;
        D.57627 = imb.b[1];
        *code.9906 = D.57627;
        code.9907 = code;
        code = code.9907 + 1;
        D.57629 = imb.b[2];
        *code.9907 = D.57629;
        code.9908 = code;
        code = code.9908 + 1;
        D.57631 = imb.b[3];
        *code.9908 = D.57631;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57622>:
  <D.28779>:
  if (1 != 0) goto <D.57632>; else goto <D.57633>;
  <D.57632>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57634>; else goto <D.57635>;
    <D.57634>:
    code.9909 = code;
    code = code.9909 + 1;
    D.57637 = _amd64_rex_bits | 64;
    *code.9909 = D.57637;
    <D.57635>:
  }
  code.9910 = code;
  code = code.9910 + 1;
  *code.9910 = 131;
  code.9911 = code;
  code = code.9911 + 1;
  *code.9911 = 196;
  *code = 8;
  code = code + 1;
  goto <D.57640>;
  <D.57633>:
  if (0 != 0) goto <D.57641>; else goto <D.57642>;
  <D.57641>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57643>; else goto <D.57644>;
    <D.57643>:
    code.9912 = code;
    code = code.9912 + 1;
    D.57646 = _amd64_rex_bits | 64;
    *code.9912 = D.57646;
    <D.57644>:
  }
  code.9913 = code;
  code = code.9913 + 1;
  *code.9913 = 5;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9914 = code;
        code = code.9914 + 1;
        D.57649 = imb.b[0];
        *code.9914 = D.57649;
        code.9915 = code;
        code = code.9915 + 1;
        D.57651 = imb.b[1];
        *code.9915 = D.57651;
        code.9916 = code;
        code = code.9916 + 1;
        D.57653 = imb.b[2];
        *code.9916 = D.57653;
        code.9917 = code;
        code = code.9917 + 1;
        D.57655 = imb.b[3];
        *code.9917 = D.57655;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.57656>;
  <D.57642>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 8;
    if (_amd64_rex_bits != 0) goto <D.57657>; else goto <D.57658>;
    <D.57657>:
    code.9918 = code;
    code = code.9918 + 1;
    D.57660 = _amd64_rex_bits | 64;
    *code.9918 = D.57660;
    <D.57658>:
  }
  code.9919 = code;
  code = code.9919 + 1;
  *code.9919 = 129;
  code.9920 = code;
  code = code.9920 + 1;
  *code.9920 = 196;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 8;
        code.9921 = code;
        code = code.9921 + 1;
        D.57664 = imb.b[0];
        *code.9921 = D.57664;
        code.9922 = code;
        code = code.9922 + 1;
        D.57666 = imb.b[1];
        *code.9922 = D.57666;
        code.9923 = code;
        code = code.9923 + 1;
        D.57668 = imb.b[2];
        *code.9923 = D.57668;
        code.9924 = code;
        code = code.9924 + 1;
        D.57670 = imb.b[3];
        *code.9924 = D.57670;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.57656>:
  <D.57640>:
  goto <D.28769>;
  <D.28786>:
  goto <D.28769>;
  <D.28787>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7732);
  <D.28769>:
  D.57671 = code;
  return D.57671;
}


mono_arch_flush_icache (guint8 * code, gint size)
{

}


mono_arch_flush_register_windows ()
{

}


mono_arch_is_inst_imm (gint64 imm)
{
  gboolean D.57678;
  unsigned long imm.9925;
  unsigned long D.57680;
  _Bool D.57681;

  imm.9925 = (unsigned long) imm;
  D.57680 = imm.9925 + 2147483648;
  D.57681 = D.57680 <= 4294967295;
  D.57678 = (gboolean) D.57681;
  return D.57678;
}


mono_arch_is_int_overflow (void * sigctx, void * info)
{
  long int D.57683;
  unsigned char D.57684;
  unsigned char D.57685;
  int D.57688;
  int D.57689;
  guint8 * D.57693;
  unsigned char D.57694;
  unsigned char D.57695;
  unsigned char D.57698;
  int D.57699;
  int D.57700;
  int D.57703;
  int D.57704;
  gboolean D.57707;
  struct MonoContext ctx;
  guint8 * rip;
  int reg;
  gint64 value;

  try
    {
      mono_arch_sigctx_to_monoctx (sigctx, &ctx);
      D.57683 = ctx.rip;
      rip = (guint8 *) D.57683;
      D.57684 = *rip;
      D.57685 = D.57684 + 192;
      if (D.57685 <= 15) goto <D.57686>; else goto <D.57687>;
      <D.57686>:
      D.57684 = *rip;
      D.57688 = (int) D.57684;
      D.57689 = D.57688 & 1;
      reg = D.57689 << 3;
      rip = rip + 1;
      goto <D.57690>;
      <D.57687>:
      reg = 0;
      <D.57690>:
      D.57684 = *rip;
      if (D.57684 == 247) goto <D.57691>; else goto <D.57692>;
      <D.57691>:
      D.57693 = rip + 1;
      D.57694 = *D.57693;
      D.57695 = D.57694 >> 6;
      if (D.57695 == 3) goto <D.57696>; else goto <D.57697>;
      <D.57696>:
      D.57693 = rip + 1;
      D.57694 = *D.57693;
      D.57698 = D.57694 >> 3;
      D.57699 = (int) D.57698;
      D.57700 = D.57699 & 7;
      if (D.57700 == 7) goto <D.57701>; else goto <D.57702>;
      <D.57701>:
      D.57693 = rip + 1;
      D.57694 = *D.57693;
      D.57703 = (int) D.57694;
      D.57704 = D.57703 & 7;
      reg = D.57704 + reg;
      switch (reg) <default: <D.28819>, case 0: <D.28806>, case 1: <D.28809>, case 2: <D.28810>, case 3: <D.28808>, case 4: <D.28812>, case 5: <D.28811>, case 6: <D.28813>, case 7: <D.28814>, case 12: <D.28815>, case 13: <D.28816>, case 14: <D.28817>, case 15: <D.28818>>
      <D.28806>:
      value = ctx.rax;
      goto <D.28807>;
      <D.28808>:
      value = ctx.rbx;
      goto <D.28807>;
      <D.28809>:
      value = ctx.rcx;
      goto <D.28807>;
      <D.28810>:
      value = ctx.rdx;
      goto <D.28807>;
      <D.28811>:
      value = ctx.rbp;
      goto <D.28807>;
      <D.28812>:
      value = ctx.rsp;
      goto <D.28807>;
      <D.28813>:
      value = ctx.rsi;
      goto <D.28807>;
      <D.28814>:
      value = ctx.rdi;
      goto <D.28807>;
      <D.28815>:
      value = ctx.r12;
      goto <D.28807>;
      <D.28816>:
      value = ctx.r13;
      goto <D.28807>;
      <D.28817>:
      value = ctx.r14;
      goto <D.28807>;
      <D.28818>:
      value = ctx.r15;
      goto <D.28807>;
      <D.28819>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-amd64.c", 7820);
      reg = -1;
      <D.28807>:
      if (value == -1) goto <D.57705>; else goto <D.57706>;
      <D.57705>:
      D.57707 = 1;
      return D.57707;
      <D.57706>:
      <D.57702>:
      <D.57697>:
      <D.57692>:
      D.57707 = 0;
      return D.57707;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_arch_get_patch_offset (guint8 * code)
{
  guint32 D.57710;

  D.57710 = 3;
  return D.57710;
}


mono_breakpoint_clean_code (guint8 * method_start, guint8 * code, int offset, guint8 * buf, int size)
{
  sizetype D.57716;
  sizetype D.57717;
  guint8 * D.57718;
  long unsigned int D.57719;
  long int code.9926;
  long int method_start.9927;
  long int D.57722;
  int D.57723;
  int D.57724;
  long unsigned int D.57725;
  sizetype D.57726;
  sizetype D.57727;
  guint8 * D.57728;
  long int D.57729;
  sizetype D.57734;
  guint8 * D.57735;
  long int ptr.9928;
  long int D.57739;
  sizetype D.57740;
  guint8 * D.57741;
  gboolean D.57742;
  int i;
  gboolean can_write;

  can_write = 1;
  if (method_start == 0B) goto <D.57712>; else goto <D.57715>;
  <D.57715>:
  D.57716 = (sizetype) offset;
  D.57717 = -D.57716;
  D.57718 = code + D.57717;
  if (D.57718 >= method_start) goto <D.57712>; else goto <D.57713>;
  <D.57712>:
  D.57719 = (long unsigned int) size;
  D.57716 = (sizetype) offset;
  D.57717 = -D.57716;
  D.57718 = code + D.57717;
  memcpy (buf, D.57718, D.57719);
  goto <D.57714>;
  <D.57713>:
  {
    int diff;

    code.9926 = (long int) code;
    method_start.9927 = (long int) method_start;
    D.57722 = code.9926 - method_start.9927;
    diff = (int) D.57722;
    D.57719 = (long unsigned int) size;
    memset (buf, 0, D.57719);
    D.57723 = diff + size;
    D.57724 = D.57723 - offset;
    D.57725 = (long unsigned int) D.57724;
    D.57716 = (sizetype) offset;
    D.57726 = (sizetype) diff;
    D.57727 = D.57716 - D.57726;
    D.57728 = buf + D.57727;
    memcpy (D.57728, method_start, D.57725);
  }
  <D.57714>:
  D.57716 = (sizetype) offset;
  D.57717 = -D.57716;
  code = code + D.57717;
  i = 0;
  goto <D.28838>;
  <D.28837>:
  {
    int idx;
    guint8 * ptr;

    D.57729 = mono_breakpoint_info_index[i];
    idx = (int) D.57729;
    if (idx <= 0) goto <D.57730>; else goto <D.57731>;
    <D.57730>:
    // predicted unlikely by continue predictor.
    goto <D.28835>;
    <D.57731>:
    ptr = mono_breakpoint_info[idx].address;
    if (ptr >= code) goto <D.57732>; else goto <D.57733>;
    <D.57732>:
    D.57734 = (sizetype) size;
    D.57735 = code + D.57734;
    if (D.57735 > ptr) goto <D.57736>; else goto <D.57737>;
    <D.57736>:
    {
      guint8 saved_byte;

      saved_byte = mono_breakpoint_info[idx].saved_byte;
      can_write = 0;
      ptr.9928 = (long int) ptr;
      code.9926 = (long int) code;
      D.57739 = ptr.9928 - code.9926;
      D.57740 = (sizetype) D.57739;
      D.57741 = buf + D.57740;
      *D.57741 = saved_byte;
    }
    <D.57737>:
    <D.57733>:
  }
  <D.28835>:
  i = i + 1;
  <D.28838>:
  if (i <= 63) goto <D.28837>; else goto <D.28839>;
  <D.28839>:
  D.57742 = can_write;
  return D.57742;
}


mono_arch_get_this_arg_reg (guint8 * code)
{
  int D.57744;

  D.57744 = 7;
  return D.57744;
}


mono_arch_get_this_arg_from_call (mgreg_t * regs, guint8 * code)
{
  void * D.57746;
  int D.57747;
  long unsigned int D.57748;
  long unsigned int D.57749;
  mgreg_t * D.57750;
  long int D.57751;

  D.57747 = mono_arch_get_this_arg_reg (code);
  D.57748 = (long unsigned int) D.57747;
  D.57749 = D.57748 * 8;
  D.57750 = regs + D.57749;
  D.57751 = *D.57750;
  D.57746 = (void *) D.57751;
  return D.57746;
}


mono_arch_get_delegate_invoke_impls ()
{
  unsigned int code_len.9929;
  struct MonoTrampInfo * D.57754;
  unsigned int i.9930;
  struct MonoTrampInfo * D.57756;
  struct GSList * D.57757;
  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.9929 = code_len;
      D.57754 = mono_tramp_info_create ("delegate_invoke_impl_has_target", code, code_len.9929, 0B, 0B);
      res = monoeg_g_slist_prepend (res, D.57754);
      i = 0;
      goto <D.28916>;
      <D.28915>:
      i.9930 = (unsigned int) i;
      code = get_delegate_invoke_impl (0, i.9930, &code_len);
      tramp_name = monoeg_g_strdup_printf ("delegate_invoke_impl_target_%d", i);
      code_len.9929 = code_len;
      D.57756 = mono_tramp_info_create (tramp_name, code, code_len.9929, 0B, 0B);
      res = monoeg_g_slist_prepend (res, D.57756);
      monoeg_g_free (tramp_name);
      i = i + 1;
      <D.28916>:
      if (i <= 9) goto <D.28915>; else goto <D.28917>;
      <D.28917>:
      D.57757 = res;
      return D.57757;
    }
  finally
    {
      code_len = {CLOBBER};
    }
}


get_delegate_invoke_impl (gboolean has_target, guint32 param_count, guint32 * code_len)
{
  void * code.9931;
  guint8 * code.9932;
  guint8 * code.9933;
  guint8 * code.9934;
  guint8 * code.9935;
  guint8 * code.9936;
  unsigned char D.57772;
  guint8 * code.9937;
  guint8 * code.9938;
  guint8 * code.9939;
  guint8 * code.9940;
  guint8 * code.9941;
  guint8 * code.9942;
  guint8 * code.9943;
  guint8 * code.9944;
  guint8 * code.9945;
  guint8 * code.9946;
  unsigned char D.57787;
  guint8 * code.9947;
  guint8 * code.9948;
  guint8 * code.9949;
  guint8 * code.9950;
  guint8 * code.9951;
  guint8 * code.9952;
  guint8 * code.9953;
  guint8 * code.9954;
  unsigned char D.57798;
  guint8 * code.9955;
  guint8 * code.9956;
  unsigned char D.57801;
  guint8 * code.9957;
  guint8 * code.9958;
  unsigned char D.57804;
  guint8 * code.9959;
  guint8 * code.9960;
  unsigned char D.57807;
  guint8 * code.9961;
  guint8 * code.9962;
  guint8 * code.9963;
  guint8 * code.9964;
  guint8 * code.9965;
  guint8 * code.9966;
  guint8 * code.9967;
  guint8 * code.9968;
  guint8 * code.9969;
  guint8 * code.9970;
  guint8 * code.9971;
  guint8 * code.9972;
  guint8 * code.9973;
  guint8 * code.9974;
  guint8 * code.9975;
  unsigned char D.57832;
  guint8 * code.9976;
  guint8 * code.9977;
  unsigned char D.57835;
  guint8 * code.9978;
  guint8 * code.9979;
  unsigned char D.57838;
  guint8 * code.9980;
  guint8 * code.9981;
  unsigned char D.57841;
  guint8 * code.9982;
  guint8 * code.9983;
  guint8 * code.9984;
  guint8 * code.9985;
  guint8 * code.9986;
  guint8 * code.9987;
  guint8 * code.9988;
  guint8 * code.9989;
  unsigned char D.57855;
  guint8 * code.9990;
  guint8 * code.9991;
  unsigned char D.57858;
  guint8 * code.9992;
  guint8 * code.9993;
  unsigned char D.57861;
  guint8 * code.9994;
  guint8 * code.9995;
  unsigned char D.57864;
  guint8 * code.9996;
  guint8 * code.9997;
  unsigned char D.57869;
  guint8 * code.9998;
  guint8 * code.9999;
  guint8 * code.10000;
  guint8 * code.10001;
  guint8 * code.10002;
  guint8 * code.10003;
  unsigned char D.57878;
  guint8 * code.10004;
  guint8 * code.10005;
  unsigned char D.57881;
  guint8 * code.10006;
  guint8 * code.10007;
  unsigned char D.57884;
  guint8 * code.10008;
  guint8 * code.10009;
  unsigned char D.57887;
  guint8 * code.10010;
  guint8 * code.10011;
  guint8 * code.10012;
  guint8 * code.10013;
  guint8 * code.10014;
  guint8 * code.10015;
  guint8 * code.10016;
  guint8 * code.10017;
  guint8 * code.10018;
  guint8 * code.10019;
  guint8 * code.10020;
  guint8 * code.10021;
  guint8 * code.10022;
  guint8 * code.10023;
  unsigned char D.57911;
  guint8 * code.10024;
  guint8 * code.10025;
  unsigned char D.57914;
  guint8 * code.10026;
  guint8 * code.10027;
  unsigned char D.57917;
  guint8 * code.10028;
  guint8 * code.10029;
  unsigned char D.57920;
  guint8 * code.10030;
  guint8 * code.10031;
  guint8 * code.10032;
  guint8 * code.10033;
  guint8 * code.10034;
  guint8 * code.10035;
  guint8 * code.10036;
  guint8 * code.10037;
  unsigned char D.57934;
  guint8 * code.10038;
  guint8 * code.10039;
  unsigned char D.57937;
  guint8 * code.10040;
  guint8 * code.10041;
  unsigned char D.57940;
  guint8 * code.10042;
  guint8 * code.10043;
  unsigned char D.57943;
  long int code.10044;
  guint8 * start.10045;
  long int start.10046;
  long int D.57947;
  _Bool D.57948;
  long int D.57949;
  long int D.57950;
  void * code.10047;
  guint8 * code.10048;
  guint8 * code.10049;
  unsigned char D.57961;
  guint8 * code.10050;
  guint8 * code.10051;
  guint8 * code.10052;
  guint8 * code.10053;
  guint8 * code.10054;
  guint8 * code.10055;
  unsigned char D.57970;
  guint8 * code.10056;
  guint8 * code.10057;
  unsigned char D.57973;
  guint8 * code.10058;
  guint8 * code.10059;
  unsigned char D.57976;
  guint8 * code.10060;
  guint8 * code.10061;
  unsigned char D.57979;
  guint8 * code.10062;
  guint8 * code.10063;
  guint8 * code.10064;
  guint8 * code.10065;
  guint8 * code.10066;
  guint8 * code.10067;
  guint8 * code.10068;
  guint8 * code.10069;
  guint8 * code.10070;
  guint8 * code.10071;
  guint8 * code.10072;
  guint8 * code.10073;
  guint8 * code.10074;
  guint8 * code.10075;
  unsigned char D.58003;
  guint8 * code.10076;
  guint8 * code.10077;
  unsigned char D.58006;
  guint8 * code.10078;
  guint8 * code.10079;
  unsigned char D.58009;
  guint8 * code.10080;
  guint8 * code.10081;
  unsigned char D.58012;
  guint8 * code.10082;
  guint8 * code.10083;
  guint8 * code.10084;
  guint8 * code.10085;
  guint8 * code.10086;
  guint8 * code.10087;
  guint8 * code.10088;
  guint8 * code.10089;
  unsigned char D.58026;
  guint8 * code.10090;
  guint8 * code.10091;
  unsigned char D.58029;
  guint8 * code.10092;
  guint8 * code.10093;
  unsigned char D.58032;
  guint8 * code.10094;
  guint8 * code.10095;
  unsigned char D.58035;
  guint8 * code.10096;
  guint8 * code.10097;
  guint8 * code.10098;
  guint8 * code.10099;
  unsigned char D.58045;
  guint8 * code.10100;
  guint8 * code.10101;
  guint8 * code.10102;
  guint8 * code.10103;
  guint8 * code.10104;
  guint8 * code.10105;
  guint8 * code.10106;
  guint8 * code.10107;
  signed char iftmp.10108;
  <unnamed type> D.58057;
  int D.58061;
  <unnamed type> D.58062;
  _Bool D.58063;
  signed char D.58064;
  signed char D.58065;
  guint8 * code.10109;
  guint8 * code.10110;
  unsigned char D.58070;
  guint8 * code.10111;
  guint8 * code.10112;
  guint8 * code.10113;
  guint8 * code.10114;
  guint8 * code.10115;
  guint8 * code.10116;
  unsigned char D.58077;
  unsigned char D.58078;
  unsigned char D.58079;
  unsigned char D.58080;
  unsigned char D.58081;
  unsigned char D.58082;
  unsigned char D.58083;
  unsigned int i.10117;
  guint8 * code.10118;
  guint8 * code.10119;
  unsigned char D.58089;
  guint8 * code.10120;
  guint8 * code.10121;
  guint8 * code.10122;
  guint8 * code.10123;
  guint8 * code.10124;
  guint8 * code.10125;
  unsigned char D.58098;
  guint8 * code.10126;
  guint8 * code.10127;
  unsigned char D.58101;
  guint8 * code.10128;
  guint8 * code.10129;
  unsigned char D.58104;
  guint8 * code.10130;
  guint8 * code.10131;
  unsigned char D.58107;
  guint8 * code.10132;
  guint8 * code.10133;
  guint8 * code.10134;
  guint8 * code.10135;
  guint8 * code.10136;
  guint8 * code.10137;
  guint8 * code.10138;
  guint8 * code.10139;
  guint8 * code.10140;
  guint8 * code.10141;
  guint8 * code.10142;
  guint8 * code.10143;
  guint8 * code.10144;
  guint8 * code.10145;
  unsigned char D.58131;
  guint8 * code.10146;
  guint8 * code.10147;
  unsigned char D.58134;
  guint8 * code.10148;
  guint8 * code.10149;
  unsigned char D.58137;
  guint8 * code.10150;
  guint8 * code.10151;
  unsigned char D.58140;
  guint8 * code.10152;
  guint8 * code.10153;
  guint8 * code.10154;
  guint8 * code.10155;
  guint8 * code.10156;
  guint8 * code.10157;
  guint8 * code.10158;
  guint8 * code.10159;
  unsigned char D.58154;
  guint8 * code.10160;
  guint8 * code.10161;
  unsigned char D.58157;
  guint8 * code.10162;
  guint8 * code.10163;
  unsigned char D.58160;
  guint8 * code.10164;
  guint8 * code.10165;
  unsigned char D.58163;
  int D.58166;
  unsigned int D.58169;
  int D.58170;
  void * D.58178;
  guint8 * code;
  guint8 * start;
  int i;
  static const char __PRETTY_FUNCTION__[25] = "get_delegate_invoke_impl";

  try
    {
      if (has_target != 0) goto <D.57760>; else goto <D.57761>;
      <D.57760>:
      code.9931 = mono_global_codeman_reserve (64);
      code = code.9931;
      code.9932 = code;
      start = code.9932;
      if (0 != 0) goto <D.57764>; else goto <D.57765>;
      <D.57764>:
      code.9932 = code;
      code.9933 = code.9932;
      code.9934 = code.9933 + 1;
      code = code.9934;
      *code.9933 = 102;
      <D.57765>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.57768>; else goto <D.57769>;
        <D.57768>:
        code.9932 = code;
        code.9935 = code.9932;
        code.9936 = code.9935 + 1;
        code = code.9936;
        D.57772 = _amd64_rex_bits | 64;
        *code.9935 = D.57772;
        <D.57769>:
      }
      switch (8) <default: <D.28861>, case 1: <D.28856>, case 2: <D.28858>, case 4: <D.28859>, case 8: <D.28860>>
      <D.28856>:
      code.9932 = code;
      code.9937 = code.9932;
      code.9938 = code.9937 + 1;
      code = code.9938;
      *code.9937 = 138;
      goto <D.28857>;
      <D.28858>:
      <D.28859>:
      <D.28860>:
      code.9932 = code;
      code.9939 = code.9932;
      code.9940 = code.9939 + 1;
      code = code.9940;
      *code.9939 = 139;
      goto <D.28857>;
      <D.28861>:
      __assert_fail ("0", "mini-amd64.c", 7944, &__PRETTY_FUNCTION__);
      <D.28857>:
      code.9932 = code;
      code.9941 = code.9932;
      code.9942 = code.9941 + 1;
      code = code.9942;
      *code.9941 = 199;
      if (0 != 0) goto <D.57779>; else goto <D.57780>;
      <D.57779>:
      code.9932 = code;
      code.9943 = code.9932;
      code.9944 = code.9943 + 1;
      code = code.9944;
      *code.9943 = 102;
      <D.57780>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.57783>; else goto <D.57784>;
        <D.57783>:
        code.9932 = code;
        code.9945 = code.9932;
        code.9946 = code.9945 + 1;
        code = code.9946;
        D.57787 = _amd64_rex_bits | 64;
        *code.9945 = D.57787;
        <D.57784>:
      }
      switch (8) <default: <D.28869>, case 1: <D.28864>, case 2: <D.28866>, case 4: <D.28867>, case 8: <D.28868>>
      <D.28864>:
      code.9932 = code;
      code.9947 = code.9932;
      code.9948 = code.9947 + 1;
      code = code.9948;
      *code.9947 = 138;
      goto <D.28865>;
      <D.28866>:
      <D.28867>:
      <D.28868>:
      code.9932 = code;
      code.9949 = code.9932;
      code.9950 = code.9949 + 1;
      code = code.9950;
      *code.9949 = 139;
      goto <D.28865>;
      <D.28869>:
      __assert_fail ("0", "mini-amd64.c", 7945, &__PRETTY_FUNCTION__);
      <D.28865>:
      if (0 != 0) goto <D.57792>; else goto <D.57793>;
      <D.57792>:
      code.9932 = code;
      code.9951 = code.9932;
      code.9952 = code.9951 + 1;
      code = code.9952;
      *code.9951 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.9932 = code;
            code.9953 = code.9932;
            code.9954 = code.9953 + 1;
            code = code.9954;
            D.57798 = imb.b[0];
            *code.9953 = D.57798;
            code.9932 = code;
            code.9955 = code.9932;
            code.9956 = code.9955 + 1;
            code = code.9956;
            D.57801 = imb.b[1];
            *code.9955 = D.57801;
            code.9932 = code;
            code.9957 = code.9932;
            code.9958 = code.9957 + 1;
            code = code.9958;
            D.57804 = imb.b[2];
            *code.9957 = D.57804;
            code.9932 = code;
            code.9959 = code.9932;
            code.9960 = code.9959 + 1;
            code = code.9960;
            D.57807 = imb.b[3];
            *code.9959 = D.57807;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.57808>;
      <D.57793>:
      if (0 != 0) goto <D.57809>; else goto <D.57810>;
      <D.57809>:
      if (0 != 0) goto <D.57811>; else goto <D.57812>;
      <D.57811>:
      code.9932 = code;
      code.9961 = code.9932;
      code.9962 = code.9961 + 1;
      code = code.9962;
      *code.9961 = 60;
      code.9932 = code;
      code.9963 = code.9932;
      code.9964 = code.9963 + 1;
      code = code.9964;
      *code.9963 = 36;
      goto <D.57817>;
      <D.57812>:
      if (1 != 0) goto <D.57818>; else goto <D.57819>;
      <D.57818>:
      code.9932 = code;
      code.9965 = code.9932;
      code.9966 = code.9965 + 1;
      code = code.9966;
      *code.9965 = 124;
      code.9932 = code;
      code.9967 = code.9932;
      code.9968 = code.9967 + 1;
      code = code.9968;
      *code.9967 = 36;
      code.9932 = code;
      *code.9932 = 32;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.57825>;
      <D.57819>:
      code.9932 = code;
      code.9970 = code.9932;
      code.9971 = code.9970 + 1;
      code = code.9971;
      *code.9970 = 188;
      code.9932 = code;
      code.9972 = code.9932;
      code.9973 = code.9972 + 1;
      code = code.9973;
      *code.9972 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.9932 = code;
            code.9974 = code.9932;
            code.9975 = code.9974 + 1;
            code = code.9975;
            D.57832 = imb.b[0];
            *code.9974 = D.57832;
            code.9932 = code;
            code.9976 = code.9932;
            code.9977 = code.9976 + 1;
            code = code.9977;
            D.57835 = imb.b[1];
            *code.9976 = D.57835;
            code.9932 = code;
            code.9978 = code.9932;
            code.9979 = code.9978 + 1;
            code = code.9979;
            D.57838 = imb.b[2];
            *code.9978 = D.57838;
            code.9932 = code;
            code.9980 = code.9932;
            code.9981 = code.9980 + 1;
            code = code.9981;
            D.57841 = imb.b[3];
            *code.9980 = D.57841;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.57825>:
      <D.57817>:
      goto <D.28872>;
      <D.57810>:
      if (0 != 0) goto <D.57842>; else goto <D.57843>;
      <D.57842>:
      code.9932 = code;
      code.9982 = code.9932;
      code.9983 = code.9982 + 1;
      code = code.9983;
      *code.9982 = 56;
      goto <D.28872>;
      <D.57843>:
      if (1 != 0) goto <D.57846>; else goto <D.57847>;
      <D.57846>:
      code.9932 = code;
      code.9984 = code.9932;
      code.9985 = code.9984 + 1;
      code = code.9985;
      *code.9984 = 120;
      code.9932 = code;
      *code.9932 = 32;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.57850>;
      <D.57847>:
      code.9932 = code;
      code.9986 = code.9932;
      code.9987 = code.9986 + 1;
      code = code.9987;
      *code.9986 = 184;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.9932 = code;
            code.9988 = code.9932;
            code.9989 = code.9988 + 1;
            code = code.9989;
            D.57855 = imb.b[0];
            *code.9988 = D.57855;
            code.9932 = code;
            code.9990 = code.9932;
            code.9991 = code.9990 + 1;
            code = code.9991;
            D.57858 = imb.b[1];
            *code.9990 = D.57858;
            code.9932 = code;
            code.9992 = code.9932;
            code.9993 = code.9992 + 1;
            code = code.9993;
            D.57861 = imb.b[2];
            *code.9992 = D.57861;
            code.9932 = code;
            code.9994 = code.9932;
            code.9995 = code.9994 + 1;
            code = code.9995;
            D.57864 = imb.b[3];
            *code.9994 = D.57864;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.57850>:
      <D.28872>:
      <D.57808>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.57865>; else goto <D.57866>;
        <D.57865>:
        code.9932 = code;
        code.9996 = code.9932;
        code.9997 = code.9996 + 1;
        code = code.9997;
        D.57869 = _amd64_rex_bits | 64;
        *code.9996 = D.57869;
        <D.57866>:
      }
      code.9932 = code;
      code.9998 = code.9932;
      code.9999 = code.9998 + 1;
      code = code.9999;
      *code.9998 = 255;
      if (0 != 0) goto <D.57872>; else goto <D.57873>;
      <D.57872>:
      code.9932 = code;
      code.10000 = code.9932;
      code.10001 = code.10000 + 1;
      code = code.10001;
      *code.10000 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10002 = code.9932;
            code.10003 = code.10002 + 1;
            code = code.10003;
            D.57878 = imb.b[0];
            *code.10002 = D.57878;
            code.9932 = code;
            code.10004 = code.9932;
            code.10005 = code.10004 + 1;
            code = code.10005;
            D.57881 = imb.b[1];
            *code.10004 = D.57881;
            code.9932 = code;
            code.10006 = code.9932;
            code.10007 = code.10006 + 1;
            code = code.10007;
            D.57884 = imb.b[2];
            *code.10006 = D.57884;
            code.9932 = code;
            code.10008 = code.9932;
            code.10009 = code.10008 + 1;
            code = code.10009;
            D.57887 = imb.b[3];
            *code.10008 = D.57887;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.57888>;
      <D.57873>:
      if (0 != 0) goto <D.57889>; else goto <D.57890>;
      <D.57889>:
      if (0 != 0) goto <D.57891>; else goto <D.57892>;
      <D.57891>:
      code.9932 = code;
      code.10010 = code.9932;
      code.10011 = code.10010 + 1;
      code = code.10011;
      *code.10010 = 36;
      code.9932 = code;
      code.10012 = code.9932;
      code.10013 = code.10012 + 1;
      code = code.10013;
      *code.10012 = 36;
      goto <D.57897>;
      <D.57892>:
      if (1 != 0) goto <D.57898>; else goto <D.57899>;
      <D.57898>:
      code.9932 = code;
      code.10014 = code.9932;
      code.10015 = code.10014 + 1;
      code = code.10015;
      *code.10014 = 100;
      code.9932 = code;
      code.10016 = code.9932;
      code.10017 = code.10016 + 1;
      code = code.10017;
      *code.10016 = 36;
      code.9932 = code;
      *code.9932 = 16;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.57904>;
      <D.57899>:
      code.9932 = code;
      code.10018 = code.9932;
      code.10019 = code.10018 + 1;
      code = code.10019;
      *code.10018 = 164;
      code.9932 = code;
      code.10020 = code.9932;
      code.10021 = code.10020 + 1;
      code = code.10021;
      *code.10020 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10022 = code.9932;
            code.10023 = code.10022 + 1;
            code = code.10023;
            D.57911 = imb.b[0];
            *code.10022 = D.57911;
            code.9932 = code;
            code.10024 = code.9932;
            code.10025 = code.10024 + 1;
            code = code.10025;
            D.57914 = imb.b[1];
            *code.10024 = D.57914;
            code.9932 = code;
            code.10026 = code.9932;
            code.10027 = code.10026 + 1;
            code = code.10027;
            D.57917 = imb.b[2];
            *code.10026 = D.57917;
            code.9932 = code;
            code.10028 = code.9932;
            code.10029 = code.10028 + 1;
            code = code.10029;
            D.57920 = imb.b[3];
            *code.10028 = D.57920;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.57904>:
      <D.57897>:
      goto <D.28877>;
      <D.57890>:
      if (0 != 0) goto <D.57921>; else goto <D.57922>;
      <D.57921>:
      code.9932 = code;
      code.10030 = code.9932;
      code.10031 = code.10030 + 1;
      code = code.10031;
      *code.10030 = 32;
      goto <D.28877>;
      <D.57922>:
      if (1 != 0) goto <D.57925>; else goto <D.57926>;
      <D.57925>:
      code.9932 = code;
      code.10032 = code.9932;
      code.10033 = code.10032 + 1;
      code = code.10033;
      *code.10032 = 96;
      code.9932 = code;
      *code.9932 = 16;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.57929>;
      <D.57926>:
      code.9932 = code;
      code.10034 = code.9932;
      code.10035 = code.10034 + 1;
      code = code.10035;
      *code.10034 = 160;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10036 = code.9932;
            code.10037 = code.10036 + 1;
            code = code.10037;
            D.57934 = imb.b[0];
            *code.10036 = D.57934;
            code.9932 = code;
            code.10038 = code.9932;
            code.10039 = code.10038 + 1;
            code = code.10039;
            D.57937 = imb.b[1];
            *code.10038 = D.57937;
            code.9932 = code;
            code.10040 = code.9932;
            code.10041 = code.10040 + 1;
            code = code.10041;
            D.57940 = imb.b[2];
            *code.10040 = D.57940;
            code.9932 = code;
            code.10042 = code.9932;
            code.10043 = code.10042 + 1;
            code = code.10043;
            D.57943 = imb.b[3];
            *code.10042 = D.57943;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.57929>:
      <D.28877>:
      <D.57888>:
      code.9932 = code;
      code.10044 = (long int) code.9932;
      start.10045 = start;
      start.10046 = (long int) start.10045;
      D.57947 = code.10044 - start.10046;
      D.57948 = D.57947 > 63;
      D.57949 = (long int) D.57948;
      D.57950 = __builtin_expect (D.57949, 0);
      if (D.57950 != 0) goto <D.57951>; else goto <D.57952>;
      <D.57951>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7948, "(code - start) < 64");
      <D.57952>:
      goto <D.57953>;
      <D.57761>:
      code.10047 = mono_global_codeman_reserve (64);
      code = code.10047;
      code.9932 = code;
      start = code.9932;
      if (param_count == 0) goto <D.57955>; else goto <D.57956>;
      <D.57955>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.57957>; else goto <D.57958>;
        <D.57957>:
        code.9932 = code;
        code.10048 = code.9932;
        code.10049 = code.10048 + 1;
        code = code.10049;
        D.57961 = _amd64_rex_bits | 64;
        *code.10048 = D.57961;
        <D.57958>:
      }
      code.9932 = code;
      code.10050 = code.9932;
      code.10051 = code.10050 + 1;
      code = code.10051;
      *code.10050 = 255;
      if (0 != 0) goto <D.57964>; else goto <D.57965>;
      <D.57964>:
      code.9932 = code;
      code.10052 = code.9932;
      code.10053 = code.10052 + 1;
      code = code.10053;
      *code.10052 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10054 = code.9932;
            code.10055 = code.10054 + 1;
            code = code.10055;
            D.57970 = imb.b[0];
            *code.10054 = D.57970;
            code.9932 = code;
            code.10056 = code.9932;
            code.10057 = code.10056 + 1;
            code = code.10057;
            D.57973 = imb.b[1];
            *code.10056 = D.57973;
            code.9932 = code;
            code.10058 = code.9932;
            code.10059 = code.10058 + 1;
            code = code.10059;
            D.57976 = imb.b[2];
            *code.10058 = D.57976;
            code.9932 = code;
            code.10060 = code.9932;
            code.10061 = code.10060 + 1;
            code = code.10061;
            D.57979 = imb.b[3];
            *code.10060 = D.57979;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.57980>;
      <D.57965>:
      if (0 != 0) goto <D.57981>; else goto <D.57982>;
      <D.57981>:
      if (0 != 0) goto <D.57983>; else goto <D.57984>;
      <D.57983>:
      code.9932 = code;
      code.10062 = code.9932;
      code.10063 = code.10062 + 1;
      code = code.10063;
      *code.10062 = 36;
      code.9932 = code;
      code.10064 = code.9932;
      code.10065 = code.10064 + 1;
      code = code.10065;
      *code.10064 = 36;
      goto <D.57989>;
      <D.57984>:
      if (1 != 0) goto <D.57990>; else goto <D.57991>;
      <D.57990>:
      code.9932 = code;
      code.10066 = code.9932;
      code.10067 = code.10066 + 1;
      code = code.10067;
      *code.10066 = 100;
      code.9932 = code;
      code.10068 = code.9932;
      code.10069 = code.10068 + 1;
      code = code.10069;
      *code.10068 = 36;
      code.9932 = code;
      *code.9932 = 16;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.57996>;
      <D.57991>:
      code.9932 = code;
      code.10070 = code.9932;
      code.10071 = code.10070 + 1;
      code = code.10071;
      *code.10070 = 164;
      code.9932 = code;
      code.10072 = code.9932;
      code.10073 = code.10072 + 1;
      code = code.10073;
      *code.10072 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10074 = code.9932;
            code.10075 = code.10074 + 1;
            code = code.10075;
            D.58003 = imb.b[0];
            *code.10074 = D.58003;
            code.9932 = code;
            code.10076 = code.9932;
            code.10077 = code.10076 + 1;
            code = code.10077;
            D.58006 = imb.b[1];
            *code.10076 = D.58006;
            code.9932 = code;
            code.10078 = code.9932;
            code.10079 = code.10078 + 1;
            code = code.10079;
            D.58009 = imb.b[2];
            *code.10078 = D.58009;
            code.9932 = code;
            code.10080 = code.9932;
            code.10081 = code.10080 + 1;
            code = code.10081;
            D.58012 = imb.b[3];
            *code.10080 = D.58012;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.57996>:
      <D.57989>:
      goto <D.28882>;
      <D.57982>:
      if (0 != 0) goto <D.58013>; else goto <D.58014>;
      <D.58013>:
      code.9932 = code;
      code.10082 = code.9932;
      code.10083 = code.10082 + 1;
      code = code.10083;
      *code.10082 = 39;
      goto <D.28882>;
      <D.58014>:
      if (1 != 0) goto <D.58017>; else goto <D.58018>;
      <D.58017>:
      code.9932 = code;
      code.10084 = code.9932;
      code.10085 = code.10084 + 1;
      code = code.10085;
      *code.10084 = 103;
      code.9932 = code;
      *code.9932 = 16;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.58021>;
      <D.58018>:
      code.9932 = code;
      code.10086 = code.9932;
      code.10087 = code.10086 + 1;
      code = code.10087;
      *code.10086 = 167;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10088 = code.9932;
            code.10089 = code.10088 + 1;
            code = code.10089;
            D.58026 = imb.b[0];
            *code.10088 = D.58026;
            code.9932 = code;
            code.10090 = code.9932;
            code.10091 = code.10090 + 1;
            code = code.10091;
            D.58029 = imb.b[1];
            *code.10090 = D.58029;
            code.9932 = code;
            code.10092 = code.9932;
            code.10093 = code.10092 + 1;
            code = code.10093;
            D.58032 = imb.b[2];
            *code.10092 = D.58032;
            code.9932 = code;
            code.10094 = code.9932;
            code.10095 = code.10094 + 1;
            code = code.10095;
            D.58035 = imb.b[3];
            *code.10094 = D.58035;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.58021>:
      <D.28882>:
      <D.57980>:
      goto <D.58036>;
      <D.57956>:
      if (0 != 0) goto <D.58037>; else goto <D.58038>;
      <D.58037>:
      code.9932 = code;
      code.10096 = code.9932;
      code.10097 = code.10096 + 1;
      code = code.10097;
      *code.10096 = 102;
      <D.58038>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.58041>; else goto <D.58042>;
        <D.58041>:
        code.9932 = code;
        code.10098 = code.9932;
        code.10099 = code.10098 + 1;
        code = code.10099;
        D.58045 = _amd64_rex_bits | 64;
        *code.10098 = D.58045;
        <D.58042>:
      }
      switch (8) <default: <D.28890>, case 1: <D.28885>, case 2: <D.28887>, case 4: <D.28888>, case 8: <D.28889>>
      <D.28885>:
      code.9932 = code;
      code.10100 = code.9932;
      code.10101 = code.10100 + 1;
      code = code.10101;
      *code.10100 = 138;
      goto <D.28886>;
      <D.28887>:
      <D.28888>:
      <D.28889>:
      code.9932 = code;
      code.10102 = code.9932;
      code.10103 = code.10102 + 1;
      code = code.10103;
      *code.10102 = 139;
      goto <D.28886>;
      <D.28890>:
      __assert_fail ("0", "mini-amd64.c", 7956, &__PRETTY_FUNCTION__);
      <D.28886>:
      code.9932 = code;
      code.10104 = code.9932;
      code.10105 = code.10104 + 1;
      code = code.10105;
      *code.10104 = 199;
      i = 0;
      goto <D.28899>;
      <D.28898>:
      if (0 != 0) goto <D.58052>; else goto <D.58053>;
      <D.58052>:
      code.9932 = code;
      code.10106 = code.9932;
      code.10107 = code.10106 + 1;
      code = code.10107;
      *code.10106 = 102;
      <D.58053>:
      {
        unsigned char _amd64_rex_bits;

        D.58057 = param_regs[i];
        if (D.58057 > 7) goto <D.58058>; else goto <D.58059>;
        <D.58058>:
        iftmp.10108 = 12;
        goto <D.58060>;
        <D.58059>:
        iftmp.10108 = 8;
        <D.58060>:
        D.58061 = i + 1;
        D.58062 = param_regs[D.58061];
        D.58063 = D.58062 > 7;
        D.58064 = (signed char) D.58063;
        D.58065 = iftmp.10108 | D.58064;
        _amd64_rex_bits = (unsigned char) D.58065;
        if (_amd64_rex_bits != 0) goto <D.58066>; else goto <D.58067>;
        <D.58066>:
        code.9932 = code;
        code.10109 = code.9932;
        code.10110 = code.10109 + 1;
        code = code.10110;
        D.58070 = _amd64_rex_bits | 64;
        *code.10109 = D.58070;
        <D.58067>:
      }
      switch (8) <default: <D.28897>, case 1: <D.28892>, case 2: <D.28894>, case 4: <D.28895>, case 8: <D.28896>>
      <D.28892>:
      code.9932 = code;
      code.10111 = code.9932;
      code.10112 = code.10111 + 1;
      code = code.10112;
      *code.10111 = 138;
      goto <D.28893>;
      <D.28894>:
      <D.28895>:
      <D.28896>:
      code.9932 = code;
      code.10113 = code.9932;
      code.10114 = code.10113 + 1;
      code = code.10114;
      *code.10113 = 139;
      goto <D.28893>;
      <D.28897>:
      __assert_fail ("0", "mini-amd64.c", 7964, &__PRETTY_FUNCTION__);
      <D.28893>:
      code.9932 = code;
      code.10115 = code.9932;
      code.10116 = code.10115 + 1;
      code = code.10116;
      D.58057 = param_regs[i];
      D.58077 = (unsigned char) D.58057;
      D.58078 = D.58077 & 7;
      D.58079 = D.58078 << 3;
      D.58061 = i + 1;
      D.58062 = param_regs[D.58061];
      D.58080 = (unsigned char) D.58062;
      D.58081 = D.58080 & 7;
      D.58082 = D.58079 | D.58081;
      D.58083 = D.58082 | 192;
      *code.10115 = D.58083;
      i = i + 1;
      <D.28899>:
      i.10117 = (unsigned int) i;
      if (i.10117 < param_count) goto <D.28898>; else goto <D.28900>;
      <D.28900>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.58085>; else goto <D.58086>;
        <D.58085>:
        code.9932 = code;
        code.10118 = code.9932;
        code.10119 = code.10118 + 1;
        code = code.10119;
        D.58089 = _amd64_rex_bits | 64;
        *code.10118 = D.58089;
        <D.58086>:
      }
      code.9932 = code;
      code.10120 = code.9932;
      code.10121 = code.10120 + 1;
      code = code.10121;
      *code.10120 = 255;
      if (0 != 0) goto <D.58092>; else goto <D.58093>;
      <D.58092>:
      code.9932 = code;
      code.10122 = code.9932;
      code.10123 = code.10122 + 1;
      code = code.10123;
      *code.10122 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10124 = code.9932;
            code.10125 = code.10124 + 1;
            code = code.10125;
            D.58098 = imb.b[0];
            *code.10124 = D.58098;
            code.9932 = code;
            code.10126 = code.9932;
            code.10127 = code.10126 + 1;
            code = code.10127;
            D.58101 = imb.b[1];
            *code.10126 = D.58101;
            code.9932 = code;
            code.10128 = code.9932;
            code.10129 = code.10128 + 1;
            code = code.10129;
            D.58104 = imb.b[2];
            *code.10128 = D.58104;
            code.9932 = code;
            code.10130 = code.9932;
            code.10131 = code.10130 + 1;
            code = code.10131;
            D.58107 = imb.b[3];
            *code.10130 = D.58107;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.58108>;
      <D.58093>:
      if (0 != 0) goto <D.58109>; else goto <D.58110>;
      <D.58109>:
      if (0 != 0) goto <D.58111>; else goto <D.58112>;
      <D.58111>:
      code.9932 = code;
      code.10132 = code.9932;
      code.10133 = code.10132 + 1;
      code = code.10133;
      *code.10132 = 36;
      code.9932 = code;
      code.10134 = code.9932;
      code.10135 = code.10134 + 1;
      code = code.10135;
      *code.10134 = 36;
      goto <D.58117>;
      <D.58112>:
      if (1 != 0) goto <D.58118>; else goto <D.58119>;
      <D.58118>:
      code.9932 = code;
      code.10136 = code.9932;
      code.10137 = code.10136 + 1;
      code = code.10137;
      *code.10136 = 100;
      code.9932 = code;
      code.10138 = code.9932;
      code.10139 = code.10138 + 1;
      code = code.10139;
      *code.10138 = 36;
      code.9932 = code;
      *code.9932 = 16;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.58124>;
      <D.58119>:
      code.9932 = code;
      code.10140 = code.9932;
      code.10141 = code.10140 + 1;
      code = code.10141;
      *code.10140 = 164;
      code.9932 = code;
      code.10142 = code.9932;
      code.10143 = code.10142 + 1;
      code = code.10143;
      *code.10142 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10144 = code.9932;
            code.10145 = code.10144 + 1;
            code = code.10145;
            D.58131 = imb.b[0];
            *code.10144 = D.58131;
            code.9932 = code;
            code.10146 = code.9932;
            code.10147 = code.10146 + 1;
            code = code.10147;
            D.58134 = imb.b[1];
            *code.10146 = D.58134;
            code.9932 = code;
            code.10148 = code.9932;
            code.10149 = code.10148 + 1;
            code = code.10149;
            D.58137 = imb.b[2];
            *code.10148 = D.58137;
            code.9932 = code;
            code.10150 = code.9932;
            code.10151 = code.10150 + 1;
            code = code.10151;
            D.58140 = imb.b[3];
            *code.10150 = D.58140;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.58124>:
      <D.58117>:
      goto <D.28904>;
      <D.58110>:
      if (0 != 0) goto <D.58141>; else goto <D.58142>;
      <D.58141>:
      code.9932 = code;
      code.10152 = code.9932;
      code.10153 = code.10152 + 1;
      code = code.10153;
      *code.10152 = 32;
      goto <D.28904>;
      <D.58142>:
      if (1 != 0) goto <D.58145>; else goto <D.58146>;
      <D.58145>:
      code.9932 = code;
      code.10154 = code.9932;
      code.10155 = code.10154 + 1;
      code = code.10155;
      *code.10154 = 96;
      code.9932 = code;
      *code.9932 = 16;
      code.9932 = code;
      code.9969 = code.9932 + 1;
      code = code.9969;
      goto <D.58149>;
      <D.58146>:
      code.9932 = code;
      code.10156 = code.9932;
      code.10157 = code.10156 + 1;
      code = code.10157;
      *code.10156 = 160;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.9932 = code;
            code.10158 = code.9932;
            code.10159 = code.10158 + 1;
            code = code.10159;
            D.58154 = imb.b[0];
            *code.10158 = D.58154;
            code.9932 = code;
            code.10160 = code.9932;
            code.10161 = code.10160 + 1;
            code = code.10161;
            D.58157 = imb.b[1];
            *code.10160 = D.58157;
            code.9932 = code;
            code.10162 = code.9932;
            code.10163 = code.10162 + 1;
            code = code.10163;
            D.58160 = imb.b[2];
            *code.10162 = D.58160;
            code.9932 = code;
            code.10164 = code.9932;
            code.10165 = code.10164 + 1;
            code = code.10165;
            D.58163 = imb.b[3];
            *code.10164 = D.58163;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.58149>:
      <D.28904>:
      <D.58108>:
      <D.58036>:
      code.9932 = code;
      code.10044 = (long int) code.9932;
      start.10045 = start;
      start.10046 = (long int) start.10045;
      D.57947 = code.10044 - start.10046;
      D.57948 = D.57947 > 63;
      D.57949 = (long int) D.57948;
      D.57950 = __builtin_expect (D.57949, 0);
      if (D.57950 != 0) goto <D.58164>; else goto <D.58165>;
      <D.58164>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 7970, "(code - start) < 64");
      <D.58165>:
      <D.57953>:
      nacl_global_codeman_validate (&start, 64, &code);
      code.9932 = code;
      code.10044 = (long int) code.9932;
      start.10045 = start;
      start.10046 = (long int) start.10045;
      D.57947 = code.10044 - start.10046;
      D.58166 = (int) D.57947;
      start.10045 = start;
      mono_debug_add_delegate_trampoline (start.10045, D.58166);
      if (code_len != 0B) goto <D.58167>; else goto <D.58168>;
      <D.58167>:
      code.9932 = code;
      code.10044 = (long int) code.9932;
      start.10045 = start;
      start.10046 = (long int) start.10045;
      D.57947 = code.10044 - start.10046;
      D.58169 = (unsigned int) D.57947;
      *code_len = D.58169;
      <D.58168>:
      D.58170 = mono_jit_map_is_enabled ();
      if (D.58170 != 0) goto <D.58171>; else goto <D.58172>;
      <D.58171>:
      {
        char * buff;

        if (has_target != 0) goto <D.58173>; else goto <D.58174>;
        <D.58173>:
        buff = "delegate_invoke_has_target";
        goto <D.58175>;
        <D.58174>:
        buff = monoeg_g_strdup_printf ("delegate_invoke_no_target_%d", param_count);
        <D.58175>:
        code.9932 = code;
        code.10044 = (long int) code.9932;
        start.10045 = start;
        start.10046 = (long int) start.10045;
        D.57947 = code.10044 - start.10046;
        D.58166 = (int) D.57947;
        start.10045 = start;
        mono_emit_jit_tramp (start.10045, D.58166, buff);
        if (has_target == 0) goto <D.58176>; else goto <D.58177>;
        <D.58176>:
        monoeg_g_free (buff);
        <D.58177>:
      }
      <D.58172>:
      D.58178 = start;
      return D.58178;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_get_delegate_invoke_impl (struct MonoMethodSignature * sig, gboolean has_target)
{
  short unsigned int D.58181;
  void * D.58184;
  struct MonoType * D.58185;
  struct MonoType * D.58186;
  int D.58187;
  guint8 * cached.10166;
  int mono_aot_only.10167;
  struct MonoType * D.58200;
  int D.58201;
  int D.58204;
  unsigned int D.58212;
  guint8 * code;
  guint8 * start;
  int i;

  D.58181 = sig->param_count;
  if (D.58181 > 10) goto <D.58182>; else goto <D.58183>;
  <D.58182>:
  D.58184 = 0B;
  return D.58184;
  <D.58183>:
  D.58185 = sig->ret;
  D.58186 = mini_replace_type (D.58185);
  D.58187 = mono_type_is_struct (D.58186);
  if (D.58187 != 0) goto <D.58188>; else goto <D.58189>;
  <D.58188>:
  D.58184 = 0B;
  return D.58184;
  <D.58189>:
  if (has_target != 0) goto <D.58190>; else goto <D.58191>;
  <D.58190>:
  {
    static guint8 * cached = 0B;

    cached.10166 = cached;
    if (cached.10166 != 0B) goto <D.58193>; else goto <D.58194>;
    <D.58193>:
    D.58184 = cached;
    return D.58184;
    <D.58194>:
    mono_aot_only.10167 = mono_aot_only;
    if (mono_aot_only.10167 != 0) goto <D.58196>; else goto <D.58197>;
    <D.58196>:
    start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
    goto <D.58198>;
    <D.58197>:
    start = get_delegate_invoke_impl (1, 0, 0B);
    <D.58198>:
    mono_memory_barrier ();
    cached = start;
  }
  goto <D.58199>;
  <D.58191>:
  {
    static guint8 * cache[11] = {0B};

    i = 0;
    goto <D.28928>;
    <D.28927>:
    D.58200 = sig->params[i];
    D.58201 = mono_is_regsize_var (D.58200);
    if (D.58201 == 0) goto <D.58202>; else goto <D.58203>;
    <D.58202>:
    D.58184 = 0B;
    return D.58184;
    <D.58203>:
    i = i + 1;
    <D.28928>:
    D.58181 = sig->param_count;
    D.58204 = (int) D.58181;
    if (D.58204 > i) goto <D.28927>; else goto <D.28929>;
    <D.28929>:
    D.58181 = sig->param_count;
    if (D.58181 > 4) goto <D.58205>; else goto <D.58206>;
    <D.58205>:
    D.58184 = 0B;
    return D.58184;
    <D.58206>:
    D.58181 = sig->param_count;
    D.58204 = (int) D.58181;
    code = cache[D.58204];
    if (code != 0B) goto <D.58207>; else goto <D.58208>;
    <D.58207>:
    D.58184 = code;
    return D.58184;
    <D.58208>:
    mono_aot_only.10167 = mono_aot_only;
    if (mono_aot_only.10167 != 0) goto <D.58209>; else goto <D.58210>;
    <D.58209>:
    {
      char * name;

      D.58181 = sig->param_count;
      D.58204 = (int) D.58181;
      name = monoeg_g_strdup_printf ("delegate_invoke_impl_target_%d", D.58204);
      start = mono_aot_get_trampoline (name);
      monoeg_g_free (name);
    }
    goto <D.58211>;
    <D.58210>:
    D.58181 = sig->param_count;
    D.58212 = (unsigned int) D.58181;
    start = get_delegate_invoke_impl (0, D.58212, 0B);
    <D.58211>:
    mono_memory_barrier ();
    D.58181 = sig->param_count;
    D.58204 = (int) D.58181;
    cache[D.58204] = start;
  }
  <D.58199>:
  D.58184 = start;
  return D.58184;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_arch_finish_init ()
{
  int D.58214;
  _Bool D.58215;
  int optimize_for_xen.10168;

  D.58214 = access ("/proc/xen", 0);
  D.58215 = D.58214 == 0;
  optimize_for_xen.10168 = (int) D.58215;
  optimize_for_xen = optimize_for_xen.10168;
}


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)
{
  long unsigned int vtable.10169;
  long int vtable.10170;
  int D.58219;
  long unsigned int D.58220;
  _Bool D.58221;
  long unsigned int D.58222;
  long unsigned int D.58223;
  struct MonoIMTCheckItem * * D.58224;
  unsigned char D.58225;
  int D.58228;
  unsigned char D.58231;
  void * D.58234;
  unsigned long D.58235;
  unsigned long D.58236;
  unsigned char D.58239;
  unsigned char D.58240;
  unsigned char D.58242;
  unsigned char D.58243;
  unsigned char D.58246;
  unsigned char D.58250;
  unsigned char D.58252;
  unsigned char D.58256;
  unsigned char D.58261;
  long unsigned int D.58266;
  long unsigned int D.58267;
  struct MonoIMTCheckItem * * D.58268;
  struct MonoIMTCheckItem * D.58269;
  int D.58270;
  void * code.10171;
  void * code.10172;
  guint8 * code.10173;
  unsigned char D.58277;
  int iftmp.10174;
  int D.58283;
  int D.58286;
  unsigned char D.58291;
  void * D.58293;
  unsigned long D.58294;
  unsigned long D.58295;
  long int D.58298;
  unsigned int D.58299;
  unsigned int D.58300;
  guint8 * code.10175;
  guint8 * code.10176;
  unsigned char D.58307;
  guint8 * code.10177;
  guint8 * code.10178;
  guint8 * code.10179;
  guint8 * code.10180;
  unsigned char D.58312;
  guint8 * code.10181;
  guint8 * code.10182;
  guint8 * code.10183;
  unsigned char D.58321;
  guint8 * code.10184;
  guint8 * code.10185;
  int D.58324;
  guint8 * code.10186;
  guint8 * code.10187;
  unsigned char D.58327;
  guint8 * code.10188;
  guint8 * code.10189;
  unsigned char D.58330;
  guint8 * code.10190;
  guint8 * code.10191;
  unsigned char D.58333;
  guint8 * code.10192;
  guint8 * code.10193;
  unsigned char D.58336;
  guint8 * code.10194;
  guint8 * code.10195;
  unsigned char D.58342;
  guint8 * code.10196;
  guint8 * code.10197;
  guint8 * code.10198;
  guint8 * code.10199;
  guint8 * code.10200;
  guint8 * code.10201;
  unsigned char D.58349;
  guint8 * code.10202;
  guint8 * code.10203;
  unsigned char D.58352;
  guint8 * code.10204;
  guint8 * code.10205;
  unsigned char D.58355;
  guint8 * code.10206;
  guint8 * code.10207;
  unsigned char D.58358;
  long unsigned int D.58360;
  long unsigned int D.58361;
  _Bool D.58362;
  unsigned char iftmp.10208;
  guint8 * code.10209;
  guint8 * code.10210;
  unsigned char D.58371;
  guint8 * code.10211;
  guint8 * code.10212;
  guint8 * code.10213;
  guint8 * code.10214;
  unsigned char D.58378;
  guint8 * code.10215;
  guint8 * code.10216;
  unsigned char D.58381;
  guint8 * code.10217;
  guint8 * code.10218;
  unsigned char D.58384;
  guint8 * code.10219;
  guint8 * code.10220;
  unsigned char D.58387;
  guint8 * code.10221;
  guint8 * code.10222;
  unsigned char D.58390;
  guint8 * code.10223;
  guint8 * code.10224;
  unsigned char D.58393;
  guint8 * code.10225;
  guint8 * code.10226;
  unsigned char D.58396;
  guint8 * code.10227;
  guint8 * code.10228;
  unsigned char D.58399;
  guint8 * code.10229;
  guint8 * code.10230;
  unsigned char D.58403;
  guint8 * code.10231;
  guint8 * code.10232;
  unsigned char D.58406;
  guint8 * code.10233;
  guint8 * code.10234;
  unsigned char D.58409;
  guint8 * code.10235;
  guint8 * code.10236;
  unsigned char D.58412;
  guint8 * code.10237;
  guint8 * code.10238;
  unsigned char D.58417;
  guint8 * code.10239;
  guint8 * code.10240;
  guint8 * code.10241;
  guint8 * code.10242;
  guint8 * code.10243;
  guint8 * code.10244;
  unsigned char D.58426;
  guint8 * code.10245;
  guint8 * code.10246;
  unsigned char D.58430;
  unsigned char D.58431;
  void * D.58434;
  long unsigned int D.58435;
  long int D.58436;
  int D.58437;
  long unsigned int D.58438;
  _Bool D.58439;
  unsigned char iftmp.10247;
  guint8 * code.10248;
  guint8 * code.10249;
  unsigned char D.58448;
  guint8 * code.10250;
  guint8 * code.10251;
  guint8 * code.10252;
  guint8 * code.10253;
  unsigned char D.58455;
  guint8 * code.10254;
  guint8 * code.10255;
  unsigned char D.58458;
  guint8 * code.10256;
  guint8 * code.10257;
  unsigned char D.58461;
  guint8 * code.10258;
  guint8 * code.10259;
  unsigned char D.58464;
  guint8 * code.10260;
  guint8 * code.10261;
  unsigned char D.58467;
  guint8 * code.10262;
  guint8 * code.10263;
  unsigned char D.58470;
  guint8 * code.10264;
  guint8 * code.10265;
  unsigned char D.58473;
  guint8 * code.10266;
  guint8 * code.10267;
  unsigned char D.58476;
  guint8 * code.10268;
  guint8 * code.10269;
  unsigned char D.58480;
  guint8 * code.10270;
  guint8 * code.10271;
  unsigned char D.58483;
  guint8 * code.10272;
  guint8 * code.10273;
  unsigned char D.58486;
  guint8 * code.10274;
  guint8 * code.10275;
  unsigned char D.58489;
  guint8 * code.10276;
  guint8 * code.10277;
  unsigned char D.58494;
  guint8 * code.10278;
  guint8 * code.10279;
  guint8 * code.10280;
  guint8 * code.10281;
  int D.58500;
  void * * D.58501;
  long unsigned int D.58502;
  long int D.58503;
  int D.58504;
  long unsigned int D.58505;
  _Bool D.58506;
  unsigned char iftmp.10282;
  guint8 * code.10283;
  guint8 * code.10284;
  unsigned char D.58515;
  guint8 * code.10285;
  guint8 * code.10286;
  guint8 * code.10287;
  guint8 * code.10288;
  unsigned char D.58522;
  guint8 * code.10289;
  guint8 * code.10290;
  unsigned char D.58525;
  guint8 * code.10291;
  guint8 * code.10292;
  unsigned char D.58528;
  guint8 * code.10293;
  guint8 * code.10294;
  unsigned char D.58531;
  guint8 * code.10295;
  guint8 * code.10296;
  unsigned char D.58534;
  guint8 * code.10297;
  guint8 * code.10298;
  unsigned char D.58537;
  guint8 * code.10299;
  guint8 * code.10300;
  unsigned char D.58540;
  guint8 * code.10301;
  guint8 * code.10302;
  unsigned char D.58543;
  guint8 * code.10303;
  guint8 * code.10304;
  unsigned char D.58547;
  guint8 * code.10305;
  guint8 * code.10306;
  unsigned char D.58550;
  guint8 * code.10307;
  guint8 * code.10308;
  unsigned char D.58553;
  guint8 * code.10309;
  guint8 * code.10310;
  unsigned char D.58556;
  guint8 * code.10311;
  guint8 * code.10312;
  unsigned char D.58561;
  guint8 * code.10313;
  guint8 * code.10314;
  guint8 * code.10315;
  guint8 * code.10316;
  guint8 * code.10317;
  guint8 * code.10318;
  unsigned char D.58570;
  guint8 * code.10319;
  guint8 * code.10320;
  unsigned char D.58573;
  guint8 * code.10321;
  guint8 * code.10322;
  unsigned char D.58576;
  guint8 * code.10323;
  guint8 * code.10324;
  unsigned char D.58579;
  guint8 * code.10325;
  guint8 * code.10326;
  guint8 * code.10327;
  guint8 * code.10328;
  guint8 * code.10329;
  guint8 * code.10330;
  guint8 * code.10331;
  guint8 * code.10332;
  guint8 * code.10333;
  guint8 * code.10334;
  guint8 * code.10335;
  guint8 * code.10336;
  guint8 * code.10337;
  guint8 * code.10338;
  unsigned char D.58603;
  guint8 * code.10339;
  guint8 * code.10340;
  unsigned char D.58606;
  guint8 * code.10341;
  guint8 * code.10342;
  unsigned char D.58609;
  guint8 * code.10343;
  guint8 * code.10344;
  unsigned char D.58612;
  guint8 * code.10345;
  guint8 * code.10346;
  guint8 * code.10347;
  guint8 * code.10348;
  guint8 * code.10349;
  guint8 * code.10350;
  guint8 * code.10351;
  guint8 * code.10352;
  unsigned char D.58626;
  guint8 * code.10353;
  guint8 * code.10354;
  unsigned char D.58629;
  guint8 * code.10355;
  guint8 * code.10356;
  unsigned char D.58632;
  guint8 * code.10357;
  guint8 * code.10358;
  unsigned char D.58635;
  guint8 * D.58638;
  long unsigned int fail_tramp.10359;
  long int fail_tramp.10360;
  int D.58641;
  long unsigned int D.58642;
  _Bool D.58643;
  unsigned char iftmp.10361;
  guint8 * code.10362;
  guint8 * code.10363;
  unsigned char D.58652;
  guint8 * code.10364;
  guint8 * code.10365;
  guint8 * code.10366;
  guint8 * code.10367;
  unsigned char D.58659;
  guint8 * code.10368;
  guint8 * code.10369;
  unsigned char D.58662;
  guint8 * code.10370;
  guint8 * code.10371;
  unsigned char D.58665;
  guint8 * code.10372;
  guint8 * code.10373;
  unsigned char D.58668;
  guint8 * code.10374;
  guint8 * code.10375;
  unsigned char D.58671;
  guint8 * code.10376;
  guint8 * code.10377;
  unsigned char D.58674;
  guint8 * code.10378;
  guint8 * code.10379;
  unsigned char D.58677;
  guint8 * code.10380;
  guint8 * code.10381;
  unsigned char D.58680;
  guint8 * code.10382;
  guint8 * code.10383;
  unsigned char D.58684;
  guint8 * code.10384;
  guint8 * code.10385;
  unsigned char D.58687;
  guint8 * code.10386;
  guint8 * code.10387;
  unsigned char D.58690;
  guint8 * code.10388;
  guint8 * code.10389;
  unsigned char D.58693;
  guint8 * code.10390;
  guint8 * code.10391;
  unsigned char D.58698;
  guint8 * code.10392;
  guint8 * code.10393;
  guint8 * code.10394;
  guint8 * code.10395;
  unsigned char iftmp.10396;
  guint8 * code.10397;
  guint8 * code.10398;
  unsigned char D.58712;
  guint8 * code.10399;
  guint8 * code.10400;
  guint8 * code.10401;
  guint8 * code.10402;
  unsigned char D.58719;
  guint8 * code.10403;
  guint8 * code.10404;
  unsigned char D.58722;
  guint8 * code.10405;
  guint8 * code.10406;
  unsigned char D.58725;
  guint8 * code.10407;
  guint8 * code.10408;
  unsigned char D.58728;
  guint8 * code.10409;
  guint8 * code.10410;
  unsigned char D.58731;
  guint8 * code.10411;
  guint8 * code.10412;
  unsigned char D.58734;
  guint8 * code.10413;
  guint8 * code.10414;
  unsigned char D.58737;
  guint8 * code.10415;
  guint8 * code.10416;
  unsigned char D.58740;
  guint8 * code.10417;
  guint8 * code.10418;
  unsigned char D.58744;
  guint8 * code.10419;
  guint8 * code.10420;
  unsigned char D.58747;
  guint8 * code.10421;
  guint8 * code.10422;
  unsigned char D.58750;
  guint8 * code.10423;
  guint8 * code.10424;
  unsigned char D.58753;
  guint8 * code.10425;
  guint8 * code.10426;
  unsigned char D.58758;
  guint8 * code.10427;
  guint8 * code.10428;
  guint8 * code.10429;
  guint8 * code.10430;
  guint8 * code.10431;
  guint8 * code.10432;
  unsigned char D.58767;
  guint8 * code.10433;
  guint8 * code.10434;
  unsigned char D.58770;
  guint8 * code.10435;
  guint8 * code.10436;
  unsigned char D.58773;
  guint8 * code.10437;
  guint8 * code.10438;
  unsigned char D.58776;
  guint8 * code.10439;
  guint8 * code.10440;
  guint8 * code.10441;
  guint8 * code.10442;
  guint8 * code.10443;
  guint8 * code.10444;
  guint8 * code.10445;
  guint8 * code.10446;
  guint8 * code.10447;
  guint8 * code.10448;
  guint8 * code.10449;
  guint8 * code.10450;
  guint8 * code.10451;
  guint8 * code.10452;
  unsigned char D.58800;
  guint8 * code.10453;
  guint8 * code.10454;
  unsigned char D.58803;
  guint8 * code.10455;
  guint8 * code.10456;
  unsigned char D.58806;
  guint8 * code.10457;
  guint8 * code.10458;
  unsigned char D.58809;
  guint8 * code.10459;
  guint8 * code.10460;
  guint8 * code.10461;
  guint8 * code.10462;
  guint8 * code.10463;
  guint8 * code.10464;
  guint8 * code.10465;
  guint8 * code.10466;
  unsigned char D.58823;
  guint8 * code.10467;
  guint8 * code.10468;
  unsigned char D.58826;
  guint8 * code.10469;
  guint8 * code.10470;
  unsigned char D.58829;
  guint8 * code.10471;
  guint8 * code.10472;
  unsigned char D.58832;
  guint8 * code.10473;
  guint8 * code.10474;
  unsigned char D.58842;
  guint8 * code.10475;
  guint8 * code.10476;
  guint8 * code.10477;
  guint8 * code.10478;
  guint8 * code.10479;
  guint8 * code.10480;
  unsigned char D.58854;
  guint8 * code.10481;
  guint8 * code.10482;
  guint8 * code.10483;
  guint8 * code.10484;
  unsigned char D.58859;
  guint8 * code.10485;
  guint8 * code.10486;
  unsigned char D.58862;
  guint8 * code.10487;
  guint8 * code.10488;
  unsigned char D.58865;
  guint8 * code.10489;
  guint8 * code.10490;
  unsigned char D.58868;
  guint8 * code.10491;
  guint8 * code.10492;
  unsigned char D.58874;
  guint8 * code.10493;
  guint8 * code.10494;
  guint8 * code.10495;
  guint8 * code.10496;
  guint8 * code.10497;
  guint8 * code.10498;
  unsigned char D.58881;
  guint8 * code.10499;
  guint8 * code.10500;
  unsigned char D.58884;
  guint8 * code.10501;
  guint8 * code.10502;
  unsigned char D.58887;
  guint8 * code.10503;
  guint8 * code.10504;
  unsigned char D.58890;
  unsigned char iftmp.10505;
  guint8 * code.10506;
  guint8 * code.10507;
  unsigned char D.58900;
  guint8 * code.10508;
  guint8 * code.10509;
  guint8 * code.10510;
  guint8 * code.10511;
  unsigned char D.58907;
  guint8 * code.10512;
  guint8 * code.10513;
  unsigned char D.58910;
  guint8 * code.10514;
  guint8 * code.10515;
  unsigned char D.58913;
  guint8 * code.10516;
  guint8 * code.10517;
  unsigned char D.58916;
  guint8 * code.10518;
  guint8 * code.10519;
  unsigned char D.58919;
  guint8 * code.10520;
  guint8 * code.10521;
  unsigned char D.58922;
  guint8 * code.10522;
  guint8 * code.10523;
  unsigned char D.58925;
  guint8 * code.10524;
  guint8 * code.10525;
  unsigned char D.58928;
  guint8 * code.10526;
  guint8 * code.10527;
  unsigned char D.58932;
  guint8 * code.10528;
  guint8 * code.10529;
  unsigned char D.58935;
  guint8 * code.10530;
  guint8 * code.10531;
  unsigned char D.58938;
  guint8 * code.10532;
  guint8 * code.10533;
  unsigned char D.58941;
  guint8 * code.10534;
  guint8 * code.10535;
  unsigned char D.58946;
  guint8 * code.10536;
  guint8 * code.10537;
  guint8 * code.10538;
  guint8 * code.10539;
  int D.58953;
  int D.58955;
  guint8 * code.10540;
  guint8 * code.10541;
  unsigned char D.58961;
  guint8 * code.10542;
  guint8 * code.10543;
  unsigned char D.58965;
  guint8 * code.10544;
  guint8 * code.10545;
  guint8 * code.10546;
  guint8 * code.10547;
  unsigned char D.58972;
  guint8 * code.10548;
  guint8 * code.10549;
  unsigned char D.58976;
  guint8 * code.10550;
  guint8 * code.10551;
  unsigned char D.58979;
  guint8 * code.10552;
  guint8 * code.10553;
  unsigned char D.58982;
  guint8 * code.10554;
  guint8 * code.10555;
  unsigned char D.58985;
  guint8 * code.10556;
  guint8 * code.10557;
  unsigned char D.58988;
  long int code.10558;
  guint8 * D.58990;
  long int D.58991;
  long int D.58992;
  unsigned char D.58993;
  long int D.58994;
  _Bool D.58995;
  long int D.58996;
  long int D.58997;
  guint8 * D.59000;
  int D.59003;
  long unsigned int D.59006;
  long unsigned int D.59007;
  struct MonoIMTCheckItem * * D.59008;
  struct MonoIMTCheckItem * D.59009;
  guint8 * D.59010;
  long unsigned int D.59013;
  guint8 * start.10559;
  long int start.10560;
  long int D.59016;
  long unsigned int D.59017;
  long unsigned int D.59018;
  long int D.59019;
  _Bool D.59020;
  long int D.59021;
  long int D.59022;
  void * D.59025;
  int i;
  int size;
  guint8 * code;
  guint8 * start;
  gboolean vtable_is_32bit;

  try
    {
      size = 0;
      vtable.10169 = (long unsigned int) vtable;
      vtable.10170 = (long int) vtable;
      D.58219 = (int) vtable.10170;
      D.58220 = (long unsigned int) D.58219;
      D.58221 = vtable.10169 == D.58220;
      vtable_is_32bit = (gboolean) D.58221;
      i = 0;
      goto <D.28961>;
      <D.28960>:
      {
        struct MonoIMTCheckItem * item;

        D.58222 = (long unsigned int) i;
        D.58223 = D.58222 * 8;
        D.58224 = imt_entries + D.58223;
        item = *D.58224;
        D.58225 = item->is_equals;
        if (D.58225 != 0) goto <D.58226>; else goto <D.58227>;
        <D.58226>:
        D.58228 = item->check_target_idx;
        if (D.58228 != 0) goto <D.58229>; else goto <D.58230>;
        <D.58229>:
        D.58231 = item->compare_done;
        if (D.58231 == 0) goto <D.58232>; else goto <D.58233>;
        <D.58232>:
        D.58234 = item->key;
        D.58235 = (unsigned long) D.58234;
        D.58236 = D.58235 + 2147483648;
        if (D.58236 <= 4294967295) goto <D.58237>; else goto <D.58238>;
        <D.58237>:
        D.58239 = item->chunk_size;
        D.58240 = D.58239 + 7;
        item->chunk_size = D.58240;
        goto <D.58241>;
        <D.58238>:
        D.58239 = item->chunk_size;
        D.58242 = D.58239 + 15;
        item->chunk_size = D.58242;
        <D.58241>:
        <D.58233>:
        D.58243 = item->has_target_code;
        if (D.58243 != 0) goto <D.58244>; else goto <D.58245>;
        <D.58244>:
        D.58239 = item->chunk_size;
        D.58246 = D.58239 + 10;
        item->chunk_size = D.58246;
        goto <D.58247>;
        <D.58245>:
        if (vtable_is_32bit != 0) goto <D.58248>; else goto <D.58249>;
        <D.58248>:
        D.58239 = item->chunk_size;
        D.58250 = D.58239 + 6;
        item->chunk_size = D.58250;
        goto <D.58251>;
        <D.58249>:
        D.58239 = item->chunk_size;
        D.58246 = D.58239 + 10;
        item->chunk_size = D.58246;
        <D.58251>:
        <D.58247>:
        D.58239 = item->chunk_size;
        D.58252 = D.58239 + 5;
        item->chunk_size = D.58252;
        goto <D.58253>;
        <D.58230>:
        if (fail_tramp != 0B) goto <D.58254>; else goto <D.58255>;
        <D.58254>:
        D.58239 = item->chunk_size;
        D.58256 = D.58239 + 43;
        item->chunk_size = D.58256;
        goto <D.58257>;
        <D.58255>:
        if (vtable_is_32bit != 0) goto <D.58258>; else goto <D.58259>;
        <D.58258>:
        D.58239 = item->chunk_size;
        D.58250 = D.58239 + 6;
        item->chunk_size = D.58250;
        goto <D.58260>;
        <D.58259>:
        D.58239 = item->chunk_size;
        D.58246 = D.58239 + 10;
        item->chunk_size = D.58246;
        <D.58260>:
        D.58239 = item->chunk_size;
        D.58261 = D.58239 + 3;
        item->chunk_size = D.58261;
        <D.58257>:
        <D.58253>:
        goto <D.58262>;
        <D.58227>:
        D.58234 = item->key;
        D.58235 = (unsigned long) D.58234;
        D.58236 = D.58235 + 2147483648;
        if (D.58236 <= 4294967295) goto <D.58263>; else goto <D.58264>;
        <D.58263>:
        D.58239 = item->chunk_size;
        D.58240 = D.58239 + 7;
        item->chunk_size = D.58240;
        goto <D.58265>;
        <D.58264>:
        D.58239 = item->chunk_size;
        D.58242 = D.58239 + 15;
        item->chunk_size = D.58242;
        <D.58265>:
        D.58239 = item->chunk_size;
        D.58250 = D.58239 + 6;
        item->chunk_size = D.58250;
        D.58228 = item->check_target_idx;
        D.58266 = (long unsigned int) D.58228;
        D.58267 = D.58266 * 8;
        D.58268 = imt_entries + D.58267;
        D.58269 = *D.58268;
        D.58269->compare_done = 1;
        <D.58262>:
        D.58239 = item->chunk_size;
        D.58270 = (int) D.58239;
        size = D.58270 + size;
      }
      i = i + 1;
      <D.28961>:
      if (i < count) goto <D.28960>; else goto <D.28962>;
      <D.28962>:
      if (fail_tramp != 0B) goto <D.58271>; else goto <D.58272>;
      <D.58271>:
      code.10171 = mono_method_alloc_generic_virtual_thunk (domain, size);
      code = code.10171;
      goto <D.58274>;
      <D.58272>:
      code.10172 = mono_domain_code_reserve (domain, size);
      code = code.10172;
      <D.58274>:
      code.10173 = code;
      start = code.10173;
      i = 0;
      goto <D.29015>;
      <D.29014>:
      {
        struct MonoIMTCheckItem * item;

        D.58222 = (long unsigned int) i;
        D.58223 = D.58222 * 8;
        D.58224 = imt_entries + D.58223;
        item = *D.58224;
        code.10173 = code;
        item->code_target = code.10173;
        D.58277 = item->is_equals;
        if (D.58277 != 0) goto <D.58278>; else goto <D.58279>;
        <D.58278>:
        {
          gboolean fail_case;

          D.58283 = item->check_target_idx;
          if (D.58283 == 0) goto <D.58284>; else goto <D.58281>;
          <D.58284>:
          if (fail_tramp != 0B) goto <D.58285>; else goto <D.58281>;
          <D.58285>:
          iftmp.10174 = 1;
          goto <D.58282>;
          <D.58281>:
          iftmp.10174 = 0;
          <D.58282>:
          fail_case = iftmp.10174;
          D.58283 = item->check_target_idx;
          D.58286 = D.58283 | fail_case;
          if (D.58286 != 0) goto <D.58287>; else goto <D.58288>;
          <D.58287>:
          D.58291 = item->compare_done;
          if (D.58291 == 0) goto <D.58289>; else goto <D.58292>;
          <D.58292>:
          if (fail_case != 0) goto <D.58289>; else goto <D.58290>;
          <D.58289>:
          D.58293 = item->key;
          D.58294 = (unsigned long) D.58293;
          D.58295 = D.58294 + 2147483648;
          if (D.58295 <= 4294967295) goto <D.58296>; else goto <D.58297>;
          <D.58296>:
          D.58293 = item->key;
          D.58298 = (long int) D.58293;
          D.58299 = (unsigned int) D.58298;
          D.58300 = D.58299 + 128;
          if (D.58300 <= 255) goto <D.58301>; else goto <D.58302>;
          <D.58301>:
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 9;
            if (_amd64_rex_bits != 0) goto <D.58303>; else goto <D.58304>;
            <D.58303>:
            code.10173 = code;
            code.10175 = code.10173;
            code.10176 = code.10175 + 1;
            code = code.10176;
            D.58307 = _amd64_rex_bits | 64;
            *code.10175 = D.58307;
            <D.58304>:
          }
          code.10173 = code;
          code.10177 = code.10173;
          code.10178 = code.10177 + 1;
          code = code.10178;
          *code.10177 = 131;
          code.10173 = code;
          code.10179 = code.10173;
          code.10180 = code.10179 + 1;
          code = code.10180;
          *code.10179 = 250;
          code.10173 = code;
          D.58293 = item->key;
          D.58298 = (long int) D.58293;
          D.58312 = (unsigned char) D.58298;
          *code.10173 = D.58312;
          code.10173 = code;
          code.10181 = code.10173 + 1;
          code = code.10181;
          goto <D.58314>;
          <D.58302>:
          if (0 != 0) goto <D.58315>; else goto <D.58316>;
          <D.58315>:
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 8;
            if (_amd64_rex_bits != 0) goto <D.58317>; else goto <D.58318>;
            <D.58317>:
            code.10173 = code;
            code.10182 = code.10173;
            code.10183 = code.10182 + 1;
            code = code.10183;
            D.58321 = _amd64_rex_bits | 64;
            *code.10182 = D.58321;
            <D.58318>:
          }
          code.10173 = code;
          code.10184 = code.10173;
          code.10185 = code.10184 + 1;
          code = code.10185;
          *code.10184 = 61;
          {
            union x86_imm_buf imb;

            try
              {
                D.58293 = item->key;
                D.58298 = (long int) D.58293;
                D.58324 = (int) D.58298;
                imb.val = D.58324;
                code.10173 = code;
                code.10186 = code.10173;
                code.10187 = code.10186 + 1;
                code = code.10187;
                D.58327 = imb.b[0];
                *code.10186 = D.58327;
                code.10173 = code;
                code.10188 = code.10173;
                code.10189 = code.10188 + 1;
                code = code.10189;
                D.58330 = imb.b[1];
                *code.10188 = D.58330;
                code.10173 = code;
                code.10190 = code.10173;
                code.10191 = code.10190 + 1;
                code = code.10191;
                D.58333 = imb.b[2];
                *code.10190 = D.58333;
                code.10173 = code;
                code.10192 = code.10173;
                code.10193 = code.10192 + 1;
                code = code.10193;
                D.58336 = imb.b[3];
                *code.10192 = D.58336;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.58337>;
          <D.58316>:
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 9;
            if (_amd64_rex_bits != 0) goto <D.58338>; else goto <D.58339>;
            <D.58338>:
            code.10173 = code;
            code.10194 = code.10173;
            code.10195 = code.10194 + 1;
            code = code.10195;
            D.58342 = _amd64_rex_bits | 64;
            *code.10194 = D.58342;
            <D.58339>:
          }
          code.10173 = code;
          code.10196 = code.10173;
          code.10197 = code.10196 + 1;
          code = code.10197;
          *code.10196 = 129;
          code.10173 = code;
          code.10198 = code.10173;
          code.10199 = code.10198 + 1;
          code = code.10199;
          *code.10198 = 250;
          {
            union x86_imm_buf imb;

            try
              {
                D.58293 = item->key;
                D.58298 = (long int) D.58293;
                D.58324 = (int) D.58298;
                imb.val = D.58324;
                code.10173 = code;
                code.10200 = code.10173;
                code.10201 = code.10200 + 1;
                code = code.10201;
                D.58349 = imb.b[0];
                *code.10200 = D.58349;
                code.10173 = code;
                code.10202 = code.10173;
                code.10203 = code.10202 + 1;
                code = code.10203;
                D.58352 = imb.b[1];
                *code.10202 = D.58352;
                code.10173 = code;
                code.10204 = code.10173;
                code.10205 = code.10204 + 1;
                code = code.10205;
                D.58355 = imb.b[2];
                *code.10204 = D.58355;
                code.10173 = code;
                code.10206 = code.10173;
                code.10207 = code.10206 + 1;
                code = code.10207;
                D.58358 = imb.b[3];
                *code.10206 = D.58358;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.58337>:
          <D.58314>:
          goto <D.58359>;
          <D.58297>:
          {
            int _amd64_width_temp;

            D.58293 = item->key;
            D.58360 = (long unsigned int) D.58293;
            D.58293 = item->key;
            D.58298 = (long int) D.58293;
            D.58324 = (int) D.58298;
            D.58361 = (long unsigned int) D.58324;
            D.58362 = D.58360 == D.58361;
            _amd64_width_temp = (int) D.58362;
            {
              unsigned char _amd64_rex_bits;

              if (_amd64_width_temp == 0) goto <D.58364>; else goto <D.58365>;
              <D.58364>:
              iftmp.10208 = 9;
              goto <D.58366>;
              <D.58365>:
              iftmp.10208 = 1;
              <D.58366>:
              _amd64_rex_bits = iftmp.10208;
              if (_amd64_rex_bits != 0) goto <D.58367>; else goto <D.58368>;
              <D.58367>:
              code.10173 = code;
              code.10209 = code.10173;
              code.10210 = code.10209 + 1;
              code = code.10210;
              D.58371 = _amd64_rex_bits | 64;
              *code.10209 = D.58371;
              <D.58368>:
            }
            code.10173 = code;
            code.10211 = code.10173;
            code.10212 = code.10211 + 1;
            code = code.10212;
            *code.10211 = 187;
            if (_amd64_width_temp == 0) goto <D.58374>; else goto <D.58375>;
            <D.58374>:
            {
              union amd64_imm_buf imb;

              try
                {
                  D.58293 = item->key;
                  D.58360 = (long unsigned int) D.58293;
                  imb.val = D.58360;
                  code.10173 = code;
                  code.10213 = code.10173;
                  code.10214 = code.10213 + 1;
                  code = code.10214;
                  D.58378 = imb.b[0];
                  *code.10213 = D.58378;
                  code.10173 = code;
                  code.10215 = code.10173;
                  code.10216 = code.10215 + 1;
                  code = code.10216;
                  D.58381 = imb.b[1];
                  *code.10215 = D.58381;
                  code.10173 = code;
                  code.10217 = code.10173;
                  code.10218 = code.10217 + 1;
                  code = code.10218;
                  D.58384 = imb.b[2];
                  *code.10217 = D.58384;
                  code.10173 = code;
                  code.10219 = code.10173;
                  code.10220 = code.10219 + 1;
                  code = code.10220;
                  D.58387 = imb.b[3];
                  *code.10219 = D.58387;
                  code.10173 = code;
                  code.10221 = code.10173;
                  code.10222 = code.10221 + 1;
                  code = code.10222;
                  D.58390 = imb.b[4];
                  *code.10221 = D.58390;
                  code.10173 = code;
                  code.10223 = code.10173;
                  code.10224 = code.10223 + 1;
                  code = code.10224;
                  D.58393 = imb.b[5];
                  *code.10223 = D.58393;
                  code.10173 = code;
                  code.10225 = code.10173;
                  code.10226 = code.10225 + 1;
                  code = code.10226;
                  D.58396 = imb.b[6];
                  *code.10225 = D.58396;
                  code.10173 = code;
                  code.10227 = code.10173;
                  code.10228 = code.10227 + 1;
                  code = code.10228;
                  D.58399 = imb.b[7];
                  *code.10227 = D.58399;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            goto <D.58400>;
            <D.58375>:
            {
              union x86_imm_buf imb;

              try
                {
                  D.58293 = item->key;
                  D.58298 = (long int) D.58293;
                  D.58324 = (int) D.58298;
                  imb.val = D.58324;
                  code.10173 = code;
                  code.10229 = code.10173;
                  code.10230 = code.10229 + 1;
                  code = code.10230;
                  D.58403 = imb.b[0];
                  *code.10229 = D.58403;
                  code.10173 = code;
                  code.10231 = code.10173;
                  code.10232 = code.10231 + 1;
                  code = code.10232;
                  D.58406 = imb.b[1];
                  *code.10231 = D.58406;
                  code.10173 = code;
                  code.10233 = code.10173;
                  code.10234 = code.10233 + 1;
                  code = code.10234;
                  D.58409 = imb.b[2];
                  *code.10233 = D.58409;
                  code.10173 = code;
                  code.10235 = code.10173;
                  code.10236 = code.10235 + 1;
                  code = code.10236;
                  D.58412 = imb.b[3];
                  *code.10235 = D.58412;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.58400>:
          }
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 13;
            if (_amd64_rex_bits != 0) goto <D.58413>; else goto <D.58414>;
            <D.58413>:
            code.10173 = code;
            code.10237 = code.10173;
            code.10238 = code.10237 + 1;
            code = code.10238;
            D.58417 = _amd64_rex_bits | 64;
            *code.10237 = D.58417;
            <D.58414>:
          }
          code.10173 = code;
          code.10239 = code.10173;
          code.10240 = code.10239 + 1;
          code = code.10240;
          *code.10239 = 59;
          code.10173 = code;
          code.10241 = code.10173;
          code.10242 = code.10241 + 1;
          code = code.10242;
          *code.10241 = 211;
          <D.58359>:
          <D.58290>:
          code.10173 = code;
          item->jmp_code = code.10173;
          if (0 != 0) goto <D.58422>; else goto <D.58423>;
          <D.58422>:
          code.10173 = code;
          code.10243 = code.10173;
          code.10244 = code.10243 + 1;
          code = code.10244;
          D.58426 = 117;
          *code.10243 = D.58426;
          goto <D.58427>;
          <D.58423>:
          code.10173 = code;
          code.10245 = code.10173;
          code.10246 = code.10245 + 1;
          code = code.10246;
          D.58430 = 117;
          *code.10245 = D.58430;
          <D.58427>:
          code.10173 = code;
          *code.10173 = 0;
          code.10173 = code;
          code.10181 = code.10173 + 1;
          code = code.10181;
          D.58431 = item->has_target_code;
          if (D.58431 != 0) goto <D.58432>; else goto <D.58433>;
          <D.58432>:
          {
            int _amd64_width_temp;

            D.58434 = item->value.target_code;
            D.58435 = (long unsigned int) D.58434;
            D.58434 = item->value.target_code;
            D.58436 = (long int) D.58434;
            D.58437 = (int) D.58436;
            D.58438 = (long unsigned int) D.58437;
            D.58439 = D.58435 == D.58438;
            _amd64_width_temp = (int) D.58439;
            {
              unsigned char _amd64_rex_bits;

              if (_amd64_width_temp == 0) goto <D.58441>; else goto <D.58442>;
              <D.58441>:
              iftmp.10247 = 9;
              goto <D.58443>;
              <D.58442>:
              iftmp.10247 = 1;
              <D.58443>:
              _amd64_rex_bits = iftmp.10247;
              if (_amd64_rex_bits != 0) goto <D.58444>; else goto <D.58445>;
              <D.58444>:
              code.10173 = code;
              code.10248 = code.10173;
              code.10249 = code.10248 + 1;
              code = code.10249;
              D.58448 = _amd64_rex_bits | 64;
              *code.10248 = D.58448;
              <D.58445>:
            }
            code.10173 = code;
            code.10250 = code.10173;
            code.10251 = code.10250 + 1;
            code = code.10251;
            *code.10250 = 187;
            if (_amd64_width_temp == 0) goto <D.58451>; else goto <D.58452>;
            <D.58451>:
            {
              union amd64_imm_buf imb;

              try
                {
                  D.58434 = item->value.target_code;
                  D.58435 = (long unsigned int) D.58434;
                  imb.val = D.58435;
                  code.10173 = code;
                  code.10252 = code.10173;
                  code.10253 = code.10252 + 1;
                  code = code.10253;
                  D.58455 = imb.b[0];
                  *code.10252 = D.58455;
                  code.10173 = code;
                  code.10254 = code.10173;
                  code.10255 = code.10254 + 1;
                  code = code.10255;
                  D.58458 = imb.b[1];
                  *code.10254 = D.58458;
                  code.10173 = code;
                  code.10256 = code.10173;
                  code.10257 = code.10256 + 1;
                  code = code.10257;
                  D.58461 = imb.b[2];
                  *code.10256 = D.58461;
                  code.10173 = code;
                  code.10258 = code.10173;
                  code.10259 = code.10258 + 1;
                  code = code.10259;
                  D.58464 = imb.b[3];
                  *code.10258 = D.58464;
                  code.10173 = code;
                  code.10260 = code.10173;
                  code.10261 = code.10260 + 1;
                  code = code.10261;
                  D.58467 = imb.b[4];
                  *code.10260 = D.58467;
                  code.10173 = code;
                  code.10262 = code.10173;
                  code.10263 = code.10262 + 1;
                  code = code.10263;
                  D.58470 = imb.b[5];
                  *code.10262 = D.58470;
                  code.10173 = code;
                  code.10264 = code.10173;
                  code.10265 = code.10264 + 1;
                  code = code.10265;
                  D.58473 = imb.b[6];
                  *code.10264 = D.58473;
                  code.10173 = code;
                  code.10266 = code.10173;
                  code.10267 = code.10266 + 1;
                  code = code.10267;
                  D.58476 = imb.b[7];
                  *code.10266 = D.58476;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            goto <D.58477>;
            <D.58452>:
            {
              union x86_imm_buf imb;

              try
                {
                  D.58434 = item->value.target_code;
                  D.58436 = (long int) D.58434;
                  D.58437 = (int) D.58436;
                  imb.val = D.58437;
                  code.10173 = code;
                  code.10268 = code.10173;
                  code.10269 = code.10268 + 1;
                  code = code.10269;
                  D.58480 = imb.b[0];
                  *code.10268 = D.58480;
                  code.10173 = code;
                  code.10270 = code.10173;
                  code.10271 = code.10270 + 1;
                  code = code.10271;
                  D.58483 = imb.b[1];
                  *code.10270 = D.58483;
                  code.10173 = code;
                  code.10272 = code.10173;
                  code.10273 = code.10272 + 1;
                  code = code.10273;
                  D.58486 = imb.b[2];
                  *code.10272 = D.58486;
                  code.10173 = code;
                  code.10274 = code.10173;
                  code.10275 = code.10274 + 1;
                  code = code.10275;
                  D.58489 = imb.b[3];
                  *code.10274 = D.58489;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.58477>:
          }
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 1;
            if (_amd64_rex_bits != 0) goto <D.58490>; else goto <D.58491>;
            <D.58490>:
            code.10173 = code;
            code.10276 = code.10173;
            code.10277 = code.10276 + 1;
            code = code.10277;
            D.58494 = _amd64_rex_bits | 64;
            *code.10276 = D.58494;
            <D.58491>:
          }
          code.10173 = code;
          code.10278 = code.10173;
          code.10279 = code.10278 + 1;
          code = code.10279;
          *code.10278 = 255;
          code.10173 = code;
          code.10280 = code.10173;
          code.10281 = code.10280 + 1;
          code = code.10281;
          *code.10280 = 227;
          goto <D.58499>;
          <D.58433>:
          {
            int _amd64_width_temp;

            D.58500 = item->value.vtable_slot;
            D.58501 = &vtable->vtable[D.58500];
            D.58502 = (long unsigned int) D.58501;
            D.58500 = item->value.vtable_slot;
            D.58501 = &vtable->vtable[D.58500];
            D.58503 = (long int) D.58501;
            D.58504 = (int) D.58503;
            D.58505 = (long unsigned int) D.58504;
            D.58506 = D.58502 == D.58505;
            _amd64_width_temp = (int) D.58506;
            {
              unsigned char _amd64_rex_bits;

              if (_amd64_width_temp == 0) goto <D.58508>; else goto <D.58509>;
              <D.58508>:
              iftmp.10282 = 9;
              goto <D.58510>;
              <D.58509>:
              iftmp.10282 = 1;
              <D.58510>:
              _amd64_rex_bits = iftmp.10282;
              if (_amd64_rex_bits != 0) goto <D.58511>; else goto <D.58512>;
              <D.58511>:
              code.10173 = code;
              code.10283 = code.10173;
              code.10284 = code.10283 + 1;
              code = code.10284;
              D.58515 = _amd64_rex_bits | 64;
              *code.10283 = D.58515;
              <D.58512>:
            }
            code.10173 = code;
            code.10285 = code.10173;
            code.10286 = code.10285 + 1;
            code = code.10286;
            *code.10285 = 187;
            if (_amd64_width_temp == 0) goto <D.58518>; else goto <D.58519>;
            <D.58518>:
            {
              union amd64_imm_buf imb;

              try
                {
                  D.58500 = item->value.vtable_slot;
                  D.58501 = &vtable->vtable[D.58500];
                  D.58502 = (long unsigned int) D.58501;
                  imb.val = D.58502;
                  code.10173 = code;
                  code.10287 = code.10173;
                  code.10288 = code.10287 + 1;
                  code = code.10288;
                  D.58522 = imb.b[0];
                  *code.10287 = D.58522;
                  code.10173 = code;
                  code.10289 = code.10173;
                  code.10290 = code.10289 + 1;
                  code = code.10290;
                  D.58525 = imb.b[1];
                  *code.10289 = D.58525;
                  code.10173 = code;
                  code.10291 = code.10173;
                  code.10292 = code.10291 + 1;
                  code = code.10292;
                  D.58528 = imb.b[2];
                  *code.10291 = D.58528;
                  code.10173 = code;
                  code.10293 = code.10173;
                  code.10294 = code.10293 + 1;
                  code = code.10294;
                  D.58531 = imb.b[3];
                  *code.10293 = D.58531;
                  code.10173 = code;
                  code.10295 = code.10173;
                  code.10296 = code.10295 + 1;
                  code = code.10296;
                  D.58534 = imb.b[4];
                  *code.10295 = D.58534;
                  code.10173 = code;
                  code.10297 = code.10173;
                  code.10298 = code.10297 + 1;
                  code = code.10298;
                  D.58537 = imb.b[5];
                  *code.10297 = D.58537;
                  code.10173 = code;
                  code.10299 = code.10173;
                  code.10300 = code.10299 + 1;
                  code = code.10300;
                  D.58540 = imb.b[6];
                  *code.10299 = D.58540;
                  code.10173 = code;
                  code.10301 = code.10173;
                  code.10302 = code.10301 + 1;
                  code = code.10302;
                  D.58543 = imb.b[7];
                  *code.10301 = D.58543;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            goto <D.58544>;
            <D.58519>:
            {
              union x86_imm_buf imb;

              try
                {
                  D.58500 = item->value.vtable_slot;
                  D.58501 = &vtable->vtable[D.58500];
                  D.58503 = (long int) D.58501;
                  D.58504 = (int) D.58503;
                  imb.val = D.58504;
                  code.10173 = code;
                  code.10303 = code.10173;
                  code.10304 = code.10303 + 1;
                  code = code.10304;
                  D.58547 = imb.b[0];
                  *code.10303 = D.58547;
                  code.10173 = code;
                  code.10305 = code.10173;
                  code.10306 = code.10305 + 1;
                  code = code.10306;
                  D.58550 = imb.b[1];
                  *code.10305 = D.58550;
                  code.10173 = code;
                  code.10307 = code.10173;
                  code.10308 = code.10307 + 1;
                  code = code.10308;
                  D.58553 = imb.b[2];
                  *code.10307 = D.58553;
                  code.10173 = code;
                  code.10309 = code.10173;
                  code.10310 = code.10309 + 1;
                  code = code.10310;
                  D.58556 = imb.b[3];
                  *code.10309 = D.58556;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.58544>:
          }
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 1;
            if (_amd64_rex_bits != 0) goto <D.58557>; else goto <D.58558>;
            <D.58557>:
            code.10173 = code;
            code.10311 = code.10173;
            code.10312 = code.10311 + 1;
            code = code.10312;
            D.58561 = _amd64_rex_bits | 64;
            *code.10311 = D.58561;
            <D.58558>:
          }
          code.10173 = code;
          code.10313 = code.10173;
          code.10314 = code.10313 + 1;
          code = code.10314;
          *code.10313 = 255;
          if (0 != 0) goto <D.58564>; else goto <D.58565>;
          <D.58564>:
          code.10173 = code;
          code.10315 = code.10173;
          code.10316 = code.10315 + 1;
          code = code.10316;
          *code.10315 = 37;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.10173 = code;
                code.10317 = code.10173;
                code.10318 = code.10317 + 1;
                code = code.10318;
                D.58570 = imb.b[0];
                *code.10317 = D.58570;
                code.10173 = code;
                code.10319 = code.10173;
                code.10320 = code.10319 + 1;
                code = code.10320;
                D.58573 = imb.b[1];
                *code.10319 = D.58573;
                code.10173 = code;
                code.10321 = code.10173;
                code.10322 = code.10321 + 1;
                code = code.10322;
                D.58576 = imb.b[2];
                *code.10321 = D.58576;
                code.10173 = code;
                code.10323 = code.10173;
                code.10324 = code.10323 + 1;
                code = code.10324;
                D.58579 = imb.b[3];
                *code.10323 = D.58579;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.58580>;
          <D.58565>:
          if (0 != 0) goto <D.58581>; else goto <D.58582>;
          <D.58581>:
          if (1 != 0) goto <D.58583>; else goto <D.58584>;
          <D.58583>:
          code.10173 = code;
          code.10325 = code.10173;
          code.10326 = code.10325 + 1;
          code = code.10326;
          *code.10325 = 36;
          code.10173 = code;
          code.10327 = code.10173;
          code.10328 = code.10327 + 1;
          code = code.10328;
          *code.10327 = 36;
          goto <D.58589>;
          <D.58584>:
          if (1 != 0) goto <D.58590>; else goto <D.58591>;
          <D.58590>:
          code.10173 = code;
          code.10329 = code.10173;
          code.10330 = code.10329 + 1;
          code = code.10330;
          *code.10329 = 100;
          code.10173 = code;
          code.10331 = code.10173;
          code.10332 = code.10331 + 1;
          code = code.10332;
          *code.10331 = 36;
          code.10173 = code;
          *code.10173 = 0;
          code.10173 = code;
          code.10181 = code.10173 + 1;
          code = code.10181;
          goto <D.58596>;
          <D.58591>:
          code.10173 = code;
          code.10333 = code.10173;
          code.10334 = code.10333 + 1;
          code = code.10334;
          *code.10333 = 164;
          code.10173 = code;
          code.10335 = code.10173;
          code.10336 = code.10335 + 1;
          code = code.10336;
          *code.10335 = 36;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.10173 = code;
                code.10337 = code.10173;
                code.10338 = code.10337 + 1;
                code = code.10338;
                D.58603 = imb.b[0];
                *code.10337 = D.58603;
                code.10173 = code;
                code.10339 = code.10173;
                code.10340 = code.10339 + 1;
                code = code.10340;
                D.58606 = imb.b[1];
                *code.10339 = D.58606;
                code.10173 = code;
                code.10341 = code.10173;
                code.10342 = code.10341 + 1;
                code = code.10342;
                D.58609 = imb.b[2];
                *code.10341 = D.58609;
                code.10173 = code;
                code.10343 = code.10173;
                code.10344 = code.10343 + 1;
                code = code.10344;
                D.58612 = imb.b[3];
                *code.10343 = D.58612;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.58596>:
          <D.58589>:
          goto <D.28987>;
          <D.58582>:
          if (1 != 0) goto <D.58613>; else goto <D.58614>;
          <D.58613>:
          code.10173 = code;
          code.10345 = code.10173;
          code.10346 = code.10345 + 1;
          code = code.10346;
          *code.10345 = 35;
          goto <D.28987>;
          <D.58614>:
          if (1 != 0) goto <D.58617>; else goto <D.58618>;
          <D.58617>:
          code.10173 = code;
          code.10347 = code.10173;
          code.10348 = code.10347 + 1;
          code = code.10348;
          *code.10347 = 99;
          code.10173 = code;
          *code.10173 = 0;
          code.10173 = code;
          code.10181 = code.10173 + 1;
          code = code.10181;
          goto <D.58621>;
          <D.58618>:
          code.10173 = code;
          code.10349 = code.10173;
          code.10350 = code.10349 + 1;
          code = code.10350;
          *code.10349 = 163;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.10173 = code;
                code.10351 = code.10173;
                code.10352 = code.10351 + 1;
                code = code.10352;
                D.58626 = imb.b[0];
                *code.10351 = D.58626;
                code.10173 = code;
                code.10353 = code.10173;
                code.10354 = code.10353 + 1;
                code = code.10354;
                D.58629 = imb.b[1];
                *code.10353 = D.58629;
                code.10173 = code;
                code.10355 = code.10173;
                code.10356 = code.10355 + 1;
                code = code.10356;
                D.58632 = imb.b[2];
                *code.10355 = D.58632;
                code.10173 = code;
                code.10357 = code.10173;
                code.10358 = code.10357 + 1;
                code = code.10358;
                D.58635 = imb.b[3];
                *code.10357 = D.58635;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.58621>:
          <D.28987>:
          <D.58580>:
          <D.58499>:
          if (fail_case != 0) goto <D.58636>; else goto <D.58637>;
          <D.58636>:
          code.10173 = code;
          D.58638 = item->jmp_code;
          amd64_patch (D.58638, code.10173);
          {
            int _amd64_width_temp;

            fail_tramp.10359 = (long unsigned int) fail_tramp;
            fail_tramp.10360 = (long int) fail_tramp;
            D.58641 = (int) fail_tramp.10360;
            D.58642 = (long unsigned int) D.58641;
            D.58643 = fail_tramp.10359 == D.58642;
            _amd64_width_temp = (int) D.58643;
            {
              unsigned char _amd64_rex_bits;

              if (_amd64_width_temp == 0) goto <D.58645>; else goto <D.58646>;
              <D.58645>:
              iftmp.10361 = 9;
              goto <D.58647>;
              <D.58646>:
              iftmp.10361 = 1;
              <D.58647>:
              _amd64_rex_bits = iftmp.10361;
              if (_amd64_rex_bits != 0) goto <D.58648>; else goto <D.58649>;
              <D.58648>:
              code.10173 = code;
              code.10362 = code.10173;
              code.10363 = code.10362 + 1;
              code = code.10363;
              D.58652 = _amd64_rex_bits | 64;
              *code.10362 = D.58652;
              <D.58649>:
            }
            code.10173 = code;
            code.10364 = code.10173;
            code.10365 = code.10364 + 1;
            code = code.10365;
            *code.10364 = 187;
            if (_amd64_width_temp == 0) goto <D.58655>; else goto <D.58656>;
            <D.58655>:
            {
              union amd64_imm_buf imb;

              try
                {
                  fail_tramp.10359 = (long unsigned int) fail_tramp;
                  imb.val = fail_tramp.10359;
                  code.10173 = code;
                  code.10366 = code.10173;
                  code.10367 = code.10366 + 1;
                  code = code.10367;
                  D.58659 = imb.b[0];
                  *code.10366 = D.58659;
                  code.10173 = code;
                  code.10368 = code.10173;
                  code.10369 = code.10368 + 1;
                  code = code.10369;
                  D.58662 = imb.b[1];
                  *code.10368 = D.58662;
                  code.10173 = code;
                  code.10370 = code.10173;
                  code.10371 = code.10370 + 1;
                  code = code.10371;
                  D.58665 = imb.b[2];
                  *code.10370 = D.58665;
                  code.10173 = code;
                  code.10372 = code.10173;
                  code.10373 = code.10372 + 1;
                  code = code.10373;
                  D.58668 = imb.b[3];
                  *code.10372 = D.58668;
                  code.10173 = code;
                  code.10374 = code.10173;
                  code.10375 = code.10374 + 1;
                  code = code.10375;
                  D.58671 = imb.b[4];
                  *code.10374 = D.58671;
                  code.10173 = code;
                  code.10376 = code.10173;
                  code.10377 = code.10376 + 1;
                  code = code.10377;
                  D.58674 = imb.b[5];
                  *code.10376 = D.58674;
                  code.10173 = code;
                  code.10378 = code.10173;
                  code.10379 = code.10378 + 1;
                  code = code.10379;
                  D.58677 = imb.b[6];
                  *code.10378 = D.58677;
                  code.10173 = code;
                  code.10380 = code.10173;
                  code.10381 = code.10380 + 1;
                  code = code.10381;
                  D.58680 = imb.b[7];
                  *code.10380 = D.58680;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            goto <D.58681>;
            <D.58656>:
            {
              union x86_imm_buf imb;

              try
                {
                  fail_tramp.10360 = (long int) fail_tramp;
                  D.58641 = (int) fail_tramp.10360;
                  imb.val = D.58641;
                  code.10173 = code;
                  code.10382 = code.10173;
                  code.10383 = code.10382 + 1;
                  code = code.10383;
                  D.58684 = imb.b[0];
                  *code.10382 = D.58684;
                  code.10173 = code;
                  code.10384 = code.10173;
                  code.10385 = code.10384 + 1;
                  code = code.10385;
                  D.58687 = imb.b[1];
                  *code.10384 = D.58687;
                  code.10173 = code;
                  code.10386 = code.10173;
                  code.10387 = code.10386 + 1;
                  code = code.10387;
                  D.58690 = imb.b[2];
                  *code.10386 = D.58690;
                  code.10173 = code;
                  code.10388 = code.10173;
                  code.10389 = code.10388 + 1;
                  code = code.10389;
                  D.58693 = imb.b[3];
                  *code.10388 = D.58693;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.58681>:
          }
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 1;
            if (_amd64_rex_bits != 0) goto <D.58694>; else goto <D.58695>;
            <D.58694>:
            code.10173 = code;
            code.10390 = code.10173;
            code.10391 = code.10390 + 1;
            code = code.10391;
            D.58698 = _amd64_rex_bits | 64;
            *code.10390 = D.58698;
            <D.58695>:
          }
          code.10173 = code;
          code.10392 = code.10173;
          code.10393 = code.10392 + 1;
          code = code.10393;
          *code.10392 = 255;
          code.10173 = code;
          code.10394 = code.10173;
          code.10395 = code.10394 + 1;
          code = code.10395;
          *code.10394 = 227;
          item->jmp_code = 0B;
          <D.58637>:
          goto <D.58703>;
          <D.58288>:
          {
            int _amd64_width_temp;

            D.58500 = item->value.vtable_slot;
            D.58501 = &vtable->vtable[D.58500];
            D.58502 = (long unsigned int) D.58501;
            D.58500 = item->value.vtable_slot;
            D.58501 = &vtable->vtable[D.58500];
            D.58503 = (long int) D.58501;
            D.58504 = (int) D.58503;
            D.58505 = (long unsigned int) D.58504;
            D.58506 = D.58502 == D.58505;
            _amd64_width_temp = (int) D.58506;
            {
              unsigned char _amd64_rex_bits;

              if (_amd64_width_temp == 0) goto <D.58705>; else goto <D.58706>;
              <D.58705>:
              iftmp.10396 = 9;
              goto <D.58707>;
              <D.58706>:
              iftmp.10396 = 1;
              <D.58707>:
              _amd64_rex_bits = iftmp.10396;
              if (_amd64_rex_bits != 0) goto <D.58708>; else goto <D.58709>;
              <D.58708>:
              code.10173 = code;
              code.10397 = code.10173;
              code.10398 = code.10397 + 1;
              code = code.10398;
              D.58712 = _amd64_rex_bits | 64;
              *code.10397 = D.58712;
              <D.58709>:
            }
            code.10173 = code;
            code.10399 = code.10173;
            code.10400 = code.10399 + 1;
            code = code.10400;
            *code.10399 = 187;
            if (_amd64_width_temp == 0) goto <D.58715>; else goto <D.58716>;
            <D.58715>:
            {
              union amd64_imm_buf imb;

              try
                {
                  D.58500 = item->value.vtable_slot;
                  D.58501 = &vtable->vtable[D.58500];
                  D.58502 = (long unsigned int) D.58501;
                  imb.val = D.58502;
                  code.10173 = code;
                  code.10401 = code.10173;
                  code.10402 = code.10401 + 1;
                  code = code.10402;
                  D.58719 = imb.b[0];
                  *code.10401 = D.58719;
                  code.10173 = code;
                  code.10403 = code.10173;
                  code.10404 = code.10403 + 1;
                  code = code.10404;
                  D.58722 = imb.b[1];
                  *code.10403 = D.58722;
                  code.10173 = code;
                  code.10405 = code.10173;
                  code.10406 = code.10405 + 1;
                  code = code.10406;
                  D.58725 = imb.b[2];
                  *code.10405 = D.58725;
                  code.10173 = code;
                  code.10407 = code.10173;
                  code.10408 = code.10407 + 1;
                  code = code.10408;
                  D.58728 = imb.b[3];
                  *code.10407 = D.58728;
                  code.10173 = code;
                  code.10409 = code.10173;
                  code.10410 = code.10409 + 1;
                  code = code.10410;
                  D.58731 = imb.b[4];
                  *code.10409 = D.58731;
                  code.10173 = code;
                  code.10411 = code.10173;
                  code.10412 = code.10411 + 1;
                  code = code.10412;
                  D.58734 = imb.b[5];
                  *code.10411 = D.58734;
                  code.10173 = code;
                  code.10413 = code.10173;
                  code.10414 = code.10413 + 1;
                  code = code.10414;
                  D.58737 = imb.b[6];
                  *code.10413 = D.58737;
                  code.10173 = code;
                  code.10415 = code.10173;
                  code.10416 = code.10415 + 1;
                  code = code.10416;
                  D.58740 = imb.b[7];
                  *code.10415 = D.58740;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            goto <D.58741>;
            <D.58716>:
            {
              union x86_imm_buf imb;

              try
                {
                  D.58500 = item->value.vtable_slot;
                  D.58501 = &vtable->vtable[D.58500];
                  D.58503 = (long int) D.58501;
                  D.58504 = (int) D.58503;
                  imb.val = D.58504;
                  code.10173 = code;
                  code.10417 = code.10173;
                  code.10418 = code.10417 + 1;
                  code = code.10418;
                  D.58744 = imb.b[0];
                  *code.10417 = D.58744;
                  code.10173 = code;
                  code.10419 = code.10173;
                  code.10420 = code.10419 + 1;
                  code = code.10420;
                  D.58747 = imb.b[1];
                  *code.10419 = D.58747;
                  code.10173 = code;
                  code.10421 = code.10173;
                  code.10422 = code.10421 + 1;
                  code = code.10422;
                  D.58750 = imb.b[2];
                  *code.10421 = D.58750;
                  code.10173 = code;
                  code.10423 = code.10173;
                  code.10424 = code.10423 + 1;
                  code = code.10424;
                  D.58753 = imb.b[3];
                  *code.10423 = D.58753;
                }
              finally
                {
                  imb = {CLOBBER};
                }
            }
            <D.58741>:
          }
          {
            unsigned char _amd64_rex_bits;

            _amd64_rex_bits = 1;
            if (_amd64_rex_bits != 0) goto <D.58754>; else goto <D.58755>;
            <D.58754>:
            code.10173 = code;
            code.10425 = code.10173;
            code.10426 = code.10425 + 1;
            code = code.10426;
            D.58758 = _amd64_rex_bits | 64;
            *code.10425 = D.58758;
            <D.58755>:
          }
          code.10173 = code;
          code.10427 = code.10173;
          code.10428 = code.10427 + 1;
          code = code.10428;
          *code.10427 = 255;
          if (0 != 0) goto <D.58761>; else goto <D.58762>;
          <D.58761>:
          code.10173 = code;
          code.10429 = code.10173;
          code.10430 = code.10429 + 1;
          code = code.10430;
          *code.10429 = 37;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.10173 = code;
                code.10431 = code.10173;
                code.10432 = code.10431 + 1;
                code = code.10432;
                D.58767 = imb.b[0];
                *code.10431 = D.58767;
                code.10173 = code;
                code.10433 = code.10173;
                code.10434 = code.10433 + 1;
                code = code.10434;
                D.58770 = imb.b[1];
                *code.10433 = D.58770;
                code.10173 = code;
                code.10435 = code.10173;
                code.10436 = code.10435 + 1;
                code = code.10436;
                D.58773 = imb.b[2];
                *code.10435 = D.58773;
                code.10173 = code;
                code.10437 = code.10173;
                code.10438 = code.10437 + 1;
                code = code.10438;
                D.58776 = imb.b[3];
                *code.10437 = D.58776;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.58777>;
          <D.58762>:
          if (0 != 0) goto <D.58778>; else goto <D.58779>;
          <D.58778>:
          if (1 != 0) goto <D.58780>; else goto <D.58781>;
          <D.58780>:
          code.10173 = code;
          code.10439 = code.10173;
          code.10440 = code.10439 + 1;
          code = code.10440;
          *code.10439 = 36;
          code.10173 = code;
          code.10441 = code.10173;
          code.10442 = code.10441 + 1;
          code = code.10442;
          *code.10441 = 36;
          goto <D.58786>;
          <D.58781>:
          if (1 != 0) goto <D.58787>; else goto <D.58788>;
          <D.58787>:
          code.10173 = code;
          code.10443 = code.10173;
          code.10444 = code.10443 + 1;
          code = code.10444;
          *code.10443 = 100;
          code.10173 = code;
          code.10445 = code.10173;
          code.10446 = code.10445 + 1;
          code = code.10446;
          *code.10445 = 36;
          code.10173 = code;
          *code.10173 = 0;
          code.10173 = code;
          code.10181 = code.10173 + 1;
          code = code.10181;
          goto <D.58793>;
          <D.58788>:
          code.10173 = code;
          code.10447 = code.10173;
          code.10448 = code.10447 + 1;
          code = code.10448;
          *code.10447 = 164;
          code.10173 = code;
          code.10449 = code.10173;
          code.10450 = code.10449 + 1;
          code = code.10450;
          *code.10449 = 36;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.10173 = code;
                code.10451 = code.10173;
                code.10452 = code.10451 + 1;
                code = code.10452;
                D.58800 = imb.b[0];
                *code.10451 = D.58800;
                code.10173 = code;
                code.10453 = code.10173;
                code.10454 = code.10453 + 1;
                code = code.10454;
                D.58803 = imb.b[1];
                *code.10453 = D.58803;
                code.10173 = code;
                code.10455 = code.10173;
                code.10456 = code.10455 + 1;
                code = code.10456;
                D.58806 = imb.b[2];
                *code.10455 = D.58806;
                code.10173 = code;
                code.10457 = code.10173;
                code.10458 = code.10457 + 1;
                code = code.10458;
                D.58809 = imb.b[3];
                *code.10457 = D.58809;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.58793>:
          <D.58786>:
          goto <D.29001>;
          <D.58779>:
          if (1 != 0) goto <D.58810>; else goto <D.58811>;
          <D.58810>:
          code.10173 = code;
          code.10459 = code.10173;
          code.10460 = code.10459 + 1;
          code = code.10460;
          *code.10459 = 35;
          goto <D.29001>;
          <D.58811>:
          if (1 != 0) goto <D.58814>; else goto <D.58815>;
          <D.58814>:
          code.10173 = code;
          code.10461 = code.10173;
          code.10462 = code.10461 + 1;
          code = code.10462;
          *code.10461 = 99;
          code.10173 = code;
          *code.10173 = 0;
          code.10173 = code;
          code.10181 = code.10173 + 1;
          code = code.10181;
          goto <D.58818>;
          <D.58815>:
          code.10173 = code;
          code.10463 = code.10173;
          code.10464 = code.10463 + 1;
          code = code.10464;
          *code.10463 = 163;
          {
            union x86_imm_buf imb;

            try
              {
                imb.val = 0;
                code.10173 = code;
                code.10465 = code.10173;
                code.10466 = code.10465 + 1;
                code = code.10466;
                D.58823 = imb.b[0];
                *code.10465 = D.58823;
                code.10173 = code;
                code.10467 = code.10173;
                code.10468 = code.10467 + 1;
                code = code.10468;
                D.58826 = imb.b[1];
                *code.10467 = D.58826;
                code.10173 = code;
                code.10469 = code.10173;
                code.10470 = code.10469 + 1;
                code = code.10470;
                D.58829 = imb.b[2];
                *code.10469 = D.58829;
                code.10173 = code;
                code.10471 = code.10173;
                code.10472 = code.10471 + 1;
                code = code.10472;
                D.58832 = imb.b[3];
                *code.10471 = D.58832;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.58818>:
          <D.29001>:
          <D.58777>:
          <D.58703>:
        }
        goto <D.58833>;
        <D.58279>:
        D.58293 = item->key;
        D.58294 = (unsigned long) D.58293;
        D.58295 = D.58294 + 2147483648;
        if (D.58295 <= 4294967295) goto <D.58834>; else goto <D.58835>;
        <D.58834>:
        D.58293 = item->key;
        D.58298 = (long int) D.58293;
        D.58299 = (unsigned int) D.58298;
        D.58300 = D.58299 + 128;
        if (D.58300 <= 255) goto <D.58836>; else goto <D.58837>;
        <D.58836>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 9;
          if (_amd64_rex_bits != 0) goto <D.58838>; else goto <D.58839>;
          <D.58838>:
          code.10173 = code;
          code.10473 = code.10173;
          code.10474 = code.10473 + 1;
          code = code.10474;
          D.58842 = _amd64_rex_bits | 64;
          *code.10473 = D.58842;
          <D.58839>:
        }
        code.10173 = code;
        code.10475 = code.10173;
        code.10476 = code.10475 + 1;
        code = code.10476;
        *code.10475 = 131;
        code.10173 = code;
        code.10477 = code.10173;
        code.10478 = code.10477 + 1;
        code = code.10478;
        *code.10477 = 250;
        code.10173 = code;
        D.58293 = item->key;
        D.58298 = (long int) D.58293;
        D.58312 = (unsigned char) D.58298;
        *code.10173 = D.58312;
        code.10173 = code;
        code.10181 = code.10173 + 1;
        code = code.10181;
        goto <D.58847>;
        <D.58837>:
        if (0 != 0) goto <D.58848>; else goto <D.58849>;
        <D.58848>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 8;
          if (_amd64_rex_bits != 0) goto <D.58850>; else goto <D.58851>;
          <D.58850>:
          code.10173 = code;
          code.10479 = code.10173;
          code.10480 = code.10479 + 1;
          code = code.10480;
          D.58854 = _amd64_rex_bits | 64;
          *code.10479 = D.58854;
          <D.58851>:
        }
        code.10173 = code;
        code.10481 = code.10173;
        code.10482 = code.10481 + 1;
        code = code.10482;
        *code.10481 = 61;
        {
          union x86_imm_buf imb;

          try
            {
              D.58293 = item->key;
              D.58298 = (long int) D.58293;
              D.58324 = (int) D.58298;
              imb.val = D.58324;
              code.10173 = code;
              code.10483 = code.10173;
              code.10484 = code.10483 + 1;
              code = code.10484;
              D.58859 = imb.b[0];
              *code.10483 = D.58859;
              code.10173 = code;
              code.10485 = code.10173;
              code.10486 = code.10485 + 1;
              code = code.10486;
              D.58862 = imb.b[1];
              *code.10485 = D.58862;
              code.10173 = code;
              code.10487 = code.10173;
              code.10488 = code.10487 + 1;
              code = code.10488;
              D.58865 = imb.b[2];
              *code.10487 = D.58865;
              code.10173 = code;
              code.10489 = code.10173;
              code.10490 = code.10489 + 1;
              code = code.10490;
              D.58868 = imb.b[3];
              *code.10489 = D.58868;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.58869>;
        <D.58849>:
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 9;
          if (_amd64_rex_bits != 0) goto <D.58870>; else goto <D.58871>;
          <D.58870>:
          code.10173 = code;
          code.10491 = code.10173;
          code.10492 = code.10491 + 1;
          code = code.10492;
          D.58874 = _amd64_rex_bits | 64;
          *code.10491 = D.58874;
          <D.58871>:
        }
        code.10173 = code;
        code.10493 = code.10173;
        code.10494 = code.10493 + 1;
        code = code.10494;
        *code.10493 = 129;
        code.10173 = code;
        code.10495 = code.10173;
        code.10496 = code.10495 + 1;
        code = code.10496;
        *code.10495 = 250;
        {
          union x86_imm_buf imb;

          try
            {
              D.58293 = item->key;
              D.58298 = (long int) D.58293;
              D.58324 = (int) D.58298;
              imb.val = D.58324;
              code.10173 = code;
              code.10497 = code.10173;
              code.10498 = code.10497 + 1;
              code = code.10498;
              D.58881 = imb.b[0];
              *code.10497 = D.58881;
              code.10173 = code;
              code.10499 = code.10173;
              code.10500 = code.10499 + 1;
              code = code.10500;
              D.58884 = imb.b[1];
              *code.10499 = D.58884;
              code.10173 = code;
              code.10501 = code.10173;
              code.10502 = code.10501 + 1;
              code = code.10502;
              D.58887 = imb.b[2];
              *code.10501 = D.58887;
              code.10173 = code;
              code.10503 = code.10173;
              code.10504 = code.10503 + 1;
              code = code.10504;
              D.58890 = imb.b[3];
              *code.10503 = D.58890;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.58869>:
        <D.58847>:
        goto <D.58891>;
        <D.58835>:
        {
          int _amd64_width_temp;

          D.58293 = item->key;
          D.58360 = (long unsigned int) D.58293;
          D.58293 = item->key;
          D.58298 = (long int) D.58293;
          D.58324 = (int) D.58298;
          D.58361 = (long unsigned int) D.58324;
          D.58362 = D.58360 == D.58361;
          _amd64_width_temp = (int) D.58362;
          {
            unsigned char _amd64_rex_bits;

            if (_amd64_width_temp == 0) goto <D.58893>; else goto <D.58894>;
            <D.58893>:
            iftmp.10505 = 9;
            goto <D.58895>;
            <D.58894>:
            iftmp.10505 = 1;
            <D.58895>:
            _amd64_rex_bits = iftmp.10505;
            if (_amd64_rex_bits != 0) goto <D.58896>; else goto <D.58897>;
            <D.58896>:
            code.10173 = code;
            code.10506 = code.10173;
            code.10507 = code.10506 + 1;
            code = code.10507;
            D.58900 = _amd64_rex_bits | 64;
            *code.10506 = D.58900;
            <D.58897>:
          }
          code.10173 = code;
          code.10508 = code.10173;
          code.10509 = code.10508 + 1;
          code = code.10509;
          *code.10508 = 187;
          if (_amd64_width_temp == 0) goto <D.58903>; else goto <D.58904>;
          <D.58903>:
          {
            union amd64_imm_buf imb;

            try
              {
                D.58293 = item->key;
                D.58360 = (long unsigned int) D.58293;
                imb.val = D.58360;
                code.10173 = code;
                code.10510 = code.10173;
                code.10511 = code.10510 + 1;
                code = code.10511;
                D.58907 = imb.b[0];
                *code.10510 = D.58907;
                code.10173 = code;
                code.10512 = code.10173;
                code.10513 = code.10512 + 1;
                code = code.10513;
                D.58910 = imb.b[1];
                *code.10512 = D.58910;
                code.10173 = code;
                code.10514 = code.10173;
                code.10515 = code.10514 + 1;
                code = code.10515;
                D.58913 = imb.b[2];
                *code.10514 = D.58913;
                code.10173 = code;
                code.10516 = code.10173;
                code.10517 = code.10516 + 1;
                code = code.10517;
                D.58916 = imb.b[3];
                *code.10516 = D.58916;
                code.10173 = code;
                code.10518 = code.10173;
                code.10519 = code.10518 + 1;
                code = code.10519;
                D.58919 = imb.b[4];
                *code.10518 = D.58919;
                code.10173 = code;
                code.10520 = code.10173;
                code.10521 = code.10520 + 1;
                code = code.10521;
                D.58922 = imb.b[5];
                *code.10520 = D.58922;
                code.10173 = code;
                code.10522 = code.10173;
                code.10523 = code.10522 + 1;
                code = code.10523;
                D.58925 = imb.b[6];
                *code.10522 = D.58925;
                code.10173 = code;
                code.10524 = code.10173;
                code.10525 = code.10524 + 1;
                code = code.10525;
                D.58928 = imb.b[7];
                *code.10524 = D.58928;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          goto <D.58929>;
          <D.58904>:
          {
            union x86_imm_buf imb;

            try
              {
                D.58293 = item->key;
                D.58298 = (long int) D.58293;
                D.58324 = (int) D.58298;
                imb.val = D.58324;
                code.10173 = code;
                code.10526 = code.10173;
                code.10527 = code.10526 + 1;
                code = code.10527;
                D.58932 = imb.b[0];
                *code.10526 = D.58932;
                code.10173 = code;
                code.10528 = code.10173;
                code.10529 = code.10528 + 1;
                code = code.10529;
                D.58935 = imb.b[1];
                *code.10528 = D.58935;
                code.10173 = code;
                code.10530 = code.10173;
                code.10531 = code.10530 + 1;
                code = code.10531;
                D.58938 = imb.b[2];
                *code.10530 = D.58938;
                code.10173 = code;
                code.10532 = code.10173;
                code.10533 = code.10532 + 1;
                code = code.10533;
                D.58941 = imb.b[3];
                *code.10532 = D.58941;
              }
            finally
              {
                imb = {CLOBBER};
              }
          }
          <D.58929>:
        }
        {
          unsigned char _amd64_rex_bits;

          _amd64_rex_bits = 13;
          if (_amd64_rex_bits != 0) goto <D.58942>; else goto <D.58943>;
          <D.58942>:
          code.10173 = code;
          code.10534 = code.10173;
          code.10535 = code.10534 + 1;
          code = code.10535;
          D.58946 = _amd64_rex_bits | 64;
          *code.10534 = D.58946;
          <D.58943>:
        }
        code.10173 = code;
        code.10536 = code.10173;
        code.10537 = code.10536 + 1;
        code = code.10537;
        *code.10536 = 59;
        code.10173 = code;
        code.10538 = code.10173;
        code.10539 = code.10538 + 1;
        code = code.10539;
        *code.10538 = 211;
        <D.58891>:
        code.10173 = code;
        item->jmp_code = code.10173;
        D.58283 = item->check_target_idx;
        D.58953 = imt_branch_distance (imt_entries, i, D.58283);
        if (D.58953 >= -128) goto <D.58954>; else goto <D.58951>;
        <D.58954>:
        D.58283 = item->check_target_idx;
        D.58955 = imt_branch_distance (imt_entries, i, D.58283);
        if (D.58955 <= 127) goto <D.58956>; else goto <D.58951>;
        <D.58956>:
        if (0 != 0) goto <D.58957>; else goto <D.58958>;
        <D.58957>:
        code.10173 = code;
        code.10540 = code.10173;
        code.10541 = code.10540 + 1;
        code = code.10541;
        D.58961 = 125;
        *code.10540 = D.58961;
        goto <D.58962>;
        <D.58958>:
        code.10173 = code;
        code.10542 = code.10173;
        code.10543 = code.10542 + 1;
        code = code.10543;
        D.58965 = 115;
        *code.10542 = D.58965;
        <D.58962>:
        code.10173 = code;
        *code.10173 = 0;
        code.10173 = code;
        code.10181 = code.10173 + 1;
        code = code.10181;
        goto <D.58952>;
        <D.58951>:
        code.10173 = code;
        code.10544 = code.10173;
        code.10545 = code.10544 + 1;
        code = code.10545;
        *code.10544 = 15;
        if (0 != 0) goto <D.58968>; else goto <D.58969>;
        <D.58968>:
        code.10173 = code;
        code.10546 = code.10173;
        code.10547 = code.10546 + 1;
        code = code.10547;
        D.58961 = 125;
        D.58972 = D.58961 + 16;
        *code.10546 = D.58972;
        goto <D.58973>;
        <D.58969>:
        code.10173 = code;
        code.10548 = code.10173;
        code.10549 = code.10548 + 1;
        code = code.10549;
        D.58965 = 115;
        D.58976 = D.58965 + 16;
        *code.10548 = D.58976;
        <D.58973>:
        {
          union x86_imm_buf imb;

          try
            {
              imb.val = 0;
              code.10173 = code;
              code.10550 = code.10173;
              code.10551 = code.10550 + 1;
              code = code.10551;
              D.58979 = imb.b[0];
              *code.10550 = D.58979;
              code.10173 = code;
              code.10552 = code.10173;
              code.10553 = code.10552 + 1;
              code = code.10553;
              D.58982 = imb.b[1];
              *code.10552 = D.58982;
              code.10173 = code;
              code.10554 = code.10173;
              code.10555 = code.10554 + 1;
              code = code.10555;
              D.58985 = imb.b[2];
              *code.10554 = D.58985;
              code.10173 = code;
              code.10556 = code.10173;
              code.10557 = code.10556 + 1;
              code = code.10557;
              D.58988 = imb.b[3];
              *code.10556 = D.58988;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.58952>:
        <D.58833>:
        code.10173 = code;
        code.10558 = (long int) code.10173;
        D.58990 = item->code_target;
        D.58991 = (long int) D.58990;
        D.58992 = code.10558 - D.58991;
        D.58993 = item->chunk_size;
        D.58994 = (long int) D.58993;
        D.58995 = D.58992 > D.58994;
        D.58996 = (long int) D.58995;
        D.58997 = __builtin_expect (D.58996, 0);
        if (D.58997 != 0) goto <D.58998>; else goto <D.58999>;
        <D.58998>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8280, "code - item->code_target <= item->chunk_size");
        <D.58999>:
      }
      i = i + 1;
      <D.29015>:
      if (i < count) goto <D.29014>; else goto <D.29016>;
      <D.29016>:
      i = 0;
      goto <D.29019>;
      <D.29018>:
      {
        struct MonoIMTCheckItem * item;

        D.58222 = (long unsigned int) i;
        D.58223 = D.58222 * 8;
        D.58224 = imt_entries + D.58223;
        item = *D.58224;
        D.59000 = item->jmp_code;
        if (D.59000 != 0B) goto <D.59001>; else goto <D.59002>;
        <D.59001>:
        D.59003 = item->check_target_idx;
        if (D.59003 != 0) goto <D.59004>; else goto <D.59005>;
        <D.59004>:
        D.59003 = item->check_target_idx;
        D.59006 = (long unsigned int) D.59003;
        D.59007 = D.59006 * 8;
        D.59008 = imt_entries + D.59007;
        D.59009 = *D.59008;
        D.59010 = D.59009->code_target;
        D.59000 = item->jmp_code;
        amd64_patch (D.59000, D.59010);
        <D.59005>:
        <D.59002>:
      }
      i = i + 1;
      <D.29019>:
      if (i < count) goto <D.29018>; else goto <D.29020>;
      <D.29020>:
      if (fail_tramp == 0B) goto <D.59011>; else goto <D.59012>;
      <D.59011>:
      D.59013 = mono_stats.imt_thunks_size;
      code.10173 = code;
      code.10558 = (long int) code.10173;
      start.10559 = start;
      start.10560 = (long int) start.10559;
      D.59016 = code.10558 - start.10560;
      D.59017 = (long unsigned int) D.59016;
      D.59018 = D.59013 + D.59017;
      mono_stats.imt_thunks_size = D.59018;
      <D.59012>:
      code.10173 = code;
      code.10558 = (long int) code.10173;
      start.10559 = start;
      start.10560 = (long int) start.10559;
      D.59016 = code.10558 - start.10560;
      D.59019 = (long int) size;
      D.59020 = D.59016 > D.59019;
      D.59021 = (long int) D.59020;
      D.59022 = __builtin_expect (D.59021, 0);
      if (D.59022 != 0) goto <D.59023>; else goto <D.59024>;
      <D.59023>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8294, "code - start <= size");
      <D.59024>:
      nacl_domain_code_validate (domain, &start, size, &code);
      D.59025 = start;
      return D.59025;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


imt_branch_distance (struct MonoIMTCheckItem * * imt_entries, int start, int target)
{
  long unsigned int D.59028;
  long unsigned int D.59029;
  struct MonoIMTCheckItem * * D.59030;
  struct MonoIMTCheckItem * D.59031;
  unsigned char D.59032;
  int D.59033;
  int D.59034;
  int i;
  int distance;

  distance = 0;
  i = start;
  goto <D.28945>;
  <D.28944>:
  D.59028 = (long unsigned int) i;
  D.59029 = D.59028 * 8;
  D.59030 = imt_entries + D.59029;
  D.59031 = *D.59030;
  D.59032 = D.59031->chunk_size;
  D.59033 = (int) D.59032;
  distance = D.59033 + distance;
  i = i + 1;
  <D.28945>:
  if (i < target) goto <D.28944>; else goto <D.28946>;
  <D.28946>:
  D.59034 = distance;
  return D.59034;
}


mono_arch_find_imt_method (mgreg_t * regs, guint8 * code)
{
  struct MonoMethod * D.59036;
  mgreg_t * D.59037;
  long int D.59038;

  D.59037 = regs + 80;
  D.59038 = *D.59037;
  D.59036 = (struct MonoMethod *) D.59038;
  return D.59036;
}


mono_arch_find_static_call_vtable (mgreg_t * regs, guint8 * code)
{
  struct MonoVTable * D.59040;
  mgreg_t * D.59041;
  long int D.59042;

  D.59041 = regs + 80;
  D.59042 = *D.59041;
  D.59040 = (struct MonoVTable *) D.59042;
  return D.59040;
}


mono_arch_get_cie_program ()
{
  struct MonoUnwindOp * D.59044;
  struct MonoUnwindOp * D.59045;
  struct GSList * D.59046;
  struct GSList * l;

  l = 0B;
  D.59044 = mono_create_unwind_op (0, 12, 4, 8);
  l = monoeg_g_slist_append (l, D.59044);
  D.59045 = mono_create_unwind_op (0, 128, 16, -8);
  l = monoeg_g_slist_append (l, D.59045);
  D.59046 = l;
  return D.59046;
}


mono_arch_emit_inst_for_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoClass * D.59048;
  struct MonoClass * D.59049;
  int D.29049;
  int iftmp.10561;
  int D.29048;
  const char[4] * D.59055;
  unsigned char D.59056;
  int D.59057;
  unsigned char D.59058;
  int D.59059;
  _Bool D.59060;
  _Bool D.59061;
  _Bool D.59062;
  const unsigned char * D.59065;
  unsigned char D.59066;
  int D.59067;
  const unsigned char * D.59068;
  unsigned char D.59069;
  int D.59070;
  _Bool D.59071;
  _Bool D.59072;
  const unsigned char * D.59075;
  unsigned char D.59076;
  int D.59077;
  const unsigned char * D.59078;
  unsigned char D.59079;
  int D.59080;
  _Bool D.59081;
  _Bool D.59082;
  const unsigned char * D.59085;
  unsigned char D.59086;
  int D.59087;
  const unsigned char * D.59088;
  unsigned char D.59089;
  int D.59090;
  const char * D.59092;
  int D.29058;
  int iftmp.10562;
  int D.29057;
  const char[4] * D.59099;
  unsigned char D.59100;
  int D.59101;
  unsigned char D.59102;
  int D.59103;
  _Bool D.59104;
  _Bool D.59105;
  _Bool D.59106;
  const unsigned char * D.59109;
  unsigned char D.59110;
  int D.59111;
  const unsigned char * D.59112;
  unsigned char D.59113;
  int D.59114;
  _Bool D.59115;
  _Bool D.59116;
  const unsigned char * D.59119;
  unsigned char D.59120;
  int D.59121;
  const unsigned char * D.59122;
  unsigned char D.59123;
  int D.59124;
  _Bool D.59125;
  _Bool D.59126;
  const unsigned char * D.59129;
  unsigned char D.59130;
  int D.59131;
  const unsigned char * D.59132;
  unsigned char D.59133;
  int D.59134;
  int D.29067;
  int iftmp.10563;
  int D.29066;
  const char[5] * D.59142;
  unsigned char D.59143;
  int D.59144;
  unsigned char D.59145;
  int D.59146;
  _Bool D.59147;
  _Bool D.59148;
  _Bool D.59149;
  const unsigned char * D.59152;
  unsigned char D.59153;
  int D.59154;
  const unsigned char * D.59155;
  unsigned char D.59156;
  int D.59157;
  _Bool D.59158;
  _Bool D.59159;
  const unsigned char * D.59162;
  unsigned char D.59163;
  int D.59164;
  const unsigned char * D.59165;
  unsigned char D.59166;
  int D.59167;
  _Bool D.59168;
  _Bool D.59169;
  const unsigned char * D.59172;
  unsigned char D.59173;
  int D.59174;
  const unsigned char * D.59175;
  unsigned char D.59176;
  int D.59177;
  int D.29076;
  int iftmp.10564;
  int D.29075;
  const char[4] * D.59185;
  unsigned char D.59186;
  int D.59187;
  unsigned char D.59188;
  int D.59189;
  _Bool D.59190;
  _Bool D.59191;
  _Bool D.59192;
  const unsigned char * D.59195;
  unsigned char D.59196;
  int D.59197;
  const unsigned char * D.59198;
  unsigned char D.59199;
  int D.59200;
  _Bool D.59201;
  _Bool D.59202;
  const unsigned char * D.59205;
  unsigned char D.59206;
  int D.59207;
  const unsigned char * D.59208;
  unsigned char D.59209;
  int D.59210;
  _Bool D.59211;
  _Bool D.59212;
  const unsigned char * D.59215;
  unsigned char D.59216;
  int D.59217;
  const unsigned char * D.59218;
  unsigned char D.59219;
  int D.59220;
  struct MonoType * D.59224;
  unsigned char D.59225;
  struct MonoMemPool * D.59230;
  long int D.59231;
  struct MonoInst * D.59232;
  short unsigned int D.59233;
  int D.59234;
  int D.59235;
  const unsigned char * D.59236;
  unsigned int D.59237;
  int D.59238;
  struct MonoInst * D.59239;
  int D.59240;
  struct MonoBasicBlock * D.59241;
  struct MonoInst * D.59242;
  unsigned int D.59246;
  unsigned int D.59247;
  int D.29085;
  int iftmp.10565;
  int D.29084;
  const char[4] * D.59253;
  unsigned char D.59254;
  int D.59255;
  unsigned char D.59256;
  int D.59257;
  _Bool D.59258;
  _Bool D.59259;
  _Bool D.59260;
  const unsigned char * D.59263;
  unsigned char D.59264;
  int D.59265;
  const unsigned char * D.59266;
  unsigned char D.59267;
  int D.59268;
  _Bool D.59269;
  _Bool D.59270;
  const unsigned char * D.59273;
  unsigned char D.59274;
  int D.59275;
  const unsigned char * D.59276;
  unsigned char D.59277;
  int D.59278;
  _Bool D.59279;
  _Bool D.59280;
  const unsigned char * D.59283;
  unsigned char D.59284;
  int D.59285;
  const unsigned char * D.59286;
  unsigned char D.59287;
  int D.59288;
  int D.29094;
  int iftmp.10566;
  int D.29093;
  const char[4] * D.59306;
  unsigned char D.59307;
  int D.59308;
  unsigned char D.59309;
  int D.59310;
  _Bool D.59311;
  _Bool D.59312;
  _Bool D.59313;
  const unsigned char * D.59316;
  unsigned char D.59317;
  int D.59318;
  const unsigned char * D.59319;
  unsigned char D.59320;
  int D.59321;
  _Bool D.59322;
  _Bool D.59323;
  const unsigned char * D.59326;
  unsigned char D.59327;
  int D.59328;
  const unsigned char * D.59329;
  unsigned char D.59330;
  int D.59331;
  _Bool D.59332;
  _Bool D.59333;
  const unsigned char * D.59336;
  unsigned char D.59337;
  int D.59338;
  const unsigned char * D.59339;
  unsigned char D.59340;
  int D.59341;
  guint8 iftmp.10567;
  unsigned int D.59361;
  int D.59362;
  struct MonoInst * * D.59363;
  struct MonoInst * D.59364;
  int D.59365;
  struct MonoInst * D.59369;
  struct MonoInst * ins;
  int opcode;

  ins = 0B;
  opcode = 0;
  D.59048 = cmethod->klass;
  D.59049 = mono_defaults.math_class;
  if (D.59048 == D.59049) goto <D.59050>; else goto <D.59051>;
  <D.59050>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.59055 = "Sin";
      D.59056 = MEM[(const unsigned char *)D.59055];
      D.59057 = (int) D.59056;
      D.59058 = *__s2;
      D.59059 = (int) D.59058;
      __result = D.59057 - D.59059;
      {
        D.59060 = __s2_len != 0;
        D.59061 = __result == 0;
        D.59062 = D.59060 & D.59061;
        if (D.59062 != 0) goto <D.59063>; else goto <D.59064>;
        <D.59063>:
        D.59065 = &MEM[(void *)"Sin" + 1B];
        D.59066 = *D.59065;
        D.59067 = (int) D.59066;
        D.59068 = __s2 + 1;
        D.59069 = *D.59068;
        D.59070 = (int) D.59069;
        __result = D.59067 - D.59070;
        D.59071 = __s2_len > 1;
        D.59061 = __result == 0;
        D.59072 = D.59071 & D.59061;
        if (D.59072 != 0) goto <D.59073>; else goto <D.59074>;
        <D.59073>:
        D.59075 = &MEM[(void *)"Sin" + 2B];
        D.59076 = *D.59075;
        D.59077 = (int) D.59076;
        D.59078 = __s2 + 2;
        D.59079 = *D.59078;
        D.59080 = (int) D.59079;
        __result = D.59077 - D.59080;
        D.59081 = __s2_len > 2;
        D.59061 = __result == 0;
        D.59082 = D.59081 & D.59061;
        if (D.59082 != 0) goto <D.59083>; else goto <D.59084>;
        <D.59083>:
        D.59085 = &MEM[(void *)"Sin" + 3B];
        D.59086 = *D.59085;
        D.59087 = (int) D.59086;
        D.59088 = __s2 + 3;
        D.59089 = *D.59088;
        D.59090 = (int) D.59089;
        __result = D.59087 - D.59090;
        <D.59084>:
        <D.59074>:
        <D.59064>:
      }
      D.29048 = __result;
    }
    iftmp.10561 = -D.29048;
    goto <D.59091>;
    <D.59054>:
    D.59092 = cmethod->name;
    iftmp.10561 = __builtin_strcmp (D.59092, "Sin");
    <D.59091>:
    D.29049 = iftmp.10561;
  }
  if (D.29049 == 0) goto <D.59093>; else goto <D.59094>;
  <D.59093>:
  opcode = 778;
  goto <D.59095>;
  <D.59094>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.59099 = "Cos";
      D.59100 = MEM[(const unsigned char *)D.59099];
      D.59101 = (int) D.59100;
      D.59102 = *__s2;
      D.59103 = (int) D.59102;
      __result = D.59101 - D.59103;
      {
        D.59104 = __s2_len != 0;
        D.59105 = __result == 0;
        D.59106 = D.59104 & D.59105;
        if (D.59106 != 0) goto <D.59107>; else goto <D.59108>;
        <D.59107>:
        D.59109 = &MEM[(void *)"Cos" + 1B];
        D.59110 = *D.59109;
        D.59111 = (int) D.59110;
        D.59112 = __s2 + 1;
        D.59113 = *D.59112;
        D.59114 = (int) D.59113;
        __result = D.59111 - D.59114;
        D.59115 = __s2_len > 1;
        D.59105 = __result == 0;
        D.59116 = D.59115 & D.59105;
        if (D.59116 != 0) goto <D.59117>; else goto <D.59118>;
        <D.59117>:
        D.59119 = &MEM[(void *)"Cos" + 2B];
        D.59120 = *D.59119;
        D.59121 = (int) D.59120;
        D.59122 = __s2 + 2;
        D.59123 = *D.59122;
        D.59124 = (int) D.59123;
        __result = D.59121 - D.59124;
        D.59125 = __s2_len > 2;
        D.59105 = __result == 0;
        D.59126 = D.59125 & D.59105;
        if (D.59126 != 0) goto <D.59127>; else goto <D.59128>;
        <D.59127>:
        D.59129 = &MEM[(void *)"Cos" + 3B];
        D.59130 = *D.59129;
        D.59131 = (int) D.59130;
        D.59132 = __s2 + 3;
        D.59133 = *D.59132;
        D.59134 = (int) D.59133;
        __result = D.59131 - D.59134;
        <D.59128>:
        <D.59118>:
        <D.59108>:
      }
      D.29057 = __result;
    }
    iftmp.10562 = -D.29057;
    goto <D.59135>;
    <D.59098>:
    D.59092 = cmethod->name;
    iftmp.10562 = __builtin_strcmp (D.59092, "Cos");
    <D.59135>:
    D.29058 = iftmp.10562;
  }
  if (D.29058 == 0) goto <D.59136>; else goto <D.59137>;
  <D.59136>:
  opcode = 779;
  goto <D.59138>;
  <D.59137>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.59140>; else goto <D.59141>;
    <D.59140>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.59142 = "Sqrt";
      D.59143 = MEM[(const unsigned char *)D.59142];
      D.59144 = (int) D.59143;
      D.59145 = *__s2;
      D.59146 = (int) D.59145;
      __result = D.59144 - D.59146;
      {
        D.59147 = __s2_len != 0;
        D.59148 = __result == 0;
        D.59149 = D.59147 & D.59148;
        if (D.59149 != 0) goto <D.59150>; else goto <D.59151>;
        <D.59150>:
        D.59152 = &MEM[(void *)"Sqrt" + 1B];
        D.59153 = *D.59152;
        D.59154 = (int) D.59153;
        D.59155 = __s2 + 1;
        D.59156 = *D.59155;
        D.59157 = (int) D.59156;
        __result = D.59154 - D.59157;
        D.59158 = __s2_len > 1;
        D.59148 = __result == 0;
        D.59159 = D.59158 & D.59148;
        if (D.59159 != 0) goto <D.59160>; else goto <D.59161>;
        <D.59160>:
        D.59162 = &MEM[(void *)"Sqrt" + 2B];
        D.59163 = *D.59162;
        D.59164 = (int) D.59163;
        D.59165 = __s2 + 2;
        D.59166 = *D.59165;
        D.59167 = (int) D.59166;
        __result = D.59164 - D.59167;
        D.59168 = __s2_len > 2;
        D.59148 = __result == 0;
        D.59169 = D.59168 & D.59148;
        if (D.59169 != 0) goto <D.59170>; else goto <D.59171>;
        <D.59170>:
        D.59172 = &MEM[(void *)"Sqrt" + 3B];
        D.59173 = *D.59172;
        D.59174 = (int) D.59173;
        D.59175 = __s2 + 3;
        D.59176 = *D.59175;
        D.59177 = (int) D.59176;
        __result = D.59174 - D.59177;
        <D.59171>:
        <D.59161>:
        <D.59151>:
      }
      D.29066 = __result;
    }
    iftmp.10563 = -D.29066;
    goto <D.59178>;
    <D.59141>:
    D.59092 = cmethod->name;
    iftmp.10563 = __builtin_strcmp (D.59092, "Sqrt");
    <D.59178>:
    D.29067 = iftmp.10563;
  }
  if (D.29067 == 0) goto <D.59179>; else goto <D.59180>;
  <D.59179>:
  opcode = 783;
  goto <D.59181>;
  <D.59180>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.59185 = "Abs";
      D.59186 = MEM[(const unsigned char *)D.59185];
      D.59187 = (int) D.59186;
      D.59188 = *__s2;
      D.59189 = (int) D.59188;
      __result = D.59187 - D.59189;
      {
        D.59190 = __s2_len != 0;
        D.59191 = __result == 0;
        D.59192 = D.59190 & D.59191;
        if (D.59192 != 0) goto <D.59193>; else goto <D.59194>;
        <D.59193>:
        D.59195 = &MEM[(void *)"Abs" + 1B];
        D.59196 = *D.59195;
        D.59197 = (int) D.59196;
        D.59198 = __s2 + 1;
        D.59199 = *D.59198;
        D.59200 = (int) D.59199;
        __result = D.59197 - D.59200;
        D.59201 = __s2_len > 1;
        D.59191 = __result == 0;
        D.59202 = D.59201 & D.59191;
        if (D.59202 != 0) goto <D.59203>; else goto <D.59204>;
        <D.59203>:
        D.59205 = &MEM[(void *)"Abs" + 2B];
        D.59206 = *D.59205;
        D.59207 = (int) D.59206;
        D.59208 = __s2 + 2;
        D.59209 = *D.59208;
        D.59210 = (int) D.59209;
        __result = D.59207 - D.59210;
        D.59211 = __s2_len > 2;
        D.59191 = __result == 0;
        D.59212 = D.59211 & D.59191;
        if (D.59212 != 0) goto <D.59213>; else goto <D.59214>;
        <D.59213>:
        D.59215 = &MEM[(void *)"Abs" + 3B];
        D.59216 = *D.59215;
        D.59217 = (int) D.59216;
        D.59218 = __s2 + 3;
        D.59219 = *D.59218;
        D.59220 = (int) D.59219;
        __result = D.59217 - D.59220;
        <D.59214>:
        <D.59204>:
        <D.59194>:
      }
      D.29075 = __result;
    }
    iftmp.10564 = -D.29075;
    goto <D.59221>;
    <D.59184>:
    D.59092 = cmethod->name;
    iftmp.10564 = __builtin_strcmp (D.59092, "Abs");
    <D.59221>:
    D.29076 = iftmp.10564;
  }
  if (D.29076 == 0) goto <D.59222>; else goto <D.59223>;
  <D.59222>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 13) goto <D.59226>; else goto <D.59227>;
  <D.59226>:
  opcode = 780;
  <D.59227>:
  <D.59223>:
  <D.59181>:
  <D.59138>:
  <D.59095>:
  if (opcode != 0) goto <D.59228>; else goto <D.59229>;
  <D.59228>:
  D.59230 = cfg->mempool;
  ins = mono_mempool_alloc (D.59230, 80);
  ins->data.op[1].const_val = 0;
  D.59231 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.59231;
  ins->prev = 0B;
  D.59232 = ins->prev;
  ins->next = D.59232;
  D.59233 = (short unsigned int) opcode;
  ins->opcode = D.59233;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.59234 = ins->sreg3;
  ins->sreg2 = D.59234;
  D.59235 = ins->sreg2;
  ins->sreg1 = D.59235;
  D.59236 = cfg->ip;
  ins->cil_code = D.59236;
  ins->type = 4;
  D.59237 = mono_alloc_freg (cfg);
  D.59238 = (int) D.59237;
  ins->dreg = D.59238;
  D.59239 = *args;
  D.59240 = D.59239->dreg;
  ins->sreg1 = D.59240;
  D.59241 = cfg->cbb;
  D.59242 = D.59241->last_ins;
  if (D.59242 != 0B) goto <D.59243>; else goto <D.59244>;
  <D.59243>:
  D.59241 = cfg->cbb;
  D.59242 = D.59241->last_ins;
  D.59242->next = ins;
  D.59241 = cfg->cbb;
  D.59242 = D.59241->last_ins;
  ins->prev = D.59242;
  D.59241 = cfg->cbb;
  D.59241->last_ins = ins;
  goto <D.59245>;
  <D.59244>:
  D.59241 = cfg->cbb;
  D.59241 = cfg->cbb;
  D.59241->last_ins = ins;
  D.59242 = D.59241->last_ins;
  D.59241->code = D.59242;
  <D.59245>:
  <D.59229>:
  opcode = 0;
  D.59246 = cfg->opt;
  D.59247 = D.59246 & 256;
  if (D.59247 != 0) goto <D.59248>; else goto <D.59249>;
  <D.59248>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.59253 = "Min";
      D.59254 = MEM[(const unsigned char *)D.59253];
      D.59255 = (int) D.59254;
      D.59256 = *__s2;
      D.59257 = (int) D.59256;
      __result = D.59255 - D.59257;
      {
        D.59258 = __s2_len != 0;
        D.59259 = __result == 0;
        D.59260 = D.59258 & D.59259;
        if (D.59260 != 0) goto <D.59261>; else goto <D.59262>;
        <D.59261>:
        D.59263 = &MEM[(void *)"Min" + 1B];
        D.59264 = *D.59263;
        D.59265 = (int) D.59264;
        D.59266 = __s2 + 1;
        D.59267 = *D.59266;
        D.59268 = (int) D.59267;
        __result = D.59265 - D.59268;
        D.59269 = __s2_len > 1;
        D.59259 = __result == 0;
        D.59270 = D.59269 & D.59259;
        if (D.59270 != 0) goto <D.59271>; else goto <D.59272>;
        <D.59271>:
        D.59273 = &MEM[(void *)"Min" + 2B];
        D.59274 = *D.59273;
        D.59275 = (int) D.59274;
        D.59276 = __s2 + 2;
        D.59277 = *D.59276;
        D.59278 = (int) D.59277;
        __result = D.59275 - D.59278;
        D.59279 = __s2_len > 2;
        D.59259 = __result == 0;
        D.59280 = D.59279 & D.59259;
        if (D.59280 != 0) goto <D.59281>; else goto <D.59282>;
        <D.59281>:
        D.59283 = &MEM[(void *)"Min" + 3B];
        D.59284 = *D.59283;
        D.59285 = (int) D.59284;
        D.59286 = __s2 + 3;
        D.59287 = *D.59286;
        D.59288 = (int) D.59287;
        __result = D.59285 - D.59288;
        <D.59282>:
        <D.59272>:
        <D.59262>:
      }
      D.29084 = __result;
    }
    iftmp.10565 = -D.29084;
    goto <D.59289>;
    <D.59252>:
    D.59092 = cmethod->name;
    iftmp.10565 = __builtin_strcmp (D.59092, "Min");
    <D.59289>:
    D.29085 = iftmp.10565;
  }
  if (D.29085 == 0) goto <D.59290>; else goto <D.59291>;
  <D.59290>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 8) goto <D.59292>; else goto <D.59293>;
  <D.59292>:
  opcode = 751;
  <D.59293>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 9) goto <D.59294>; else goto <D.59295>;
  <D.59294>:
  opcode = 745;
  goto <D.59296>;
  <D.59295>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 10) goto <D.59297>; else goto <D.59298>;
  <D.59297>:
  opcode = 753;
  goto <D.59299>;
  <D.59298>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 11) goto <D.59300>; else goto <D.59301>;
  <D.59300>:
  opcode = 747;
  <D.59301>:
  <D.59299>:
  <D.59296>:
  goto <D.59302>;
  <D.59291>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.59306 = "Max";
      D.59307 = MEM[(const unsigned char *)D.59306];
      D.59308 = (int) D.59307;
      D.59309 = *__s2;
      D.59310 = (int) D.59309;
      __result = D.59308 - D.59310;
      {
        D.59311 = __s2_len != 0;
        D.59312 = __result == 0;
        D.59313 = D.59311 & D.59312;
        if (D.59313 != 0) goto <D.59314>; else goto <D.59315>;
        <D.59314>:
        D.59316 = &MEM[(void *)"Max" + 1B];
        D.59317 = *D.59316;
        D.59318 = (int) D.59317;
        D.59319 = __s2 + 1;
        D.59320 = *D.59319;
        D.59321 = (int) D.59320;
        __result = D.59318 - D.59321;
        D.59322 = __s2_len > 1;
        D.59312 = __result == 0;
        D.59323 = D.59322 & D.59312;
        if (D.59323 != 0) goto <D.59324>; else goto <D.59325>;
        <D.59324>:
        D.59326 = &MEM[(void *)"Max" + 2B];
        D.59327 = *D.59326;
        D.59328 = (int) D.59327;
        D.59329 = __s2 + 2;
        D.59330 = *D.59329;
        D.59331 = (int) D.59330;
        __result = D.59328 - D.59331;
        D.59332 = __s2_len > 2;
        D.59312 = __result == 0;
        D.59333 = D.59332 & D.59312;
        if (D.59333 != 0) goto <D.59334>; else goto <D.59335>;
        <D.59334>:
        D.59336 = &MEM[(void *)"Max" + 3B];
        D.59337 = *D.59336;
        D.59338 = (int) D.59337;
        D.59339 = __s2 + 3;
        D.59340 = *D.59339;
        D.59341 = (int) D.59340;
        __result = D.59338 - D.59341;
        <D.59335>:
        <D.59325>:
        <D.59315>:
      }
      D.29093 = __result;
    }
    iftmp.10566 = -D.29093;
    goto <D.59342>;
    <D.59305>:
    D.59092 = cmethod->name;
    iftmp.10566 = __builtin_strcmp (D.59092, "Max");
    <D.59342>:
    D.29094 = iftmp.10566;
  }
  if (D.29094 == 0) goto <D.59343>; else goto <D.59344>;
  <D.59343>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 8) goto <D.59345>; else goto <D.59346>;
  <D.59345>:
  opcode = 752;
  <D.59346>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 9) goto <D.59347>; else goto <D.59348>;
  <D.59347>:
  opcode = 746;
  goto <D.59349>;
  <D.59348>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 10) goto <D.59350>; else goto <D.59351>;
  <D.59350>:
  opcode = 754;
  goto <D.59352>;
  <D.59351>:
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 11) goto <D.59353>; else goto <D.59354>;
  <D.59353>:
  opcode = 748;
  <D.59354>:
  <D.59352>:
  <D.59349>:
  <D.59344>:
  <D.59302>:
  <D.59249>:
  if (opcode != 0) goto <D.59355>; else goto <D.59356>;
  <D.59355>:
  D.59230 = cfg->mempool;
  ins = mono_mempool_alloc (D.59230, 80);
  ins->data.op[1].const_val = 0;
  D.59231 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.59231;
  ins->prev = 0B;
  D.59232 = ins->prev;
  ins->next = D.59232;
  D.59233 = (short unsigned int) opcode;
  ins->opcode = D.59233;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.59234 = ins->sreg3;
  ins->sreg2 = D.59234;
  D.59235 = ins->sreg2;
  ins->sreg1 = D.59235;
  D.59236 = cfg->ip;
  ins->cil_code = D.59236;
  D.59224 = fsig->params[0];
  D.59225 = D.59224->type;
  if (D.59225 == 8) goto <D.59358>; else goto <D.59359>;
  <D.59358>:
  iftmp.10567 = 1;
  goto <D.59360>;
  <D.59359>:
  iftmp.10567 = 2;
  <D.59360>:
  ins->type = iftmp.10567;
  D.59361 = mono_alloc_ireg (cfg);
  D.59362 = (int) D.59361;
  ins->dreg = D.59362;
  D.59239 = *args;
  D.59240 = D.59239->dreg;
  ins->sreg1 = D.59240;
  D.59363 = args + 8;
  D.59364 = *D.59363;
  D.59365 = D.59364->dreg;
  ins->sreg2 = D.59365;
  D.59241 = cfg->cbb;
  D.59242 = D.59241->last_ins;
  if (D.59242 != 0B) goto <D.59366>; else goto <D.59367>;
  <D.59366>:
  D.59241 = cfg->cbb;
  D.59242 = D.59241->last_ins;
  D.59242->next = ins;
  D.59241 = cfg->cbb;
  D.59242 = D.59241->last_ins;
  ins->prev = D.59242;
  D.59241 = cfg->cbb;
  D.59241->last_ins = ins;
  goto <D.59368>;
  <D.59367>:
  D.59241 = cfg->cbb;
  D.59241 = cfg->cbb;
  D.59241->last_ins = ins;
  D.59242 = D.59241->last_ins;
  D.59241->code = D.59242;
  <D.59368>:
  <D.59356>:
  <D.59051>:
  D.59369 = ins;
  return D.59369;
}


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

  D.59371 = 0;
  return D.59371;
}


mono_arch_context_get_int_reg (struct MonoContext * ctx, int reg)
{
  mgreg_t D.59373;
  mgreg_t * D.59374;
  long unsigned int D.59375;
  long unsigned int D.59376;
  mgreg_t * D.59377;

  switch (reg) <default: <D.29108>, case 1: <D.29103>, case 2: <D.29104>, case 3: <D.29105>, case 4: <D.29107>, case 5: <D.29106>>
  <D.29103>:
  D.59373 = ctx->rcx;
  return D.59373;
  <D.29104>:
  D.59373 = ctx->rdx;
  return D.59373;
  <D.29105>:
  D.59373 = ctx->rbx;
  return D.59373;
  <D.29106>:
  D.59373 = ctx->rbp;
  return D.59373;
  <D.29107>:
  D.59373 = ctx->rsp;
  return D.59373;
  <D.29108>:
  D.59374 = &ctx->rax;
  D.59375 = (long unsigned int) reg;
  D.59376 = D.59375 * 8;
  D.59377 = D.59374 + D.59376;
  D.59373 = *D.59377;
  return D.59373;
}


mono_arch_context_set_int_reg (struct MonoContext * ctx, int reg, mgreg_t val)
{
  mgreg_t * D.59379;
  long unsigned int D.59380;
  long unsigned int D.59381;
  mgreg_t * D.59382;

  switch (reg) <default: <D.29120>, case 1: <D.29114>, case 2: <D.29116>, case 3: <D.29117>, case 4: <D.29119>, case 5: <D.29118>>
  <D.29114>:
  ctx->rcx = val;
  goto <D.29115>;
  <D.29116>:
  ctx->rdx = val;
  goto <D.29115>;
  <D.29117>:
  ctx->rbx = val;
  goto <D.29115>;
  <D.29118>:
  ctx->rbp = val;
  goto <D.29115>;
  <D.29119>:
  ctx->rsp = val;
  goto <D.29115>;
  <D.29120>:
  D.59379 = &ctx->rax;
  D.59380 = (long unsigned int) reg;
  D.59381 = D.59380 * 8;
  D.59382 = D.59379 + D.59381;
  *D.59382 = val;
  <D.29115>:
}


mono_arch_install_handler_block_guard (struct MonoJitInfo * ji, struct MonoJitExceptionInfo * clause, struct MonoContext * ctx, void * new_value)
{
  unsigned char D.59383;
  void * D.59386;
  signed char * D.59391;
  signed char D.59392;
  long int D.59397;
  sizetype D.59398;
  void * * D.59399;
  void * D.59402;
  int D.59404;
  sizetype D.59405;
  char * D.59406;
  int offset;
  void * * sp;
  void * old_value;
  char * bp;
  const unsigned char * handler;

  handler = clause->handler_start;
  D.59383 = *handler;
  if (D.59383 != 72) goto <D.59384>; else goto <D.59385>;
  <D.59384>:
  D.59386 = 0B;
  return D.59386;
  <D.59385>:
  handler = handler + 1;
  D.59383 = *handler;
  if (D.59383 != 137) goto <D.59387>; else goto <D.59388>;
  <D.59387>:
  D.59386 = 0B;
  return D.59386;
  <D.59388>:
  handler = handler + 1;
  D.59383 = *handler;
  if (D.59383 == 101) goto <D.59389>; else goto <D.59390>;
  <D.59389>:
  D.59391 = handler + 1;
  D.59392 = *D.59391;
  offset = (int) D.59392;
  goto <D.59393>;
  <D.59390>:
  D.59383 = *handler;
  if (D.59383 == 165) goto <D.59394>; else goto <D.59395>;
  <D.59394>:
  offset = MEM[(int *)handler + 1B];
  goto <D.59396>;
  <D.59395>:
  D.59386 = 0B;
  return D.59386;
  <D.59396>:
  <D.59393>:
  D.59397 = ctx->rbp;
  bp = (char *) D.59397;
  D.59398 = (sizetype) offset;
  D.59399 = bp + D.59398;
  sp = *D.59399;
  old_value = *sp;
  D.59402 = ji->code_start;
  if (D.59402 > old_value) goto <D.59400>; else goto <D.59403>;
  <D.59403>:
  D.59402 = ji->code_start;
  D.59404 = ji->code_size;
  D.59405 = (sizetype) D.59404;
  D.59406 = D.59402 + D.59405;
  if (D.59406 < old_value) goto <D.59400>; else goto <D.59401>;
  <D.59400>:
  D.59386 = old_value;
  return D.59386;
  <D.59401>:
  *sp = new_value;
  D.59386 = old_value;
  return D.59386;
}


mono_arch_emit_load_aotconst (guint8 * start, guint8 * code, struct MonoJumpInfo * * ji, int tramp_type, const void * target)
{
  <unnamed type> tramp_type.10568;
  long int code.10569;
  long int start.10570;
  long int D.59411;
  int D.59412;
  struct MonoJumpInfo * D.59413;
  struct MonoJumpInfo * D.59414;
  guint8 * code.10571;
  guint8 * code.10572;
  unsigned char D.59421;
  guint8 * code.10573;
  guint8 * code.10574;
  guint8 * code.10575;
  guint8 * code.10576;
  unsigned char D.59428;
  guint8 * code.10577;
  unsigned char D.59430;
  guint8 * code.10578;
  unsigned char D.59432;
  guint8 * code.10579;
  unsigned char D.59434;
  guint8 * code.10580;
  guint8 * code.10581;
  guint8 * code.10582;
  guint8 * code.10583;
  guint8 * code.10584;
  guint8 * code.10585;
  guint8 * code.10586;
  unsigned char D.59451;
  guint8 * code.10587;
  unsigned char D.59453;
  guint8 * code.10588;
  unsigned char D.59455;
  guint8 * code.10589;
  unsigned char D.59457;
  guint8 * code.10590;
  guint8 * code.10591;
  guint8 * code.10592;
  guint8 * code.10593;
  unsigned char D.59467;
  guint8 * code.10594;
  unsigned char D.59469;
  guint8 * code.10595;
  unsigned char D.59471;
  guint8 * code.10596;
  unsigned char D.59473;
  guint8 * D.59474;
  static const char __PRETTY_FUNCTION__[29] = "mono_arch_emit_load_aotconst";

  tramp_type.10568 = (<unnamed type>) tramp_type;
  code.10569 = (long int) code;
  start.10570 = (long int) start;
  D.59411 = code.10569 - start.10570;
  D.59412 = (int) D.59411;
  D.59413 = *ji;
  D.59414 = mono_patch_info_list_prepend (D.59413, D.59412, tramp_type.10568, target);
  *ji = D.59414;
  if (0 != 0) goto <D.59415>; else goto <D.59416>;
  <D.59415>:
  code.10571 = code;
  code = code.10571 + 1;
  *code.10571 = 102;
  <D.59416>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 13;
    if (_amd64_rex_bits != 0) goto <D.59418>; else goto <D.59419>;
    <D.59418>:
    code.10572 = code;
    code = code.10572 + 1;
    D.59421 = _amd64_rex_bits | 64;
    *code.10572 = D.59421;
    <D.59419>:
  }
  switch (8) <default: <D.29145>, case 1: <D.29140>, case 2: <D.29142>, case 4: <D.29143>, case 8: <D.29144>>
  <D.29140>:
  code.10573 = code;
  code = code.10573 + 1;
  *code.10573 = 138;
  goto <D.29141>;
  <D.29142>:
  <D.29143>:
  <D.29144>:
  code.10574 = code;
  code = code.10574 + 1;
  *code.10574 = 139;
  goto <D.29141>;
  <D.29145>:
  __assert_fail ("0", "mini-amd64.c", 8510, &__PRETTY_FUNCTION__);
  <D.29141>:
  if (1 != 0) goto <D.59424>; else goto <D.59425>;
  <D.59424>:
  code.10575 = code;
  code = code.10575 + 1;
  *code.10575 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.10576 = code;
        code = code.10576 + 1;
        D.59428 = imb.b[0];
        *code.10576 = D.59428;
        code.10577 = code;
        code = code.10577 + 1;
        D.59430 = imb.b[1];
        *code.10577 = D.59430;
        code.10578 = code;
        code = code.10578 + 1;
        D.59432 = imb.b[2];
        *code.10578 = D.59432;
        code.10579 = code;
        code = code.10579 + 1;
        D.59434 = imb.b[3];
        *code.10579 = D.59434;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.59435>;
  <D.59425>:
  if (0 != 0) goto <D.59436>; else goto <D.59437>;
  <D.59436>:
  if (1 != 0) goto <D.59438>; else goto <D.59439>;
  <D.59438>:
  code.10580 = code;
  code = code.10580 + 1;
  *code.10580 = 28;
  code.10581 = code;
  code = code.10581 + 1;
  *code.10581 = 36;
  goto <D.59442>;
  <D.59439>:
  if (1 != 0) goto <D.59443>; else goto <D.59444>;
  <D.59443>:
  code.10582 = code;
  code = code.10582 + 1;
  *code.10582 = 92;
  code.10583 = code;
  code = code.10583 + 1;
  *code.10583 = 36;
  *code = 0;
  code = code + 1;
  goto <D.59447>;
  <D.59444>:
  code.10584 = code;
  code = code.10584 + 1;
  *code.10584 = 156;
  code.10585 = code;
  code = code.10585 + 1;
  *code.10585 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.10586 = code;
        code = code.10586 + 1;
        D.59451 = imb.b[0];
        *code.10586 = D.59451;
        code.10587 = code;
        code = code.10587 + 1;
        D.59453 = imb.b[1];
        *code.10587 = D.59453;
        code.10588 = code;
        code = code.10588 + 1;
        D.59455 = imb.b[2];
        *code.10588 = D.59455;
        code.10589 = code;
        code = code.10589 + 1;
        D.59457 = imb.b[3];
        *code.10589 = D.59457;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.59447>:
  <D.59442>:
  goto <D.29149>;
  <D.59437>:
  if (1 != 0) goto <D.59458>; else goto <D.59459>;
  <D.59458>:
  code.10590 = code;
  code = code.10590 + 1;
  *code.10590 = 24;
  goto <D.29149>;
  <D.59459>:
  if (1 != 0) goto <D.59461>; else goto <D.59462>;
  <D.59461>:
  code.10591 = code;
  code = code.10591 + 1;
  *code.10591 = 88;
  *code = 0;
  code = code + 1;
  goto <D.59464>;
  <D.59462>:
  code.10592 = code;
  code = code.10592 + 1;
  *code.10592 = 152;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.10593 = code;
        code = code.10593 + 1;
        D.59467 = imb.b[0];
        *code.10593 = D.59467;
        code.10594 = code;
        code = code.10594 + 1;
        D.59469 = imb.b[1];
        *code.10594 = D.59469;
        code.10595 = code;
        code = code.10595 + 1;
        D.59471 = imb.b[2];
        *code.10595 = D.59471;
        code.10596 = code;
        code = code.10596 + 1;
        D.59473 = imb.b[3];
        *code.10596 = D.59473;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.59464>:
  <D.29149>:
  <D.59435>:
  D.59474 = code;
  return D.59474;
}


mono_arch_get_trampolines (gboolean aot)
{
  struct GSList * D.59476;

  D.59476 = mono_amd64_get_exception_trampolines (aot);
  return D.59476;
}


mono_arch_set_breakpoint (struct MonoJitInfo * ji, guint8 * ip)
{
  unsigned char D.59478;
  unsigned char D.59479;
  long int ip.10597;
  void * D.59483;
  long int D.59484;
  long int D.59485;
  struct MonoDomain * D.59486;
  void * D.59487;
  _Bool D.59488;
  long int D.59489;
  long int D.59490;
  void * bp_trigger_page.10598;
  unsigned char D.59495;
  _Bool D.59496;
  long int D.59497;
  long int D.59498;
  int breakpoint_size.10599;
  guint8 * code.10600;
  guint8 * code.10601;
  unsigned char D.59510;
  guint8 * code.10602;
  guint8 * code.10603;
  guint8 * code.10604;
  guint8 * code.10605;
  long int bp_trigger_page.10606;
  int D.59516;
  guint8 * code.10607;
  unsigned char D.59518;
  guint8 * code.10608;
  unsigned char D.59520;
  guint8 * code.10609;
  unsigned char D.59522;
  guint8 * code.10610;
  unsigned char D.59524;
  guint8 * code.10611;
  unsigned char D.59529;
  guint8 * code.10612;
  long unsigned int bp_trigger_page.10613;
  guint8 * code.10614;
  unsigned char D.59535;
  guint8 * code.10615;
  unsigned char D.59537;
  guint8 * code.10616;
  unsigned char D.59539;
  guint8 * code.10617;
  unsigned char D.59541;
  guint8 * code.10618;
  unsigned char D.59543;
  guint8 * code.10619;
  unsigned char D.59545;
  guint8 * code.10620;
  unsigned char D.59547;
  guint8 * code.10621;
  unsigned char D.59549;
  guint8 * code.10622;
  unsigned char D.59552;
  guint8 * code.10623;
  unsigned char D.59554;
  guint8 * code.10624;
  unsigned char D.59556;
  guint8 * code.10625;
  unsigned char D.59558;
  guint8 * code.10626;
  guint8 * code.10627;
  unsigned char D.59565;
  guint8 * code.10628;
  guint8 * code.10629;
  guint8 * code.10630;
  guint8 * code.10631;
  unsigned char D.59572;
  guint8 * code.10632;
  unsigned char D.59574;
  guint8 * code.10633;
  unsigned char D.59576;
  guint8 * code.10634;
  unsigned char D.59578;
  guint8 * code.10635;
  guint8 * code.10636;
  guint8 * code.10637;
  guint8 * code.10638;
  guint8 * code.10639;
  guint8 * code.10640;
  guint8 * code.10641;
  unsigned char D.59595;
  guint8 * code.10642;
  unsigned char D.59597;
  guint8 * code.10643;
  unsigned char D.59599;
  guint8 * code.10644;
  unsigned char D.59601;
  guint8 * code.10645;
  guint8 * code.10646;
  guint8 * code.10647;
  guint8 * code.10648;
  unsigned char D.59611;
  guint8 * code.10649;
  unsigned char D.59613;
  guint8 * code.10650;
  unsigned char D.59615;
  guint8 * code.10651;
  unsigned char D.59617;
  long int code.10652;
  long int orig_code.10653;
  long int D.59620;
  long int D.59621;
  _Bool D.59622;
  long int D.59623;
  long int D.59624;
  guint8 * code;
  guint8 * orig_code;
  static const char __PRETTY_FUNCTION__[25] = "mono_arch_set_breakpoint";

  code = ip;
  orig_code = code;
  D.59478 = BIT_FIELD_REF <*ji, 8, 272>;
  D.59479 = D.59478 & 16;
  if (D.59479 != 0) goto <D.59480>; else goto <D.59481>;
  <D.59480>:
  {
    guint32 native_offset;
    struct SeqPointInfo * info;

    ip.10597 = (long int) ip;
    D.59483 = ji->code_start;
    D.59484 = (long int) D.59483;
    D.59485 = ip.10597 - D.59484;
    native_offset = (guint32) D.59485;
    D.59483 = ji->code_start;
    D.59486 = mono_domain_get ();
    info = mono_arch_get_seq_point_info (D.59486, D.59483);
    D.59487 = info->bp_addrs[native_offset];
    D.59488 = D.59487 != 0B;
    D.59489 = (long int) D.59488;
    D.59490 = __builtin_expect (D.59489, 0);
    if (D.59490 != 0) goto <D.59491>; else goto <D.59492>;
    <D.59491>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8546, "info->bp_addrs [native_offset] == 0");
    <D.59492>:
    bp_trigger_page.10598 = bp_trigger_page;
    info->bp_addrs[native_offset] = bp_trigger_page.10598;
  }
  goto <D.59494>;
  <D.59481>:
  D.59495 = *code;
  D.59496 = D.59495 != 144;
  D.59497 = (long int) D.59496;
  D.59498 = __builtin_expect (D.59497, 0);
  if (D.59498 != 0) goto <D.59499>; else goto <D.59500>;
  <D.59499>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8554, "code [0] == 0x90");
  <D.59500>:
  breakpoint_size.10599 = breakpoint_size;
  if (breakpoint_size.10599 == 8) goto <D.59502>; else goto <D.59503>;
  <D.59502>:
  if (0 != 0) goto <D.59504>; else goto <D.59505>;
  <D.59504>:
  code.10600 = code;
  code = code.10600 + 1;
  *code.10600 = 102;
  <D.59505>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 4;
    if (_amd64_rex_bits != 0) goto <D.59507>; else goto <D.59508>;
    <D.59507>:
    code.10601 = code;
    code = code.10601 + 1;
    D.59510 = _amd64_rex_bits | 64;
    *code.10601 = D.59510;
    <D.59508>:
  }
  switch (4) <default: <D.29168>, case 1: <D.29163>, case 2: <D.29165>, case 4: <D.29166>, case 8: <D.29167>>
  <D.29163>:
  code.10602 = code;
  code = code.10602 + 1;
  *code.10602 = 138;
  goto <D.29164>;
  <D.29165>:
  <D.29166>:
  <D.29167>:
  code.10603 = code;
  code = code.10603 + 1;
  *code.10603 = 139;
  goto <D.29164>;
  <D.29168>:
  __assert_fail ("0", "mini-amd64.c", 8556, &__PRETTY_FUNCTION__);
  <D.29164>:
  code.10604 = code;
  code = code.10604 + 1;
  *code.10604 = 28;
  code.10605 = code;
  code = code.10605 + 1;
  *code.10605 = 37;
  {
    union x86_imm_buf imb;

    try
      {
        bp_trigger_page.10598 = bp_trigger_page;
        bp_trigger_page.10606 = (long int) bp_trigger_page.10598;
        D.59516 = (int) bp_trigger_page.10606;
        imb.val = D.59516;
        code.10607 = code;
        code = code.10607 + 1;
        D.59518 = imb.b[0];
        *code.10607 = D.59518;
        code.10608 = code;
        code = code.10608 + 1;
        D.59520 = imb.b[1];
        *code.10608 = D.59520;
        code.10609 = code;
        code = code.10609 + 1;
        D.59522 = imb.b[2];
        *code.10609 = D.59522;
        code.10610 = code;
        code = code.10610 + 1;
        D.59524 = imb.b[3];
        *code.10610 = D.59524;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.59525>;
  <D.59503>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 9;
    if (_amd64_rex_bits != 0) goto <D.59526>; else goto <D.59527>;
    <D.59526>:
    code.10611 = code;
    code = code.10611 + 1;
    D.59529 = _amd64_rex_bits | 64;
    *code.10611 = D.59529;
    <D.59527>:
  }
  code.10612 = code;
  code = code.10612 + 1;
  *code.10612 = 187;
  if (1 != 0) goto <D.59531>; else goto <D.59532>;
  <D.59531>:
  {
    union amd64_imm_buf imb;

    try
      {
        bp_trigger_page.10598 = bp_trigger_page;
        bp_trigger_page.10613 = (long unsigned int) bp_trigger_page.10598;
        imb.val = bp_trigger_page.10613;
        code.10614 = code;
        code = code.10614 + 1;
        D.59535 = imb.b[0];
        *code.10614 = D.59535;
        code.10615 = code;
        code = code.10615 + 1;
        D.59537 = imb.b[1];
        *code.10615 = D.59537;
        code.10616 = code;
        code = code.10616 + 1;
        D.59539 = imb.b[2];
        *code.10616 = D.59539;
        code.10617 = code;
        code = code.10617 + 1;
        D.59541 = imb.b[3];
        *code.10617 = D.59541;
        code.10618 = code;
        code = code.10618 + 1;
        D.59543 = imb.b[4];
        *code.10618 = D.59543;
        code.10619 = code;
        code = code.10619 + 1;
        D.59545 = imb.b[5];
        *code.10619 = D.59545;
        code.10620 = code;
        code = code.10620 + 1;
        D.59547 = imb.b[6];
        *code.10620 = D.59547;
        code.10621 = code;
        code = code.10621 + 1;
        D.59549 = imb.b[7];
        *code.10621 = D.59549;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.59550>;
  <D.59532>:
  {
    union x86_imm_buf imb;

    try
      {
        bp_trigger_page.10598 = bp_trigger_page;
        bp_trigger_page.10606 = (long int) bp_trigger_page.10598;
        D.59516 = (int) bp_trigger_page.10606;
        imb.val = D.59516;
        code.10622 = code;
        code = code.10622 + 1;
        D.59552 = imb.b[0];
        *code.10622 = D.59552;
        code.10623 = code;
        code = code.10623 + 1;
        D.59554 = imb.b[1];
        *code.10623 = D.59554;
        code.10624 = code;
        code = code.10624 + 1;
        D.59556 = imb.b[2];
        *code.10624 = D.59556;
        code.10625 = code;
        code = code.10625 + 1;
        D.59558 = imb.b[3];
        *code.10625 = D.59558;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.59550>:
  if (0 != 0) goto <D.59559>; else goto <D.59560>;
  <D.59559>:
  code.10626 = code;
  code = code.10626 + 1;
  *code.10626 = 102;
  <D.59560>:
  {
    unsigned char _amd64_rex_bits;

    _amd64_rex_bits = 5;
    if (_amd64_rex_bits != 0) goto <D.59562>; else goto <D.59563>;
    <D.59562>:
    code.10627 = code;
    code = code.10627 + 1;
    D.59565 = _amd64_rex_bits | 64;
    *code.10627 = D.59565;
    <D.59563>:
  }
  switch (4) <default: <D.29180>, case 1: <D.29175>, case 2: <D.29177>, case 4: <D.29178>, case 8: <D.29179>>
  <D.29175>:
  code.10628 = code;
  code = code.10628 + 1;
  *code.10628 = 138;
  goto <D.29176>;
  <D.29177>:
  <D.29178>:
  <D.29179>:
  code.10629 = code;
  code = code.10629 + 1;
  *code.10629 = 139;
  goto <D.29176>;
  <D.29180>:
  __assert_fail ("0", "mini-amd64.c", 8559, &__PRETTY_FUNCTION__);
  <D.29176>:
  if (0 != 0) goto <D.59568>; else goto <D.59569>;
  <D.59568>:
  code.10630 = code;
  code = code.10630 + 1;
  *code.10630 = 29;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.10631 = code;
        code = code.10631 + 1;
        D.59572 = imb.b[0];
        *code.10631 = D.59572;
        code.10632 = code;
        code = code.10632 + 1;
        D.59574 = imb.b[1];
        *code.10632 = D.59574;
        code.10633 = code;
        code = code.10633 + 1;
        D.59576 = imb.b[2];
        *code.10633 = D.59576;
        code.10634 = code;
        code = code.10634 + 1;
        D.59578 = imb.b[3];
        *code.10634 = D.59578;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  goto <D.59579>;
  <D.59569>:
  if (0 != 0) goto <D.59580>; else goto <D.59581>;
  <D.59580>:
  if (1 != 0) goto <D.59582>; else goto <D.59583>;
  <D.59582>:
  code.10635 = code;
  code = code.10635 + 1;
  *code.10635 = 28;
  code.10636 = code;
  code = code.10636 + 1;
  *code.10636 = 36;
  goto <D.59586>;
  <D.59583>:
  if (1 != 0) goto <D.59587>; else goto <D.59588>;
  <D.59587>:
  code.10637 = code;
  code = code.10637 + 1;
  *code.10637 = 92;
  code.10638 = code;
  code = code.10638 + 1;
  *code.10638 = 36;
  *code = 0;
  code = code + 1;
  goto <D.59591>;
  <D.59588>:
  code.10639 = code;
  code = code.10639 + 1;
  *code.10639 = 156;
  code.10640 = code;
  code = code.10640 + 1;
  *code.10640 = 36;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.10641 = code;
        code = code.10641 + 1;
        D.59595 = imb.b[0];
        *code.10641 = D.59595;
        code.10642 = code;
        code = code.10642 + 1;
        D.59597 = imb.b[1];
        *code.10642 = D.59597;
        code.10643 = code;
        code = code.10643 + 1;
        D.59599 = imb.b[2];
        *code.10643 = D.59599;
        code.10644 = code;
        code = code.10644 + 1;
        D.59601 = imb.b[3];
        *code.10644 = D.59601;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.59591>:
  <D.59586>:
  goto <D.29183>;
  <D.59581>:
  if (1 != 0) goto <D.59602>; else goto <D.59603>;
  <D.59602>:
  code.10645 = code;
  code = code.10645 + 1;
  *code.10645 = 27;
  goto <D.29183>;
  <D.59603>:
  if (1 != 0) goto <D.59605>; else goto <D.59606>;
  <D.59605>:
  code.10646 = code;
  code = code.10646 + 1;
  *code.10646 = 91;
  *code = 0;
  code = code + 1;
  goto <D.59608>;
  <D.59606>:
  code.10647 = code;
  code = code.10647 + 1;
  *code.10647 = 155;
  {
    union x86_imm_buf imb;

    try
      {
        imb.val = 0;
        code.10648 = code;
        code = code.10648 + 1;
        D.59611 = imb.b[0];
        *code.10648 = D.59611;
        code.10649 = code;
        code = code.10649 + 1;
        D.59613 = imb.b[1];
        *code.10649 = D.59613;
        code.10650 = code;
        code = code.10650 + 1;
        D.59615 = imb.b[2];
        *code.10650 = D.59615;
        code.10651 = code;
        code = code.10651 + 1;
        D.59617 = imb.b[3];
        *code.10651 = D.59617;
      }
    finally
      {
        imb = {CLOBBER};
      }
  }
  <D.59608>:
  <D.29183>:
  <D.59579>:
  <D.59525>:
  code.10652 = (long int) code;
  orig_code.10653 = (long int) orig_code;
  D.59620 = code.10652 - orig_code.10653;
  breakpoint_size.10599 = breakpoint_size;
  D.59621 = (long int) breakpoint_size.10599;
  D.59622 = D.59620 != D.59621;
  D.59623 = (long int) D.59622;
  D.59624 = __builtin_expect (D.59623, 0);
  if (D.59624 != 0) goto <D.59625>; else goto <D.59626>;
  <D.59625>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8562, "code - orig_code == breakpoint_size");
  <D.59626>:
  <D.59494>:
}


mono_arch_clear_breakpoint (struct MonoJitInfo * ji, guint8 * ip)
{
  unsigned char D.59627;
  unsigned char D.59628;
  long int ip.10654;
  void * D.59632;
  long int D.59633;
  long int D.59634;
  struct MonoDomain * D.59635;
  void * D.59636;
  _Bool D.59637;
  long int D.59638;
  long int D.59639;
  guint8 * code.10655;
  int breakpoint_size.10656;
  guint8 * code;
  int i;

  code = ip;
  D.59627 = BIT_FIELD_REF <*ji, 8, 272>;
  D.59628 = D.59627 & 16;
  if (D.59628 != 0) goto <D.59629>; else goto <D.59630>;
  <D.59629>:
  {
    guint32 native_offset;
    struct SeqPointInfo * info;

    ip.10654 = (long int) ip;
    D.59632 = ji->code_start;
    D.59633 = (long int) D.59632;
    D.59634 = ip.10654 - D.59633;
    native_offset = (guint32) D.59634;
    D.59632 = ji->code_start;
    D.59635 = mono_domain_get ();
    info = mono_arch_get_seq_point_info (D.59635, D.59632);
    D.59636 = info->bp_addrs[native_offset];
    D.59637 = D.59636 != 0B;
    D.59638 = (long int) D.59637;
    D.59639 = __builtin_expect (D.59638, 0);
    if (D.59639 != 0) goto <D.59640>; else goto <D.59641>;
    <D.59640>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8581, "info->bp_addrs [native_offset] == 0");
    <D.59641>:
    info->bp_addrs[native_offset] = info;
  }
  goto <D.59642>;
  <D.59630>:
  i = 0;
  goto <D.29194>;
  <D.29193>:
  code.10655 = code;
  code = code.10655 + 1;
  *code.10655 = 144;
  i = i + 1;
  <D.29194>:
  breakpoint_size.10656 = breakpoint_size;
  if (i < breakpoint_size.10656) goto <D.29193>; else goto <D.29195>;
  <D.29195>:
  <D.59642>:
}


mono_arch_is_breakpoint_event (void * info, void * sigctx)
{
  void * D.59646;
  void * bp_trigger_page.10657;
  guint8 * D.59649;
  gboolean D.59651;
  struct siginfo_t * sinfo;

  sinfo = info;
  D.59646 = sinfo->_sifields._sigfault.si_addr;
  bp_trigger_page.10657 = bp_trigger_page;
  if (D.59646 >= bp_trigger_page.10657) goto <D.59648>; else goto <D.59645>;
  <D.59648>:
  D.59646 = sinfo->_sifields._sigfault.si_addr;
  bp_trigger_page.10657 = bp_trigger_page;
  D.59649 = bp_trigger_page.10657 + 128;
  if (D.59646 <= D.59649) goto <D.59650>; else goto <D.59645>;
  <D.59650>:
  D.59651 = 1;
  return D.59651;
  <D.59645>:
  D.59651 = 0;
  return D.59651;
}


mono_arch_skip_breakpoint (struct MonoContext * ctx, struct MonoJitInfo * ji)
{
  unsigned char D.59653;
  unsigned char D.59654;
  long int D.59657;
  sizetype D.59658;
  sizetype D.59659;
  long int D.59660;
  int breakpoint_fault_size.10658;
  sizetype D.59663;
  sizetype D.59664;
  long int D.59665;

  D.59653 = BIT_FIELD_REF <*ji, 8, 272>;
  D.59654 = D.59653 & 16;
  if (D.59654 != 0) goto <D.59655>; else goto <D.59656>;
  <D.59655>:
  D.59657 = ctx->rip;
  D.59658 = (sizetype) D.59657;
  D.59659 = D.59658 + 3;
  D.59660 = (long int) D.59659;
  ctx->rip = D.59660;
  goto <D.59661>;
  <D.59656>:
  breakpoint_fault_size.10658 = breakpoint_fault_size;
  D.59663 = (sizetype) breakpoint_fault_size.10658;
  D.59657 = ctx->rip;
  D.59658 = (sizetype) D.59657;
  D.59664 = D.59663 + D.59658;
  D.59665 = (long int) D.59664;
  ctx->rip = D.59665;
  <D.59661>:
}


mono_arch_start_single_stepping ()
{
  int D.59666;
  long unsigned int D.59667;
  void * ss_trigger_page.10659;

  D.59666 = mono_pagesize ();
  D.59667 = (long unsigned int) D.59666;
  ss_trigger_page.10659 = ss_trigger_page;
  mono_mprotect (ss_trigger_page.10659, D.59667, 0);
}


mono_arch_stop_single_stepping ()
{
  int D.59669;
  long unsigned int D.59670;
  void * ss_trigger_page.10660;

  D.59669 = mono_pagesize ();
  D.59670 = (long unsigned int) D.59669;
  ss_trigger_page.10660 = ss_trigger_page;
  mono_mprotect (ss_trigger_page.10660, D.59670, 1);
}


mono_arch_is_single_step_event (void * info, void * sigctx)
{
  void * D.59673;
  void * ss_trigger_page.10661;
  guint8 * D.59676;
  gboolean D.59678;
  struct siginfo_t * sinfo;

  sinfo = info;
  D.59673 = sinfo->_sifields._sigfault.si_addr;
  ss_trigger_page.10661 = ss_trigger_page;
  if (D.59673 >= ss_trigger_page.10661) goto <D.59675>; else goto <D.59672>;
  <D.59675>:
  D.59673 = sinfo->_sifields._sigfault.si_addr;
  ss_trigger_page.10661 = ss_trigger_page;
  D.59676 = ss_trigger_page.10661 + 128;
  if (D.59673 <= D.59676) goto <D.59677>; else goto <D.59672>;
  <D.59677>:
  D.59678 = 1;
  return D.59678;
  <D.59672>:
  D.59678 = 0;
  return D.59678;
}


mono_arch_skip_single_step (struct MonoContext * ctx)
{
  int single_step_fault_size.10662;
  sizetype D.59681;
  long int D.59682;
  sizetype D.59683;
  sizetype D.59684;
  long int D.59685;

  single_step_fault_size.10662 = single_step_fault_size;
  D.59681 = (sizetype) single_step_fault_size.10662;
  D.59682 = ctx->rip;
  D.59683 = (sizetype) D.59682;
  D.59684 = D.59681 + D.59683;
  D.59685 = (long int) D.59684;
  ctx->rip = D.59685;
}


mono_arch_get_seq_point_info (struct MonoDomain * domain, guint8 * code)
{
  union mono_mutex_t * D.59686;
  _Bool D.59689;
  long int D.59690;
  long int D.59691;
  void * D.59694;
  struct GHashTable * D.59695;
  _Bool D.59698;
  long int D.59699;
  long int D.59700;
  _Bool D.59705;
  long int D.59706;
  long int D.59707;
  int D.59710;
  long unsigned int D.59711;
  long unsigned int D.59712;
  long unsigned int D.59713;
  void * ss_trigger_page.10663;
  void * bp_trigger_page.10664;
  _Bool D.59718;
  long int D.59719;
  long int D.59720;
  _Bool D.59725;
  long int D.59726;
  long int D.59727;
  void * D.59730;
  struct SeqPointInfo * info;
  struct MonoJitInfo * ji;
  int i;

  {
    int ret;

    D.59686 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.59686);
    if (ret != 0) goto <D.59687>; else goto <D.59688>;
    <D.59687>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.59688>:
    D.59689 = ret != 0;
    D.59690 = (long int) D.59689;
    D.59691 = __builtin_expect (D.59690, 0);
    if (D.59691 != 0) goto <D.59692>; else goto <D.59693>;
    <D.59692>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8693, "ret == 0");
    <D.59693>:
  }
  D.59694 = domain->runtime_info;
  D.59695 = MEM[(struct MonoJitDomainInfo *)D.59694].arch_seq_points;
  info = monoeg_g_hash_table_lookup (D.59695, code);
  {
    int ret;

    D.59686 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.59686);
    if (ret != 0) goto <D.59696>; else goto <D.59697>;
    <D.59696>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.59697>:
    D.59698 = ret != 0;
    D.59699 = (long int) D.59698;
    D.59700 = __builtin_expect (D.59699, 0);
    if (D.59700 != 0) goto <D.59701>; else goto <D.59702>;
    <D.59701>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8696, "ret == 0");
    <D.59702>:
  }
  if (info == 0B) goto <D.59703>; else goto <D.59704>;
  <D.59703>:
  ji = mono_jit_info_table_find (domain, code);
  D.59705 = ji == 0B;
  D.59706 = (long int) D.59705;
  D.59707 = __builtin_expect (D.59706, 0);
  if (D.59707 != 0) goto <D.59708>; else goto <D.59709>;
  <D.59708>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8700, "ji");
  <D.59709>:
  D.59710 = ji->code_size;
  D.59711 = (long unsigned int) D.59710;
  D.59712 = D.59711 + 2;
  D.59713 = D.59712 * 8;
  info = monoeg_malloc0 (D.59713);
  ss_trigger_page.10663 = ss_trigger_page;
  info->ss_trigger_page = ss_trigger_page.10663;
  bp_trigger_page.10664 = bp_trigger_page;
  info->bp_trigger_page = bp_trigger_page.10664;
  i = 0;
  goto <D.29229>;
  <D.29228>:
  info->bp_addrs[i] = info;
  i = i + 1;
  <D.29229>:
  D.59710 = ji->code_size;
  if (D.59710 > i) goto <D.29228>; else goto <D.29230>;
  <D.29230>:
  {
    int ret;

    D.59686 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.59686);
    if (ret != 0) goto <D.59716>; else goto <D.59717>;
    <D.59716>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.59717>:
    D.59718 = ret != 0;
    D.59719 = (long int) D.59718;
    D.59720 = __builtin_expect (D.59719, 0);
    if (D.59720 != 0) goto <D.59721>; else goto <D.59722>;
    <D.59721>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8711, "ret == 0");
    <D.59722>:
  }
  D.59694 = domain->runtime_info;
  D.59695 = MEM[(struct MonoJitDomainInfo *)D.59694].arch_seq_points;
  monoeg_g_hash_table_insert_replace (D.59695, code, info, 0);
  {
    int ret;

    D.59686 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.59686);
    if (ret != 0) goto <D.59723>; else goto <D.59724>;
    <D.59723>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.59724>:
    D.59725 = ret != 0;
    D.59726 = (long int) D.59725;
    D.59727 = __builtin_expect (D.59726, 0);
    if (D.59727 != 0) goto <D.59728>; else goto <D.59729>;
    <D.59728>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-amd64.c", 8714, "ret == 0");
    <D.59729>:
  }
  <D.59704>:
  D.59730 = info;
  return D.59730;
}


mono_arch_init_lmf_ext (struct MonoLMFExt * ext, void * prev_lmf)
{
  void * D.59732;
  long int D.59733;
  long int D.59734;
  void * D.59735;
  long unsigned int ext.10665;

  ext->lmf.previous_lmf = prev_lmf;
  D.59732 = ext->lmf.previous_lmf;
  D.59733 = (long int) D.59732;
  D.59734 = D.59733 | 2;
  D.59735 = (void *) D.59734;
  ext->lmf.previous_lmf = D.59735;
  ext.10665 = (long unsigned int) ext;
  ext->lmf.rsp = ext.10665;
}