mono_simd_intrinsics_init ()
{
  unsigned int simd_supported_versions.0;

  simd_supported_versions.0 = mono_arch_cpu_enumerate_simd_versions ();
  simd_supported_versions = simd_supported_versions.0;
}


mono_simd_simplify_indirection (struct MonoCompile * cfg)
{
  struct MonoInst * * D.23177;
  long unsigned int D.23178;
  long unsigned int D.23179;
  struct MonoInst * * D.23180;
  struct MonoClass * D.23181;
  unsigned char D.23182;
  unsigned char D.23183;
  unsigned char D.23186;
  unsigned char D.23187;
  int D.23188;
  unsigned int i.1;
  unsigned int D.23190;
  struct MonoInst * D.23193;
  short unsigned int D.23196;
  struct MonoClass * D.23199;
  unsigned char D.23200;
  unsigned char D.23201;
  unsigned char D.23204;
  unsigned char D.23205;
  unsigned int D.23206;
  int D.23209;
  long unsigned int D.23210;
  long unsigned int D.23211;
  long unsigned int D.23212;
  struct MonoClass * D.23213;
  unsigned char D.23214;
  unsigned char D.23215;
  unsigned char D.23218;
  int D.23219;
  int D.23220;
  int D.23223;
  sizetype D.23224;
  char * D.23225;
  int D.23230;
  sizetype D.23231;
  char * D.23232;
  char D.23233;
  int D.23234;
  int D.23235;
  signed char D.23240;
  void * D.23243;
  int D.23244;
  int D.23245;
  int D.23248;
  int D.23251;
  int D.23252;
  int D.23253;
  int D.23254;
  int D.23255;
  signed char D.23256;
  int D.23257;
  int D.23258;
  struct MonoClass * D.23262;
  unsigned char D.23263;
  unsigned char D.23264;
  int D.23267;
  sizetype D.23268;
  char * D.23269;
  char D.23270;
  int D.23271;
  int D.23272;
  int D.23277;
  int D.23284;
  int D.23287;
  int D.23290;
  int D.23291;
  struct MonoClass * D.23294;
  unsigned char D.23295;
  unsigned char D.23296;
  int D.23299;
  sizetype D.23300;
  char * D.23301;
  char D.23302;
  int D.23303;
  int D.23304;
  int D.23309;
  long unsigned int D.23316;
  long unsigned int D.23317;
  struct MonoBasicBlock * * D.23318;
  struct MonoBasicBlock * D.23319;
  int D.23320;
  struct MonoMemPool * D.23328;
  long int D.23329;
  struct MonoInst * D.23330;
  int D.23331;
  int D.23332;
  const unsigned char * D.23333;
  int D.23336;
  int i;
  int max_vreg;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * first_bb;
  struct MonoBasicBlock * * target_bb;
  struct MonoInst * ins;
  char * vreg_flags;

  max_vreg = 0;
  first_bb = 0B;
  i = 0;
  goto <D.22558>;
  <D.22557>:
  {
    struct MonoInst * var;

    D.23177 = cfg->varinfo;
    D.23178 = (long unsigned int) i;
    D.23179 = D.23178 * 8;
    D.23180 = D.23177 + D.23179;
    var = *D.23180;
    D.23181 = var->klass;
    D.23182 = BIT_FIELD_REF <*D.23181, 8, 288>;
    D.23183 = D.23182 & 2;
    if (D.23183 != 0) goto <D.23184>; else goto <D.23185>;
    <D.23184>:
    D.23186 = var->flags;
    D.23187 = D.23186 & 239;
    var->flags = D.23187;
    D.23188 = var->dreg;
    max_vreg = MAX_EXPR <D.23188, max_vreg>;
    <D.23185>:
  }
  i = i + 1;
  <D.22558>:
  i.1 = (unsigned int) i;
  D.23190 = cfg->num_varinfo;
  if (i.1 < D.23190) goto <D.22557>; else goto <D.22559>;
  <D.22559>:
  bb = cfg->bb_entry;
  goto <D.22565>;
  <D.22564>:
  if (first_bb == 0B) goto <D.23191>; else goto <D.23192>;
  <D.23191>:
  D.23193 = bb->code;
  if (D.23193 != 0B) goto <D.23194>; else goto <D.23195>;
  <D.23194>:
  first_bb = bb;
  <D.23195>:
  <D.23192>:
  ins = bb->code;
  goto <D.22562>;
  <D.22561>:
  D.23196 = ins->opcode;
  if (D.23196 == 314) goto <D.23197>; else goto <D.23198>;
  <D.23197>:
  {
    struct MonoInst * var;

    var = ins->data.op[0].p;
    D.23199 = var->klass;
    D.23200 = BIT_FIELD_REF <*D.23199, 8, 288>;
    D.23201 = D.23200 & 2;
    if (D.23201 != 0) goto <D.23202>; else goto <D.23203>;
    <D.23202>:
    D.23204 = var->flags;
    D.23205 = D.23204 | 16;
    var->flags = D.23205;
    <D.23203>:
  }
  <D.23198>:
  ins = ins->next;
  <D.22562>:
  if (ins != 0B) goto <D.22561>; else goto <D.22563>;
  <D.22563>:
  bb = bb->next_bb;
  <D.22565>:
  if (bb != 0B) goto <D.22564>; else goto <D.22566>;
  <D.22566>:
  D.23206 = cfg->verbose_level;
  if (D.23206 > 2) goto <D.23207>; else goto <D.23208>;
  <D.23207>:
  printf ("[simd-simplify] max vreg is %d\n", max_vreg);
  <D.23208>:
  D.23209 = max_vreg + 1;
  D.23210 = (long unsigned int) D.23209;
  vreg_flags = monoeg_malloc0 (D.23210);
  D.23209 = max_vreg + 1;
  D.23211 = (long unsigned int) D.23209;
  D.23212 = D.23211 * 8;
  target_bb = monoeg_malloc0 (D.23212);
  i = 0;
  goto <D.22569>;
  <D.22568>:
  {
    struct MonoInst * var;

    D.23177 = cfg->varinfo;
    D.23178 = (long unsigned int) i;
    D.23179 = D.23178 * 8;
    D.23180 = D.23177 + D.23179;
    var = *D.23180;
    D.23213 = var->klass;
    D.23214 = BIT_FIELD_REF <*D.23213, 8, 288>;
    D.23215 = D.23214 & 2;
    if (D.23215 != 0) goto <D.23216>; else goto <D.23217>;
    <D.23216>:
    D.23218 = var->flags;
    D.23219 = (int) D.23218;
    D.23220 = D.23219 & 20;
    if (D.23220 == 0) goto <D.23221>; else goto <D.23222>;
    <D.23221>:
    D.23223 = var->dreg;
    D.23224 = (sizetype) D.23223;
    D.23225 = vreg_flags + D.23224;
    *D.23225 = 1;
    D.23206 = cfg->verbose_level;
    if (D.23206 > 2) goto <D.23226>; else goto <D.23227>;
    <D.23226>:
    D.23223 = var->dreg;
    printf ("[simd-simplify] processing var %d with vreg %d\n", i, D.23223);
    <D.23227>:
    <D.23222>:
    <D.23217>:
  }
  i = i + 1;
  <D.22569>:
  i.1 = (unsigned int) i;
  D.23190 = cfg->num_varinfo;
  if (i.1 < D.23190) goto <D.22568>; else goto <D.22570>;
  <D.22570>:
  ins = first_bb->code;
  goto <D.22578>;
  <D.22577>:
  {
    int num_sregs;
    int sregs[3];

    try
      {
        D.23196 = ins->opcode;
        if (D.23196 == 963) goto <D.23228>; else goto <D.23229>;
        <D.23228>:
        D.23230 = ins->dreg;
        D.23231 = (sizetype) D.23230;
        D.23232 = vreg_flags + D.23231;
        D.23233 = *D.23232;
        D.23234 = (int) D.23233;
        D.23235 = D.23234 & 4;
        if (D.23235 == 0) goto <D.23236>; else goto <D.23237>;
        <D.23236>:
        D.23206 = cfg->verbose_level;
        if (D.23206 > 2) goto <D.23238>; else goto <D.23239>;
        <D.23238>:
        D.23230 = ins->dreg;
        printf ("[simd-simplify] R%d has vzero: ", D.23230);
        mono_print_ins (ins);
        <D.23239>:
        D.23230 = ins->dreg;
        D.23231 = (sizetype) D.23230;
        D.23232 = vreg_flags + D.23231;
        D.23230 = ins->dreg;
        D.23231 = (sizetype) D.23230;
        D.23232 = vreg_flags + D.23231;
        D.23233 = *D.23232;
        D.23240 = D.23233 | 2;
        *D.23232 = D.23240;
        <D.23237>:
        // predicted unlikely by continue predictor.
        goto <D.22573>;
        <D.23229>:
        D.23196 = ins->opcode;
        if (D.23196 == 314) goto <D.23241>; else goto <D.23242>;
        <D.23241>:
        D.23243 = ins->data.op[0].p;
        D.23244 = MEM[(struct MonoInst *)D.23243].dreg;
        D.23245 = apply_vreg_first_block_interference (cfg, ins, D.23244, max_vreg, vreg_flags);
        if (D.23245 != 0) goto <D.23246>; else goto <D.23247>;
        <D.23246>:
        // predicted unlikely by continue predictor.
        goto <D.22573>;
        <D.23247>:
        <D.23242>:
        D.23230 = ins->dreg;
        D.23248 = apply_vreg_first_block_interference (cfg, ins, D.23230, max_vreg, vreg_flags);
        if (D.23248 != 0) goto <D.23249>; else goto <D.23250>;
        <D.23249>:
        // predicted unlikely by continue predictor.
        goto <D.22573>;
        <D.23250>:
        D.23251 = ins->sreg1;
        sregs[0] = D.23251;
        D.23252 = ins->sreg2;
        sregs[1] = D.23252;
        D.23253 = ins->sreg3;
        sregs[2] = D.23253;
        D.23196 = ins->opcode;
        D.23254 = (int) D.23196;
        D.23255 = D.23254 + -313;
        D.23256 = ins_sreg_counts[D.23255];
        num_sregs = (int) D.23256;
        i = 0;
        goto <D.22576>;
        <D.22575>:
        D.23257 = sregs[i];
        D.23258 = apply_vreg_first_block_interference (cfg, ins, D.23257, max_vreg, vreg_flags);
        if (D.23258 != 0) goto <D.22574>; else goto <D.23259>;
        <D.23259>:
        i = i + 1;
        <D.22576>:
        if (i < num_sregs) goto <D.22575>; else goto <D.22574>;
        <D.22574>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22573>:
  ins = ins->next;
  <D.22578>:
  if (ins != 0B) goto <D.22577>; else goto <D.22579>;
  <D.22579>:
  D.23206 = cfg->verbose_level;
  if (D.23206 > 2) goto <D.23260>; else goto <D.23261>;
  <D.23260>:
  i = 0;
  goto <D.22582>;
  <D.22581>:
  {
    struct MonoInst * var;

    D.23177 = cfg->varinfo;
    D.23178 = (long unsigned int) i;
    D.23179 = D.23178 * 8;
    D.23180 = D.23177 + D.23179;
    var = *D.23180;
    D.23262 = var->klass;
    D.23263 = BIT_FIELD_REF <*D.23262, 8, 288>;
    D.23264 = D.23263 & 2;
    if (D.23264 != 0) goto <D.23265>; else goto <D.23266>;
    <D.23265>:
    D.23267 = var->dreg;
    D.23268 = (sizetype) D.23267;
    D.23269 = vreg_flags + D.23268;
    D.23270 = *D.23269;
    D.23271 = (int) D.23270;
    D.23272 = D.23271 & 2;
    if (D.23272 != 0) goto <D.23273>; else goto <D.23274>;
    <D.23273>:
    D.23206 = cfg->verbose_level;
    if (D.23206 > 2) goto <D.23275>; else goto <D.23276>;
    <D.23275>:
    D.23267 = var->dreg;
    printf ("[simd-simplify] R%d has xzero only\n", D.23267);
    <D.23276>:
    <D.23274>:
    D.23267 = var->dreg;
    D.23268 = (sizetype) D.23267;
    D.23269 = vreg_flags + D.23268;
    D.23270 = *D.23269;
    D.23271 = (int) D.23270;
    D.23277 = D.23271 & 4;
    if (D.23277 != 0) goto <D.23278>; else goto <D.23279>;
    <D.23278>:
    D.23206 = cfg->verbose_level;
    if (D.23206 > 2) goto <D.23280>; else goto <D.23281>;
    <D.23280>:
    D.23267 = var->dreg;
    printf ("[simd-simplify] R%d has other ops on bb0\n", D.23267);
    <D.23281>:
    <D.23279>:
    <D.23266>:
  }
  i = i + 1;
  <D.22582>:
  i.1 = (unsigned int) i;
  D.23190 = cfg->num_varinfo;
  if (i.1 < D.23190) goto <D.22581>; else goto <D.22583>;
  <D.22583>:
  <D.23261>:
  bb = first_bb->next_bb;
  goto <D.22595>;
  <D.22594>:
  ins = bb->code;
  goto <D.22592>;
  <D.22591>:
  {
    int num_sregs;
    int sregs[3];

    try
      {
        D.23196 = ins->opcode;
        if (D.23196 == 314) goto <D.23282>; else goto <D.23283>;
        <D.23282>:
        D.23243 = ins->data.op[0].p;
        D.23244 = MEM[(struct MonoInst *)D.23243].dreg;
        D.23284 = apply_vreg_following_block_interference (cfg, ins, D.23244, bb, max_vreg, vreg_flags, target_bb);
        if (D.23284 != 0) goto <D.23285>; else goto <D.23286>;
        <D.23285>:
        // predicted unlikely by continue predictor.
        goto <D.22586>;
        <D.23286>:
        <D.23283>:
        D.23230 = ins->dreg;
        D.23287 = apply_vreg_following_block_interference (cfg, ins, D.23230, bb, max_vreg, vreg_flags, target_bb);
        if (D.23287 != 0) goto <D.23288>; else goto <D.23289>;
        <D.23288>:
        // predicted unlikely by continue predictor.
        goto <D.22586>;
        <D.23289>:
        D.23251 = ins->sreg1;
        sregs[0] = D.23251;
        D.23252 = ins->sreg2;
        sregs[1] = D.23252;
        D.23253 = ins->sreg3;
        sregs[2] = D.23253;
        D.23196 = ins->opcode;
        D.23254 = (int) D.23196;
        D.23255 = D.23254 + -313;
        D.23256 = ins_sreg_counts[D.23255];
        num_sregs = (int) D.23256;
        i = 0;
        goto <D.22589>;
        <D.22588>:
        D.23290 = sregs[i];
        D.23291 = apply_vreg_following_block_interference (cfg, ins, D.23290, bb, max_vreg, vreg_flags, target_bb);
        if (D.23291 != 0) goto <D.23292>; else goto <D.23293>;
        <D.23292>:
        // predicted unlikely by continue predictor.
        goto <D.22587>;
        <D.23293>:
        <D.22587>:
        i = i + 1;
        <D.22589>:
        if (i < num_sregs) goto <D.22588>; else goto <D.22590>;
        <D.22590>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22586>:
  ins = ins->next;
  <D.22592>:
  if (ins != 0B) goto <D.22591>; else goto <D.22593>;
  <D.22593>:
  bb = bb->next_bb;
  <D.22595>:
  if (bb != 0B) goto <D.22594>; else goto <D.22596>;
  <D.22596>:
  i = 0;
  goto <D.22611>;
  <D.22610>:
  {
    struct MonoInst * var;

    D.23177 = cfg->varinfo;
    D.23178 = (long unsigned int) i;
    D.23179 = D.23178 * 8;
    D.23180 = D.23177 + D.23179;
    var = *D.23180;
    D.23294 = var->klass;
    D.23295 = BIT_FIELD_REF <*D.23294, 8, 288>;
    D.23296 = D.23295 & 2;
    if (D.23296 == 0) goto <D.23297>; else goto <D.23298>;
    <D.23297>:
    // predicted unlikely by continue predictor.
    goto <D.22598>;
    <D.23298>:
    D.23299 = var->dreg;
    D.23300 = (sizetype) D.23299;
    D.23301 = vreg_flags + D.23300;
    D.23302 = *D.23301;
    D.23303 = (int) D.23302;
    D.23304 = D.23303 & 8;
    if (D.23304 != 0) goto <D.23305>; else goto <D.23306>;
    <D.23305>:
    D.23206 = cfg->verbose_level;
    if (D.23206 > 2) goto <D.23307>; else goto <D.23308>;
    <D.23307>:
    D.23299 = var->dreg;
    printf ("[simd-simplify] R%d has single bb use\n", D.23299);
    <D.23308>:
    <D.23306>:
    D.23299 = var->dreg;
    D.23300 = (sizetype) D.23299;
    D.23301 = vreg_flags + D.23300;
    D.23302 = *D.23301;
    D.23303 = (int) D.23302;
    D.23309 = D.23303 & 16;
    if (D.23309 != 0) goto <D.23310>; else goto <D.23311>;
    <D.23310>:
    D.23206 = cfg->verbose_level;
    if (D.23206 > 2) goto <D.23312>; else goto <D.23313>;
    <D.23312>:
    D.23299 = var->dreg;
    printf ("[simd-simplify] R%d has many bb in use\n", D.23299);
    <D.23313>:
    <D.23311>:
    D.23299 = var->dreg;
    D.23300 = (sizetype) D.23299;
    D.23301 = vreg_flags + D.23300;
    D.23302 = *D.23301;
    D.23303 = (int) D.23302;
    D.23304 = D.23303 & 8;
    if (D.23304 == 0) goto <D.23314>; else goto <D.23315>;
    <D.23314>:
    // predicted unlikely by continue predictor.
    goto <D.22598>;
    <D.23315>:
    D.23299 = var->dreg;
    D.23316 = (long unsigned int) D.23299;
    D.23317 = D.23316 * 8;
    D.23318 = target_bb + D.23317;
    D.23319 = *D.23318;
    ins = D.23319->code;
    goto <D.22609>;
    <D.22608>:
    {
      int num_sregs;
      int j;
      int sregs[3];
      gboolean found;

      try
        {
          found = 0;
          D.23251 = ins->sreg1;
          sregs[0] = D.23251;
          D.23252 = ins->sreg2;
          sregs[1] = D.23252;
          D.23253 = ins->sreg3;
          sregs[2] = D.23253;
          D.23196 = ins->opcode;
          D.23254 = (int) D.23196;
          D.23255 = D.23254 + -313;
          D.23256 = ins_sreg_counts[D.23255];
          num_sregs = (int) D.23256;
          j = 0;
          goto <D.22604>;
          <D.22603>:
          D.23320 = sregs[i];
          D.23299 = var->dreg;
          if (D.23320 == D.23299) goto <D.23321>; else goto <D.23322>;
          <D.23321>:
          found = 1;
          <D.23322>:
          j = j + 1;
          <D.22604>:
          if (j < num_sregs) goto <D.22603>; else goto <D.22605>;
          <D.22605>:
          D.23230 = ins->dreg;
          D.23299 = var->dreg;
          if (D.23230 == D.23299) goto <D.23325>; else goto <D.23323>;
          <D.23325>:
          if (found == 0) goto <D.22606>; else goto <D.23323>;
          goto <D.23324>;
          <D.23323>:
          if (found != 0) goto <D.23326>; else goto <D.23327>;
          <D.23326>:
          {
            struct MonoInst * tmp;

            D.23328 = cfg->mempool;
            tmp = mono_mempool_alloc (D.23328, 80);
            tmp->data.op[1].const_val = 0;
            D.23329 = tmp->data.op[1].const_val;
            tmp->data.op[0].const_val = D.23329;
            tmp->prev = 0B;
            D.23330 = tmp->prev;
            tmp->next = D.23330;
            tmp->opcode = 963;
            tmp->flags = 0;
            tmp->type = 0;
            tmp->dreg = -1;
            tmp->sreg3 = -1;
            D.23331 = tmp->sreg3;
            tmp->sreg2 = D.23331;
            D.23332 = tmp->sreg2;
            tmp->sreg1 = D.23332;
            D.23333 = cfg->ip;
            tmp->cil_code = D.23333;
            D.23299 = var->dreg;
            tmp->dreg = D.23299;
            tmp->type = 7;
            D.23294 = var->klass;
            tmp->klass = D.23294;
            D.23299 = var->dreg;
            D.23316 = (long unsigned int) D.23299;
            D.23317 = D.23316 * 8;
            D.23318 = target_bb + D.23317;
            D.23319 = *D.23318;
            mono_bblock_insert_before_ins (D.23319, ins, tmp);
            goto <D.22606>;
          }
          <D.23327>:
          <D.23324>:
        }
      finally
        {
          sregs = {CLOBBER};
        }
    }
    ins = ins->next;
    <D.22609>:
    if (ins != 0B) goto <D.22608>; else goto <D.22606>;
    <D.22606>:
  }
  <D.22598>:
  i = i + 1;
  <D.22611>:
  i.1 = (unsigned int) i;
  D.23190 = cfg->num_varinfo;
  if (i.1 < D.23190) goto <D.22610>; else goto <D.22612>;
  <D.22612>:
  ins = first_bb->code;
  goto <D.22614>;
  <D.22613>:
  D.23196 = ins->opcode;
  if (D.23196 == 963) goto <D.23334>; else goto <D.23335>;
  <D.23334>:
  D.23230 = ins->dreg;
  D.23231 = (sizetype) D.23230;
  D.23232 = vreg_flags + D.23231;
  D.23233 = *D.23232;
  D.23234 = (int) D.23233;
  D.23336 = D.23234 & 8;
  if (D.23336 != 0) goto <D.23337>; else goto <D.23338>;
  <D.23337>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.23253 = ins->sreg3;
  ins->sreg2 = D.23253;
  D.23252 = ins->sreg2;
  ins->sreg1 = D.23252;
  <D.23338>:
  <D.23335>:
  ins = ins->next;
  <D.22614>:
  if (ins != 0B) goto <D.22613>; else goto <D.22615>;
  <D.22615>:
  monoeg_g_free (vreg_flags);
  monoeg_g_free (target_bb);
}


apply_vreg_first_block_interference (struct MonoCompile * cfg, struct MonoInst * ins, int reg, int max_vreg, char * vreg_flags)
{
  _Bool D.23345;
  _Bool D.23346;
  _Bool D.23347;
  sizetype D.23350;
  char * D.23351;
  char D.23352;
  char D.23355;
  signed char D.23356;
  unsigned int D.23357;
  gboolean D.23360;

  D.23345 = reg != -1;
  D.23346 = reg <= max_vreg;
  D.23347 = D.23345 & D.23346;
  if (D.23347 != 0) goto <D.23348>; else goto <D.23349>;
  <D.23348>:
  D.23350 = (sizetype) reg;
  D.23351 = vreg_flags + D.23350;
  D.23352 = *D.23351;
  if (D.23352 != 0) goto <D.23353>; else goto <D.23354>;
  <D.23353>:
  D.23350 = (sizetype) reg;
  D.23351 = vreg_flags + D.23350;
  D.23350 = (sizetype) reg;
  D.23351 = vreg_flags + D.23350;
  D.23352 = *D.23351;
  D.23355 = D.23352 & -3;
  *D.23351 = D.23355;
  D.23350 = (sizetype) reg;
  D.23351 = vreg_flags + D.23350;
  D.23350 = (sizetype) reg;
  D.23351 = vreg_flags + D.23350;
  D.23352 = *D.23351;
  D.23356 = D.23352 | 4;
  *D.23351 = D.23356;
  D.23357 = cfg->verbose_level;
  if (D.23357 > 2) goto <D.23358>; else goto <D.23359>;
  <D.23358>:
  printf ("[simd-simplify] R%d used: ", reg);
  mono_print_ins (ins);
  <D.23359>:
  D.23360 = 1;
  return D.23360;
  <D.23354>:
  <D.23349>:
  D.23360 = 0;
  return D.23360;
}


apply_vreg_following_block_interference (struct MonoCompile * cfg, struct MonoInst * ins, int reg, struct MonoBasicBlock * bb, int max_vreg, char * vreg_flags, struct MonoBasicBlock * * target_bb)
{
  _Bool D.23364;
  _Bool D.23365;
  _Bool D.23366;
  sizetype D.23368;
  char * D.23369;
  char D.23370;
  int D.23371;
  int D.23372;
  long unsigned int D.23374;
  long unsigned int D.23375;
  struct MonoBasicBlock * * D.23376;
  struct MonoBasicBlock * D.23377;
  gboolean D.23378;
  int D.23379;
  char D.23382;
  signed char D.23383;
  unsigned int D.23384;
  int D.23387;
  signed char D.23390;

  D.23364 = reg == -1;
  D.23365 = reg > max_vreg;
  D.23366 = D.23364 | D.23365;
  if (D.23366 != 0) goto <D.23362>; else goto <D.23367>;
  <D.23367>:
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23370 = *D.23369;
  D.23371 = (int) D.23370;
  D.23372 = D.23371 & 2;
  if (D.23372 == 0) goto <D.23362>; else goto <D.23373>;
  <D.23373>:
  D.23374 = (long unsigned int) reg;
  D.23375 = D.23374 * 8;
  D.23376 = target_bb + D.23375;
  D.23377 = *D.23376;
  if (D.23377 == bb) goto <D.23362>; else goto <D.23363>;
  <D.23362>:
  D.23378 = 0;
  return D.23378;
  <D.23363>:
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23370 = *D.23369;
  D.23371 = (int) D.23370;
  D.23379 = D.23371 & 8;
  if (D.23379 != 0) goto <D.23380>; else goto <D.23381>;
  <D.23380>:
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23370 = *D.23369;
  D.23382 = D.23370 & -9;
  *D.23369 = D.23382;
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23370 = *D.23369;
  D.23383 = D.23370 | 16;
  *D.23369 = D.23383;
  D.23384 = cfg->verbose_level;
  if (D.23384 > 2) goto <D.23385>; else goto <D.23386>;
  <D.23385>:
  printf ("[simd-simplify] R%d used by many bb: ", reg);
  mono_print_ins (ins);
  <D.23386>:
  D.23378 = 1;
  return D.23378;
  <D.23381>:
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23370 = *D.23369;
  D.23371 = (int) D.23370;
  D.23387 = D.23371 & 16;
  if (D.23387 == 0) goto <D.23388>; else goto <D.23389>;
  <D.23388>:
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23368 = (sizetype) reg;
  D.23369 = vreg_flags + D.23368;
  D.23370 = *D.23369;
  D.23390 = D.23370 | 8;
  *D.23369 = D.23390;
  D.23374 = (long unsigned int) reg;
  D.23375 = D.23374 * 8;
  D.23376 = target_bb + D.23375;
  *D.23376 = bb;
  D.23384 = cfg->verbose_level;
  if (D.23384 > 2) goto <D.23391>; else goto <D.23392>;
  <D.23391>:
  printf ("[simd-simplify] R%d first used by: ", reg);
  mono_print_ins (ins);
  <D.23392>:
  D.23378 = 1;
  return D.23378;
  <D.23389>:
  D.23378 = 0;
  return D.23378;
}


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

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


mono_emit_simd_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  int D.23057;
  int iftmp.2;
  int D.23053;
  struct MonoClass * D.23399;
  const char[10] * D.23400;
  unsigned char D.23401;
  int D.23402;
  unsigned char D.23403;
  int D.23404;
  _Bool D.23405;
  _Bool D.23406;
  _Bool D.23407;
  const unsigned char * D.23410;
  unsigned char D.23411;
  int D.23412;
  const unsigned char * D.23413;
  unsigned char D.23414;
  int D.23415;
  _Bool D.23416;
  _Bool D.23417;
  const unsigned char * D.23420;
  unsigned char D.23421;
  int D.23422;
  const unsigned char * D.23423;
  unsigned char D.23424;
  int D.23425;
  _Bool D.23426;
  _Bool D.23427;
  const unsigned char * D.23430;
  unsigned char D.23431;
  int D.23432;
  const unsigned char * D.23433;
  unsigned char D.23434;
  int D.23435;
  const char * D.23437;
  struct MonoInst * D.23440;
  int D.23066;
  int iftmp.3;
  int D.23062;
  const char[12] * D.23444;
  unsigned char D.23445;
  int D.23446;
  unsigned char D.23447;
  int D.23448;
  _Bool D.23449;
  _Bool D.23450;
  _Bool D.23451;
  const unsigned char * D.23454;
  unsigned char D.23455;
  int D.23456;
  const unsigned char * D.23457;
  unsigned char D.23458;
  int D.23459;
  _Bool D.23460;
  _Bool D.23461;
  const unsigned char * D.23464;
  unsigned char D.23465;
  int D.23466;
  const unsigned char * D.23467;
  unsigned char D.23468;
  int D.23469;
  _Bool D.23470;
  _Bool D.23471;
  const unsigned char * D.23474;
  unsigned char D.23475;
  int D.23476;
  const unsigned char * D.23477;
  unsigned char D.23478;
  int D.23479;
  int D.23075;
  int iftmp.4;
  int D.23071;
  const char[16] * D.23486;
  unsigned char D.23487;
  int D.23488;
  unsigned char D.23489;
  int D.23490;
  _Bool D.23491;
  _Bool D.23492;
  _Bool D.23493;
  const unsigned char * D.23496;
  unsigned char D.23497;
  int D.23498;
  const unsigned char * D.23499;
  unsigned char D.23500;
  int D.23501;
  _Bool D.23502;
  _Bool D.23503;
  const unsigned char * D.23506;
  unsigned char D.23507;
  int D.23508;
  const unsigned char * D.23509;
  unsigned char D.23510;
  int D.23511;
  _Bool D.23512;
  _Bool D.23513;
  const unsigned char * D.23516;
  unsigned char D.23517;
  int D.23518;
  const unsigned char * D.23519;
  unsigned char D.23520;
  int D.23521;
  int D.23084;
  int iftmp.5;
  int D.23080;
  const char[17] * D.23528;
  unsigned char D.23529;
  int D.23530;
  unsigned char D.23531;
  int D.23532;
  _Bool D.23533;
  _Bool D.23534;
  _Bool D.23535;
  const unsigned char * D.23538;
  unsigned char D.23539;
  int D.23540;
  const unsigned char * D.23541;
  unsigned char D.23542;
  int D.23543;
  _Bool D.23544;
  _Bool D.23545;
  const unsigned char * D.23548;
  unsigned char D.23549;
  int D.23550;
  const unsigned char * D.23551;
  unsigned char D.23552;
  int D.23553;
  _Bool D.23554;
  _Bool D.23555;
  const unsigned char * D.23558;
  unsigned char D.23559;
  int D.23560;
  const unsigned char * D.23561;
  unsigned char D.23562;
  int D.23563;
  short unsigned int D.23567;
  int D.23568;
  int D.23569;
  struct MonoMethodSignature * D.23572;
  struct MonoType * D.23573;
  struct MonoClass * D.23574;
  unsigned char D.23576;
  unsigned char D.23577;
  int D.23093;
  int iftmp.6;
  int D.23089;
  const char[9] * D.23583;
  unsigned char D.23584;
  int D.23585;
  unsigned char D.23586;
  int D.23587;
  _Bool D.23588;
  _Bool D.23589;
  _Bool D.23590;
  const unsigned char * D.23593;
  unsigned char D.23594;
  int D.23595;
  const unsigned char * D.23596;
  unsigned char D.23597;
  int D.23598;
  _Bool D.23599;
  _Bool D.23600;
  const unsigned char * D.23603;
  unsigned char D.23604;
  int D.23605;
  const unsigned char * D.23606;
  unsigned char D.23607;
  int D.23608;
  _Bool D.23609;
  _Bool D.23610;
  const unsigned char * D.23613;
  unsigned char D.23614;
  int D.23615;
  const unsigned char * D.23616;
  unsigned char D.23617;
  int D.23618;
  int D.23102;
  int iftmp.7;
  int D.23098;
  const char[9] * D.23625;
  unsigned char D.23626;
  int D.23627;
  unsigned char D.23628;
  int D.23629;
  _Bool D.23630;
  _Bool D.23631;
  _Bool D.23632;
  const unsigned char * D.23635;
  unsigned char D.23636;
  int D.23637;
  const unsigned char * D.23638;
  unsigned char D.23639;
  int D.23640;
  _Bool D.23641;
  _Bool D.23642;
  const unsigned char * D.23645;
  unsigned char D.23646;
  int D.23647;
  const unsigned char * D.23648;
  unsigned char D.23649;
  int D.23650;
  _Bool D.23651;
  _Bool D.23652;
  const unsigned char * D.23655;
  unsigned char D.23656;
  int D.23657;
  const unsigned char * D.23658;
  unsigned char D.23659;
  int D.23660;
  int D.23111;
  int iftmp.8;
  int D.23107;
  const char[10] * D.23667;
  unsigned char D.23668;
  int D.23669;
  unsigned char D.23670;
  int D.23671;
  _Bool D.23672;
  _Bool D.23673;
  _Bool D.23674;
  const unsigned char * D.23677;
  unsigned char D.23678;
  int D.23679;
  const unsigned char * D.23680;
  unsigned char D.23681;
  int D.23682;
  _Bool D.23683;
  _Bool D.23684;
  const unsigned char * D.23687;
  unsigned char D.23688;
  int D.23689;
  const unsigned char * D.23690;
  unsigned char D.23691;
  int D.23692;
  _Bool D.23693;
  _Bool D.23694;
  const unsigned char * D.23697;
  unsigned char D.23698;
  int D.23699;
  const unsigned char * D.23700;
  unsigned char D.23701;
  int D.23702;
  int D.23120;
  int iftmp.9;
  int D.23116;
  const char[9] * D.23709;
  unsigned char D.23710;
  int D.23711;
  unsigned char D.23712;
  int D.23713;
  _Bool D.23714;
  _Bool D.23715;
  _Bool D.23716;
  const unsigned char * D.23719;
  unsigned char D.23720;
  int D.23721;
  const unsigned char * D.23722;
  unsigned char D.23723;
  int D.23724;
  _Bool D.23725;
  _Bool D.23726;
  const unsigned char * D.23729;
  unsigned char D.23730;
  int D.23731;
  const unsigned char * D.23732;
  unsigned char D.23733;
  int D.23734;
  _Bool D.23735;
  _Bool D.23736;
  const unsigned char * D.23739;
  unsigned char D.23740;
  int D.23741;
  const unsigned char * D.23742;
  unsigned char D.23743;
  int D.23744;
  int D.23129;
  int iftmp.10;
  int D.23125;
  const char[10] * D.23751;
  unsigned char D.23752;
  int D.23753;
  unsigned char D.23754;
  int D.23755;
  _Bool D.23756;
  _Bool D.23757;
  _Bool D.23758;
  const unsigned char * D.23761;
  unsigned char D.23762;
  int D.23763;
  const unsigned char * D.23764;
  unsigned char D.23765;
  int D.23766;
  _Bool D.23767;
  _Bool D.23768;
  const unsigned char * D.23771;
  unsigned char D.23772;
  int D.23773;
  const unsigned char * D.23774;
  unsigned char D.23775;
  int D.23776;
  _Bool D.23777;
  _Bool D.23778;
  const unsigned char * D.23781;
  unsigned char D.23782;
  int D.23783;
  const unsigned char * D.23784;
  unsigned char D.23785;
  int D.23786;
  int D.23138;
  int iftmp.11;
  int D.23134;
  const char[9] * D.23793;
  unsigned char D.23794;
  int D.23795;
  unsigned char D.23796;
  int D.23797;
  _Bool D.23798;
  _Bool D.23799;
  _Bool D.23800;
  const unsigned char * D.23803;
  unsigned char D.23804;
  int D.23805;
  const unsigned char * D.23806;
  unsigned char D.23807;
  int D.23808;
  _Bool D.23809;
  _Bool D.23810;
  const unsigned char * D.23813;
  unsigned char D.23814;
  int D.23815;
  const unsigned char * D.23816;
  unsigned char D.23817;
  int D.23818;
  _Bool D.23819;
  _Bool D.23820;
  const unsigned char * D.23823;
  unsigned char D.23824;
  int D.23825;
  const unsigned char * D.23826;
  unsigned char D.23827;
  int D.23828;
  int D.23147;
  int iftmp.12;
  int D.23143;
  const char[10] * D.23835;
  unsigned char D.23836;
  int D.23837;
  unsigned char D.23838;
  int D.23839;
  _Bool D.23840;
  _Bool D.23841;
  _Bool D.23842;
  const unsigned char * D.23845;
  unsigned char D.23846;
  int D.23847;
  const unsigned char * D.23848;
  unsigned char D.23849;
  int D.23850;
  _Bool D.23851;
  _Bool D.23852;
  const unsigned char * D.23855;
  unsigned char D.23856;
  int D.23857;
  const unsigned char * D.23858;
  unsigned char D.23859;
  int D.23860;
  _Bool D.23861;
  _Bool D.23862;
  const unsigned char * D.23865;
  unsigned char D.23866;
  int D.23867;
  const unsigned char * D.23868;
  unsigned char D.23869;
  int D.23870;
  int D.23156;
  int iftmp.13;
  int D.23152;
  const char[9] * D.23877;
  unsigned char D.23878;
  int D.23879;
  unsigned char D.23880;
  int D.23881;
  _Bool D.23882;
  _Bool D.23883;
  _Bool D.23884;
  const unsigned char * D.23887;
  unsigned char D.23888;
  int D.23889;
  const unsigned char * D.23890;
  unsigned char D.23891;
  int D.23892;
  _Bool D.23893;
  _Bool D.23894;
  const unsigned char * D.23897;
  unsigned char D.23898;
  int D.23899;
  const unsigned char * D.23900;
  unsigned char D.23901;
  int D.23902;
  _Bool D.23903;
  _Bool D.23904;
  const unsigned char * D.23907;
  unsigned char D.23908;
  int D.23909;
  const unsigned char * D.23910;
  unsigned char D.23911;
  int D.23912;
  int D.23165;
  int iftmp.14;
  int D.23161;
  const char[10] * D.23919;
  unsigned char D.23920;
  int D.23921;
  unsigned char D.23922;
  int D.23923;
  _Bool D.23924;
  _Bool D.23925;
  _Bool D.23926;
  const unsigned char * D.23929;
  unsigned char D.23930;
  int D.23931;
  const unsigned char * D.23932;
  unsigned char D.23933;
  int D.23934;
  _Bool D.23935;
  _Bool D.23936;
  const unsigned char * D.23939;
  unsigned char D.23940;
  int D.23941;
  const unsigned char * D.23942;
  unsigned char D.23943;
  int D.23944;
  _Bool D.23945;
  _Bool D.23946;
  const unsigned char * D.23949;
  unsigned char D.23950;
  int D.23951;
  const unsigned char * D.23952;
  unsigned char D.23953;
  int D.23954;
  int D.23174;
  int iftmp.15;
  int D.23170;
  const char[11] * D.23961;
  unsigned char D.23962;
  int D.23963;
  unsigned char D.23964;
  int D.23965;
  _Bool D.23966;
  _Bool D.23967;
  _Bool D.23968;
  const unsigned char * D.23971;
  unsigned char D.23972;
  int D.23973;
  const unsigned char * D.23974;
  unsigned char D.23975;
  int D.23976;
  _Bool D.23977;
  _Bool D.23978;
  const unsigned char * D.23981;
  unsigned char D.23982;
  int D.23983;
  const unsigned char * D.23984;
  unsigned char D.23985;
  int D.23986;
  _Bool D.23987;
  _Bool D.23988;
  const unsigned char * D.23991;
  unsigned char D.23992;
  int D.23993;
  const unsigned char * D.23994;
  unsigned char D.23995;
  int D.23996;
  const char * class_name;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.23397>; else goto <D.23398>;
    <D.23397>:
    {
      const unsigned char * __s2;
      int __result;

      D.23399 = cmethod->klass;
      __s2 = D.23399->name_space;
      D.23400 = "Mono.Simd";
      D.23401 = MEM[(const unsigned char *)D.23400];
      D.23402 = (int) D.23401;
      D.23403 = *__s2;
      D.23404 = (int) D.23403;
      __result = D.23402 - D.23404;
      {
        D.23405 = __s1_len != 0;
        D.23406 = __result == 0;
        D.23407 = D.23405 & D.23406;
        if (D.23407 != 0) goto <D.23408>; else goto <D.23409>;
        <D.23408>:
        D.23410 = &MEM[(void *)"Mono.Simd" + 1B];
        D.23411 = *D.23410;
        D.23412 = (int) D.23411;
        D.23413 = __s2 + 1;
        D.23414 = *D.23413;
        D.23415 = (int) D.23414;
        __result = D.23412 - D.23415;
        D.23416 = __s1_len > 1;
        D.23406 = __result == 0;
        D.23417 = D.23416 & D.23406;
        if (D.23417 != 0) goto <D.23418>; else goto <D.23419>;
        <D.23418>:
        D.23420 = &MEM[(void *)"Mono.Simd" + 2B];
        D.23421 = *D.23420;
        D.23422 = (int) D.23421;
        D.23423 = __s2 + 2;
        D.23424 = *D.23423;
        D.23425 = (int) D.23424;
        __result = D.23422 - D.23425;
        D.23426 = __s1_len > 2;
        D.23406 = __result == 0;
        D.23427 = D.23426 & D.23406;
        if (D.23427 != 0) goto <D.23428>; else goto <D.23429>;
        <D.23428>:
        D.23430 = &MEM[(void *)"Mono.Simd" + 3B];
        D.23431 = *D.23430;
        D.23432 = (int) D.23431;
        D.23433 = __s2 + 3;
        D.23434 = *D.23433;
        D.23435 = (int) D.23434;
        __result = D.23432 - D.23435;
        <D.23429>:
        <D.23419>:
        <D.23409>:
      }
      D.23053 = __result;
    }
    iftmp.2 = D.23053;
    goto <D.23436>;
    <D.23398>:
    D.23399 = cmethod->klass;
    D.23437 = D.23399->name_space;
    iftmp.2 = __builtin_strcmp ("Mono.Simd", D.23437);
    <D.23436>:
    D.23057 = iftmp.2;
  }
  if (D.23057 != 0) goto <D.23438>; else goto <D.23439>;
  <D.23438>:
  D.23440 = 0B;
  return D.23440;
  <D.23439>:
  D.23399 = cmethod->klass;
  class_name = D.23399->name;
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 11;
    if (__s1_len <= 3) goto <D.23442>; else goto <D.23443>;
    <D.23442>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23444 = "SimdRuntime";
      D.23445 = MEM[(const unsigned char *)D.23444];
      D.23446 = (int) D.23445;
      D.23447 = *__s2;
      D.23448 = (int) D.23447;
      __result = D.23446 - D.23448;
      {
        D.23449 = __s1_len != 0;
        D.23450 = __result == 0;
        D.23451 = D.23449 & D.23450;
        if (D.23451 != 0) goto <D.23452>; else goto <D.23453>;
        <D.23452>:
        D.23454 = &MEM[(void *)"SimdRuntime" + 1B];
        D.23455 = *D.23454;
        D.23456 = (int) D.23455;
        D.23457 = __s2 + 1;
        D.23458 = *D.23457;
        D.23459 = (int) D.23458;
        __result = D.23456 - D.23459;
        D.23460 = __s1_len > 1;
        D.23450 = __result == 0;
        D.23461 = D.23460 & D.23450;
        if (D.23461 != 0) goto <D.23462>; else goto <D.23463>;
        <D.23462>:
        D.23464 = &MEM[(void *)"SimdRuntime" + 2B];
        D.23465 = *D.23464;
        D.23466 = (int) D.23465;
        D.23467 = __s2 + 2;
        D.23468 = *D.23467;
        D.23469 = (int) D.23468;
        __result = D.23466 - D.23469;
        D.23470 = __s1_len > 2;
        D.23450 = __result == 0;
        D.23471 = D.23470 & D.23450;
        if (D.23471 != 0) goto <D.23472>; else goto <D.23473>;
        <D.23472>:
        D.23474 = &MEM[(void *)"SimdRuntime" + 3B];
        D.23475 = *D.23474;
        D.23476 = (int) D.23475;
        D.23477 = __s2 + 3;
        D.23478 = *D.23477;
        D.23479 = (int) D.23478;
        __result = D.23476 - D.23479;
        <D.23473>:
        <D.23463>:
        <D.23453>:
      }
      D.23062 = __result;
    }
    iftmp.3 = D.23062;
    goto <D.23480>;
    <D.23443>:
    iftmp.3 = __builtin_strcmp ("SimdRuntime", class_name);
    <D.23480>:
    D.23066 = iftmp.3;
  }
  if (D.23066 == 0) goto <D.23481>; else goto <D.23482>;
  <D.23481>:
  D.23440 = emit_simd_runtime_intrinsics (cfg, cmethod, fsig, args);
  return D.23440;
  <D.23482>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 15;
    if (__s1_len <= 3) goto <D.23484>; else goto <D.23485>;
    <D.23484>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23486 = "ArrayExtensions";
      D.23487 = MEM[(const unsigned char *)D.23486];
      D.23488 = (int) D.23487;
      D.23489 = *__s2;
      D.23490 = (int) D.23489;
      __result = D.23488 - D.23490;
      {
        D.23491 = __s1_len != 0;
        D.23492 = __result == 0;
        D.23493 = D.23491 & D.23492;
        if (D.23493 != 0) goto <D.23494>; else goto <D.23495>;
        <D.23494>:
        D.23496 = &MEM[(void *)"ArrayExtensions" + 1B];
        D.23497 = *D.23496;
        D.23498 = (int) D.23497;
        D.23499 = __s2 + 1;
        D.23500 = *D.23499;
        D.23501 = (int) D.23500;
        __result = D.23498 - D.23501;
        D.23502 = __s1_len > 1;
        D.23492 = __result == 0;
        D.23503 = D.23502 & D.23492;
        if (D.23503 != 0) goto <D.23504>; else goto <D.23505>;
        <D.23504>:
        D.23506 = &MEM[(void *)"ArrayExtensions" + 2B];
        D.23507 = *D.23506;
        D.23508 = (int) D.23507;
        D.23509 = __s2 + 2;
        D.23510 = *D.23509;
        D.23511 = (int) D.23510;
        __result = D.23508 - D.23511;
        D.23512 = __s1_len > 2;
        D.23492 = __result == 0;
        D.23513 = D.23512 & D.23492;
        if (D.23513 != 0) goto <D.23514>; else goto <D.23515>;
        <D.23514>:
        D.23516 = &MEM[(void *)"ArrayExtensions" + 3B];
        D.23517 = *D.23516;
        D.23518 = (int) D.23517;
        D.23519 = __s2 + 3;
        D.23520 = *D.23519;
        D.23521 = (int) D.23520;
        __result = D.23518 - D.23521;
        <D.23515>:
        <D.23505>:
        <D.23495>:
      }
      D.23071 = __result;
    }
    iftmp.4 = D.23071;
    goto <D.23522>;
    <D.23485>:
    iftmp.4 = __builtin_strcmp ("ArrayExtensions", class_name);
    <D.23522>:
    D.23075 = iftmp.4;
  }
  if (D.23075 == 0) goto <D.23523>; else goto <D.23524>;
  <D.23523>:
  D.23440 = emit_array_extension_intrinsics (cfg, cmethod, fsig, args);
  return D.23440;
  <D.23524>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 16;
    if (__s1_len <= 3) goto <D.23526>; else goto <D.23527>;
    <D.23526>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23528 = "VectorOperations";
      D.23529 = MEM[(const unsigned char *)D.23528];
      D.23530 = (int) D.23529;
      D.23531 = *__s2;
      D.23532 = (int) D.23531;
      __result = D.23530 - D.23532;
      {
        D.23533 = __s1_len != 0;
        D.23534 = __result == 0;
        D.23535 = D.23533 & D.23534;
        if (D.23535 != 0) goto <D.23536>; else goto <D.23537>;
        <D.23536>:
        D.23538 = &MEM[(void *)"VectorOperations" + 1B];
        D.23539 = *D.23538;
        D.23540 = (int) D.23539;
        D.23541 = __s2 + 1;
        D.23542 = *D.23541;
        D.23543 = (int) D.23542;
        __result = D.23540 - D.23543;
        D.23544 = __s1_len > 1;
        D.23534 = __result == 0;
        D.23545 = D.23544 & D.23534;
        if (D.23545 != 0) goto <D.23546>; else goto <D.23547>;
        <D.23546>:
        D.23548 = &MEM[(void *)"VectorOperations" + 2B];
        D.23549 = *D.23548;
        D.23550 = (int) D.23549;
        D.23551 = __s2 + 2;
        D.23552 = *D.23551;
        D.23553 = (int) D.23552;
        __result = D.23550 - D.23553;
        D.23554 = __s1_len > 2;
        D.23534 = __result == 0;
        D.23555 = D.23554 & D.23534;
        if (D.23555 != 0) goto <D.23556>; else goto <D.23557>;
        <D.23556>:
        D.23558 = &MEM[(void *)"VectorOperations" + 3B];
        D.23559 = *D.23558;
        D.23560 = (int) D.23559;
        D.23561 = __s2 + 3;
        D.23562 = *D.23561;
        D.23563 = (int) D.23562;
        __result = D.23560 - D.23563;
        <D.23557>:
        <D.23547>:
        <D.23537>:
      }
      D.23080 = __result;
    }
    iftmp.5 = D.23080;
    goto <D.23564>;
    <D.23527>:
    iftmp.5 = __builtin_strcmp ("VectorOperations", class_name);
    <D.23564>:
    D.23084 = iftmp.5;
  }
  if (D.23084 == 0) goto <D.23565>; else goto <D.23566>;
  <D.23565>:
  D.23567 = cmethod->flags;
  D.23568 = (int) D.23567;
  D.23569 = D.23568 & 16;
  if (D.23569 == 0) goto <D.23570>; else goto <D.23571>;
  <D.23570>:
  D.23440 = 0B;
  return D.23440;
  <D.23571>:
  D.23572 = mono_method_signature (cmethod);
  D.23573 = D.23572->params[0];
  D.23574 = mono_class_from_mono_type (D.23573);
  class_name = D.23574->name;
  goto <D.23575>;
  <D.23566>:
  D.23399 = cmethod->klass;
  D.23576 = BIT_FIELD_REF <*D.23399, 8, 288>;
  D.23577 = D.23576 & 2;
  if (D.23577 == 0) goto <D.23578>; else goto <D.23579>;
  <D.23578>:
  D.23440 = 0B;
  return D.23440;
  <D.23579>:
  <D.23575>:
  cfg->uses_simd_intrinsics = 1;
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.23581>; else goto <D.23582>;
    <D.23581>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23583 = "Vector2d";
      D.23584 = MEM[(const unsigned char *)D.23583];
      D.23585 = (int) D.23584;
      D.23586 = *__s2;
      D.23587 = (int) D.23586;
      __result = D.23585 - D.23587;
      {
        D.23588 = __s1_len != 0;
        D.23589 = __result == 0;
        D.23590 = D.23588 & D.23589;
        if (D.23590 != 0) goto <D.23591>; else goto <D.23592>;
        <D.23591>:
        D.23593 = &MEM[(void *)"Vector2d" + 1B];
        D.23594 = *D.23593;
        D.23595 = (int) D.23594;
        D.23596 = __s2 + 1;
        D.23597 = *D.23596;
        D.23598 = (int) D.23597;
        __result = D.23595 - D.23598;
        D.23599 = __s1_len > 1;
        D.23589 = __result == 0;
        D.23600 = D.23599 & D.23589;
        if (D.23600 != 0) goto <D.23601>; else goto <D.23602>;
        <D.23601>:
        D.23603 = &MEM[(void *)"Vector2d" + 2B];
        D.23604 = *D.23603;
        D.23605 = (int) D.23604;
        D.23606 = __s2 + 2;
        D.23607 = *D.23606;
        D.23608 = (int) D.23607;
        __result = D.23605 - D.23608;
        D.23609 = __s1_len > 2;
        D.23589 = __result == 0;
        D.23610 = D.23609 & D.23589;
        if (D.23610 != 0) goto <D.23611>; else goto <D.23612>;
        <D.23611>:
        D.23613 = &MEM[(void *)"Vector2d" + 3B];
        D.23614 = *D.23613;
        D.23615 = (int) D.23614;
        D.23616 = __s2 + 3;
        D.23617 = *D.23616;
        D.23618 = (int) D.23617;
        __result = D.23615 - D.23618;
        <D.23612>:
        <D.23602>:
        <D.23592>:
      }
      D.23089 = __result;
    }
    iftmp.6 = D.23089;
    goto <D.23619>;
    <D.23582>:
    iftmp.6 = __builtin_strcmp ("Vector2d", class_name);
    <D.23619>:
    D.23093 = iftmp.6;
  }
  if (D.23093 == 0) goto <D.23620>; else goto <D.23621>;
  <D.23620>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector2d_intrinsics, 41);
  return D.23440;
  <D.23621>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.23623>; else goto <D.23624>;
    <D.23623>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23625 = "Vector4f";
      D.23626 = MEM[(const unsigned char *)D.23625];
      D.23627 = (int) D.23626;
      D.23628 = *__s2;
      D.23629 = (int) D.23628;
      __result = D.23627 - D.23629;
      {
        D.23630 = __s1_len != 0;
        D.23631 = __result == 0;
        D.23632 = D.23630 & D.23631;
        if (D.23632 != 0) goto <D.23633>; else goto <D.23634>;
        <D.23633>:
        D.23635 = &MEM[(void *)"Vector4f" + 1B];
        D.23636 = *D.23635;
        D.23637 = (int) D.23636;
        D.23638 = __s2 + 1;
        D.23639 = *D.23638;
        D.23640 = (int) D.23639;
        __result = D.23637 - D.23640;
        D.23641 = __s1_len > 1;
        D.23631 = __result == 0;
        D.23642 = D.23641 & D.23631;
        if (D.23642 != 0) goto <D.23643>; else goto <D.23644>;
        <D.23643>:
        D.23645 = &MEM[(void *)"Vector4f" + 2B];
        D.23646 = *D.23645;
        D.23647 = (int) D.23646;
        D.23648 = __s2 + 2;
        D.23649 = *D.23648;
        D.23650 = (int) D.23649;
        __result = D.23647 - D.23650;
        D.23651 = __s1_len > 2;
        D.23631 = __result == 0;
        D.23652 = D.23651 & D.23631;
        if (D.23652 != 0) goto <D.23653>; else goto <D.23654>;
        <D.23653>:
        D.23655 = &MEM[(void *)"Vector4f" + 3B];
        D.23656 = *D.23655;
        D.23657 = (int) D.23656;
        D.23658 = __s2 + 3;
        D.23659 = *D.23658;
        D.23660 = (int) D.23659;
        __result = D.23657 - D.23660;
        <D.23654>:
        <D.23644>:
        <D.23634>:
      }
      D.23098 = __result;
    }
    iftmp.7 = D.23098;
    goto <D.23661>;
    <D.23624>:
    iftmp.7 = __builtin_strcmp ("Vector4f", class_name);
    <D.23661>:
    D.23102 = iftmp.7;
  }
  if (D.23102 == 0) goto <D.23662>; else goto <D.23663>;
  <D.23662>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector4f_intrinsics, 51);
  return D.23440;
  <D.23663>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.23665>; else goto <D.23666>;
    <D.23665>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23667 = "Vector2ul";
      D.23668 = MEM[(const unsigned char *)D.23667];
      D.23669 = (int) D.23668;
      D.23670 = *__s2;
      D.23671 = (int) D.23670;
      __result = D.23669 - D.23671;
      {
        D.23672 = __s1_len != 0;
        D.23673 = __result == 0;
        D.23674 = D.23672 & D.23673;
        if (D.23674 != 0) goto <D.23675>; else goto <D.23676>;
        <D.23675>:
        D.23677 = &MEM[(void *)"Vector2ul" + 1B];
        D.23678 = *D.23677;
        D.23679 = (int) D.23678;
        D.23680 = __s2 + 1;
        D.23681 = *D.23680;
        D.23682 = (int) D.23681;
        __result = D.23679 - D.23682;
        D.23683 = __s1_len > 1;
        D.23673 = __result == 0;
        D.23684 = D.23683 & D.23673;
        if (D.23684 != 0) goto <D.23685>; else goto <D.23686>;
        <D.23685>:
        D.23687 = &MEM[(void *)"Vector2ul" + 2B];
        D.23688 = *D.23687;
        D.23689 = (int) D.23688;
        D.23690 = __s2 + 2;
        D.23691 = *D.23690;
        D.23692 = (int) D.23691;
        __result = D.23689 - D.23692;
        D.23693 = __s1_len > 2;
        D.23673 = __result == 0;
        D.23694 = D.23693 & D.23673;
        if (D.23694 != 0) goto <D.23695>; else goto <D.23696>;
        <D.23695>:
        D.23697 = &MEM[(void *)"Vector2ul" + 3B];
        D.23698 = *D.23697;
        D.23699 = (int) D.23698;
        D.23700 = __s2 + 3;
        D.23701 = *D.23700;
        D.23702 = (int) D.23701;
        __result = D.23699 - D.23702;
        <D.23696>:
        <D.23686>:
        <D.23676>:
      }
      D.23107 = __result;
    }
    iftmp.8 = D.23107;
    goto <D.23703>;
    <D.23666>:
    iftmp.8 = __builtin_strcmp ("Vector2ul", class_name);
    <D.23703>:
    D.23111 = iftmp.8;
  }
  if (D.23111 == 0) goto <D.23704>; else goto <D.23705>;
  <D.23704>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector2ul_intrinsics, 24);
  return D.23440;
  <D.23705>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.23707>; else goto <D.23708>;
    <D.23707>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23709 = "Vector2l";
      D.23710 = MEM[(const unsigned char *)D.23709];
      D.23711 = (int) D.23710;
      D.23712 = *__s2;
      D.23713 = (int) D.23712;
      __result = D.23711 - D.23713;
      {
        D.23714 = __s1_len != 0;
        D.23715 = __result == 0;
        D.23716 = D.23714 & D.23715;
        if (D.23716 != 0) goto <D.23717>; else goto <D.23718>;
        <D.23717>:
        D.23719 = &MEM[(void *)"Vector2l" + 1B];
        D.23720 = *D.23719;
        D.23721 = (int) D.23720;
        D.23722 = __s2 + 1;
        D.23723 = *D.23722;
        D.23724 = (int) D.23723;
        __result = D.23721 - D.23724;
        D.23725 = __s1_len > 1;
        D.23715 = __result == 0;
        D.23726 = D.23725 & D.23715;
        if (D.23726 != 0) goto <D.23727>; else goto <D.23728>;
        <D.23727>:
        D.23729 = &MEM[(void *)"Vector2l" + 2B];
        D.23730 = *D.23729;
        D.23731 = (int) D.23730;
        D.23732 = __s2 + 2;
        D.23733 = *D.23732;
        D.23734 = (int) D.23733;
        __result = D.23731 - D.23734;
        D.23735 = __s1_len > 2;
        D.23715 = __result == 0;
        D.23736 = D.23735 & D.23715;
        if (D.23736 != 0) goto <D.23737>; else goto <D.23738>;
        <D.23737>:
        D.23739 = &MEM[(void *)"Vector2l" + 3B];
        D.23740 = *D.23739;
        D.23741 = (int) D.23740;
        D.23742 = __s2 + 3;
        D.23743 = *D.23742;
        D.23744 = (int) D.23743;
        __result = D.23741 - D.23744;
        <D.23738>:
        <D.23728>:
        <D.23718>:
      }
      D.23116 = __result;
    }
    iftmp.9 = D.23116;
    goto <D.23745>;
    <D.23708>:
    iftmp.9 = __builtin_strcmp ("Vector2l", class_name);
    <D.23745>:
    D.23120 = iftmp.9;
  }
  if (D.23120 == 0) goto <D.23746>; else goto <D.23747>;
  <D.23746>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector2l_intrinsics, 25);
  return D.23440;
  <D.23747>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.23749>; else goto <D.23750>;
    <D.23749>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23751 = "Vector4ui";
      D.23752 = MEM[(const unsigned char *)D.23751];
      D.23753 = (int) D.23752;
      D.23754 = *__s2;
      D.23755 = (int) D.23754;
      __result = D.23753 - D.23755;
      {
        D.23756 = __s1_len != 0;
        D.23757 = __result == 0;
        D.23758 = D.23756 & D.23757;
        if (D.23758 != 0) goto <D.23759>; else goto <D.23760>;
        <D.23759>:
        D.23761 = &MEM[(void *)"Vector4ui" + 1B];
        D.23762 = *D.23761;
        D.23763 = (int) D.23762;
        D.23764 = __s2 + 1;
        D.23765 = *D.23764;
        D.23766 = (int) D.23765;
        __result = D.23763 - D.23766;
        D.23767 = __s1_len > 1;
        D.23757 = __result == 0;
        D.23768 = D.23767 & D.23757;
        if (D.23768 != 0) goto <D.23769>; else goto <D.23770>;
        <D.23769>:
        D.23771 = &MEM[(void *)"Vector4ui" + 2B];
        D.23772 = *D.23771;
        D.23773 = (int) D.23772;
        D.23774 = __s2 + 2;
        D.23775 = *D.23774;
        D.23776 = (int) D.23775;
        __result = D.23773 - D.23776;
        D.23777 = __s1_len > 2;
        D.23757 = __result == 0;
        D.23778 = D.23777 & D.23757;
        if (D.23778 != 0) goto <D.23779>; else goto <D.23780>;
        <D.23779>:
        D.23781 = &MEM[(void *)"Vector4ui" + 3B];
        D.23782 = *D.23781;
        D.23783 = (int) D.23782;
        D.23784 = __s2 + 3;
        D.23785 = *D.23784;
        D.23786 = (int) D.23785;
        __result = D.23783 - D.23786;
        <D.23780>:
        <D.23770>:
        <D.23760>:
      }
      D.23125 = __result;
    }
    iftmp.10 = D.23125;
    goto <D.23787>;
    <D.23750>:
    iftmp.10 = __builtin_strcmp ("Vector4ui", class_name);
    <D.23787>:
    D.23129 = iftmp.10;
  }
  if (D.23129 == 0) goto <D.23788>; else goto <D.23789>;
  <D.23788>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector4ui_intrinsics, 35);
  return D.23440;
  <D.23789>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.23791>; else goto <D.23792>;
    <D.23791>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23793 = "Vector4i";
      D.23794 = MEM[(const unsigned char *)D.23793];
      D.23795 = (int) D.23794;
      D.23796 = *__s2;
      D.23797 = (int) D.23796;
      __result = D.23795 - D.23797;
      {
        D.23798 = __s1_len != 0;
        D.23799 = __result == 0;
        D.23800 = D.23798 & D.23799;
        if (D.23800 != 0) goto <D.23801>; else goto <D.23802>;
        <D.23801>:
        D.23803 = &MEM[(void *)"Vector4i" + 1B];
        D.23804 = *D.23803;
        D.23805 = (int) D.23804;
        D.23806 = __s2 + 1;
        D.23807 = *D.23806;
        D.23808 = (int) D.23807;
        __result = D.23805 - D.23808;
        D.23809 = __s1_len > 1;
        D.23799 = __result == 0;
        D.23810 = D.23809 & D.23799;
        if (D.23810 != 0) goto <D.23811>; else goto <D.23812>;
        <D.23811>:
        D.23813 = &MEM[(void *)"Vector4i" + 2B];
        D.23814 = *D.23813;
        D.23815 = (int) D.23814;
        D.23816 = __s2 + 2;
        D.23817 = *D.23816;
        D.23818 = (int) D.23817;
        __result = D.23815 - D.23818;
        D.23819 = __s1_len > 2;
        D.23799 = __result == 0;
        D.23820 = D.23819 & D.23799;
        if (D.23820 != 0) goto <D.23821>; else goto <D.23822>;
        <D.23821>:
        D.23823 = &MEM[(void *)"Vector4i" + 3B];
        D.23824 = *D.23823;
        D.23825 = (int) D.23824;
        D.23826 = __s2 + 3;
        D.23827 = *D.23826;
        D.23828 = (int) D.23827;
        __result = D.23825 - D.23828;
        <D.23822>:
        <D.23812>:
        <D.23802>:
      }
      D.23134 = __result;
    }
    iftmp.11 = D.23134;
    goto <D.23829>;
    <D.23792>:
    iftmp.11 = __builtin_strcmp ("Vector4i", class_name);
    <D.23829>:
    D.23138 = iftmp.11;
  }
  if (D.23138 == 0) goto <D.23830>; else goto <D.23831>;
  <D.23830>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector4i_intrinsics, 38);
  return D.23440;
  <D.23831>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.23833>; else goto <D.23834>;
    <D.23833>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23835 = "Vector8us";
      D.23836 = MEM[(const unsigned char *)D.23835];
      D.23837 = (int) D.23836;
      D.23838 = *__s2;
      D.23839 = (int) D.23838;
      __result = D.23837 - D.23839;
      {
        D.23840 = __s1_len != 0;
        D.23841 = __result == 0;
        D.23842 = D.23840 & D.23841;
        if (D.23842 != 0) goto <D.23843>; else goto <D.23844>;
        <D.23843>:
        D.23845 = &MEM[(void *)"Vector8us" + 1B];
        D.23846 = *D.23845;
        D.23847 = (int) D.23846;
        D.23848 = __s2 + 1;
        D.23849 = *D.23848;
        D.23850 = (int) D.23849;
        __result = D.23847 - D.23850;
        D.23851 = __s1_len > 1;
        D.23841 = __result == 0;
        D.23852 = D.23851 & D.23841;
        if (D.23852 != 0) goto <D.23853>; else goto <D.23854>;
        <D.23853>:
        D.23855 = &MEM[(void *)"Vector8us" + 2B];
        D.23856 = *D.23855;
        D.23857 = (int) D.23856;
        D.23858 = __s2 + 2;
        D.23859 = *D.23858;
        D.23860 = (int) D.23859;
        __result = D.23857 - D.23860;
        D.23861 = __s1_len > 2;
        D.23841 = __result == 0;
        D.23862 = D.23861 & D.23841;
        if (D.23862 != 0) goto <D.23863>; else goto <D.23864>;
        <D.23863>:
        D.23865 = &MEM[(void *)"Vector8us" + 3B];
        D.23866 = *D.23865;
        D.23867 = (int) D.23866;
        D.23868 = __s2 + 3;
        D.23869 = *D.23868;
        D.23870 = (int) D.23869;
        __result = D.23867 - D.23870;
        <D.23864>:
        <D.23854>:
        <D.23844>:
      }
      D.23143 = __result;
    }
    iftmp.12 = D.23143;
    goto <D.23871>;
    <D.23834>:
    iftmp.12 = __builtin_strcmp ("Vector8us", class_name);
    <D.23871>:
    D.23147 = iftmp.12;
  }
  if (D.23147 == 0) goto <D.23872>; else goto <D.23873>;
  <D.23872>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector8us_intrinsics, 48);
  return D.23440;
  <D.23873>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.23875>; else goto <D.23876>;
    <D.23875>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23877 = "Vector8s";
      D.23878 = MEM[(const unsigned char *)D.23877];
      D.23879 = (int) D.23878;
      D.23880 = *__s2;
      D.23881 = (int) D.23880;
      __result = D.23879 - D.23881;
      {
        D.23882 = __s1_len != 0;
        D.23883 = __result == 0;
        D.23884 = D.23882 & D.23883;
        if (D.23884 != 0) goto <D.23885>; else goto <D.23886>;
        <D.23885>:
        D.23887 = &MEM[(void *)"Vector8s" + 1B];
        D.23888 = *D.23887;
        D.23889 = (int) D.23888;
        D.23890 = __s2 + 1;
        D.23891 = *D.23890;
        D.23892 = (int) D.23891;
        __result = D.23889 - D.23892;
        D.23893 = __s1_len > 1;
        D.23883 = __result == 0;
        D.23894 = D.23893 & D.23883;
        if (D.23894 != 0) goto <D.23895>; else goto <D.23896>;
        <D.23895>:
        D.23897 = &MEM[(void *)"Vector8s" + 2B];
        D.23898 = *D.23897;
        D.23899 = (int) D.23898;
        D.23900 = __s2 + 2;
        D.23901 = *D.23900;
        D.23902 = (int) D.23901;
        __result = D.23899 - D.23902;
        D.23903 = __s1_len > 2;
        D.23883 = __result == 0;
        D.23904 = D.23903 & D.23883;
        if (D.23904 != 0) goto <D.23905>; else goto <D.23906>;
        <D.23905>:
        D.23907 = &MEM[(void *)"Vector8s" + 3B];
        D.23908 = *D.23907;
        D.23909 = (int) D.23908;
        D.23910 = __s2 + 3;
        D.23911 = *D.23910;
        D.23912 = (int) D.23911;
        __result = D.23909 - D.23912;
        <D.23906>:
        <D.23896>:
        <D.23886>:
      }
      D.23152 = __result;
    }
    iftmp.13 = D.23152;
    goto <D.23913>;
    <D.23876>:
    iftmp.13 = __builtin_strcmp ("Vector8s", class_name);
    <D.23913>:
    D.23156 = iftmp.13;
  }
  if (D.23156 == 0) goto <D.23914>; else goto <D.23915>;
  <D.23914>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector8s_intrinsics, 48);
  return D.23440;
  <D.23915>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.23917>; else goto <D.23918>;
    <D.23917>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23919 = "Vector16b";
      D.23920 = MEM[(const unsigned char *)D.23919];
      D.23921 = (int) D.23920;
      D.23922 = *__s2;
      D.23923 = (int) D.23922;
      __result = D.23921 - D.23923;
      {
        D.23924 = __s1_len != 0;
        D.23925 = __result == 0;
        D.23926 = D.23924 & D.23925;
        if (D.23926 != 0) goto <D.23927>; else goto <D.23928>;
        <D.23927>:
        D.23929 = &MEM[(void *)"Vector16b" + 1B];
        D.23930 = *D.23929;
        D.23931 = (int) D.23930;
        D.23932 = __s2 + 1;
        D.23933 = *D.23932;
        D.23934 = (int) D.23933;
        __result = D.23931 - D.23934;
        D.23935 = __s1_len > 1;
        D.23925 = __result == 0;
        D.23936 = D.23935 & D.23925;
        if (D.23936 != 0) goto <D.23937>; else goto <D.23938>;
        <D.23937>:
        D.23939 = &MEM[(void *)"Vector16b" + 2B];
        D.23940 = *D.23939;
        D.23941 = (int) D.23940;
        D.23942 = __s2 + 2;
        D.23943 = *D.23942;
        D.23944 = (int) D.23943;
        __result = D.23941 - D.23944;
        D.23945 = __s1_len > 2;
        D.23925 = __result == 0;
        D.23946 = D.23945 & D.23925;
        if (D.23946 != 0) goto <D.23947>; else goto <D.23948>;
        <D.23947>:
        D.23949 = &MEM[(void *)"Vector16b" + 3B];
        D.23950 = *D.23949;
        D.23951 = (int) D.23950;
        D.23952 = __s2 + 3;
        D.23953 = *D.23952;
        D.23954 = (int) D.23953;
        __result = D.23951 - D.23954;
        <D.23948>:
        <D.23938>:
        <D.23928>:
      }
      D.23161 = __result;
    }
    iftmp.14 = D.23161;
    goto <D.23955>;
    <D.23918>:
    iftmp.14 = __builtin_strcmp ("Vector16b", class_name);
    <D.23955>:
    D.23165 = iftmp.14;
  }
  if (D.23165 == 0) goto <D.23956>; else goto <D.23957>;
  <D.23956>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector16b_intrinsics, 57);
  return D.23440;
  <D.23957>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 10;
    if (__s1_len <= 3) goto <D.23959>; else goto <D.23960>;
    <D.23959>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class_name;
      D.23961 = "Vector16sb";
      D.23962 = MEM[(const unsigned char *)D.23961];
      D.23963 = (int) D.23962;
      D.23964 = *__s2;
      D.23965 = (int) D.23964;
      __result = D.23963 - D.23965;
      {
        D.23966 = __s1_len != 0;
        D.23967 = __result == 0;
        D.23968 = D.23966 & D.23967;
        if (D.23968 != 0) goto <D.23969>; else goto <D.23970>;
        <D.23969>:
        D.23971 = &MEM[(void *)"Vector16sb" + 1B];
        D.23972 = *D.23971;
        D.23973 = (int) D.23972;
        D.23974 = __s2 + 1;
        D.23975 = *D.23974;
        D.23976 = (int) D.23975;
        __result = D.23973 - D.23976;
        D.23977 = __s1_len > 1;
        D.23967 = __result == 0;
        D.23978 = D.23977 & D.23967;
        if (D.23978 != 0) goto <D.23979>; else goto <D.23980>;
        <D.23979>:
        D.23981 = &MEM[(void *)"Vector16sb" + 2B];
        D.23982 = *D.23981;
        D.23983 = (int) D.23982;
        D.23984 = __s2 + 2;
        D.23985 = *D.23984;
        D.23986 = (int) D.23985;
        __result = D.23983 - D.23986;
        D.23987 = __s1_len > 2;
        D.23967 = __result == 0;
        D.23988 = D.23987 & D.23967;
        if (D.23988 != 0) goto <D.23989>; else goto <D.23990>;
        <D.23989>:
        D.23991 = &MEM[(void *)"Vector16sb" + 3B];
        D.23992 = *D.23991;
        D.23993 = (int) D.23992;
        D.23994 = __s2 + 3;
        D.23995 = *D.23994;
        D.23996 = (int) D.23995;
        __result = D.23993 - D.23996;
        <D.23990>:
        <D.23980>:
        <D.23970>:
      }
      D.23170 = __result;
    }
    iftmp.15 = D.23170;
    goto <D.23997>;
    <D.23960>:
    iftmp.15 = __builtin_strcmp ("Vector16sb", class_name);
    <D.23997>:
    D.23174 = iftmp.15;
  }
  if (D.23174 == 0) goto <D.23998>; else goto <D.23999>;
  <D.23998>:
  D.23440 = emit_intrinsics (cfg, cmethod, fsig, args, &vector16sb_intrinsics, 56);
  return D.23440;
  <D.23999>:
  D.23440 = 0B;
  return D.23440;
}


emit_simd_runtime_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  int D.23040;
  int iftmp.16;
  int D.23036;
  const char[14] * D.24004;
  unsigned char D.24005;
  int D.24006;
  unsigned char D.24007;
  int D.24008;
  _Bool D.24009;
  _Bool D.24010;
  _Bool D.24011;
  const unsigned char * D.24014;
  unsigned char D.24015;
  int D.24016;
  const unsigned char * D.24017;
  unsigned char D.24018;
  int D.24019;
  _Bool D.24020;
  _Bool D.24021;
  const unsigned char * D.24024;
  unsigned char D.24025;
  int D.24026;
  const unsigned char * D.24027;
  unsigned char D.24028;
  int D.24029;
  _Bool D.24030;
  _Bool D.24031;
  const unsigned char * D.24034;
  unsigned char D.24035;
  int D.24036;
  const unsigned char * D.24037;
  unsigned char D.24038;
  int D.24039;
  const char * D.24041;
  struct MonoMemPool * D.24044;
  long int D.24045;
  struct MonoInst * D.24046;
  int D.24047;
  int D.24048;
  const unsigned char * D.24049;
  unsigned int simd_supported_versions.17;
  long int D.24051;
  unsigned int D.24052;
  int D.24053;
  struct MonoBasicBlock * D.24054;
  struct MonoInst * D.24055;
  struct MonoInst * D.24059;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 13;
    if (__s1_len <= 3) goto <D.24002>; else goto <D.24003>;
    <D.24002>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.24004 = "get_AccelMode";
      D.24005 = MEM[(const unsigned char *)D.24004];
      D.24006 = (int) D.24005;
      D.24007 = *__s2;
      D.24008 = (int) D.24007;
      __result = D.24006 - D.24008;
      {
        D.24009 = __s1_len != 0;
        D.24010 = __result == 0;
        D.24011 = D.24009 & D.24010;
        if (D.24011 != 0) goto <D.24012>; else goto <D.24013>;
        <D.24012>:
        D.24014 = &MEM[(void *)"get_AccelMode" + 1B];
        D.24015 = *D.24014;
        D.24016 = (int) D.24015;
        D.24017 = __s2 + 1;
        D.24018 = *D.24017;
        D.24019 = (int) D.24018;
        __result = D.24016 - D.24019;
        D.24020 = __s1_len > 1;
        D.24010 = __result == 0;
        D.24021 = D.24020 & D.24010;
        if (D.24021 != 0) goto <D.24022>; else goto <D.24023>;
        <D.24022>:
        D.24024 = &MEM[(void *)"get_AccelMode" + 2B];
        D.24025 = *D.24024;
        D.24026 = (int) D.24025;
        D.24027 = __s2 + 2;
        D.24028 = *D.24027;
        D.24029 = (int) D.24028;
        __result = D.24026 - D.24029;
        D.24030 = __s1_len > 2;
        D.24010 = __result == 0;
        D.24031 = D.24030 & D.24010;
        if (D.24031 != 0) goto <D.24032>; else goto <D.24033>;
        <D.24032>:
        D.24034 = &MEM[(void *)"get_AccelMode" + 3B];
        D.24035 = *D.24034;
        D.24036 = (int) D.24035;
        D.24037 = __s2 + 3;
        D.24038 = *D.24037;
        D.24039 = (int) D.24038;
        __result = D.24036 - D.24039;
        <D.24033>:
        <D.24023>:
        <D.24013>:
      }
      D.23036 = __result;
    }
    iftmp.16 = D.23036;
    goto <D.24040>;
    <D.24003>:
    D.24041 = cmethod->name;
    iftmp.16 = __builtin_strcmp ("get_AccelMode", D.24041);
    <D.24040>:
    D.23040 = iftmp.16;
  }
  if (D.23040 == 0) goto <D.24042>; else goto <D.24043>;
  <D.24042>:
  {
    struct MonoInst * ins;

    D.24044 = cfg->mempool;
    ins = mono_mempool_alloc (D.24044, 80);
    ins->data.op[1].const_val = 0;
    D.24045 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24045;
    ins->prev = 0B;
    D.24046 = ins->prev;
    ins->next = D.24046;
    ins->opcode = 362;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24047 = ins->sreg3;
    ins->sreg2 = D.24047;
    D.24048 = ins->sreg2;
    ins->sreg1 = D.24048;
    D.24049 = cfg->ip;
    ins->cil_code = D.24049;
    simd_supported_versions.17 = simd_supported_versions;
    D.24051 = (long int) simd_supported_versions.17;
    ins->data.op[0].const_val = D.24051;
    ins->type = 1;
    D.24052 = alloc_dreg (cfg, 1);
    D.24053 = (int) D.24052;
    ins->dreg = D.24053;
    D.24054 = cfg->cbb;
    D.24055 = D.24054->last_ins;
    if (D.24055 != 0B) goto <D.24056>; else goto <D.24057>;
    <D.24056>:
    D.24054 = cfg->cbb;
    D.24055 = D.24054->last_ins;
    D.24055->next = ins;
    D.24054 = cfg->cbb;
    D.24055 = D.24054->last_ins;
    ins->prev = D.24055;
    D.24054 = cfg->cbb;
    D.24054->last_ins = ins;
    goto <D.24058>;
    <D.24057>:
    D.24054 = cfg->cbb;
    D.24054 = cfg->cbb;
    D.24054->last_ins = ins;
    D.24055 = D.24054->last_ins;
    D.24054->code = D.24055;
    <D.24058>:
    D.24059 = ins;
    return D.24059;
  }
  <D.24043>:
  D.24059 = 0B;
  return D.24059;
}


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

  switch (stack_type) <default: <D.22248>, case 1: <D.22241>, case 2: <D.22246>, case 3: <D.22242>, case 4: <D.22245>, case 5: <D.22243>, case 6: <D.22244>, case 7: <D.22247>>
  <D.22241>:
  <D.22242>:
  D.24061 = alloc_ireg (cfg);
  return D.24061;
  <D.22243>:
  D.24061 = alloc_ireg_mp (cfg);
  return D.24061;
  <D.22244>:
  D.24061 = alloc_ireg_ref (cfg);
  return D.24061;
  <D.22245>:
  D.24061 = alloc_freg (cfg);
  return D.24061;
  <D.22246>:
  D.24061 = alloc_lreg (cfg);
  return D.24061;
  <D.22247>:
  D.24061 = alloc_ireg (cfg);
  return D.24061;
  <D.22248>:
  monoeg_g_log (0B, 16, "Unknown stack type %x\n", stack_type);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 97);
  D.24061 = 4294967295;
  return D.24061;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.24063;
  unsigned char D.24064;
  unsigned char D.24065;
  guint32 D.24068;
  int vreg;

  D.24063 = alloc_ireg (cfg);
  vreg = (int) D.24063;
  D.24064 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.24065 = D.24064 & 128;
  if (D.24065 != 0) goto <D.24066>; else goto <D.24067>;
  <D.24066>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.24067>:
  D.24068 = (guint32) vreg;
  return D.24068;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.24070;
  unsigned char D.24071;
  unsigned char D.24072;
  guint32 D.24075;
  int vreg;

  D.24070 = alloc_ireg (cfg);
  vreg = (int) D.24070;
  D.24071 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.24072 = D.24071 & 128;
  if (D.24072 != 0) goto <D.24073>; else goto <D.24074>;
  <D.24073>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.24074>:
  D.24075 = (guint32) vreg;
  return D.24075;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.24077;
  guint32 D.24080;
  unsigned int D.24081;
  unsigned int D.24082;
  unsigned int D.24083;

  D.24077 = mono_arch_is_soft_float ();
  if (D.24077 != 0) goto <D.24078>; else goto <D.24079>;
  <D.24078>:
  D.24080 = alloc_lreg (cfg);
  return D.24080;
  <D.24079>:
  D.24081 = cfg->next_vreg;
  D.24082 = D.24081;
  D.24083 = D.24082 + 1;
  cfg->next_vreg = D.24083;
  D.24080 = D.24082;
  return D.24080;
}


mono_arch_is_soft_float ()
{
  gboolean D.24085;

  D.24085 = 0;
  return D.24085;
}


alloc_lreg (struct MonoCompile * cfg)
{
  guint32 D.24087;
  unsigned int D.24088;
  unsigned int D.24089;
  unsigned int D.24090;

  D.24088 = cfg->next_vreg;
  D.24089 = D.24088;
  D.24090 = D.24089 + 1;
  cfg->next_vreg = D.24090;
  D.24087 = D.24089;
  return D.24087;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.24092;
  unsigned int D.24093;
  unsigned int D.24094;
  unsigned int D.24095;

  D.24093 = cfg->next_vreg;
  D.24094 = D.24093;
  D.24095 = D.24094 + 1;
  cfg->next_vreg = D.24095;
  D.24092 = D.24094;
  return D.24092;
}


emit_array_extension_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  int D.22962;
  int iftmp.18;
  int D.22958;
  const char[10] * D.24102;
  unsigned char D.24103;
  int D.24104;
  unsigned char D.24105;
  int D.24106;
  _Bool D.24107;
  _Bool D.24108;
  _Bool D.24109;
  const unsigned char * D.24112;
  unsigned char D.24113;
  int D.24114;
  const unsigned char * D.24115;
  unsigned char D.24116;
  int D.24117;
  _Bool D.24118;
  _Bool D.24119;
  const unsigned char * D.24122;
  unsigned char D.24123;
  int D.24124;
  const unsigned char * D.24125;
  unsigned char D.24126;
  int D.24127;
  _Bool D.24128;
  _Bool D.24129;
  const unsigned char * D.24132;
  unsigned char D.24133;
  int D.24134;
  const unsigned char * D.24135;
  unsigned char D.24136;
  int D.24137;
  const char * D.24139;
  int D.22971;
  int iftmp.19;
  int D.22967;
  const char[17] * D.24144;
  unsigned char D.24145;
  int D.24146;
  unsigned char D.24147;
  int D.24148;
  _Bool D.24149;
  _Bool D.24150;
  _Bool D.24151;
  const unsigned char * D.24154;
  unsigned char D.24155;
  int D.24156;
  const unsigned char * D.24157;
  unsigned char D.24158;
  int D.24159;
  _Bool D.24160;
  _Bool D.24161;
  const unsigned char * D.24164;
  unsigned char D.24165;
  int D.24166;
  const unsigned char * D.24167;
  unsigned char D.24168;
  int D.24169;
  _Bool D.24170;
  _Bool D.24171;
  const unsigned char * D.24174;
  unsigned char D.24175;
  int D.24176;
  const unsigned char * D.24177;
  unsigned char D.24178;
  int D.24179;
  struct MonoInst * * D.24181;
  struct MonoInst * D.24182;
  struct MonoInst * D.24183;
  struct MonoType * D.24184;
  struct MonoMemPool * D.24185;
  long int D.24186;
  struct MonoInst * D.24187;
  guint16 iftmp.20;
  int D.22982;
  int iftmp.21;
  int D.22978;
  unsigned char D.24192;
  int D.24193;
  _Bool D.24194;
  _Bool D.24195;
  _Bool D.24196;
  const unsigned char * D.24199;
  unsigned char D.24200;
  int D.24201;
  _Bool D.24202;
  _Bool D.24203;
  const unsigned char * D.24206;
  unsigned char D.24207;
  int D.24208;
  _Bool D.24209;
  _Bool D.24210;
  const unsigned char * D.24213;
  unsigned char D.24214;
  int D.24215;
  int D.24220;
  int D.24221;
  const unsigned char * D.24222;
  struct MonoClass * D.24223;
  unsigned int D.24224;
  int D.24225;
  struct MonoBasicBlock * D.24226;
  struct MonoInst * D.24227;
  struct MonoInst * D.24231;
  int D.22991;
  int iftmp.22;
  int D.22987;
  const char[10] * D.24237;
  unsigned char D.24238;
  int D.24239;
  unsigned char D.24240;
  int D.24241;
  _Bool D.24242;
  _Bool D.24243;
  _Bool D.24244;
  const unsigned char * D.24247;
  unsigned char D.24248;
  int D.24249;
  const unsigned char * D.24250;
  unsigned char D.24251;
  int D.24252;
  _Bool D.24253;
  _Bool D.24254;
  const unsigned char * D.24257;
  unsigned char D.24258;
  int D.24259;
  const unsigned char * D.24260;
  unsigned char D.24261;
  int D.24262;
  _Bool D.24263;
  _Bool D.24264;
  const unsigned char * D.24267;
  unsigned char D.24268;
  int D.24269;
  const unsigned char * D.24270;
  unsigned char D.24271;
  int D.24272;
  int D.23000;
  int iftmp.23;
  int D.22996;
  const char[17] * D.24278;
  unsigned char D.24279;
  int D.24280;
  unsigned char D.24281;
  int D.24282;
  _Bool D.24283;
  _Bool D.24284;
  _Bool D.24285;
  const unsigned char * D.24288;
  unsigned char D.24289;
  int D.24290;
  const unsigned char * D.24291;
  unsigned char D.24292;
  int D.24293;
  _Bool D.24294;
  _Bool D.24295;
  const unsigned char * D.24298;
  unsigned char D.24299;
  int D.24300;
  const unsigned char * D.24301;
  unsigned char D.24302;
  int D.24303;
  _Bool D.24304;
  _Bool D.24305;
  const unsigned char * D.24308;
  unsigned char D.24309;
  int D.24310;
  const unsigned char * D.24311;
  unsigned char D.24312;
  int D.24313;
  struct MonoInst * * D.24315;
  struct MonoInst * D.24316;
  long int D.24317;
  struct MonoInst * D.24318;
  guint16 iftmp.24;
  int D.23012;
  int iftmp.25;
  int D.23008;
  unsigned char D.24323;
  int D.24324;
  _Bool D.24325;
  _Bool D.24326;
  _Bool D.24327;
  const unsigned char * D.24330;
  unsigned char D.24331;
  int D.24332;
  _Bool D.24333;
  _Bool D.24334;
  const unsigned char * D.24337;
  unsigned char D.24338;
  int D.24339;
  _Bool D.24340;
  _Bool D.24341;
  const unsigned char * D.24344;
  unsigned char D.24345;
  int D.24346;
  int D.24351;
  int D.24352;
  int D.23021;
  int iftmp.26;
  int D.23017;
  const char[10] * D.24359;
  unsigned char D.24360;
  int D.24361;
  unsigned char D.24362;
  int D.24363;
  _Bool D.24364;
  _Bool D.24365;
  _Bool D.24366;
  const unsigned char * D.24369;
  unsigned char D.24370;
  int D.24371;
  const unsigned char * D.24372;
  unsigned char D.24373;
  int D.24374;
  _Bool D.24375;
  _Bool D.24376;
  const unsigned char * D.24379;
  unsigned char D.24380;
  int D.24381;
  const unsigned char * D.24382;
  unsigned char D.24383;
  int D.24384;
  _Bool D.24385;
  _Bool D.24386;
  const unsigned char * D.24389;
  unsigned char D.24390;
  int D.24391;
  const unsigned char * D.24392;
  unsigned char D.24393;
  int D.24394;
  long int D.24398;
  struct MonoInst * D.24399;
  int D.24400;
  int D.24401;
  long int D.24405;
  struct MonoInst * D.24406;
  int D.24407;
  int D.24408;
  long int D.24412;
  struct MonoInst * D.24413;
  int D.24414;
  int D.24415;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.24100>; else goto <D.24101>;
    <D.24100>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.24102 = "GetVector";
      D.24103 = MEM[(const unsigned char *)D.24102];
      D.24104 = (int) D.24103;
      D.24105 = *__s2;
      D.24106 = (int) D.24105;
      __result = D.24104 - D.24106;
      {
        D.24107 = __s1_len != 0;
        D.24108 = __result == 0;
        D.24109 = D.24107 & D.24108;
        if (D.24109 != 0) goto <D.24110>; else goto <D.24111>;
        <D.24110>:
        D.24112 = &MEM[(void *)"GetVector" + 1B];
        D.24113 = *D.24112;
        D.24114 = (int) D.24113;
        D.24115 = __s2 + 1;
        D.24116 = *D.24115;
        D.24117 = (int) D.24116;
        __result = D.24114 - D.24117;
        D.24118 = __s1_len > 1;
        D.24108 = __result == 0;
        D.24119 = D.24118 & D.24108;
        if (D.24119 != 0) goto <D.24120>; else goto <D.24121>;
        <D.24120>:
        D.24122 = &MEM[(void *)"GetVector" + 2B];
        D.24123 = *D.24122;
        D.24124 = (int) D.24123;
        D.24125 = __s2 + 2;
        D.24126 = *D.24125;
        D.24127 = (int) D.24126;
        __result = D.24124 - D.24127;
        D.24128 = __s1_len > 2;
        D.24108 = __result == 0;
        D.24129 = D.24128 & D.24108;
        if (D.24129 != 0) goto <D.24130>; else goto <D.24131>;
        <D.24130>:
        D.24132 = &MEM[(void *)"GetVector" + 3B];
        D.24133 = *D.24132;
        D.24134 = (int) D.24133;
        D.24135 = __s2 + 3;
        D.24136 = *D.24135;
        D.24137 = (int) D.24136;
        __result = D.24134 - D.24137;
        <D.24131>:
        <D.24121>:
        <D.24111>:
      }
      D.22958 = __result;
    }
    iftmp.18 = D.22958;
    goto <D.24138>;
    <D.24101>:
    D.24139 = cmethod->name;
    iftmp.18 = __builtin_strcmp ("GetVector", D.24139);
    <D.24138>:
    D.22962 = iftmp.18;
  }
  if (D.22962 == 0) goto <D.24097>; else goto <D.24140>;
  <D.24140>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 16;
    if (__s1_len <= 3) goto <D.24142>; else goto <D.24143>;
    <D.24142>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.24144 = "GetVectorAligned";
      D.24145 = MEM[(const unsigned char *)D.24144];
      D.24146 = (int) D.24145;
      D.24147 = *__s2;
      D.24148 = (int) D.24147;
      __result = D.24146 - D.24148;
      {
        D.24149 = __s1_len != 0;
        D.24150 = __result == 0;
        D.24151 = D.24149 & D.24150;
        if (D.24151 != 0) goto <D.24152>; else goto <D.24153>;
        <D.24152>:
        D.24154 = &MEM[(void *)"GetVectorAligned" + 1B];
        D.24155 = *D.24154;
        D.24156 = (int) D.24155;
        D.24157 = __s2 + 1;
        D.24158 = *D.24157;
        D.24159 = (int) D.24158;
        __result = D.24156 - D.24159;
        D.24160 = __s1_len > 1;
        D.24150 = __result == 0;
        D.24161 = D.24160 & D.24150;
        if (D.24161 != 0) goto <D.24162>; else goto <D.24163>;
        <D.24162>:
        D.24164 = &MEM[(void *)"GetVectorAligned" + 2B];
        D.24165 = *D.24164;
        D.24166 = (int) D.24165;
        D.24167 = __s2 + 2;
        D.24168 = *D.24167;
        D.24169 = (int) D.24168;
        __result = D.24166 - D.24169;
        D.24170 = __s1_len > 2;
        D.24150 = __result == 0;
        D.24171 = D.24170 & D.24150;
        if (D.24171 != 0) goto <D.24172>; else goto <D.24173>;
        <D.24172>:
        D.24174 = &MEM[(void *)"GetVectorAligned" + 3B];
        D.24175 = *D.24174;
        D.24176 = (int) D.24175;
        D.24177 = __s2 + 3;
        D.24178 = *D.24177;
        D.24179 = (int) D.24178;
        __result = D.24176 - D.24179;
        <D.24173>:
        <D.24163>:
        <D.24153>:
      }
      D.22967 = __result;
    }
    iftmp.19 = D.22967;
    goto <D.24180>;
    <D.24143>:
    D.24139 = cmethod->name;
    iftmp.19 = __builtin_strcmp ("GetVectorAligned", D.24139);
    <D.24180>:
    D.22971 = iftmp.19;
  }
  if (D.22971 == 0) goto <D.24097>; else goto <D.24098>;
  <D.24097>:
  {
    struct MonoInst * load;
    int addr;

    D.24181 = args + 8;
    D.24182 = *D.24181;
    D.24183 = *args;
    D.24184 = fsig->params[0];
    addr = mono_emit_vector_ldelema (cfg, D.24184, D.24183, D.24182, 1);
    D.24185 = cfg->mempool;
    load = mono_mempool_alloc (D.24185, 80);
    load->data.op[1].const_val = 0;
    D.24186 = load->data.op[1].const_val;
    load->data.op[0].const_val = D.24186;
    load->prev = 0B;
    D.24187 = load->prev;
    load->next = D.24187;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 16;
      if (__s1_len <= 3) goto <D.24190>; else goto <D.24191>;
      <D.24190>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = cmethod->name;
        D.24144 = "GetVectorAligned";
        D.24145 = MEM[(const unsigned char *)D.24144];
        D.24146 = (int) D.24145;
        D.24192 = *__s2;
        D.24193 = (int) D.24192;
        __result = D.24146 - D.24193;
        {
          D.24194 = __s1_len != 0;
          D.24195 = __result == 0;
          D.24196 = D.24194 & D.24195;
          if (D.24196 != 0) goto <D.24197>; else goto <D.24198>;
          <D.24197>:
          D.24154 = &MEM[(void *)"GetVectorAligned" + 1B];
          D.24155 = *D.24154;
          D.24156 = (int) D.24155;
          D.24199 = __s2 + 1;
          D.24200 = *D.24199;
          D.24201 = (int) D.24200;
          __result = D.24156 - D.24201;
          D.24202 = __s1_len > 1;
          D.24195 = __result == 0;
          D.24203 = D.24202 & D.24195;
          if (D.24203 != 0) goto <D.24204>; else goto <D.24205>;
          <D.24204>:
          D.24164 = &MEM[(void *)"GetVectorAligned" + 2B];
          D.24165 = *D.24164;
          D.24166 = (int) D.24165;
          D.24206 = __s2 + 2;
          D.24207 = *D.24206;
          D.24208 = (int) D.24207;
          __result = D.24166 - D.24208;
          D.24209 = __s1_len > 2;
          D.24195 = __result == 0;
          D.24210 = D.24209 & D.24195;
          if (D.24210 != 0) goto <D.24211>; else goto <D.24212>;
          <D.24211>:
          D.24174 = &MEM[(void *)"GetVectorAligned" + 3B];
          D.24175 = *D.24174;
          D.24176 = (int) D.24175;
          D.24213 = __s2 + 3;
          D.24214 = *D.24213;
          D.24215 = (int) D.24214;
          __result = D.24176 - D.24215;
          <D.24212>:
          <D.24205>:
          <D.24198>:
        }
        D.22978 = __result;
      }
      iftmp.21 = D.22978;
      goto <D.24216>;
      <D.24191>:
      D.24139 = cmethod->name;
      iftmp.21 = __builtin_strcmp ("GetVectorAligned", D.24139);
      <D.24216>:
      D.22982 = iftmp.21;
    }
    if (D.22982 == 0) goto <D.24217>; else goto <D.24218>;
    <D.24217>:
    iftmp.20 = 402;
    goto <D.24219>;
    <D.24218>:
    iftmp.20 = 401;
    <D.24219>:
    load->opcode = iftmp.20;
    load->flags = 0;
    load->type = 0;
    load->dreg = -1;
    load->sreg3 = -1;
    D.24220 = load->sreg3;
    load->sreg2 = D.24220;
    D.24221 = load->sreg2;
    load->sreg1 = D.24221;
    D.24222 = cfg->ip;
    load->cil_code = D.24222;
    D.24223 = cmethod->klass;
    load->klass = D.24223;
    load->sreg1 = addr;
    load->type = 7;
    D.24224 = alloc_ireg (cfg);
    D.24225 = (int) D.24224;
    load->dreg = D.24225;
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    if (D.24227 != 0B) goto <D.24228>; else goto <D.24229>;
    <D.24228>:
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    D.24227->next = load;
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    load->prev = D.24227;
    D.24226 = cfg->cbb;
    D.24226->last_ins = load;
    goto <D.24230>;
    <D.24229>:
    D.24226 = cfg->cbb;
    D.24226 = cfg->cbb;
    D.24226->last_ins = load;
    D.24227 = D.24226->last_ins;
    D.24226->code = D.24227;
    <D.24230>:
    D.24231 = load;
    return D.24231;
  }
  <D.24098>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.24235>; else goto <D.24236>;
    <D.24235>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.24237 = "SetVector";
      D.24238 = MEM[(const unsigned char *)D.24237];
      D.24239 = (int) D.24238;
      D.24240 = *__s2;
      D.24241 = (int) D.24240;
      __result = D.24239 - D.24241;
      {
        D.24242 = __s1_len != 0;
        D.24243 = __result == 0;
        D.24244 = D.24242 & D.24243;
        if (D.24244 != 0) goto <D.24245>; else goto <D.24246>;
        <D.24245>:
        D.24247 = &MEM[(void *)"SetVector" + 1B];
        D.24248 = *D.24247;
        D.24249 = (int) D.24248;
        D.24250 = __s2 + 1;
        D.24251 = *D.24250;
        D.24252 = (int) D.24251;
        __result = D.24249 - D.24252;
        D.24253 = __s1_len > 1;
        D.24243 = __result == 0;
        D.24254 = D.24253 & D.24243;
        if (D.24254 != 0) goto <D.24255>; else goto <D.24256>;
        <D.24255>:
        D.24257 = &MEM[(void *)"SetVector" + 2B];
        D.24258 = *D.24257;
        D.24259 = (int) D.24258;
        D.24260 = __s2 + 2;
        D.24261 = *D.24260;
        D.24262 = (int) D.24261;
        __result = D.24259 - D.24262;
        D.24263 = __s1_len > 2;
        D.24243 = __result == 0;
        D.24264 = D.24263 & D.24243;
        if (D.24264 != 0) goto <D.24265>; else goto <D.24266>;
        <D.24265>:
        D.24267 = &MEM[(void *)"SetVector" + 3B];
        D.24268 = *D.24267;
        D.24269 = (int) D.24268;
        D.24270 = __s2 + 3;
        D.24271 = *D.24270;
        D.24272 = (int) D.24271;
        __result = D.24269 - D.24272;
        <D.24266>:
        <D.24256>:
        <D.24246>:
      }
      D.22987 = __result;
    }
    iftmp.22 = D.22987;
    goto <D.24273>;
    <D.24236>:
    D.24139 = cmethod->name;
    iftmp.22 = __builtin_strcmp ("SetVector", D.24139);
    <D.24273>:
    D.22991 = iftmp.22;
  }
  if (D.22991 == 0) goto <D.24232>; else goto <D.24274>;
  <D.24274>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 16;
    if (__s1_len <= 3) goto <D.24276>; else goto <D.24277>;
    <D.24276>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.24278 = "SetVectorAligned";
      D.24279 = MEM[(const unsigned char *)D.24278];
      D.24280 = (int) D.24279;
      D.24281 = *__s2;
      D.24282 = (int) D.24281;
      __result = D.24280 - D.24282;
      {
        D.24283 = __s1_len != 0;
        D.24284 = __result == 0;
        D.24285 = D.24283 & D.24284;
        if (D.24285 != 0) goto <D.24286>; else goto <D.24287>;
        <D.24286>:
        D.24288 = &MEM[(void *)"SetVectorAligned" + 1B];
        D.24289 = *D.24288;
        D.24290 = (int) D.24289;
        D.24291 = __s2 + 1;
        D.24292 = *D.24291;
        D.24293 = (int) D.24292;
        __result = D.24290 - D.24293;
        D.24294 = __s1_len > 1;
        D.24284 = __result == 0;
        D.24295 = D.24294 & D.24284;
        if (D.24295 != 0) goto <D.24296>; else goto <D.24297>;
        <D.24296>:
        D.24298 = &MEM[(void *)"SetVectorAligned" + 2B];
        D.24299 = *D.24298;
        D.24300 = (int) D.24299;
        D.24301 = __s2 + 2;
        D.24302 = *D.24301;
        D.24303 = (int) D.24302;
        __result = D.24300 - D.24303;
        D.24304 = __s1_len > 2;
        D.24284 = __result == 0;
        D.24305 = D.24304 & D.24284;
        if (D.24305 != 0) goto <D.24306>; else goto <D.24307>;
        <D.24306>:
        D.24308 = &MEM[(void *)"SetVectorAligned" + 3B];
        D.24309 = *D.24308;
        D.24310 = (int) D.24309;
        D.24311 = __s2 + 3;
        D.24312 = *D.24311;
        D.24313 = (int) D.24312;
        __result = D.24310 - D.24313;
        <D.24307>:
        <D.24297>:
        <D.24287>:
      }
      D.22996 = __result;
    }
    iftmp.23 = D.22996;
    goto <D.24314>;
    <D.24277>:
    D.24139 = cmethod->name;
    iftmp.23 = __builtin_strcmp ("SetVectorAligned", D.24139);
    <D.24314>:
    D.23000 = iftmp.23;
  }
  if (D.23000 == 0) goto <D.24232>; else goto <D.24233>;
  <D.24232>:
  {
    struct MonoInst * store;
    int vreg;
    int addr;

    D.24181 = args + 8;
    D.24182 = *D.24181;
    vreg = get_simd_vreg (cfg, cmethod, D.24182);
    D.24315 = args + 16;
    D.24316 = *D.24315;
    D.24183 = *args;
    D.24184 = fsig->params[0];
    addr = mono_emit_vector_ldelema (cfg, D.24184, D.24183, D.24316, 1);
    D.24185 = cfg->mempool;
    store = mono_mempool_alloc (D.24185, 80);
    store->data.op[1].const_val = 0;
    D.24317 = store->data.op[1].const_val;
    store->data.op[0].const_val = D.24317;
    store->prev = 0B;
    D.24318 = store->prev;
    store->next = D.24318;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 16;
      if (__s1_len <= 3) goto <D.24321>; else goto <D.24322>;
      <D.24321>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = cmethod->name;
        D.24278 = "SetVectorAligned";
        D.24279 = MEM[(const unsigned char *)D.24278];
        D.24280 = (int) D.24279;
        D.24323 = *__s2;
        D.24324 = (int) D.24323;
        __result = D.24280 - D.24324;
        {
          D.24325 = __s1_len != 0;
          D.24326 = __result == 0;
          D.24327 = D.24325 & D.24326;
          if (D.24327 != 0) goto <D.24328>; else goto <D.24329>;
          <D.24328>:
          D.24288 = &MEM[(void *)"SetVectorAligned" + 1B];
          D.24289 = *D.24288;
          D.24290 = (int) D.24289;
          D.24330 = __s2 + 1;
          D.24331 = *D.24330;
          D.24332 = (int) D.24331;
          __result = D.24290 - D.24332;
          D.24333 = __s1_len > 1;
          D.24326 = __result == 0;
          D.24334 = D.24333 & D.24326;
          if (D.24334 != 0) goto <D.24335>; else goto <D.24336>;
          <D.24335>:
          D.24298 = &MEM[(void *)"SetVectorAligned" + 2B];
          D.24299 = *D.24298;
          D.24300 = (int) D.24299;
          D.24337 = __s2 + 2;
          D.24338 = *D.24337;
          D.24339 = (int) D.24338;
          __result = D.24300 - D.24339;
          D.24340 = __s1_len > 2;
          D.24326 = __result == 0;
          D.24341 = D.24340 & D.24326;
          if (D.24341 != 0) goto <D.24342>; else goto <D.24343>;
          <D.24342>:
          D.24308 = &MEM[(void *)"SetVectorAligned" + 3B];
          D.24309 = *D.24308;
          D.24310 = (int) D.24309;
          D.24344 = __s2 + 3;
          D.24345 = *D.24344;
          D.24346 = (int) D.24345;
          __result = D.24310 - D.24346;
          <D.24343>:
          <D.24336>:
          <D.24329>:
        }
        D.23008 = __result;
      }
      iftmp.25 = D.23008;
      goto <D.24347>;
      <D.24322>:
      D.24139 = cmethod->name;
      iftmp.25 = __builtin_strcmp ("SetVectorAligned", D.24139);
      <D.24347>:
      D.23012 = iftmp.25;
    }
    if (D.23012 == 0) goto <D.24348>; else goto <D.24349>;
    <D.24348>:
    iftmp.24 = 382;
    goto <D.24350>;
    <D.24349>:
    iftmp.24 = 389;
    <D.24350>:
    store->opcode = iftmp.24;
    store->flags = 0;
    store->type = 0;
    store->dreg = -1;
    store->sreg3 = -1;
    D.24351 = store->sreg3;
    store->sreg2 = D.24351;
    D.24352 = store->sreg2;
    store->sreg1 = D.24352;
    D.24222 = cfg->ip;
    store->cil_code = D.24222;
    D.24223 = cmethod->klass;
    store->klass = D.24223;
    store->dreg = addr;
    store->sreg1 = vreg;
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    if (D.24227 != 0B) goto <D.24353>; else goto <D.24354>;
    <D.24353>:
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    D.24227->next = store;
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    store->prev = D.24227;
    D.24226 = cfg->cbb;
    D.24226->last_ins = store;
    goto <D.24355>;
    <D.24354>:
    D.24226 = cfg->cbb;
    D.24226 = cfg->cbb;
    D.24226->last_ins = store;
    D.24227 = D.24226->last_ins;
    D.24226->code = D.24227;
    <D.24355>:
    D.24231 = store;
    return D.24231;
  }
  <D.24233>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.24357>; else goto <D.24358>;
    <D.24357>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cmethod->name;
      D.24359 = "IsAligned";
      D.24360 = MEM[(const unsigned char *)D.24359];
      D.24361 = (int) D.24360;
      D.24362 = *__s2;
      D.24363 = (int) D.24362;
      __result = D.24361 - D.24363;
      {
        D.24364 = __s1_len != 0;
        D.24365 = __result == 0;
        D.24366 = D.24364 & D.24365;
        if (D.24366 != 0) goto <D.24367>; else goto <D.24368>;
        <D.24367>:
        D.24369 = &MEM[(void *)"IsAligned" + 1B];
        D.24370 = *D.24369;
        D.24371 = (int) D.24370;
        D.24372 = __s2 + 1;
        D.24373 = *D.24372;
        D.24374 = (int) D.24373;
        __result = D.24371 - D.24374;
        D.24375 = __s1_len > 1;
        D.24365 = __result == 0;
        D.24376 = D.24375 & D.24365;
        if (D.24376 != 0) goto <D.24377>; else goto <D.24378>;
        <D.24377>:
        D.24379 = &MEM[(void *)"IsAligned" + 2B];
        D.24380 = *D.24379;
        D.24381 = (int) D.24380;
        D.24382 = __s2 + 2;
        D.24383 = *D.24382;
        D.24384 = (int) D.24383;
        __result = D.24381 - D.24384;
        D.24385 = __s1_len > 2;
        D.24365 = __result == 0;
        D.24386 = D.24385 & D.24365;
        if (D.24386 != 0) goto <D.24387>; else goto <D.24388>;
        <D.24387>:
        D.24389 = &MEM[(void *)"IsAligned" + 3B];
        D.24390 = *D.24389;
        D.24391 = (int) D.24390;
        D.24392 = __s2 + 3;
        D.24393 = *D.24392;
        D.24394 = (int) D.24393;
        __result = D.24391 - D.24394;
        <D.24388>:
        <D.24378>:
        <D.24368>:
      }
      D.23017 = __result;
    }
    iftmp.26 = D.23017;
    goto <D.24395>;
    <D.24358>:
    D.24139 = cmethod->name;
    iftmp.26 = __builtin_strcmp ("IsAligned", D.24139);
    <D.24395>:
    D.23021 = iftmp.26;
  }
  if (D.23021 == 0) goto <D.24396>; else goto <D.24397>;
  <D.24396>:
  {
    struct MonoInst * ins;
    int addr;

    D.24181 = args + 8;
    D.24182 = *D.24181;
    D.24183 = *args;
    D.24184 = fsig->params[0];
    addr = mono_emit_vector_ldelema (cfg, D.24184, D.24183, D.24182, 0);
    {
      struct MonoInst * inst;

      D.24185 = cfg->mempool;
      inst = mono_mempool_alloc (D.24185, 80);
      inst->data.op[1].const_val = 0;
      D.24398 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24398;
      inst->prev = 0B;
      D.24399 = inst->prev;
      inst->next = D.24399;
      inst->opcode = 440;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24400 = inst->sreg3;
      inst->sreg2 = D.24400;
      D.24401 = inst->sreg2;
      inst->sreg1 = D.24401;
      D.24222 = cfg->ip;
      inst->cil_code = D.24222;
      inst->dreg = addr;
      inst->sreg1 = addr;
      inst->data.op[1].const_val = 15;
      D.24226 = cfg->cbb;
      D.24227 = D.24226->last_ins;
      if (D.24227 != 0B) goto <D.24402>; else goto <D.24403>;
      <D.24402>:
      D.24226 = cfg->cbb;
      D.24227 = D.24226->last_ins;
      D.24227->next = inst;
      D.24226 = cfg->cbb;
      D.24227 = D.24226->last_ins;
      inst->prev = D.24227;
      D.24226 = cfg->cbb;
      D.24226->last_ins = inst;
      goto <D.24404>;
      <D.24403>:
      D.24226 = cfg->cbb;
      D.24226 = cfg->cbb;
      D.24226->last_ins = inst;
      D.24227 = D.24226->last_ins;
      D.24226->code = D.24227;
      <D.24404>:
    }
    {
      struct MonoInst * inst;

      D.24185 = cfg->mempool;
      inst = mono_mempool_alloc (D.24185, 80);
      inst->data.op[1].const_val = 0;
      D.24405 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24405;
      inst->prev = 0B;
      D.24406 = inst->prev;
      inst->next = D.24406;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24407 = inst->sreg3;
      inst->sreg2 = D.24407;
      D.24408 = inst->sreg2;
      inst->sreg1 = D.24408;
      D.24222 = cfg->ip;
      inst->cil_code = D.24222;
      inst->dreg = -1;
      inst->sreg1 = addr;
      inst->data.op[1].const_val = 0;
      D.24226 = cfg->cbb;
      D.24227 = D.24226->last_ins;
      if (D.24227 != 0B) goto <D.24409>; else goto <D.24410>;
      <D.24409>:
      D.24226 = cfg->cbb;
      D.24227 = D.24226->last_ins;
      D.24227->next = inst;
      D.24226 = cfg->cbb;
      D.24227 = D.24226->last_ins;
      inst->prev = D.24227;
      D.24226 = cfg->cbb;
      D.24226->last_ins = inst;
      goto <D.24411>;
      <D.24410>:
      D.24226 = cfg->cbb;
      D.24226 = cfg->cbb;
      D.24226->last_ins = inst;
      D.24227 = D.24226->last_ins;
      D.24226->code = D.24227;
      <D.24411>:
    }
    D.24185 = cfg->mempool;
    ins = mono_mempool_alloc (D.24185, 80);
    ins->data.op[1].const_val = 0;
    D.24412 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24412;
    ins->prev = 0B;
    D.24413 = ins->prev;
    ins->next = D.24413;
    ins->opcode = 450;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24414 = ins->sreg3;
    ins->sreg2 = D.24414;
    D.24415 = ins->sreg2;
    ins->sreg1 = D.24415;
    D.24222 = cfg->ip;
    ins->cil_code = D.24222;
    ins->dreg = addr;
    ins->sreg1 = -1;
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    if (D.24227 != 0B) goto <D.24416>; else goto <D.24417>;
    <D.24416>:
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    D.24227->next = ins;
    D.24226 = cfg->cbb;
    D.24227 = D.24226->last_ins;
    ins->prev = D.24227;
    D.24226 = cfg->cbb;
    D.24226->last_ins = ins;
    goto <D.24418>;
    <D.24417>:
    D.24226 = cfg->cbb;
    D.24226 = cfg->cbb;
    D.24226->last_ins = ins;
    D.24227 = D.24226->last_ins;
    D.24226->code = D.24227;
    <D.24418>:
    D.24231 = ins;
    return D.24231;
  }
  <D.24397>:
  D.24231 = 0B;
  return D.24231;
}


get_simd_vreg (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * src)
{
  short unsigned int D.24420;
  int D.24423;
  unsigned char D.24424;

  D.24420 = src->opcode;
  if (D.24420 == 962) goto <D.24421>; else goto <D.24422>;
  <D.24421>:
  D.24423 = src->sreg1;
  return D.24423;
  <D.24422>:
  D.24424 = src->type;
  if (D.24424 == 7) goto <D.24425>; else goto <D.24426>;
  <D.24425>:
  D.24423 = src->dreg;
  return D.24423;
  <D.24426>:
  monoeg_g_log (0B, 16, "get_simd_vreg:: could not infer source simd vreg for op");
  mono_print_ins (src);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 814);
}


mono_emit_vector_ldelema (struct MonoCompile * cfg, struct MonoType * array_type, struct MonoInst * arr, struct MonoInst * index, gboolean check_bounds)
{
  struct MonoClass * D.24428;
  int D.24429;
  unsigned int D.24430;
  unsigned int D.24431;
  struct MonoMemPool * D.24432;
  long int D.24433;
  struct MonoInst * D.24434;
  int D.24435;
  int D.24436;
  const unsigned char * D.24437;
  struct MonoBasicBlock * D.24438;
  struct MonoInst * D.24439;
  unsigned int D.24443;
  unsigned int D.24446;
  unsigned int D.24447;
  unsigned int D.24450;
  unsigned char D.24453;
  unsigned char D.24454;
  long int D.24457;
  struct MonoInst * D.24458;
  int D.24459;
  int D.24460;
  long int D.24464;
  struct MonoInst * D.24465;
  int D.24466;
  int D.24467;
  unsigned int D.24474;
  int D.24477;
  long int D.24482;
  struct MonoInst * D.24483;
  int D.24484;
  int D.24485;
  long int D.24489;
  struct MonoInst * D.24490;
  int D.24491;
  int D.24492;
  long int D.24497;
  struct MonoInst * D.24498;
  int D.24499;
  int D.24500;
  unsigned char D.24501;
  int D.24506;
  long int D.24511;
  struct MonoInst * D.24512;
  int D.24513;
  int D.24514;
  long int D.24518;
  struct MonoInst * D.24519;
  int D.24520;
  int D.24521;
  long int D.24526;
  struct MonoInst * D.24527;
  int D.24528;
  int D.24529;
  unsigned char D.24530;
  long int D.24534;
  struct MonoInst * D.24535;
  int D.24536;
  int D.24537;
  long int D.24541;
  struct MonoInst * D.24542;
  int D.24543;
  int D.24544;
  long int D.24549;
  struct MonoInst * D.24550;
  int D.24551;
  int D.24552;
  long int D.24556;
  struct MonoInst * D.24557;
  int D.24558;
  int D.24559;
  long int D.24564;
  struct MonoInst * D.24565;
  int D.24566;
  int D.24567;
  unsigned char D.24568;
  unsigned char D.24569;
  unsigned int D.24573;
  unsigned int D.24574;
  long int D.24575;
  struct MonoInst * D.24576;
  int D.24577;
  int D.24578;
  unsigned int D.24579;
  unsigned int D.24580;
  long int D.24581;
  long int D.24591;
  struct MonoInst * D.24592;
  int D.24593;
  int D.24594;
  long int D.24598;
  struct MonoInst * D.24599;
  int D.24600;
  int D.24601;
  unsigned int D.24608;
  int D.24611;
  long int D.24616;
  struct MonoInst * D.24617;
  int D.24618;
  int D.24619;
  long int D.24623;
  struct MonoInst * D.24624;
  int D.24625;
  int D.24626;
  long int D.24631;
  struct MonoInst * D.24632;
  int D.24633;
  int D.24634;
  unsigned char D.24635;
  int D.24640;
  long int D.24645;
  struct MonoInst * D.24646;
  int D.24647;
  int D.24648;
  long int D.24652;
  struct MonoInst * D.24653;
  int D.24654;
  int D.24655;
  long int D.24660;
  struct MonoInst * D.24661;
  int D.24662;
  int D.24663;
  unsigned char D.24664;
  long int D.24668;
  struct MonoInst * D.24669;
  int D.24670;
  int D.24671;
  long int D.24675;
  struct MonoInst * D.24676;
  int D.24677;
  int D.24678;
  long int D.24683;
  struct MonoInst * D.24684;
  int D.24685;
  int D.24686;
  long int D.24690;
  struct MonoInst * D.24691;
  int D.24692;
  int D.24693;
  long int D.24698;
  struct MonoInst * D.24699;
  int D.24700;
  int D.24701;
  unsigned char D.24702;
  unsigned char D.24703;
  unsigned int D.24707;
  long int D.24708;
  struct MonoInst * D.24709;
  int D.24710;
  int D.24711;
  long int D.24712;
  long int D.24716;
  struct MonoInst * D.24717;
  int D.24718;
  int D.24719;
  long int D.24723;
  struct MonoInst * D.24724;
  int D.24725;
  int D.24726;
  int D.24730;
  struct MonoInst * ins;
  guint32 size;
  int mult_reg;
  int add_reg;
  int array_reg;
  int index_reg;
  int index2_reg;
  int index3_reg;

  D.24428 = mono_class_from_mono_type (array_type);
  D.24429 = mono_array_element_size (D.24428);
  size = (guint32) D.24429;
  D.24430 = alloc_preg (cfg);
  mult_reg = (int) D.24430;
  array_reg = arr->dreg;
  index_reg = index->dreg;
  D.24431 = alloc_preg (cfg);
  index2_reg = (int) D.24431;
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24433 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24433;
    inst->prev = 0B;
    D.24434 = inst->prev;
    inst->next = D.24434;
    inst->opcode = 766;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24435 = inst->sreg3;
    inst->sreg2 = D.24435;
    D.24436 = inst->sreg2;
    inst->sreg1 = D.24436;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->dreg = index2_reg;
    inst->sreg1 = index_reg;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24440>; else goto <D.24441>;
    <D.24440>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24442>;
    <D.24441>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24442>:
  }
  D.24443 = alloc_preg (cfg);
  index3_reg = (int) D.24443;
  if (check_bounds != 0) goto <D.24444>; else goto <D.24445>;
  <D.24444>:
  D.24446 = cfg->opt;
  D.24447 = D.24446 & 134217728;
  if (D.24447 == 0) goto <D.24448>; else goto <D.24449>;
  <D.24448>:
  D.24446 = cfg->opt;
  D.24450 = D.24446 & 262144;
  if (D.24450 == 0) goto <D.24451>; else goto <D.24452>;
  <D.24451>:
  D.24453 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.24454 = D.24453 & 64;
  if (D.24454 != 0) goto <D.24455>; else goto <D.24456>;
  <D.24455>:
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24457 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24457;
    inst->prev = 0B;
    D.24458 = inst->prev;
    inst->next = D.24458;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24459 = inst->sreg3;
    inst->sreg2 = D.24459;
    D.24460 = inst->sreg2;
    inst->sreg1 = D.24460;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->dreg = -1;
    inst->sreg1 = array_reg;
    inst->data.op[1].const_val = 0;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24461>; else goto <D.24462>;
    <D.24461>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24463>;
    <D.24462>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24463>:
  }
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24464 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24464;
    inst->prev = 0B;
    D.24465 = inst->prev;
    inst->next = D.24465;
    inst->opcode = 455;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24466 = inst->sreg3;
    inst->sreg2 = D.24466;
    D.24467 = inst->sreg2;
    inst->sreg1 = D.24467;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->data.op[1].p = "NullReferenceException";
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24468>; else goto <D.24469>;
    <D.24468>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24470>;
    <D.24469>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24470>:
  }
  goto <D.24471>;
  <D.24456>:
  <D.24471>:
  if (0 != 0) goto <D.24472>; else goto <D.24473>;
  <D.24472>:
  {
    int _length_reg;

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

      __ins_flags = 32;
      D.24477 = __ins_flags & 32;
      if (D.24477 != 0) goto <D.24478>; else goto <D.24479>;
      <D.24478>:
      D.24453 = BIT_FIELD_REF <*cfg, 8, 5632>;
      D.24454 = D.24453 & 64;
      if (D.24454 != 0) goto <D.24480>; else goto <D.24481>;
      <D.24480>:
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24482 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24482;
        inst->prev = 0B;
        D.24483 = inst->prev;
        inst->next = D.24483;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24484 = inst->sreg3;
        inst->sreg2 = D.24484;
        D.24485 = inst->sreg2;
        inst->sreg1 = D.24485;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24486>; else goto <D.24487>;
        <D.24486>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24488>;
        <D.24487>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24488>:
      }
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24489 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24489;
        inst->prev = 0B;
        D.24490 = inst->prev;
        inst->next = D.24490;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24491 = inst->sreg3;
        inst->sreg2 = D.24491;
        D.24492 = inst->sreg2;
        inst->sreg1 = D.24492;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->data.op[1].p = "NullReferenceException";
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24493>; else goto <D.24494>;
        <D.24493>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24495>;
        <D.24494>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24495>:
      }
      goto <D.24496>;
      <D.24481>:
      <D.24496>:
      <D.24479>:
      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24497 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24497;
      inst->prev = 0B;
      D.24498 = inst->prev;
      inst->next = D.24498;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24499 = inst->sreg3;
      inst->sreg2 = D.24499;
      D.24500 = inst->sreg2;
      inst->sreg1 = D.24500;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.24501 = (unsigned char) __ins_flags;
      inst->flags = D.24501;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24502>; else goto <D.24503>;
      <D.24502>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24504>;
      <D.24503>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24504>:
    }
    goto <D.24505>;
    <D.24476>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.24506 = __ins_flags & 32;
      if (D.24506 != 0) goto <D.24507>; else goto <D.24508>;
      <D.24507>:
      D.24453 = BIT_FIELD_REF <*cfg, 8, 5632>;
      D.24454 = D.24453 & 64;
      if (D.24454 != 0) goto <D.24509>; else goto <D.24510>;
      <D.24509>:
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24511 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24511;
        inst->prev = 0B;
        D.24512 = inst->prev;
        inst->next = D.24512;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24513 = inst->sreg3;
        inst->sreg2 = D.24513;
        D.24514 = inst->sreg2;
        inst->sreg1 = D.24514;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24515>; else goto <D.24516>;
        <D.24515>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24517>;
        <D.24516>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24517>:
      }
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24518 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24518;
        inst->prev = 0B;
        D.24519 = inst->prev;
        inst->next = D.24519;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24520 = inst->sreg3;
        inst->sreg2 = D.24520;
        D.24521 = inst->sreg2;
        inst->sreg1 = D.24521;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->data.op[1].p = "NullReferenceException";
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24522>; else goto <D.24523>;
        <D.24522>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24524>;
        <D.24523>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24524>:
      }
      goto <D.24525>;
      <D.24510>:
      <D.24525>:
      <D.24508>:
      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24526 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24526;
      inst->prev = 0B;
      D.24527 = inst->prev;
      inst->next = D.24527;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24528 = inst->sreg3;
      inst->sreg2 = D.24528;
      D.24529 = inst->sreg2;
      inst->sreg1 = D.24529;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.24530 = (unsigned char) __ins_flags;
      inst->flags = D.24530;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24531>; else goto <D.24532>;
      <D.24531>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24533>;
      <D.24532>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24533>:
    }
    <D.24505>:
    {
      struct MonoInst * inst;

      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24534 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24534;
      inst->prev = 0B;
      D.24535 = inst->prev;
      inst->next = D.24535;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24536 = inst->sreg3;
      inst->sreg2 = D.24536;
      D.24537 = inst->sreg2;
      inst->sreg1 = D.24537;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index2_reg;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24538>; else goto <D.24539>;
      <D.24538>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24540>;
      <D.24539>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24540>:
    }
    {
      struct MonoInst * inst;

      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24541 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24541;
      inst->prev = 0B;
      D.24542 = inst->prev;
      inst->next = D.24542;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24543 = inst->sreg3;
      inst->sreg2 = D.24543;
      D.24544 = inst->sreg2;
      inst->sreg1 = D.24544;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24545>; else goto <D.24546>;
      <D.24545>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24547>;
      <D.24546>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24547>:
    }
  }
  goto <D.24548>;
  <D.24473>:
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24549 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24549;
    inst->prev = 0B;
    D.24550 = inst->prev;
    inst->next = D.24550;
    inst->opcode = 1049;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24551 = inst->sreg3;
    inst->sreg2 = D.24551;
    D.24552 = inst->sreg2;
    inst->sreg1 = D.24552;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->sreg1 = array_reg;
    inst->data.op[0].const_val = 24;
    inst->sreg2 = index2_reg;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24553>; else goto <D.24554>;
    <D.24553>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24555>;
    <D.24554>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24555>:
    {
      struct MonoInst * inst;

      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24556 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24556;
      inst->prev = 0B;
      D.24557 = inst->prev;
      inst->next = D.24557;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24558 = inst->sreg3;
      inst->sreg2 = D.24558;
      D.24559 = inst->sreg2;
      inst->sreg1 = D.24559;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24560>; else goto <D.24561>;
      <D.24560>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24562>;
      <D.24561>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24562>:
    }
  }
  <D.24548>:
  goto <D.24563>;
  <D.24452>:
  {
    struct MonoInst * ins;

    D.24432 = cfg->mempool;
    ins = mono_mempool_alloc (D.24432, 80);
    ins->data.op[1].const_val = 0;
    D.24564 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24564;
    ins->prev = 0B;
    D.24565 = ins->prev;
    ins->next = D.24565;
    ins->opcode = 788;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24566 = ins->sreg3;
    ins->sreg2 = D.24566;
    D.24567 = ins->sreg2;
    ins->sreg1 = D.24567;
    D.24437 = cfg->ip;
    ins->cil_code = D.24437;
    ins->sreg1 = array_reg;
    ins->sreg2 = index2_reg;
    ins->data.op[1].const_val = 24;
    D.24568 = ins->flags;
    D.24569 = D.24568 | 32;
    ins->flags = D.24569;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24570>; else goto <D.24571>;
    <D.24570>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = ins;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    ins->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = ins;
    goto <D.24572>;
    <D.24571>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = ins;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24572>:
    D.24573 = cfg->flags;
    D.24574 = D.24573 | 256;
    cfg->flags = D.24574;
    D.24438 = cfg->cbb;
    D.24438->has_array_access = 1;
  }
  <D.24563>:
  <D.24449>:
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24575 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24575;
    inst->prev = 0B;
    D.24576 = inst->prev;
    inst->next = D.24576;
    inst->opcode = 542;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24577 = inst->sreg3;
    inst->sreg2 = D.24577;
    D.24578 = inst->sreg2;
    inst->sreg1 = D.24578;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->dreg = index3_reg;
    inst->sreg1 = index2_reg;
    D.24579 = 16 / size;
    D.24580 = D.24579 + 4294967295;
    D.24581 = (long int) D.24580;
    inst->data.op[1].const_val = D.24581;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24582>; else goto <D.24583>;
    <D.24582>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24584>;
    <D.24583>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24584>:
  }
  D.24446 = cfg->opt;
  D.24447 = D.24446 & 134217728;
  if (D.24447 == 0) goto <D.24585>; else goto <D.24586>;
  <D.24585>:
  D.24446 = cfg->opt;
  D.24450 = D.24446 & 262144;
  if (D.24450 == 0) goto <D.24587>; else goto <D.24588>;
  <D.24587>:
  D.24453 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.24454 = D.24453 & 64;
  if (D.24454 != 0) goto <D.24589>; else goto <D.24590>;
  <D.24589>:
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24591 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24591;
    inst->prev = 0B;
    D.24592 = inst->prev;
    inst->next = D.24592;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24593 = inst->sreg3;
    inst->sreg2 = D.24593;
    D.24594 = inst->sreg2;
    inst->sreg1 = D.24594;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->dreg = -1;
    inst->sreg1 = array_reg;
    inst->data.op[1].const_val = 0;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24595>; else goto <D.24596>;
    <D.24595>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24597>;
    <D.24596>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24597>:
  }
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24598 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24598;
    inst->prev = 0B;
    D.24599 = inst->prev;
    inst->next = D.24599;
    inst->opcode = 455;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24600 = inst->sreg3;
    inst->sreg2 = D.24600;
    D.24601 = inst->sreg2;
    inst->sreg1 = D.24601;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->data.op[1].p = "NullReferenceException";
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24602>; else goto <D.24603>;
    <D.24602>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24604>;
    <D.24603>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24604>:
  }
  goto <D.24605>;
  <D.24590>:
  <D.24605>:
  if (0 != 0) goto <D.24606>; else goto <D.24607>;
  <D.24606>:
  {
    int _length_reg;

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

      __ins_flags = 32;
      D.24611 = __ins_flags & 32;
      if (D.24611 != 0) goto <D.24612>; else goto <D.24613>;
      <D.24612>:
      D.24453 = BIT_FIELD_REF <*cfg, 8, 5632>;
      D.24454 = D.24453 & 64;
      if (D.24454 != 0) goto <D.24614>; else goto <D.24615>;
      <D.24614>:
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24616 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24616;
        inst->prev = 0B;
        D.24617 = inst->prev;
        inst->next = D.24617;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24618 = inst->sreg3;
        inst->sreg2 = D.24618;
        D.24619 = inst->sreg2;
        inst->sreg1 = D.24619;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24620>; else goto <D.24621>;
        <D.24620>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24622>;
        <D.24621>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24622>:
      }
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24623 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24623;
        inst->prev = 0B;
        D.24624 = inst->prev;
        inst->next = D.24624;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24625 = inst->sreg3;
        inst->sreg2 = D.24625;
        D.24626 = inst->sreg2;
        inst->sreg1 = D.24626;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->data.op[1].p = "NullReferenceException";
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24627>; else goto <D.24628>;
        <D.24627>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24629>;
        <D.24628>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24629>:
      }
      goto <D.24630>;
      <D.24615>:
      <D.24630>:
      <D.24613>:
      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24631 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24631;
      inst->prev = 0B;
      D.24632 = inst->prev;
      inst->next = D.24632;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24633 = inst->sreg3;
      inst->sreg2 = D.24633;
      D.24634 = inst->sreg2;
      inst->sreg1 = D.24634;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.24635 = (unsigned char) __ins_flags;
      inst->flags = D.24635;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24636>; else goto <D.24637>;
      <D.24636>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24638>;
      <D.24637>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24638>:
    }
    goto <D.24639>;
    <D.24610>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.24640 = __ins_flags & 32;
      if (D.24640 != 0) goto <D.24641>; else goto <D.24642>;
      <D.24641>:
      D.24453 = BIT_FIELD_REF <*cfg, 8, 5632>;
      D.24454 = D.24453 & 64;
      if (D.24454 != 0) goto <D.24643>; else goto <D.24644>;
      <D.24643>:
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24645 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24645;
        inst->prev = 0B;
        D.24646 = inst->prev;
        inst->next = D.24646;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24647 = inst->sreg3;
        inst->sreg2 = D.24647;
        D.24648 = inst->sreg2;
        inst->sreg1 = D.24648;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24649>; else goto <D.24650>;
        <D.24649>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24651>;
        <D.24650>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24651>:
      }
      {
        struct MonoInst * inst;

        D.24432 = cfg->mempool;
        inst = mono_mempool_alloc (D.24432, 80);
        inst->data.op[1].const_val = 0;
        D.24652 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24652;
        inst->prev = 0B;
        D.24653 = inst->prev;
        inst->next = D.24653;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24654 = inst->sreg3;
        inst->sreg2 = D.24654;
        D.24655 = inst->sreg2;
        inst->sreg1 = D.24655;
        D.24437 = cfg->ip;
        inst->cil_code = D.24437;
        inst->data.op[1].p = "NullReferenceException";
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        if (D.24439 != 0B) goto <D.24656>; else goto <D.24657>;
        <D.24656>:
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        D.24439->next = inst;
        D.24438 = cfg->cbb;
        D.24439 = D.24438->last_ins;
        inst->prev = D.24439;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        goto <D.24658>;
        <D.24657>:
        D.24438 = cfg->cbb;
        D.24438 = cfg->cbb;
        D.24438->last_ins = inst;
        D.24439 = D.24438->last_ins;
        D.24438->code = D.24439;
        <D.24658>:
      }
      goto <D.24659>;
      <D.24644>:
      <D.24659>:
      <D.24642>:
      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24660 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24660;
      inst->prev = 0B;
      D.24661 = inst->prev;
      inst->next = D.24661;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24662 = inst->sreg3;
      inst->sreg2 = D.24662;
      D.24663 = inst->sreg2;
      inst->sreg1 = D.24663;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.24664 = (unsigned char) __ins_flags;
      inst->flags = D.24664;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24665>; else goto <D.24666>;
      <D.24665>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24667>;
      <D.24666>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24667>:
    }
    <D.24639>:
    {
      struct MonoInst * inst;

      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24668 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24668;
      inst->prev = 0B;
      D.24669 = inst->prev;
      inst->next = D.24669;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24670 = inst->sreg3;
      inst->sreg2 = D.24670;
      D.24671 = inst->sreg2;
      inst->sreg1 = D.24671;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index3_reg;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24672>; else goto <D.24673>;
      <D.24672>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24674>;
      <D.24673>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24674>:
    }
    {
      struct MonoInst * inst;

      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24675 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24675;
      inst->prev = 0B;
      D.24676 = inst->prev;
      inst->next = D.24676;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24677 = inst->sreg3;
      inst->sreg2 = D.24677;
      D.24678 = inst->sreg2;
      inst->sreg1 = D.24678;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24679>; else goto <D.24680>;
      <D.24679>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24681>;
      <D.24680>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24681>:
    }
  }
  goto <D.24682>;
  <D.24607>:
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24683 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24683;
    inst->prev = 0B;
    D.24684 = inst->prev;
    inst->next = D.24684;
    inst->opcode = 1049;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24685 = inst->sreg3;
    inst->sreg2 = D.24685;
    D.24686 = inst->sreg2;
    inst->sreg1 = D.24686;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->sreg1 = array_reg;
    inst->data.op[0].const_val = 24;
    inst->sreg2 = index3_reg;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24687>; else goto <D.24688>;
    <D.24687>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24689>;
    <D.24688>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24689>:
    {
      struct MonoInst * inst;

      D.24432 = cfg->mempool;
      inst = mono_mempool_alloc (D.24432, 80);
      inst->data.op[1].const_val = 0;
      D.24690 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24690;
      inst->prev = 0B;
      D.24691 = inst->prev;
      inst->next = D.24691;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24692 = inst->sreg3;
      inst->sreg2 = D.24692;
      D.24693 = inst->sreg2;
      inst->sreg1 = D.24693;
      D.24437 = cfg->ip;
      inst->cil_code = D.24437;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      if (D.24439 != 0B) goto <D.24694>; else goto <D.24695>;
      <D.24694>:
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      D.24439->next = inst;
      D.24438 = cfg->cbb;
      D.24439 = D.24438->last_ins;
      inst->prev = D.24439;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      goto <D.24696>;
      <D.24695>:
      D.24438 = cfg->cbb;
      D.24438 = cfg->cbb;
      D.24438->last_ins = inst;
      D.24439 = D.24438->last_ins;
      D.24438->code = D.24439;
      <D.24696>:
    }
  }
  <D.24682>:
  goto <D.24697>;
  <D.24588>:
  {
    struct MonoInst * ins;

    D.24432 = cfg->mempool;
    ins = mono_mempool_alloc (D.24432, 80);
    ins->data.op[1].const_val = 0;
    D.24698 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24698;
    ins->prev = 0B;
    D.24699 = ins->prev;
    ins->next = D.24699;
    ins->opcode = 788;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24700 = ins->sreg3;
    ins->sreg2 = D.24700;
    D.24701 = ins->sreg2;
    ins->sreg1 = D.24701;
    D.24437 = cfg->ip;
    ins->cil_code = D.24437;
    ins->sreg1 = array_reg;
    ins->sreg2 = index3_reg;
    ins->data.op[1].const_val = 24;
    D.24702 = ins->flags;
    D.24703 = D.24702 | 32;
    ins->flags = D.24703;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24704>; else goto <D.24705>;
    <D.24704>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = ins;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    ins->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = ins;
    goto <D.24706>;
    <D.24705>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = ins;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24706>:
    D.24573 = cfg->flags;
    D.24574 = D.24573 | 256;
    cfg->flags = D.24574;
    D.24438 = cfg->cbb;
    D.24438->has_array_access = 1;
  }
  <D.24697>:
  <D.24586>:
  <D.24445>:
  D.24707 = alloc_preg (cfg);
  add_reg = (int) D.24707;
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24708 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24708;
    inst->prev = 0B;
    D.24709 = inst->prev;
    inst->next = D.24709;
    inst->opcode = 435;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24710 = inst->sreg3;
    inst->sreg2 = D.24710;
    D.24711 = inst->sreg2;
    inst->sreg1 = D.24711;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->dreg = mult_reg;
    inst->sreg1 = index2_reg;
    D.24712 = (long int) size;
    inst->data.op[1].const_val = D.24712;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24713>; else goto <D.24714>;
    <D.24713>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24715>;
    <D.24714>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24715>:
  }
  {
    struct MonoInst * inst;

    D.24432 = cfg->mempool;
    inst = mono_mempool_alloc (D.24432, 80);
    inst->data.op[1].const_val = 0;
    D.24716 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24716;
    inst->prev = 0B;
    D.24717 = inst->prev;
    inst->next = D.24717;
    inst->opcode = 483;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24718 = inst->sreg3;
    inst->sreg2 = D.24718;
    D.24719 = inst->sreg2;
    inst->sreg1 = D.24719;
    D.24437 = cfg->ip;
    inst->cil_code = D.24437;
    inst->dreg = add_reg;
    inst->sreg1 = array_reg;
    inst->sreg2 = mult_reg;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    if (D.24439 != 0B) goto <D.24720>; else goto <D.24721>;
    <D.24720>:
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    D.24439->next = inst;
    D.24438 = cfg->cbb;
    D.24439 = D.24438->last_ins;
    inst->prev = D.24439;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    goto <D.24722>;
    <D.24721>:
    D.24438 = cfg->cbb;
    D.24438 = cfg->cbb;
    D.24438->last_ins = inst;
    D.24439 = D.24438->last_ins;
    D.24438->code = D.24439;
    <D.24722>:
  }
  D.24432 = cfg->mempool;
  ins = mono_mempool_alloc (D.24432, 80);
  ins->data.op[1].const_val = 0;
  D.24723 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24723;
  ins->prev = 0B;
  D.24724 = ins->prev;
  ins->next = D.24724;
  ins->opcode = 542;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24725 = ins->sreg3;
  ins->sreg2 = D.24725;
  D.24726 = ins->sreg2;
  ins->sreg1 = D.24726;
  D.24437 = cfg->ip;
  ins->cil_code = D.24437;
  ins->dreg = add_reg;
  ins->sreg1 = add_reg;
  ins->data.op[1].const_val = 32;
  ins->type = 3;
  D.24438 = cfg->cbb;
  D.24439 = D.24438->last_ins;
  if (D.24439 != 0B) goto <D.24727>; else goto <D.24728>;
  <D.24727>:
  D.24438 = cfg->cbb;
  D.24439 = D.24438->last_ins;
  D.24439->next = ins;
  D.24438 = cfg->cbb;
  D.24439 = D.24438->last_ins;
  ins->prev = D.24439;
  D.24438 = cfg->cbb;
  D.24438->last_ins = ins;
  goto <D.24729>;
  <D.24728>:
  D.24438 = cfg->cbb;
  D.24438 = cfg->cbb;
  D.24438->last_ins = ins;
  D.24439 = D.24438->last_ins;
  D.24438->code = D.24439;
  <D.24729>:
  D.24730 = add_reg;
  return D.24730;
}


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

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


emit_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args, const struct SimdIntrinsc * intrinsics, guint32 size)
{
  long unsigned int D.24734;
  const char * D.24735;
  unsigned int D.24738;
  short unsigned int D.24741;
  int D.24742;
  struct MonoClass * D.24743;
  const char * D.24744;
  struct MonoInst * D.24745;
  short unsigned int D.24748;
  sizetype D.24749;
  const char * D.24750;
  <unnamed-unsigned:1> D.24751;
  int D.24752;
  long unsigned int D.24753;
  long unsigned int D.24754;
  struct MonoInst * * D.24755;
  struct MonoInst * D.24756;
  unsigned char D.24757;
  unsigned int D.24760;
  unsigned int simd_supported_versions.27;
  unsigned int D.24762;
  int D.24767;
  int D.24768;
  int D.24769;
  int D.24772;
  unsigned int D.24773;
  const char * D.24774;
  <unnamed-unsigned:4> D.24775;
  int D.24776;
  const struct SimdIntrinsc * result;

  D.24734 = (long unsigned int) size;
  D.24735 = cmethod->name;
  result = mono_binary_search (D.24735, intrinsics, D.24734, 6, simd_intrinsic_compare_by_name);
  if (result == 0B) goto <D.24736>; else goto <D.24737>;
  <D.24736>:
  D.24738 = cfg->verbose_level;
  if (D.24738 > 2) goto <D.24739>; else goto <D.24740>;
  <D.24739>:
  D.24741 = fsig->param_count;
  D.24742 = (int) D.24741;
  D.24735 = cmethod->name;
  D.24743 = cmethod->klass;
  D.24744 = D.24743->name;
  printf ("function doesn\'t have a simd intrinsic %s::%s/%d\n", D.24744, D.24735, D.24742);
  <D.24740>:
  D.24745 = 0B;
  return D.24745;
  <D.24737>:
  D.24738 = cfg->verbose_level;
  if (D.24738 > 2) goto <D.24746>; else goto <D.24747>;
  <D.24746>:
  {
    int i;
    int max;

    D.24748 = result->name;
    D.24749 = (sizetype) D.24748;
    D.24750 = &method_names + D.24749;
    D.24741 = fsig->param_count;
    D.24742 = (int) D.24741;
    D.24735 = cmethod->name;
    D.24743 = cmethod->klass;
    D.24744 = D.24743->name;
    printf ("found call to intrinsic %s::%s/%d -> %s\n", D.24744, D.24735, D.24742, D.24750);
    D.24741 = fsig->param_count;
    D.24742 = (int) D.24741;
    D.24751 = fsig->hasthis;
    D.24752 = (int) D.24751;
    max = D.24742 + D.24752;
    i = 0;
    goto <D.22877>;
    <D.22876>:
    printf ("param %d:  ", i);
    D.24753 = (long unsigned int) i;
    D.24754 = D.24753 * 8;
    D.24755 = args + D.24754;
    D.24756 = *D.24755;
    mono_print_ins (D.24756);
    i = i + 1;
    <D.22877>:
    if (i < max) goto <D.22876>; else goto <D.22878>;
    <D.22878>:
  }
  <D.24747>:
  D.24757 = result->simd_version_flags;
  if (D.24757 != 0) goto <D.24758>; else goto <D.24759>;
  <D.24758>:
  D.24757 = result->simd_version_flags;
  D.24760 = (unsigned int) D.24757;
  simd_supported_versions.27 = simd_supported_versions;
  D.24762 = D.24760 & simd_supported_versions.27;
  if (D.24762 == 0) goto <D.24763>; else goto <D.24764>;
  <D.24763>:
  D.24738 = cfg->verbose_level;
  if (D.24738 > 2) goto <D.24765>; else goto <D.24766>;
  <D.24765>:
  {
    int x;

    D.24741 = fsig->param_count;
    D.24742 = (int) D.24741;
    D.24735 = cmethod->name;
    D.24743 = cmethod->klass;
    D.24744 = D.24743->name;
    printf ("function %s::%s/%d requires one of unsuported SIMD instruction set(s): ", D.24744, D.24735, D.24742);
    x = 1;
    goto <D.22881>;
    <D.22880>:
    D.24757 = result->simd_version_flags;
    D.24767 = (int) D.24757;
    D.24768 = D.24767 >> x;
    D.24769 = D.24768 & 1;
    if (D.24769 != 0) goto <D.24770>; else goto <D.24771>;
    <D.24770>:
    D.24772 = 1 << x;
    D.24773 = (unsigned int) D.24772;
    D.24774 = simd_version_name (D.24773);
    printf ("%s ", D.24774);
    <D.24771>:
    x = x + 1;
    <D.22881>:
    if (x <= 6) goto <D.22880>; else goto <D.22882>;
    <D.22882>:
    printf ("\n");
  }
  <D.24766>:
  D.24745 = 0B;
  return D.24745;
  <D.24764>:
  <D.24759>:
  D.24775 = result->simd_emit_mode;
  D.24776 = (int) D.24775;
  switch (D.24776) <default: <D.24777>, case 0: <D.22883>, case 1: <D.22884>, case 2: <D.22885>, case 3: <D.22886>, case 4: <D.22887>, case 5: <D.22888>, case 6: <D.22889>, case 7: <D.22890>, case 8: <D.22891>, case 9: <D.22892>, case 10: <D.22893>, case 11: <D.22894>, case 12: <D.22895>, case 13: <D.22896>>
  <D.22883>:
  D.24745 = simd_intrinsic_emit_binary (result, cfg, cmethod, args);
  return D.24745;
  <D.22884>:
  D.24745 = simd_intrinsic_emit_unary (result, cfg, cmethod, args);
  return D.24745;
  <D.22885>:
  D.24745 = simd_intrinsic_emit_setter (result, cfg, cmethod, args);
  return D.24745;
  <D.22886>:
  D.24745 = simd_intrinsic_emit_getter (result, cfg, cmethod, args);
  return D.24745;
  <D.22887>:
  D.24745 = simd_intrinsic_emit_long_getter (result, cfg, cmethod, args);
  return D.24745;
  <D.22888>:
  D.24745 = simd_intrinsic_emit_ctor (result, cfg, cmethod, args);
  return D.24745;
  <D.22889>:
  D.24745 = simd_intrinsic_emit_cast (result, cfg, cmethod, args);
  return D.24745;
  <D.22890>:
  D.24745 = simd_intrinsic_emit_shuffle (result, cfg, cmethod, args);
  return D.24745;
  <D.22891>:
  D.24745 = simd_intrinsic_emit_shift (result, cfg, cmethod, args);
  return D.24745;
  <D.22892>:
  D.24745 = simd_intrinsic_emit_equality (result, cfg, cmethod, args);
  return D.24745;
  <D.22893>:
  D.24745 = simd_intrinsic_emit_load_aligned (result, cfg, cmethod, args);
  return D.24745;
  <D.22894>:
  D.24745 = simd_intrinsic_emit_store (result, cfg, cmethod, args);
  return D.24745;
  <D.22895>:
  D.24745 = simd_intrinsic_emit_extract_mask (result, cfg, cmethod, args);
  return D.24745;
  <D.22896>:
  D.24745 = simd_intrinsic_emit_prefetch (result, cfg, cmethod, args);
  return D.24745;
  <D.24777>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 1538);
}


simd_intrinsic_compare_by_name (const void * key, const void * value)
{
  int D.24779;
  int D.22519;
  short unsigned int D.24780;
  sizetype D.24781;
  const char * D.24782;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.24780 = MEM[(struct SimdIntrinsc *)value].name;
    D.24781 = (sizetype) D.24780;
    D.24782 = &method_names + D.24781;
    D.22519 = __builtin_strcmp (key, D.24782);
  }
  D.24779 = D.22519;
  return D.24779;
}


simd_version_name (guint32 version)
{
  const char * D.24784;

  switch (version) <default: <D.24785>, case 1: <D.22858>, case 2: <D.22859>, case 4: <D.22860>, case 8: <D.22861>, case 16: <D.22862>, case 32: <D.22863>, case 64: <D.22864>>
  <D.22858>:
  D.24784 = "sse1";
  return D.24784;
  <D.22859>:
  D.24784 = "sse2";
  return D.24784;
  <D.22860>:
  D.24784 = "sse3";
  return D.24784;
  <D.22861>:
  D.24784 = "ssse3";
  return D.24784;
  <D.22862>:
  D.24784 = "sse41";
  return D.24784;
  <D.22863>:
  D.24784 = "sse42";
  return D.24784;
  <D.22864>:
  D.24784 = "sse4a";
  return D.24784;
  <D.24785>:
  D.24784 = "n/a";
  return D.24784;
}


simd_intrinsic_emit_binary (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24787;
  struct MonoInst * * D.24788;
  struct MonoInst * D.24789;
  struct MonoMemPool * D.24790;
  long int D.24791;
  struct MonoInst * D.24792;
  short unsigned int D.24793;
  int D.24794;
  int D.24795;
  const unsigned char * D.24796;
  struct MonoClass * D.24797;
  unsigned int D.24798;
  int D.24799;
  <unnamed-unsigned:4> D.24800;
  long int D.24801;
  struct MonoBasicBlock * D.24802;
  struct MonoInst * D.24803;
  struct MonoInst * D.24807;
  struct MonoInst * ins;
  int left_vreg;
  int right_vreg;

  D.24787 = *args;
  left_vreg = get_simd_vreg_or_expanded_scalar (cfg, cmethod, D.24787, 0);
  D.24788 = args + 8;
  D.24789 = *D.24788;
  right_vreg = get_simd_vreg_or_expanded_scalar (cfg, cmethod, D.24789, 1);
  D.24790 = cfg->mempool;
  ins = mono_mempool_alloc (D.24790, 80);
  ins->data.op[1].const_val = 0;
  D.24791 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24791;
  ins->prev = 0B;
  D.24792 = ins->prev;
  ins->next = D.24792;
  D.24793 = intrinsic->opcode;
  ins->opcode = D.24793;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24794 = ins->sreg3;
  ins->sreg2 = D.24794;
  D.24795 = ins->sreg2;
  ins->sreg1 = D.24795;
  D.24796 = cfg->ip;
  ins->cil_code = D.24796;
  D.24797 = cmethod->klass;
  ins->klass = D.24797;
  ins->sreg1 = left_vreg;
  ins->sreg2 = right_vreg;
  ins->type = 7;
  D.24798 = alloc_ireg (cfg);
  D.24799 = (int) D.24798;
  ins->dreg = D.24799;
  D.24800 = intrinsic->flags;
  D.24801 = (long int) D.24800;
  ins->data.op[0].const_val = D.24801;
  D.24802 = cfg->cbb;
  D.24803 = D.24802->last_ins;
  if (D.24803 != 0B) goto <D.24804>; else goto <D.24805>;
  <D.24804>:
  D.24802 = cfg->cbb;
  D.24803 = D.24802->last_ins;
  D.24803->next = ins;
  D.24802 = cfg->cbb;
  D.24803 = D.24802->last_ins;
  ins->prev = D.24803;
  D.24802 = cfg->cbb;
  D.24802->last_ins = ins;
  goto <D.24806>;
  <D.24805>:
  D.24802 = cfg->cbb;
  D.24802 = cfg->cbb;
  D.24802->last_ins = ins;
  D.24803 = D.24802->last_ins;
  D.24802->code = D.24803;
  <D.24806>:
  D.24807 = ins;
  return D.24807;
}


get_simd_vreg_or_expanded_scalar (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * src, int position)
{
  short unsigned int D.24809;
  _Bool D.24810;
  long int D.24811;
  long int D.24812;
  unsigned int position.28;
  _Bool D.24816;
  long int D.24817;
  long int D.24818;
  struct MonoType * D.24821;
  struct MonoClass * D.24822;
  unsigned char D.24823;
  unsigned char D.24824;
  int D.24827;
  struct MonoMemPool * D.24828;
  long int D.24829;
  struct MonoInst * D.24830;
  short unsigned int D.24831;
  int D.24832;
  int D.24833;
  const unsigned char * D.24834;
  struct MonoClass * D.24835;
  int D.24836;
  unsigned int D.24837;
  int D.24838;
  struct MonoBasicBlock * D.24839;
  struct MonoInst * D.24840;
  struct MonoInst * D.24846;
  struct MonoInst * D.24850;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int expand_op;

  sig = mono_method_signature (cmethod);
  D.24809 = sig->param_count;
  D.24810 = D.24809 != 2;
  D.24811 = (long int) D.24810;
  D.24812 = __builtin_expect (D.24811, 0);
  if (D.24812 != 0) goto <D.24813>; else goto <D.24814>;
  <D.24813>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 913, "sig->param_count == 2");
  <D.24814>:
  position.28 = (unsigned int) position;
  D.24816 = position.28 > 1;
  D.24817 = (long int) D.24816;
  D.24818 = __builtin_expect (D.24817, 0);
  if (D.24818 != 0) goto <D.24819>; else goto <D.24820>;
  <D.24819>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 914, "position == 0 || position == 1");
  <D.24820>:
  D.24821 = sig->params[position];
  D.24822 = mono_class_from_mono_type (D.24821);
  D.24823 = BIT_FIELD_REF <*D.24822, 8, 288>;
  D.24824 = D.24823 & 2;
  if (D.24824 != 0) goto <D.24825>; else goto <D.24826>;
  <D.24825>:
  D.24827 = get_simd_vreg (cfg, cmethod, src);
  return D.24827;
  <D.24826>:
  D.24821 = sig->params[position];
  expand_op = mono_type_to_expand_op (D.24821);
  D.24828 = cfg->mempool;
  ins = mono_mempool_alloc (D.24828, 80);
  ins->data.op[1].const_val = 0;
  D.24829 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24829;
  ins->prev = 0B;
  D.24830 = ins->prev;
  ins->next = D.24830;
  D.24831 = (short unsigned int) expand_op;
  ins->opcode = D.24831;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24832 = ins->sreg3;
  ins->sreg2 = D.24832;
  D.24833 = ins->sreg2;
  ins->sreg1 = D.24833;
  D.24834 = cfg->ip;
  ins->cil_code = D.24834;
  D.24835 = cmethod->klass;
  ins->klass = D.24835;
  D.24836 = src->dreg;
  ins->sreg1 = D.24836;
  ins->type = 7;
  D.24837 = alloc_ireg (cfg);
  D.24838 = (int) D.24837;
  ins->dreg = D.24838;
  D.24839 = cfg->cbb;
  D.24840 = D.24839->last_ins;
  if (D.24840 != 0B) goto <D.24841>; else goto <D.24842>;
  <D.24841>:
  D.24839 = cfg->cbb;
  D.24840 = D.24839->last_ins;
  D.24840->next = ins;
  D.24839 = cfg->cbb;
  D.24840 = D.24839->last_ins;
  ins->prev = D.24840;
  D.24839 = cfg->cbb;
  D.24839->last_ins = ins;
  goto <D.24843>;
  <D.24842>:
  D.24839 = cfg->cbb;
  D.24839 = cfg->cbb;
  D.24839->last_ins = ins;
  D.24840 = D.24839->last_ins;
  D.24839->code = D.24840;
  <D.24843>:
  if (expand_op == 950) goto <D.24844>; else goto <D.24845>;
  <D.24844>:
  D.24846 = get_int_to_float_spill_area (cfg);
  ins->backend.spill_var = D.24846;
  goto <D.24847>;
  <D.24845>:
  if (expand_op == 952) goto <D.24848>; else goto <D.24849>;
  <D.24848>:
  D.24850 = get_double_spill_area (cfg);
  ins->backend.spill_var = D.24850;
  <D.24849>:
  <D.24847>:
  D.24827 = ins->dreg;
  return D.24827;
}


mono_type_to_expand_op (struct MonoType * type)
{
  unsigned char D.24852;
  int D.24853;
  int D.24854;

  D.24852 = type->type;
  D.24853 = (int) D.24852;
  switch (D.24853) <default: <D.22652>, case 4: <D.22642>, case 5: <D.22643>, case 6: <D.22644>, case 7: <D.22645>, case 8: <D.22646>, case 9: <D.22647>, case 10: <D.22648>, case 11: <D.22649>, case 12: <D.22650>, case 13: <D.22651>>
  <D.22642>:
  <D.22643>:
  D.24854 = 947;
  return D.24854;
  <D.22644>:
  <D.22645>:
  D.24854 = 948;
  return D.24854;
  <D.22646>:
  <D.22647>:
  D.24854 = 949;
  return D.24854;
  <D.22648>:
  <D.22649>:
  D.24854 = 951;
  return D.24854;
  <D.22650>:
  D.24854 = 950;
  return D.24854;
  <D.22651>:
  D.24854 = 952;
  return D.24854;
  <D.22652>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 902);
}


get_int_to_float_spill_area (struct MonoCompile * cfg)
{
  struct MonoInst * D.24856;
  struct MonoClass * D.24859;
  struct MonoType * D.24860;
  struct MonoInst * D.24861;
  unsigned char D.24862;
  unsigned char D.24863;
  struct MonoInst * D.24864;

  D.24856 = cfg->iconv_raw_var;
  if (D.24856 == 0B) goto <D.24857>; else goto <D.24858>;
  <D.24857>:
  D.24859 = mono_defaults.int32_class;
  D.24860 = &D.24859->byval_arg;
  D.24861 = mono_compile_create_var (cfg, D.24860, 329);
  cfg->iconv_raw_var = D.24861;
  D.24856 = cfg->iconv_raw_var;
  D.24856 = cfg->iconv_raw_var;
  D.24862 = D.24856->flags;
  D.24863 = D.24862 | 4;
  D.24856->flags = D.24863;
  <D.24858>:
  D.24864 = cfg->iconv_raw_var;
  return D.24864;
}


get_double_spill_area (struct MonoCompile * cfg)
{
  struct MonoInst * D.24866;
  struct MonoClass * D.24869;
  struct MonoType * D.24870;
  struct MonoInst * D.24871;
  unsigned char D.24872;
  unsigned char D.24873;
  struct MonoInst * D.24874;

  D.24866 = cfg->fconv_to_r8_x_var;
  if (D.24866 == 0B) goto <D.24867>; else goto <D.24868>;
  <D.24867>:
  D.24869 = mono_defaults.double_class;
  D.24870 = &D.24869->byval_arg;
  D.24871 = mono_compile_create_var (cfg, D.24870, 329);
  cfg->fconv_to_r8_x_var = D.24871;
  D.24866 = cfg->fconv_to_r8_x_var;
  D.24866 = cfg->fconv_to_r8_x_var;
  D.24872 = D.24866->flags;
  D.24873 = D.24872 | 4;
  D.24866->flags = D.24873;
  <D.24868>:
  D.24874 = cfg->fconv_to_r8_x_var;
  return D.24874;
}


simd_intrinsic_emit_unary (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24876;
  struct MonoMemPool * D.24877;
  long int D.24878;
  struct MonoInst * D.24879;
  short unsigned int D.24880;
  int D.24881;
  int D.24882;
  const unsigned char * D.24883;
  struct MonoClass * D.24884;
  unsigned int D.24885;
  int D.24886;
  struct MonoBasicBlock * D.24887;
  struct MonoInst * D.24888;
  struct MonoInst * D.24892;
  struct MonoInst * ins;
  int vreg;

  D.24876 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.24876);
  D.24877 = cfg->mempool;
  ins = mono_mempool_alloc (D.24877, 80);
  ins->data.op[1].const_val = 0;
  D.24878 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24878;
  ins->prev = 0B;
  D.24879 = ins->prev;
  ins->next = D.24879;
  D.24880 = intrinsic->opcode;
  ins->opcode = D.24880;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24881 = ins->sreg3;
  ins->sreg2 = D.24881;
  D.24882 = ins->sreg2;
  ins->sreg1 = D.24882;
  D.24883 = cfg->ip;
  ins->cil_code = D.24883;
  D.24884 = cmethod->klass;
  ins->klass = D.24884;
  ins->sreg1 = vreg;
  ins->type = 7;
  D.24885 = alloc_ireg (cfg);
  D.24886 = (int) D.24885;
  ins->dreg = D.24886;
  D.24887 = cfg->cbb;
  D.24888 = D.24887->last_ins;
  if (D.24888 != 0B) goto <D.24889>; else goto <D.24890>;
  <D.24889>:
  D.24887 = cfg->cbb;
  D.24888 = D.24887->last_ins;
  D.24888->next = ins;
  D.24887 = cfg->cbb;
  D.24888 = D.24887->last_ins;
  ins->prev = D.24888;
  D.24887 = cfg->cbb;
  D.24887->last_ins = ins;
  goto <D.24891>;
  <D.24890>:
  D.24887 = cfg->cbb;
  D.24887 = cfg->cbb;
  D.24887->last_ins = ins;
  D.24888 = D.24887->last_ins;
  D.24887->code = D.24888;
  <D.24891>:
  D.24892 = ins;
  return D.24892;
}


simd_intrinsic_emit_setter (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoType * D.24894;
  struct MonoMemPool * D.24897;
  long int D.24898;
  struct MonoInst * D.24899;
  int D.24900;
  short unsigned int D.24901;
  int D.24902;
  int D.24903;
  const unsigned char * D.24904;
  struct MonoClass * D.24905;
  struct MonoInst * D.24906;
  int D.24907;
  struct MonoInst * * D.24908;
  struct MonoInst * D.24909;
  int D.24910;
  short unsigned int D.24911;
  long int D.24912;
  struct MonoBasicBlock * D.24913;
  struct MonoInst * D.24914;
  _Bool D.24922;
  _Bool D.24923;
  _Bool D.24924;
  int D.24926;
  short unsigned int D.24927;
  unsigned char D.24928;
  struct MonoInst * D.24931;
  struct MonoInst * D.24935;
  unsigned int D.24939;
  short unsigned int D.24940;
  long int D.24941;
  int indirect.29;
  int D.24951;
  struct MonoInst * D.24955;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int size;
  int align;
  gboolean indirect;
  int dreg;

  try
    {
      sig = mono_method_signature (cmethod);
      D.24894 = sig->params[0];
      size = mono_type_size (D.24894, &align);
      if (0 != 0) goto <D.24895>; else goto <D.24896>;
      <D.24895>:
      D.24897 = cfg->mempool;
      ins = mono_mempool_alloc (D.24897, 80);
      ins->data.op[1].const_val = 0;
      D.24898 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24898;
      ins->prev = 0B;
      D.24899 = ins->prev;
      ins->next = D.24899;
      D.24894 = sig->params[0];
      D.24900 = mono_type_to_insert_op (D.24894);
      D.24901 = (short unsigned int) D.24900;
      ins->opcode = D.24901;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24902 = ins->sreg3;
      ins->sreg2 = D.24902;
      D.24903 = ins->sreg2;
      ins->sreg1 = D.24903;
      D.24904 = cfg->ip;
      ins->cil_code = D.24904;
      D.24905 = cmethod->klass;
      ins->klass = D.24905;
      D.24906 = *args;
      dreg = load_simd_vreg (cfg, cmethod, D.24906, &indirect);
      ins->sreg1 = dreg;
      D.24907 = ins->sreg1;
      ins->dreg = D.24907;
      D.24908 = args + 8;
      D.24909 = *D.24908;
      D.24910 = D.24909->dreg;
      ins->sreg2 = D.24910;
      D.24911 = intrinsic->opcode;
      D.24912 = (long int) D.24911;
      ins->data.op[0].const_val = D.24912;
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      if (D.24914 != 0B) goto <D.24915>; else goto <D.24916>;
      <D.24915>:
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      D.24914->next = ins;
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      ins->prev = D.24914;
      D.24913 = cfg->cbb;
      D.24913->last_ins = ins;
      goto <D.24917>;
      <D.24916>:
      D.24913 = cfg->cbb;
      D.24913 = cfg->cbb;
      D.24913->last_ins = ins;
      D.24914 = D.24913->last_ins;
      D.24913->code = D.24914;
      <D.24917>:
      goto <D.24918>;
      <D.24896>:
      D.24922 = size == 2;
      D.24923 = size == 4;
      D.24924 = D.24922 | D.24923;
      if (D.24924 != 0) goto <D.24919>; else goto <D.24925>;
      <D.24925>:
      if (size == 8) goto <D.24919>; else goto <D.24920>;
      <D.24919>:
      D.24897 = cfg->mempool;
      ins = mono_mempool_alloc (D.24897, 80);
      ins->data.op[1].const_val = 0;
      D.24898 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24898;
      ins->prev = 0B;
      D.24899 = ins->prev;
      ins->next = D.24899;
      D.24894 = sig->params[0];
      D.24926 = mono_type_to_slow_insert_op (D.24894);
      D.24927 = (short unsigned int) D.24926;
      ins->opcode = D.24927;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24902 = ins->sreg3;
      ins->sreg2 = D.24902;
      D.24903 = ins->sreg2;
      ins->sreg1 = D.24903;
      D.24904 = cfg->ip;
      ins->cil_code = D.24904;
      D.24905 = cmethod->klass;
      ins->klass = D.24905;
      D.24906 = *args;
      dreg = load_simd_vreg (cfg, cmethod, D.24906, &indirect);
      ins->sreg1 = dreg;
      D.24907 = ins->sreg1;
      ins->dreg = D.24907;
      D.24908 = args + 8;
      D.24909 = *D.24908;
      D.24910 = D.24909->dreg;
      ins->sreg2 = D.24910;
      D.24911 = intrinsic->opcode;
      D.24912 = (long int) D.24911;
      ins->data.op[0].const_val = D.24912;
      D.24894 = sig->params[0];
      D.24928 = D.24894->type;
      if (D.24928 == 12) goto <D.24929>; else goto <D.24930>;
      <D.24929>:
      D.24931 = get_int_to_float_spill_area (cfg);
      ins->backend.spill_var = D.24931;
      goto <D.24932>;
      <D.24930>:
      D.24894 = sig->params[0];
      D.24928 = D.24894->type;
      if (D.24928 == 13) goto <D.24933>; else goto <D.24934>;
      <D.24933>:
      D.24935 = get_double_spill_area (cfg);
      ins->backend.spill_var = D.24935;
      <D.24934>:
      <D.24932>:
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      if (D.24914 != 0B) goto <D.24936>; else goto <D.24937>;
      <D.24936>:
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      D.24914->next = ins;
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      ins->prev = D.24914;
      D.24913 = cfg->cbb;
      D.24913->last_ins = ins;
      goto <D.24938>;
      <D.24937>:
      D.24913 = cfg->cbb;
      D.24913 = cfg->cbb;
      D.24913->last_ins = ins;
      D.24914 = D.24913->last_ins;
      D.24913->code = D.24914;
      <D.24938>:
      goto <D.24921>;
      <D.24920>:
      {
        int vreg;
        int sreg;

        D.24897 = cfg->mempool;
        ins = mono_mempool_alloc (D.24897, 80);
        ins->data.op[1].const_val = 0;
        D.24898 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24898;
        ins->prev = 0B;
        D.24899 = ins->prev;
        ins->next = D.24899;
        ins->opcode = 938;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24902 = ins->sreg3;
        ins->sreg2 = D.24902;
        D.24903 = ins->sreg2;
        ins->sreg1 = D.24903;
        D.24904 = cfg->ip;
        ins->cil_code = D.24904;
        D.24905 = cmethod->klass;
        ins->klass = D.24905;
        D.24906 = *args;
        dreg = load_simd_vreg (cfg, cmethod, D.24906, &indirect);
        sreg = dreg;
        ins->sreg1 = sreg;
        ins->type = 1;
        D.24939 = alloc_ireg (cfg);
        vreg = (int) D.24939;
        ins->dreg = vreg;
        D.24911 = intrinsic->opcode;
        D.24940 = D.24911 / 2;
        D.24941 = (long int) D.24940;
        ins->data.op[0].const_val = D.24941;
        D.24913 = cfg->cbb;
        D.24914 = D.24913->last_ins;
        if (D.24914 != 0B) goto <D.24942>; else goto <D.24943>;
        <D.24942>:
        D.24913 = cfg->cbb;
        D.24914 = D.24913->last_ins;
        D.24914->next = ins;
        D.24913 = cfg->cbb;
        D.24914 = D.24913->last_ins;
        ins->prev = D.24914;
        D.24913 = cfg->cbb;
        D.24913->last_ins = ins;
        goto <D.24944>;
        <D.24943>:
        D.24913 = cfg->cbb;
        D.24913 = cfg->cbb;
        D.24913->last_ins = ins;
        D.24914 = D.24913->last_ins;
        D.24913->code = D.24914;
        <D.24944>:
        D.24897 = cfg->mempool;
        ins = mono_mempool_alloc (D.24897, 80);
        ins->data.op[1].const_val = 0;
        D.24898 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24898;
        ins->prev = 0B;
        D.24899 = ins->prev;
        ins->next = D.24899;
        ins->opcode = 939;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24902 = ins->sreg3;
        ins->sreg2 = D.24902;
        D.24903 = ins->sreg2;
        ins->sreg1 = D.24903;
        D.24904 = cfg->ip;
        ins->cil_code = D.24904;
        D.24905 = cmethod->klass;
        ins->klass = D.24905;
        ins->sreg1 = vreg;
        D.24908 = args + 8;
        D.24909 = *D.24908;
        D.24910 = D.24909->dreg;
        ins->sreg2 = D.24910;
        ins->dreg = sreg;
        D.24911 = intrinsic->opcode;
        D.24912 = (long int) D.24911;
        ins->data.op[0].const_val = D.24912;
        D.24913 = cfg->cbb;
        D.24914 = D.24913->last_ins;
        if (D.24914 != 0B) goto <D.24945>; else goto <D.24946>;
        <D.24945>:
        D.24913 = cfg->cbb;
        D.24914 = D.24913->last_ins;
        D.24914->next = ins;
        D.24913 = cfg->cbb;
        D.24914 = D.24913->last_ins;
        ins->prev = D.24914;
        D.24913 = cfg->cbb;
        D.24913->last_ins = ins;
        goto <D.24947>;
        <D.24946>:
        D.24913 = cfg->cbb;
        D.24913 = cfg->cbb;
        D.24913->last_ins = ins;
        D.24914 = D.24913->last_ins;
        D.24913->code = D.24914;
        <D.24947>:
      }
      <D.24921>:
      <D.24918>:
      indirect.29 = indirect;
      if (indirect.29 != 0) goto <D.24949>; else goto <D.24950>;
      <D.24949>:
      D.24897 = cfg->mempool;
      ins = mono_mempool_alloc (D.24897, 80);
      ins->data.op[1].const_val = 0;
      D.24898 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24898;
      ins->prev = 0B;
      D.24899 = ins->prev;
      ins->next = D.24899;
      ins->opcode = 389;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24902 = ins->sreg3;
      ins->sreg2 = D.24902;
      D.24903 = ins->sreg2;
      ins->sreg1 = D.24903;
      D.24904 = cfg->ip;
      ins->cil_code = D.24904;
      D.24905 = cmethod->klass;
      ins->klass = D.24905;
      D.24906 = *args;
      D.24951 = D.24906->dreg;
      ins->dreg = D.24951;
      ins->sreg1 = dreg;
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      if (D.24914 != 0B) goto <D.24952>; else goto <D.24953>;
      <D.24952>:
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      D.24914->next = ins;
      D.24913 = cfg->cbb;
      D.24914 = D.24913->last_ins;
      ins->prev = D.24914;
      D.24913 = cfg->cbb;
      D.24913->last_ins = ins;
      goto <D.24954>;
      <D.24953>:
      D.24913 = cfg->cbb;
      D.24913 = cfg->cbb;
      D.24913->last_ins = ins;
      D.24914 = D.24913->last_ins;
      D.24913->code = D.24914;
      <D.24954>:
      <D.24950>:
      D.24955 = ins;
      return D.24955;
    }
  finally
    {
      align = {CLOBBER};
      indirect = {CLOBBER};
    }
}


mono_type_to_slow_insert_op (struct MonoType * type)
{
  unsigned char D.24958;
  int D.24959;
  int D.24960;

  D.24958 = type->type;
  D.24959 = (int) D.24958;
  switch (D.24959) <default: <D.22728>, case 4: <D.22718>, case 5: <D.22719>, case 6: <D.22720>, case 7: <D.22721>, case 8: <D.22722>, case 9: <D.22723>, case 10: <D.22724>, case 11: <D.22725>, case 12: <D.22726>, case 13: <D.22727>>
  <D.22718>:
  <D.22719>:
  D.24960 = 939;
  return D.24960;
  <D.22720>:
  <D.22721>:
  D.24960 = 937;
  return D.24960;
  <D.22722>:
  <D.22723>:
  D.24960 = 940;
  return D.24960;
  <D.22724>:
  <D.22725>:
  D.24960 = 943;
  return D.24960;
  <D.22726>:
  D.24960 = 941;
  return D.24960;
  <D.22727>:
  D.24960 = 942;
  return D.24960;
  <D.22728>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 1060);
}


load_simd_vreg (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * src, gboolean * indirect)
{
  short unsigned int D.24964;
  int D.24967;
  void * D.24970;
  int D.24971;
  int D.24972;
  unsigned char D.24973;
  unsigned char D.24976;
  _Bool D.24977;
  _Bool D.24978;
  _Bool D.24979;
  struct MonoMemPool * D.24984;
  long int D.24985;
  struct MonoInst * D.24986;
  int D.24987;
  int D.24988;
  const unsigned char * D.24989;
  struct MonoClass * D.24990;
  int D.24991;
  unsigned int D.24992;
  int D.24993;
  struct MonoBasicBlock * D.24994;
  struct MonoInst * D.24995;
  int D.24999;

  if (indirect != 0B) goto <D.24962>; else goto <D.24963>;
  <D.24962>:
  *indirect = 0;
  <D.24963>:
  D.24964 = src->opcode;
  if (D.24964 == 962) goto <D.24965>; else goto <D.24966>;
  <D.24965>:
  D.24967 = src->sreg1;
  return D.24967;
  <D.24966>:
  D.24964 = src->opcode;
  if (D.24964 == 314) goto <D.24968>; else goto <D.24969>;
  <D.24968>:
  {
    int res;

    D.24970 = src->data.op[0].p;
    res = MEM[(struct MonoInst *)D.24970].dreg;
    src->opcode = 316;
    src->dreg = -1;
    src->sreg3 = -1;
    D.24971 = src->sreg3;
    src->sreg2 = D.24971;
    D.24972 = src->sreg2;
    src->sreg1 = D.24972;
    D.24967 = res;
    return D.24967;
  }
  <D.24969>:
  D.24973 = src->type;
  if (D.24973 == 7) goto <D.24974>; else goto <D.24975>;
  <D.24974>:
  D.24967 = src->dreg;
  return D.24967;
  <D.24975>:
  D.24976 = src->type;
  D.24977 = D.24976 == 3;
  D.24978 = D.24976 == 5;
  D.24979 = D.24977 | D.24978;
  if (D.24979 != 0) goto <D.24980>; else goto <D.24981>;
  <D.24980>:
  {
    struct MonoInst * ins;

    if (indirect != 0B) goto <D.24982>; else goto <D.24983>;
    <D.24982>:
    *indirect = 1;
    <D.24983>:
    D.24984 = cfg->mempool;
    ins = mono_mempool_alloc (D.24984, 80);
    ins->data.op[1].const_val = 0;
    D.24985 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24985;
    ins->prev = 0B;
    D.24986 = ins->prev;
    ins->next = D.24986;
    ins->opcode = 401;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24987 = ins->sreg3;
    ins->sreg2 = D.24987;
    D.24988 = ins->sreg2;
    ins->sreg1 = D.24988;
    D.24989 = cfg->ip;
    ins->cil_code = D.24989;
    D.24990 = cmethod->klass;
    ins->klass = D.24990;
    D.24991 = src->dreg;
    ins->sreg1 = D.24991;
    ins->type = 7;
    D.24992 = alloc_ireg (cfg);
    D.24993 = (int) D.24992;
    ins->dreg = D.24993;
    D.24994 = cfg->cbb;
    D.24995 = D.24994->last_ins;
    if (D.24995 != 0B) goto <D.24996>; else goto <D.24997>;
    <D.24996>:
    D.24994 = cfg->cbb;
    D.24995 = D.24994->last_ins;
    D.24995->next = ins;
    D.24994 = cfg->cbb;
    D.24995 = D.24994->last_ins;
    ins->prev = D.24995;
    D.24994 = cfg->cbb;
    D.24994->last_ins = ins;
    goto <D.24998>;
    <D.24997>:
    D.24994 = cfg->cbb;
    D.24994 = cfg->cbb;
    D.24994->last_ins = ins;
    D.24995 = D.24994->last_ins;
    D.24994->code = D.24995;
    <D.24998>:
    D.24967 = ins->dreg;
    return D.24967;
  }
  <D.24981>:
  D.24973 = src->type;
  D.24999 = (int) D.24973;
  monoeg_g_log (0B, 16, "load_simd_vreg:: could not infer source simd (%d) vreg for op", D.24999);
  mono_print_ins (src);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 848);
}


simd_intrinsic_emit_getter (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoType * D.25001;
  struct MonoInst * D.25002;
  short unsigned int D.25003;
  int D.25004;
  int D.25005;
  unsigned char D.25008;
  unsigned char D.25009;
  struct MonoMemPool * D.25012;
  long int D.25013;
  struct MonoInst * D.25014;
  int D.25015;
  int D.25016;
  const unsigned char * D.25017;
  struct MonoClass * D.25018;
  long int D.25019;
  unsigned int D.25020;
  struct MonoBasicBlock * D.25021;
  struct MonoInst * D.25022;
  int D.25026;
  short unsigned int D.25027;
  unsigned int D.25028;
  long int D.25031;
  int D.25033;
  int D.25034;
  int D.25035;
  long int D.25036;
  unsigned char D.25040;
  struct MonoClass * D.25043;
  unsigned int D.25044;
  int D.25045;
  struct MonoInst * D.25046;
  struct MonoInst * D.25050;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int vreg;
  int shift_bits;

  sig = mono_method_signature (cmethod);
  D.25001 = sig->ret;
  shift_bits = mono_type_elements_shift_bits (D.25001);
  D.25002 = *args;
  vreg = load_simd_vreg (cfg, cmethod, D.25002, 0B);
  D.25003 = intrinsic->opcode;
  D.25004 = (int) D.25003;
  D.25005 = D.25004 >> shift_bits;
  if (D.25005 != 0) goto <D.25006>; else goto <D.25007>;
  <D.25006>:
  D.25008 = BIT_FIELD_REF <*cfg, 8, 5608>;
  D.25009 = D.25008 & 1;
  if (D.25009 == 0) goto <D.25010>; else goto <D.25011>;
  <D.25010>:
  D.25012 = cfg->mempool;
  ins = mono_mempool_alloc (D.25012, 80);
  ins->data.op[1].const_val = 0;
  D.25013 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25013;
  ins->prev = 0B;
  D.25014 = ins->prev;
  ins->next = D.25014;
  ins->opcode = 825;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25015 = ins->sreg3;
  ins->sreg2 = D.25015;
  D.25016 = ins->sreg2;
  ins->sreg1 = D.25016;
  D.25017 = cfg->ip;
  ins->cil_code = D.25017;
  D.25018 = cmethod->klass;
  ins->klass = D.25018;
  ins->sreg1 = vreg;
  D.25003 = intrinsic->opcode;
  D.25004 = (int) D.25003;
  D.25005 = D.25004 >> shift_bits;
  D.25019 = (long int) D.25005;
  ins->data.op[0].const_val = D.25019;
  ins->type = 7;
  D.25020 = alloc_ireg (cfg);
  vreg = (int) D.25020;
  ins->dreg = vreg;
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  if (D.25022 != 0B) goto <D.25023>; else goto <D.25024>;
  <D.25023>:
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  D.25022->next = ins;
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  ins->prev = D.25022;
  D.25021 = cfg->cbb;
  D.25021->last_ins = ins;
  goto <D.25025>;
  <D.25024>:
  D.25021 = cfg->cbb;
  D.25021 = cfg->cbb;
  D.25021->last_ins = ins;
  D.25022 = D.25021->last_ins;
  D.25021->code = D.25022;
  <D.25025>:
  <D.25011>:
  <D.25007>:
  D.25012 = cfg->mempool;
  ins = mono_mempool_alloc (D.25012, 80);
  ins->data.op[1].const_val = 0;
  D.25013 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25013;
  ins->prev = 0B;
  D.25014 = ins->prev;
  ins->next = D.25014;
  D.25001 = sig->ret;
  D.25026 = mono_type_to_extract_op (D.25001);
  D.25027 = (short unsigned int) D.25026;
  ins->opcode = D.25027;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25015 = ins->sreg3;
  ins->sreg2 = D.25015;
  D.25016 = ins->sreg2;
  ins->sreg1 = D.25016;
  D.25017 = cfg->ip;
  ins->cil_code = D.25017;
  D.25018 = cmethod->klass;
  ins->klass = D.25018;
  ins->sreg1 = vreg;
  ins->type = 1;
  D.25028 = alloc_ireg (cfg);
  vreg = (int) D.25028;
  ins->dreg = vreg;
  D.25008 = BIT_FIELD_REF <*cfg, 8, 5608>;
  D.25009 = D.25008 & 1;
  if (D.25009 != 0) goto <D.25029>; else goto <D.25030>;
  <D.25029>:
  D.25003 = intrinsic->opcode;
  D.25031 = (long int) D.25003;
  ins->data.op[0].const_val = D.25031;
  goto <D.25032>;
  <D.25030>:
  D.25003 = intrinsic->opcode;
  D.25004 = (int) D.25003;
  D.25033 = 1 << shift_bits;
  D.25034 = D.25033 + -1;
  D.25035 = D.25004 & D.25034;
  D.25036 = (long int) D.25035;
  ins->data.op[0].const_val = D.25036;
  <D.25032>:
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  if (D.25022 != 0B) goto <D.25037>; else goto <D.25038>;
  <D.25037>:
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  D.25022->next = ins;
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  ins->prev = D.25022;
  D.25021 = cfg->cbb;
  D.25021->last_ins = ins;
  goto <D.25039>;
  <D.25038>:
  D.25021 = cfg->cbb;
  D.25021 = cfg->cbb;
  D.25021->last_ins = ins;
  D.25022 = D.25021->last_ins;
  D.25021->code = D.25022;
  <D.25039>:
  D.25001 = sig->ret;
  D.25040 = D.25001->type;
  if (D.25040 == 12) goto <D.25041>; else goto <D.25042>;
  <D.25041>:
  D.25012 = cfg->mempool;
  ins = mono_mempool_alloc (D.25012, 80);
  ins->data.op[1].const_val = 0;
  D.25013 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25013;
  ins->prev = 0B;
  D.25014 = ins->prev;
  ins->next = D.25014;
  ins->opcode = 925;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25015 = ins->sreg3;
  ins->sreg2 = D.25015;
  D.25016 = ins->sreg2;
  ins->sreg1 = D.25016;
  D.25017 = cfg->ip;
  ins->cil_code = D.25017;
  D.25043 = mono_defaults.single_class;
  ins->klass = D.25043;
  ins->sreg1 = vreg;
  ins->type = 4;
  D.25044 = alloc_freg (cfg);
  D.25045 = (int) D.25044;
  ins->dreg = D.25045;
  D.25046 = get_int_to_float_spill_area (cfg);
  ins->backend.spill_var = D.25046;
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  if (D.25022 != 0B) goto <D.25047>; else goto <D.25048>;
  <D.25047>:
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  D.25022->next = ins;
  D.25021 = cfg->cbb;
  D.25022 = D.25021->last_ins;
  ins->prev = D.25022;
  D.25021 = cfg->cbb;
  D.25021->last_ins = ins;
  goto <D.25049>;
  <D.25048>:
  D.25021 = cfg->cbb;
  D.25021 = cfg->cbb;
  D.25021->last_ins = ins;
  D.25022 = D.25021->last_ins;
  D.25021->code = D.25022;
  <D.25049>:
  <D.25042>:
  D.25050 = ins;
  return D.25050;
}


mono_type_elements_shift_bits (struct MonoType * type)
{
  unsigned char D.25052;
  int D.25053;
  int D.25054;

  D.25052 = type->type;
  D.25053 = (int) D.25052;
  switch (D.25053) <default: <D.22700>, case 4: <D.22693>, case 5: <D.22694>, case 6: <D.22695>, case 7: <D.22696>, case 8: <D.22697>, case 9: <D.22698>, case 12: <D.22699>>
  <D.22693>:
  <D.22694>:
  D.25054 = 2;
  return D.25054;
  <D.22695>:
  <D.22696>:
  D.25054 = 1;
  return D.25054;
  <D.22697>:
  <D.22698>:
  <D.22699>:
  D.25054 = 0;
  return D.25054;
  <D.22700>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 1010);
}


mono_type_to_extract_op (struct MonoType * type)
{
  unsigned char D.25056;
  int D.25057;
  int D.25058;

  D.25056 = type->type;
  D.25057 = (int) D.25056;
  switch (D.25057) <default: <D.22689>, case 4: <D.22682>, case 5: <D.22683>, case 6: <D.22684>, case 7: <D.22685>, case 8: <D.22686>, case 9: <D.22687>, case 12: <D.22688>>
  <D.22682>:
  D.25058 = 928;
  return D.25058;
  <D.22683>:
  D.25058 = 929;
  return D.25058;
  <D.22684>:
  D.25058 = 926;
  return D.25058;
  <D.22685>:
  D.25058 = 927;
  return D.25058;
  <D.22686>:
  <D.22687>:
  <D.22688>:
  D.25058 = 924;
  return D.25058;
  <D.22689>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "simd-intrinsics.c", 990);
}


simd_intrinsic_emit_long_getter (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMethodSignature * D.25060;
  struct MonoType * D.25061;
  unsigned char D.25062;
  _Bool D.25063;
  struct MonoInst * D.25064;
  struct MonoMemPool * D.25065;
  long int D.25066;
  struct MonoInst * D.25067;
  guint16 iftmp.30;
  int D.25072;
  int D.25073;
  const unsigned char * D.25074;
  struct MonoClass * D.25075;
  short unsigned int D.25076;
  long int D.25077;
  unsigned int D.25080;
  int D.25081;
  struct MonoInst * D.25082;
  unsigned int D.25084;
  int D.25085;
  struct MonoBasicBlock * D.25086;
  struct MonoInst * D.25087;
  struct MonoInst * D.25091;
  struct MonoInst * ins;
  int vreg;
  gboolean is_r8;

  D.25060 = mono_method_signature (cmethod);
  D.25061 = D.25060->ret;
  D.25062 = D.25061->type;
  D.25063 = D.25062 == 13;
  is_r8 = (gboolean) D.25063;
  D.25064 = *args;
  vreg = load_simd_vreg (cfg, cmethod, D.25064, 0B);
  D.25065 = cfg->mempool;
  ins = mono_mempool_alloc (D.25065, 80);
  ins->data.op[1].const_val = 0;
  D.25066 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25066;
  ins->prev = 0B;
  D.25067 = ins->prev;
  ins->next = D.25067;
  if (is_r8 != 0) goto <D.25069>; else goto <D.25070>;
  <D.25069>:
  iftmp.30 = 930;
  goto <D.25071>;
  <D.25070>:
  iftmp.30 = 931;
  <D.25071>:
  ins->opcode = iftmp.30;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25072 = ins->sreg3;
  ins->sreg2 = D.25072;
  D.25073 = ins->sreg2;
  ins->sreg1 = D.25073;
  D.25074 = cfg->ip;
  ins->cil_code = D.25074;
  D.25075 = cmethod->klass;
  ins->klass = D.25075;
  ins->sreg1 = vreg;
  D.25076 = intrinsic->opcode;
  D.25077 = (long int) D.25076;
  ins->data.op[0].const_val = D.25077;
  if (is_r8 != 0) goto <D.25078>; else goto <D.25079>;
  <D.25078>:
  ins->type = 4;
  D.25080 = alloc_freg (cfg);
  D.25081 = (int) D.25080;
  ins->dreg = D.25081;
  D.25082 = get_double_spill_area (cfg);
  ins->backend.spill_var = D.25082;
  goto <D.25083>;
  <D.25079>:
  ins->type = 2;
  D.25084 = alloc_lreg (cfg);
  D.25085 = (int) D.25084;
  ins->dreg = D.25085;
  <D.25083>:
  D.25086 = cfg->cbb;
  D.25087 = D.25086->last_ins;
  if (D.25087 != 0B) goto <D.25088>; else goto <D.25089>;
  <D.25088>:
  D.25086 = cfg->cbb;
  D.25087 = D.25086->last_ins;
  D.25087->next = ins;
  D.25086 = cfg->cbb;
  D.25087 = D.25086->last_ins;
  ins->prev = D.25087;
  D.25086 = cfg->cbb;
  D.25086->last_ins = ins;
  goto <D.25090>;
  <D.25089>:
  D.25086 = cfg->cbb;
  D.25086 = cfg->cbb;
  D.25086->last_ins = ins;
  D.25087 = D.25086->last_ins;
  D.25086->code = D.25087;
  <D.25090>:
  D.25091 = ins;
  return D.25091;
}


simd_intrinsic_emit_ctor (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.25093;
  short unsigned int D.25094;
  _Bool D.25095;
  struct MonoType * D.25096;
  unsigned int D.25097;
  short unsigned int D.25098;
  struct MonoInst * D.25103;
  int D.25104;
  int D.25105;
  unsigned char D.25107;
  _Bool D.25108;
  _Bool D.25109;
  _Bool D.25110;
  int D.25111;
  _Bool D.25112;
  long int D.25113;
  long int D.25114;
  unsigned int D.25117;
  struct MonoMemPool * D.25118;
  long int D.25119;
  struct MonoInst * D.25120;
  short unsigned int D.25121;
  int D.25122;
  int D.25123;
  const unsigned char * D.25124;
  struct MonoClass * D.25125;
  struct MonoInst * * D.25126;
  struct MonoInst * D.25127;
  int D.25128;
  struct MonoBasicBlock * D.25129;
  struct MonoInst * D.25130;
  unsigned char D.25134;
  struct MonoInst * D.25137;
  struct MonoInst * D.25141;
  int D.25144;
  struct MonoInst * D.25148;
  struct MonoInst * D.25151;
  struct MonoInst * D.25152;
  unsigned char D.25153;
  unsigned char D.25154;
  struct MonoInst * D.25155;
  struct MonoClass * D.25156;
  unsigned int D.25157;
  int D.25158;
  int D.25159;
  _Bool D.25160;
  long int D.25161;
  long int D.25162;
  struct MonoInst * D.25165;
  struct MonoType * D.25166;
  int D.25167;
  struct MonoInst * iftmp.31;
  struct MonoInst * D.25173;
  int D.25174;
  int D.25175;
  unsigned int D.25176;
  unsigned int D.25177;
  struct MonoInst * * D.25180;
  struct MonoInst * D.25181;
  int D.25182;
  sizetype D.25183;
  sizetype D.25184;
  sizetype D.25185;
  struct MonoInst * * D.25186;
  struct MonoInst * iftmp.32;
  struct MonoInst * D.25189;
  int D.25190;
  int D.25191;
  unsigned int D.25192;
  struct MonoInst * D.25195;
  int D.25196;
  sizetype D.25197;
  sizetype D.25198;
  sizetype D.25199;
  struct MonoInst * * D.25200;
  _Bool D.25202;
  long int D.25203;
  long int D.25204;
  _Bool D.25207;
  long int D.25208;
  long int D.25209;
  unsigned char D.25212;
  unsigned char D.25213;
  unsigned char D.25214;
  unsigned char D.25215;
  unsigned char D.25220;
  _Bool D.25221;
  _Bool D.25222;
  _Bool D.25223;
  int D.25224;
  _Bool D.25225;
  long int D.25226;
  long int D.25227;
  int D.25230;
  int i.33;
  short unsigned int D.25232;
  int i.34;
  sizetype D.25234;
  sizetype D.25235;
  sizetype D.25236;
  struct MonoInst * * D.25237;
  struct MonoInst * D.25238;
  int D.25239;
  int D.25240;
  long int D.25241;
  int i.35;
  void * D.25248;
  struct MonoInst * ins;
  int i;
  int addr_reg;
  gboolean is_ldaddr;
  struct MonoMethodSignature * sig;
  int store_op;
  int arg_size;

  try
    {
      ins = 0B;
      D.25093 = *args;
      D.25094 = D.25093->opcode;
      D.25095 = D.25094 == 314;
      is_ldaddr = (gboolean) D.25095;
      sig = mono_method_signature (cmethod);
      D.25096 = sig->params[0];
      D.25097 = mono_type_to_store_membase (cfg, D.25096);
      store_op = (int) D.25097;
      D.25096 = sig->params[0];
      arg_size = mono_type_size (D.25096, &i);
      D.25098 = sig->param_count;
      if (D.25098 == 1) goto <D.25099>; else goto <D.25100>;
      <D.25099>:
      {
        int dreg;

        if (is_ldaddr != 0) goto <D.25101>; else goto <D.25102>;
        <D.25101>:
        D.25093 = *args;
        D.25103 = D.25093->data.op[0].src;
        dreg = D.25103->dreg;
        D.25093 = *args;
        D.25093->opcode = 316;
        D.25093 = *args;
        D.25093->dreg = -1;
        D.25093 = *args;
        D.25093 = *args;
        D.25093 = *args;
        D.25093->sreg3 = -1;
        D.25104 = D.25093->sreg3;
        D.25093->sreg2 = D.25104;
        D.25105 = D.25093->sreg2;
        D.25093->sreg1 = D.25105;
        goto <D.25106>;
        <D.25102>:
        D.25093 = *args;
        D.25107 = D.25093->type;
        D.25108 = D.25107 != 5;
        D.25109 = D.25107 != 3;
        D.25110 = D.25108 & D.25109;
        D.25111 = (int) D.25110;
        D.25112 = D.25111 != 0;
        D.25113 = (long int) D.25112;
        D.25114 = __builtin_expect (D.25113, 0);
        if (D.25114 != 0) goto <D.25115>; else goto <D.25116>;
        <D.25115>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 1209, "args [0]->type == STACK_MP || args [0]->type == STACK_PTR");
        <D.25116>:
        D.25117 = alloc_ireg (cfg);
        dreg = (int) D.25117;
        <D.25106>:
        D.25118 = cfg->mempool;
        ins = mono_mempool_alloc (D.25118, 80);
        ins->data.op[1].const_val = 0;
        D.25119 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.25119;
        ins->prev = 0B;
        D.25120 = ins->prev;
        ins->next = D.25120;
        D.25121 = intrinsic->opcode;
        ins->opcode = D.25121;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.25122 = ins->sreg3;
        ins->sreg2 = D.25122;
        D.25123 = ins->sreg2;
        ins->sreg1 = D.25123;
        D.25124 = cfg->ip;
        ins->cil_code = D.25124;
        D.25125 = cmethod->klass;
        ins->klass = D.25125;
        D.25126 = args + 8;
        D.25127 = *D.25126;
        D.25128 = D.25127->dreg;
        ins->sreg1 = D.25128;
        ins->type = 7;
        ins->dreg = dreg;
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        if (D.25130 != 0B) goto <D.25131>; else goto <D.25132>;
        <D.25131>:
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        D.25130->next = ins;
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        ins->prev = D.25130;
        D.25129 = cfg->cbb;
        D.25129->last_ins = ins;
        goto <D.25133>;
        <D.25132>:
        D.25129 = cfg->cbb;
        D.25129 = cfg->cbb;
        D.25129->last_ins = ins;
        D.25130 = D.25129->last_ins;
        D.25129->code = D.25130;
        <D.25133>:
        D.25096 = sig->params[0];
        D.25134 = D.25096->type;
        if (D.25134 == 12) goto <D.25135>; else goto <D.25136>;
        <D.25135>:
        D.25137 = get_int_to_float_spill_area (cfg);
        ins->backend.spill_var = D.25137;
        goto <D.25138>;
        <D.25136>:
        D.25096 = sig->params[0];
        D.25134 = D.25096->type;
        if (D.25134 == 13) goto <D.25139>; else goto <D.25140>;
        <D.25139>:
        D.25141 = get_double_spill_area (cfg);
        ins->backend.spill_var = D.25141;
        <D.25140>:
        <D.25138>:
        if (is_ldaddr == 0) goto <D.25142>; else goto <D.25143>;
        <D.25142>:
        D.25118 = cfg->mempool;
        ins = mono_mempool_alloc (D.25118, 80);
        ins->data.op[1].const_val = 0;
        D.25119 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.25119;
        ins->prev = 0B;
        D.25120 = ins->prev;
        ins->next = D.25120;
        ins->opcode = 389;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.25122 = ins->sreg3;
        ins->sreg2 = D.25122;
        D.25123 = ins->sreg2;
        ins->sreg1 = D.25123;
        D.25124 = cfg->ip;
        ins->cil_code = D.25124;
        D.25093 = *args;
        D.25144 = D.25093->dreg;
        ins->dreg = D.25144;
        ins->sreg1 = dreg;
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        if (D.25130 != 0B) goto <D.25145>; else goto <D.25146>;
        <D.25145>:
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        D.25130->next = ins;
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        ins->prev = D.25130;
        D.25129 = cfg->cbb;
        D.25129->last_ins = ins;
        goto <D.25147>;
        <D.25146>:
        D.25129 = cfg->cbb;
        D.25129 = cfg->cbb;
        D.25129->last_ins = ins;
        D.25130 = D.25129->last_ins;
        D.25129->code = D.25130;
        <D.25147>:
        <D.25143>:
        D.25148 = ins;
        return D.25148;
      }
      <D.25100>:
      if (is_ldaddr != 0) goto <D.25149>; else goto <D.25150>;
      <D.25149>:
      D.25118 = cfg->mempool;
      ins = mono_mempool_alloc (D.25118, 80);
      ins->data.op[1].const_val = 0;
      D.25119 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.25119;
      ins->prev = 0B;
      D.25120 = ins->prev;
      ins->next = D.25120;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.25122 = ins->sreg3;
      ins->sreg2 = D.25122;
      D.25123 = ins->sreg2;
      ins->sreg1 = D.25123;
      D.25124 = cfg->ip;
      ins->cil_code = D.25124;
      D.25125 = cmethod->klass;
      D.25151 = get_simd_ctor_spill_area (cfg, D.25125);
      ins->data.op[0].p = D.25151;
      D.25125 = cmethod->klass;
      D.25152 = get_simd_ctor_spill_area (cfg, D.25125);
      D.25153 = D.25152->flags;
      D.25154 = D.25153 | 16;
      D.25152->flags = D.25154;
      ins->type = 5;
      D.25125 = cmethod->klass;
      D.25155 = get_simd_ctor_spill_area (cfg, D.25125);
      D.25156 = D.25155->klass;
      ins->klass = D.25156;
      D.25157 = alloc_dreg (cfg, 5);
      D.25158 = (int) D.25157;
      ins->dreg = D.25158;
      cfg->has_indirection = 1;
      D.25159 = cfg->gsharedvt;
      D.25160 = D.25159 != 0;
      D.25161 = (long int) D.25160;
      D.25162 = __builtin_expect (D.25161, 0);
      if (D.25162 != 0) goto <D.25163>; else goto <D.25164>;
      <D.25163>:
      D.25125 = cmethod->klass;
      D.25165 = get_simd_ctor_spill_area (cfg, D.25125);
      D.25166 = D.25165->data.op[1].vtype;
      D.25167 = mini_is_gsharedvt_variable_type (cfg, D.25166);
      if (D.25167 != 0) goto <D.25168>; else goto <D.25169>;
      <D.25168>:
      handle_gsharedvt_ldaddr (cfg);
      <D.25169>:
      <D.25164>:
      if (0 != 0) goto <D.25170>; else goto <D.25171>;
      <D.25170>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.25125 = cmethod->klass;
        D.25173 = get_simd_ctor_spill_area (cfg, D.25125);
        D.25174 = D.25173->dreg;
        D.25175 = D.25174 + 1;
        D.25176 = (unsigned int) D.25175;
        D.25177 = cfg->vreg_to_inst_len;
        if (D.25176 < D.25177) goto <D.25178>; else goto <D.25179>;
        <D.25178>:
        D.25180 = cfg->vreg_to_inst;
        D.25125 = cmethod->klass;
        D.25181 = get_simd_ctor_spill_area (cfg, D.25125);
        D.25182 = D.25181->dreg;
        D.25183 = (sizetype) D.25182;
        D.25184 = D.25183 + 1;
        D.25185 = D.25184 * 8;
        D.25186 = D.25180 + D.25185;
        iftmp.31 = *D.25186;
        goto <D.25187>;
        <D.25179>:
        iftmp.31 = 0B;
        <D.25187>:
        var1 = iftmp.31;
        D.25125 = cmethod->klass;
        D.25189 = get_simd_ctor_spill_area (cfg, D.25125);
        D.25190 = D.25189->dreg;
        D.25191 = D.25190 + 2;
        D.25192 = (unsigned int) D.25191;
        D.25177 = cfg->vreg_to_inst_len;
        if (D.25192 < D.25177) goto <D.25193>; else goto <D.25194>;
        <D.25193>:
        D.25180 = cfg->vreg_to_inst;
        D.25125 = cmethod->klass;
        D.25195 = get_simd_ctor_spill_area (cfg, D.25125);
        D.25196 = D.25195->dreg;
        D.25197 = (sizetype) D.25196;
        D.25198 = D.25197 + 2;
        D.25199 = D.25198 * 8;
        D.25200 = D.25180 + D.25199;
        iftmp.32 = *D.25200;
        goto <D.25201>;
        <D.25194>:
        iftmp.32 = 0B;
        <D.25201>:
        var2 = iftmp.32;
        D.25202 = var1 == 0B;
        D.25203 = (long int) D.25202;
        D.25204 = __builtin_expect (D.25203, 0);
        if (D.25204 != 0) goto <D.25205>; else goto <D.25206>;
        <D.25205>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 1235, "var1");
        <D.25206>:
        D.25207 = var2 == 0B;
        D.25208 = (long int) D.25207;
        D.25209 = __builtin_expect (D.25208, 0);
        if (D.25209 != 0) goto <D.25210>; else goto <D.25211>;
        <D.25210>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 1235, "var2");
        <D.25211>:
        D.25212 = var1->flags;
        D.25213 = D.25212 | 16;
        var1->flags = D.25213;
        D.25214 = var2->flags;
        D.25215 = D.25214 | 16;
        var2->flags = D.25215;
      }
      <D.25171>:
      D.25129 = cfg->cbb;
      D.25130 = D.25129->last_ins;
      if (D.25130 != 0B) goto <D.25216>; else goto <D.25217>;
      <D.25216>:
      D.25129 = cfg->cbb;
      D.25130 = D.25129->last_ins;
      D.25130->next = ins;
      D.25129 = cfg->cbb;
      D.25130 = D.25129->last_ins;
      ins->prev = D.25130;
      D.25129 = cfg->cbb;
      D.25129->last_ins = ins;
      goto <D.25218>;
      <D.25217>:
      D.25129 = cfg->cbb;
      D.25129 = cfg->cbb;
      D.25129->last_ins = ins;
      D.25130 = D.25129->last_ins;
      D.25129->code = D.25130;
      <D.25218>:
      addr_reg = ins->dreg;
      goto <D.25219>;
      <D.25150>:
      D.25093 = *args;
      D.25220 = D.25093->type;
      D.25221 = D.25220 != 5;
      D.25222 = D.25220 != 3;
      D.25223 = D.25221 & D.25222;
      D.25224 = (int) D.25223;
      D.25225 = D.25224 != 0;
      D.25226 = (long int) D.25225;
      D.25227 = __builtin_expect (D.25226, 0);
      if (D.25227 != 0) goto <D.25228>; else goto <D.25229>;
      <D.25228>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 1239, "args [0]->type == STACK_MP || args [0]->type == STACK_PTR");
      <D.25229>:
      D.25093 = *args;
      addr_reg = D.25093->dreg;
      <D.25219>:
      D.25098 = sig->param_count;
      D.25230 = (int) D.25098;
      i.33 = D.25230 + -1;
      i = i.33;
      goto <D.22779>;
      <D.22778>:
      D.25118 = cfg->mempool;
      ins = mono_mempool_alloc (D.25118, 80);
      ins->data.op[1].const_val = 0;
      D.25119 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.25119;
      ins->prev = 0B;
      D.25120 = ins->prev;
      ins->next = D.25120;
      D.25232 = (short unsigned int) store_op;
      ins->opcode = D.25232;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.25122 = ins->sreg3;
      ins->sreg2 = D.25122;
      D.25123 = ins->sreg2;
      ins->sreg1 = D.25123;
      D.25124 = cfg->ip;
      ins->cil_code = D.25124;
      i.34 = i;
      D.25234 = (sizetype) i.34;
      D.25235 = D.25234 + 1;
      D.25236 = D.25235 * 8;
      D.25237 = args + D.25236;
      D.25238 = *D.25237;
      D.25239 = D.25238->dreg;
      ins->sreg1 = D.25239;
      ins->dreg = addr_reg;
      i.34 = i;
      D.25240 = i.34 * arg_size;
      D.25241 = (long int) D.25240;
      ins->data.op[0].const_val = D.25241;
      D.25129 = cfg->cbb;
      D.25130 = D.25129->last_ins;
      if (D.25130 != 0B) goto <D.25242>; else goto <D.25243>;
      <D.25242>:
      D.25129 = cfg->cbb;
      D.25130 = D.25129->last_ins;
      D.25130->next = ins;
      D.25129 = cfg->cbb;
      D.25130 = D.25129->last_ins;
      ins->prev = D.25130;
      D.25129 = cfg->cbb;
      D.25129->last_ins = ins;
      goto <D.25244>;
      <D.25243>:
      D.25129 = cfg->cbb;
      D.25129 = cfg->cbb;
      D.25129->last_ins = ins;
      D.25130 = D.25129->last_ins;
      D.25129->code = D.25130;
      <D.25244>:
      i.34 = i;
      i.35 = i.34 + -1;
      i = i.35;
      <D.22779>:
      i.34 = i;
      if (i.34 >= 0) goto <D.22778>; else goto <D.22780>;
      <D.22780>:
      if (is_ldaddr != 0) goto <D.25246>; else goto <D.25247>;
      <D.25246>:
      {
        int vreg;

        D.25093 = *args;
        D.25248 = D.25093->data.op[0].p;
        vreg = MEM[(struct MonoInst *)D.25248].dreg;
        D.25093 = *args;
        D.25093->opcode = 316;
        D.25093 = *args;
        D.25093->dreg = -1;
        D.25093 = *args;
        D.25093 = *args;
        D.25093 = *args;
        D.25093->sreg3 = -1;
        D.25104 = D.25093->sreg3;
        D.25093->sreg2 = D.25104;
        D.25105 = D.25093->sreg2;
        D.25093->sreg1 = D.25105;
        D.25118 = cfg->mempool;
        ins = mono_mempool_alloc (D.25118, 80);
        ins->data.op[1].const_val = 0;
        D.25119 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.25119;
        ins->prev = 0B;
        D.25120 = ins->prev;
        ins->next = D.25120;
        ins->opcode = 401;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.25122 = ins->sreg3;
        ins->sreg2 = D.25122;
        D.25123 = ins->sreg2;
        ins->sreg1 = D.25123;
        D.25124 = cfg->ip;
        ins->cil_code = D.25124;
        D.25125 = cmethod->klass;
        ins->klass = D.25125;
        ins->sreg1 = addr_reg;
        ins->type = 7;
        ins->dreg = vreg;
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        if (D.25130 != 0B) goto <D.25249>; else goto <D.25250>;
        <D.25249>:
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        D.25130->next = ins;
        D.25129 = cfg->cbb;
        D.25130 = D.25129->last_ins;
        ins->prev = D.25130;
        D.25129 = cfg->cbb;
        D.25129->last_ins = ins;
        goto <D.25251>;
        <D.25250>:
        D.25129 = cfg->cbb;
        D.25129 = cfg->cbb;
        D.25129->last_ins = ins;
        D.25130 = D.25129->last_ins;
        D.25129->code = D.25130;
        <D.25251>:
      }
      <D.25247>:
      D.25148 = ins;
      return D.25148;
    }
  finally
    {
      i = {CLOBBER};
    }
}


get_simd_ctor_spill_area (struct MonoCompile * cfg, struct MonoClass * avector_klass)
{
  struct MonoInst * D.25254;
  struct MonoType * D.25257;
  struct MonoInst * D.25258;
  unsigned char D.25259;
  unsigned char D.25260;
  struct MonoInst * D.25261;

  D.25254 = cfg->simd_ctor_var;
  if (D.25254 == 0B) goto <D.25255>; else goto <D.25256>;
  <D.25255>:
  D.25257 = &avector_klass->byval_arg;
  D.25258 = mono_compile_create_var (cfg, D.25257, 329);
  cfg->simd_ctor_var = D.25258;
  D.25254 = cfg->simd_ctor_var;
  D.25254 = cfg->simd_ctor_var;
  D.25259 = D.25254->flags;
  D.25260 = D.25259 | 4;
  D.25254->flags = D.25260;
  <D.25256>:
  D.25261 = cfg->simd_ctor_var;
  return D.25261;
}


handle_gsharedvt_ldaddr (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.25263;
  long int D.25264;
  struct MonoInst * D.25265;
  int D.25266;
  int D.25267;
  const unsigned char * D.25268;
  struct MonoInst * D.25269;
  int D.25270;
  struct MonoBasicBlock * D.25271;
  struct MonoInst * D.25272;
  struct MonoInst * D.25276;
  int D.25277;
  struct MonoInst * use;

  D.25263 = cfg->mempool;
  use = mono_mempool_alloc (D.25263, 80);
  use->data.op[1].const_val = 0;
  D.25264 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.25264;
  use->prev = 0B;
  D.25265 = use->prev;
  use->next = D.25265;
  use->opcode = 800;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.25266 = use->sreg3;
  use->sreg2 = D.25266;
  D.25267 = use->sreg2;
  use->sreg1 = D.25267;
  D.25268 = cfg->ip;
  use->cil_code = D.25268;
  D.25269 = cfg->gsharedvt_info_var;
  D.25270 = D.25269->dreg;
  use->sreg1 = D.25270;
  D.25271 = cfg->cbb;
  D.25272 = D.25271->last_ins;
  if (D.25272 != 0B) goto <D.25273>; else goto <D.25274>;
  <D.25273>:
  D.25271 = cfg->cbb;
  D.25272 = D.25271->last_ins;
  D.25272->next = use;
  D.25271 = cfg->cbb;
  D.25272 = D.25271->last_ins;
  use->prev = D.25272;
  D.25271 = cfg->cbb;
  D.25271->last_ins = use;
  goto <D.25275>;
  <D.25274>:
  D.25271 = cfg->cbb;
  D.25271 = cfg->cbb;
  D.25271->last_ins = use;
  D.25272 = D.25271->last_ins;
  D.25271->code = D.25272;
  <D.25275>:
  D.25263 = cfg->mempool;
  use = mono_mempool_alloc (D.25263, 80);
  use->data.op[1].const_val = 0;
  D.25264 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.25264;
  use->prev = 0B;
  D.25265 = use->prev;
  use->next = D.25265;
  use->opcode = 800;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.25266 = use->sreg3;
  use->sreg2 = D.25266;
  D.25267 = use->sreg2;
  use->sreg1 = D.25267;
  D.25268 = cfg->ip;
  use->cil_code = D.25268;
  D.25276 = cfg->gsharedvt_locals_var;
  D.25277 = D.25276->dreg;
  use->sreg1 = D.25277;
  D.25271 = cfg->cbb;
  D.25272 = D.25271->last_ins;
  if (D.25272 != 0B) goto <D.25278>; else goto <D.25279>;
  <D.25278>:
  D.25271 = cfg->cbb;
  D.25272 = D.25271->last_ins;
  D.25272->next = use;
  D.25271 = cfg->cbb;
  D.25272 = D.25271->last_ins;
  use->prev = D.25272;
  D.25271 = cfg->cbb;
  D.25271->last_ins = use;
  goto <D.25280>;
  <D.25279>:
  D.25271 = cfg->cbb;
  D.25271 = cfg->cbb;
  D.25271->last_ins = use;
  D.25272 = D.25271->last_ins;
  D.25271->code = D.25272;
  <D.25280>:
}


simd_intrinsic_emit_cast (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.25281;
  struct MonoMemPool * D.25282;
  long int D.25283;
  struct MonoInst * D.25284;
  int D.25285;
  int D.25286;
  const unsigned char * D.25287;
  struct MonoClass * D.25288;
  unsigned int D.25289;
  int D.25290;
  struct MonoBasicBlock * D.25291;
  struct MonoInst * D.25292;
  struct MonoInst * D.25296;
  struct MonoInst * ins;
  int vreg;

  D.25281 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.25281);
  D.25282 = cfg->mempool;
  ins = mono_mempool_alloc (D.25282, 80);
  ins->data.op[1].const_val = 0;
  D.25283 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25283;
  ins->prev = 0B;
  D.25284 = ins->prev;
  ins->next = D.25284;
  ins->opcode = 962;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25285 = ins->sreg3;
  ins->sreg2 = D.25285;
  D.25286 = ins->sreg2;
  ins->sreg1 = D.25286;
  D.25287 = cfg->ip;
  ins->cil_code = D.25287;
  D.25288 = cmethod->klass;
  ins->klass = D.25288;
  ins->type = 7;
  ins->sreg1 = vreg;
  D.25289 = alloc_ireg (cfg);
  D.25290 = (int) D.25289;
  ins->dreg = D.25290;
  D.25291 = cfg->cbb;
  D.25292 = D.25291->last_ins;
  if (D.25292 != 0B) goto <D.25293>; else goto <D.25294>;
  <D.25293>:
  D.25291 = cfg->cbb;
  D.25292 = D.25291->last_ins;
  D.25292->next = ins;
  D.25291 = cfg->cbb;
  D.25292 = D.25291->last_ins;
  ins->prev = D.25292;
  D.25291 = cfg->cbb;
  D.25291->last_ins = ins;
  goto <D.25295>;
  <D.25294>:
  D.25291 = cfg->cbb;
  D.25291 = cfg->cbb;
  D.25291->last_ins = ins;
  D.25292 = D.25291->last_ins;
  D.25291->code = D.25292;
  <D.25295>:
  D.25296 = ins;
  return D.25296;
}


simd_intrinsic_emit_shuffle (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMethodSignature * D.25298;
  short unsigned int D.25299;
  long unsigned int D.25300;
  long unsigned int D.25301;
  sizetype D.25302;
  struct MonoInst * * D.25303;
  struct MonoInst * D.25304;
  short unsigned int D.25305;
  struct MonoInst * D.25308;
  struct MonoInst * D.25309;
  struct MonoInst * * D.25312;
  struct MonoInst * D.25313;
  int D.25314;
  int D.25315;
  struct MonoMemPool * D.25316;
  long int D.25317;
  struct MonoInst * D.25318;
  short unsigned int D.25319;
  int D.25320;
  int D.25321;
  const unsigned char * D.25322;
  struct MonoClass * D.25323;
  long int D.25324;
  unsigned int D.25325;
  int D.25326;
  struct MonoBasicBlock * D.25327;
  struct MonoInst * D.25328;
  short unsigned int D.25334;
  struct MonoInst * ins;
  int vreg;
  int vreg2;
  int param_count;

  vreg2 = -1;
  D.25298 = mono_method_signature (cmethod);
  D.25299 = D.25298->param_count;
  param_count = (int) D.25299;
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25305 = D.25304->opcode;
  if (D.25305 != 362) goto <D.25306>; else goto <D.25307>;
  <D.25306>:
  D.25308 = 0B;
  return D.25308;
  <D.25307>:
  D.25309 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.25309);
  if (param_count == 3) goto <D.25310>; else goto <D.25311>;
  <D.25310>:
  D.25312 = args + 8;
  D.25313 = *D.25312;
  vreg2 = get_simd_vreg (cfg, cmethod, D.25313);
  <D.25311>:
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25304->opcode = 316;
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25304->dreg = -1;
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25304->sreg3 = -1;
  D.25314 = D.25304->sreg3;
  D.25304->sreg2 = D.25314;
  D.25315 = D.25304->sreg2;
  D.25304->sreg1 = D.25315;
  D.25316 = cfg->mempool;
  ins = mono_mempool_alloc (D.25316, 80);
  ins->data.op[1].const_val = 0;
  D.25317 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25317;
  ins->prev = 0B;
  D.25318 = ins->prev;
  ins->next = D.25318;
  D.25319 = intrinsic->opcode;
  ins->opcode = D.25319;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25320 = ins->sreg3;
  ins->sreg2 = D.25320;
  D.25321 = ins->sreg2;
  ins->sreg1 = D.25321;
  D.25322 = cfg->ip;
  ins->cil_code = D.25322;
  D.25323 = cmethod->klass;
  ins->klass = D.25323;
  ins->sreg1 = vreg;
  ins->sreg2 = vreg2;
  D.25300 = (long unsigned int) param_count;
  D.25301 = D.25300 * 8;
  D.25302 = D.25301 + 18446744073709551608;
  D.25303 = args + D.25302;
  D.25304 = *D.25303;
  D.25324 = D.25304->data.op[0].const_val;
  ins->data.op[0].const_val = D.25324;
  ins->type = 7;
  D.25325 = alloc_ireg (cfg);
  D.25326 = (int) D.25325;
  ins->dreg = D.25326;
  D.25327 = cfg->cbb;
  D.25328 = D.25327->last_ins;
  if (D.25328 != 0B) goto <D.25329>; else goto <D.25330>;
  <D.25329>:
  D.25327 = cfg->cbb;
  D.25328 = D.25327->last_ins;
  D.25328->next = ins;
  D.25327 = cfg->cbb;
  D.25328 = D.25327->last_ins;
  ins->prev = D.25328;
  D.25327 = cfg->cbb;
  D.25327->last_ins = ins;
  goto <D.25331>;
  <D.25330>:
  D.25327 = cfg->cbb;
  D.25327 = cfg->cbb;
  D.25327->last_ins = ins;
  D.25328 = D.25327->last_ins;
  D.25327->code = D.25328;
  <D.25331>:
  if (param_count == 3) goto <D.25332>; else goto <D.25333>;
  <D.25332>:
  D.25334 = ins->opcode;
  if (D.25334 == 825) goto <D.25335>; else goto <D.25336>;
  <D.25335>:
  ins->opcode = 826;
  <D.25336>:
  <D.25333>:
  D.25308 = ins;
  return D.25308;
}


simd_intrinsic_emit_shift (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  short unsigned int D.25338;
  struct MonoInst * D.25339;
  struct MonoInst * * D.25340;
  struct MonoInst * D.25341;
  short unsigned int D.25342;
  struct MonoMemPool * D.25345;
  long int D.25346;
  struct MonoInst * D.25347;
  int D.25348;
  int D.25349;
  const unsigned char * D.25350;
  struct MonoClass * D.25351;
  int D.25352;
  unsigned int D.25353;
  struct MonoBasicBlock * D.25354;
  struct MonoInst * D.25355;
  short unsigned int D.25359;
  struct MonoClass * D.25360;
  long int D.25363;
  int D.25364;
  int D.25365;
  unsigned int D.25366;
  int D.25367;
  struct MonoInst * D.25371;
  struct MonoInst * ins;
  int vreg;
  int vreg2;
  int opcode;

  vreg2 = -1;
  D.25338 = intrinsic->opcode;
  opcode = (int) D.25338;
  D.25339 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.25339);
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25342 = D.25341->opcode;
  if (D.25342 != 362) goto <D.25343>; else goto <D.25344>;
  <D.25343>:
  D.25345 = cfg->mempool;
  ins = mono_mempool_alloc (D.25345, 80);
  ins->data.op[1].const_val = 0;
  D.25346 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25346;
  ins->prev = 0B;
  D.25347 = ins->prev;
  ins->next = D.25347;
  ins->opcode = 946;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25348 = ins->sreg3;
  ins->sreg2 = D.25348;
  D.25349 = ins->sreg2;
  ins->sreg1 = D.25349;
  D.25350 = cfg->ip;
  ins->cil_code = D.25350;
  D.25351 = mono_defaults.int32_class;
  ins->klass = D.25351;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25352 = D.25341->dreg;
  ins->sreg1 = D.25352;
  ins->type = 1;
  D.25353 = alloc_ireg (cfg);
  vreg2 = (int) D.25353;
  ins->dreg = vreg2;
  D.25354 = cfg->cbb;
  D.25355 = D.25354->last_ins;
  if (D.25355 != 0B) goto <D.25356>; else goto <D.25357>;
  <D.25356>:
  D.25354 = cfg->cbb;
  D.25355 = D.25354->last_ins;
  D.25355->next = ins;
  D.25354 = cfg->cbb;
  D.25355 = D.25354->last_ins;
  ins->prev = D.25355;
  D.25354 = cfg->cbb;
  D.25354->last_ins = ins;
  goto <D.25358>;
  <D.25357>:
  D.25354 = cfg->cbb;
  D.25354 = cfg->cbb;
  D.25354->last_ins = ins;
  D.25355 = D.25354->last_ins;
  D.25354->code = D.25355;
  <D.25358>:
  opcode = opcode + 1;
  <D.25344>:
  D.25345 = cfg->mempool;
  ins = mono_mempool_alloc (D.25345, 80);
  ins->data.op[1].const_val = 0;
  D.25346 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25346;
  ins->prev = 0B;
  D.25347 = ins->prev;
  ins->next = D.25347;
  D.25359 = (short unsigned int) opcode;
  ins->opcode = D.25359;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25348 = ins->sreg3;
  ins->sreg2 = D.25348;
  D.25349 = ins->sreg2;
  ins->sreg1 = D.25349;
  D.25350 = cfg->ip;
  ins->cil_code = D.25350;
  D.25360 = cmethod->klass;
  ins->klass = D.25360;
  ins->sreg1 = vreg;
  ins->sreg2 = vreg2;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25342 = D.25341->opcode;
  if (D.25342 == 362) goto <D.25361>; else goto <D.25362>;
  <D.25361>:
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25363 = D.25341->data.op[0].const_val;
  ins->data.op[1].const_val = D.25363;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25341->opcode = 316;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25341->dreg = -1;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25340 = args + 8;
  D.25341 = *D.25340;
  D.25341->sreg3 = -1;
  D.25364 = D.25341->sreg3;
  D.25341->sreg2 = D.25364;
  D.25365 = D.25341->sreg2;
  D.25341->sreg1 = D.25365;
  <D.25362>:
  ins->type = 7;
  D.25366 = alloc_ireg (cfg);
  D.25367 = (int) D.25366;
  ins->dreg = D.25367;
  D.25354 = cfg->cbb;
  D.25355 = D.25354->last_ins;
  if (D.25355 != 0B) goto <D.25368>; else goto <D.25369>;
  <D.25368>:
  D.25354 = cfg->cbb;
  D.25355 = D.25354->last_ins;
  D.25355->next = ins;
  D.25354 = cfg->cbb;
  D.25355 = D.25354->last_ins;
  ins->prev = D.25355;
  D.25354 = cfg->cbb;
  D.25354->last_ins = ins;
  goto <D.25370>;
  <D.25369>:
  D.25354 = cfg->cbb;
  D.25354 = cfg->cbb;
  D.25354->last_ins = ins;
  D.25355 = D.25354->last_ins;
  D.25354->code = D.25355;
  <D.25370>:
  D.25371 = ins;
  return D.25371;
}


simd_intrinsic_emit_equality (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.25373;
  struct MonoInst * * D.25374;
  struct MonoInst * D.25375;
  struct MonoMemPool * D.25376;
  long int D.25377;
  struct MonoInst * D.25378;
  short unsigned int D.25379;
  int D.25380;
  int D.25381;
  const unsigned char * D.25382;
  struct MonoClass * D.25383;
  unsigned int D.25384;
  <unnamed-unsigned:4> D.25385;
  long int D.25386;
  struct MonoBasicBlock * D.25387;
  struct MonoInst * D.25388;
  unsigned int D.25392;
  int D.25399;
  int D.25400;
  unsigned char D.25402;
  unsigned char D.25403;
  long int D.25404;
  struct MonoInst * D.25405;
  int D.25406;
  int D.25407;
  guint16 iftmp.36;
  long int D.25415;
  struct MonoInst * D.25416;
  int D.25417;
  int D.25418;
  struct MonoInst * D.25425;
  struct MonoInst * ins;
  int left_vreg;
  int right_vreg;
  int tmp_vreg;

  D.25373 = *args;
  left_vreg = get_simd_vreg (cfg, cmethod, D.25373);
  D.25374 = args + 8;
  D.25375 = *D.25374;
  right_vreg = get_simd_vreg (cfg, cmethod, D.25375);
  D.25376 = cfg->mempool;
  ins = mono_mempool_alloc (D.25376, 80);
  ins->data.op[1].const_val = 0;
  D.25377 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25377;
  ins->prev = 0B;
  D.25378 = ins->prev;
  ins->next = D.25378;
  D.25379 = intrinsic->opcode;
  ins->opcode = D.25379;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25380 = ins->sreg3;
  ins->sreg2 = D.25380;
  D.25381 = ins->sreg2;
  ins->sreg1 = D.25381;
  D.25382 = cfg->ip;
  ins->cil_code = D.25382;
  D.25383 = cmethod->klass;
  ins->klass = D.25383;
  ins->sreg1 = left_vreg;
  ins->sreg2 = right_vreg;
  ins->type = 7;
  D.25383 = cmethod->klass;
  ins->klass = D.25383;
  D.25384 = alloc_ireg (cfg);
  tmp_vreg = (int) D.25384;
  ins->dreg = tmp_vreg;
  D.25385 = intrinsic->flags;
  D.25386 = (long int) D.25385;
  ins->data.op[0].const_val = D.25386;
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  if (D.25388 != 0B) goto <D.25389>; else goto <D.25390>;
  <D.25389>:
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  D.25388->next = ins;
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  ins->prev = D.25388;
  D.25387 = cfg->cbb;
  D.25387->last_ins = ins;
  goto <D.25391>;
  <D.25390>:
  D.25387 = cfg->cbb;
  D.25387 = cfg->cbb;
  D.25387->last_ins = ins;
  D.25388 = D.25387->last_ins;
  D.25387->code = D.25388;
  <D.25391>:
  D.25376 = cfg->mempool;
  ins = mono_mempool_alloc (D.25376, 80);
  ins->data.op[1].const_val = 0;
  D.25377 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25377;
  ins->prev = 0B;
  D.25378 = ins->prev;
  ins->next = D.25378;
  ins->opcode = 844;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25380 = ins->sreg3;
  ins->sreg2 = D.25380;
  D.25381 = ins->sreg2;
  ins->sreg1 = D.25381;
  D.25382 = cfg->ip;
  ins->cil_code = D.25382;
  D.25383 = cmethod->klass;
  ins->klass = D.25383;
  ins->sreg1 = tmp_vreg;
  ins->type = 1;
  D.25392 = alloc_ireg (cfg);
  tmp_vreg = (int) D.25392;
  ins->dreg = tmp_vreg;
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  if (D.25388 != 0B) goto <D.25393>; else goto <D.25394>;
  <D.25393>:
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  D.25388->next = ins;
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  ins->prev = D.25388;
  D.25387 = cfg->cbb;
  D.25387->last_ins = ins;
  goto <D.25395>;
  <D.25394>:
  D.25387 = cfg->cbb;
  D.25387 = cfg->cbb;
  D.25387->last_ins = ins;
  D.25388 = D.25387->last_ins;
  D.25387->code = D.25388;
  <D.25395>:
  D.25379 = intrinsic->opcode;
  D.25399 = (int) D.25379;
  D.25400 = mono_op_is_packed_compare (D.25399);
  if (D.25400 != 0) goto <D.25396>; else goto <D.25401>;
  <D.25401>:
  D.25402 = BIT_FIELD_REF <*intrinsic, 8, 40>;
  D.25403 = D.25402 & 240;
  if (D.25403 == 0) goto <D.25396>; else goto <D.25397>;
  <D.25396>:
  {
    struct MonoInst * inst;

    D.25376 = cfg->mempool;
    inst = mono_mempool_alloc (D.25376, 80);
    inst->data.op[1].const_val = 0;
    D.25404 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25404;
    inst->prev = 0B;
    D.25405 = inst->prev;
    inst->next = D.25405;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25406 = inst->sreg3;
    inst->sreg2 = D.25406;
    D.25407 = inst->sreg2;
    inst->sreg1 = D.25407;
    D.25382 = cfg->ip;
    inst->cil_code = D.25382;
    inst->dreg = -1;
    inst->sreg1 = tmp_vreg;
    inst->data.op[1].const_val = 65535;
    D.25387 = cfg->cbb;
    D.25388 = D.25387->last_ins;
    if (D.25388 != 0B) goto <D.25408>; else goto <D.25409>;
    <D.25408>:
    D.25387 = cfg->cbb;
    D.25388 = D.25387->last_ins;
    D.25388->next = inst;
    D.25387 = cfg->cbb;
    D.25388 = D.25387->last_ins;
    inst->prev = D.25388;
    D.25387 = cfg->cbb;
    D.25387->last_ins = inst;
    goto <D.25410>;
    <D.25409>:
    D.25387 = cfg->cbb;
    D.25387 = cfg->cbb;
    D.25387->last_ins = inst;
    D.25388 = D.25387->last_ins;
    D.25387->code = D.25388;
    <D.25410>:
  }
  D.25376 = cfg->mempool;
  ins = mono_mempool_alloc (D.25376, 80);
  ins->data.op[1].const_val = 0;
  D.25377 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25377;
  ins->prev = 0B;
  D.25378 = ins->prev;
  ins->next = D.25378;
  D.25402 = BIT_FIELD_REF <*intrinsic, 8, 40>;
  D.25403 = D.25402 & 240;
  if (D.25403 == 0) goto <D.25412>; else goto <D.25413>;
  <D.25412>:
  iftmp.36 = 450;
  goto <D.25414>;
  <D.25413>:
  iftmp.36 = 454;
  <D.25414>:
  ins->opcode = iftmp.36;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25380 = ins->sreg3;
  ins->sreg2 = D.25380;
  D.25381 = ins->sreg2;
  ins->sreg1 = D.25381;
  D.25382 = cfg->ip;
  ins->cil_code = D.25382;
  ins->dreg = tmp_vreg;
  ins->sreg1 = -1;
  goto <D.25398>;
  <D.25397>:
  {
    struct MonoInst * inst;

    D.25376 = cfg->mempool;
    inst = mono_mempool_alloc (D.25376, 80);
    inst->data.op[1].const_val = 0;
    D.25415 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25415;
    inst->prev = 0B;
    D.25416 = inst->prev;
    inst->next = D.25416;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25417 = inst->sreg3;
    inst->sreg2 = D.25417;
    D.25418 = inst->sreg2;
    inst->sreg1 = D.25418;
    D.25382 = cfg->ip;
    inst->cil_code = D.25382;
    inst->dreg = -1;
    inst->sreg1 = tmp_vreg;
    inst->data.op[1].const_val = 0;
    D.25387 = cfg->cbb;
    D.25388 = D.25387->last_ins;
    if (D.25388 != 0B) goto <D.25419>; else goto <D.25420>;
    <D.25419>:
    D.25387 = cfg->cbb;
    D.25388 = D.25387->last_ins;
    D.25388->next = inst;
    D.25387 = cfg->cbb;
    D.25388 = D.25387->last_ins;
    inst->prev = D.25388;
    D.25387 = cfg->cbb;
    D.25387->last_ins = inst;
    goto <D.25421>;
    <D.25420>:
    D.25387 = cfg->cbb;
    D.25387 = cfg->cbb;
    D.25387->last_ins = inst;
    D.25388 = D.25387->last_ins;
    D.25387->code = D.25388;
    <D.25421>:
  }
  D.25376 = cfg->mempool;
  ins = mono_mempool_alloc (D.25376, 80);
  ins->data.op[1].const_val = 0;
  D.25377 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25377;
  ins->prev = 0B;
  D.25378 = ins->prev;
  ins->next = D.25378;
  ins->opcode = 452;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25380 = ins->sreg3;
  ins->sreg2 = D.25380;
  D.25381 = ins->sreg2;
  ins->sreg1 = D.25381;
  D.25382 = cfg->ip;
  ins->cil_code = D.25382;
  ins->dreg = tmp_vreg;
  ins->sreg1 = -1;
  <D.25398>:
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  if (D.25388 != 0B) goto <D.25422>; else goto <D.25423>;
  <D.25422>:
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  D.25388->next = ins;
  D.25387 = cfg->cbb;
  D.25388 = D.25387->last_ins;
  ins->prev = D.25388;
  D.25387 = cfg->cbb;
  D.25387->last_ins = ins;
  goto <D.25424>;
  <D.25423>:
  D.25387 = cfg->cbb;
  D.25387 = cfg->cbb;
  D.25387->last_ins = ins;
  D.25388 = D.25387->last_ins;
  D.25387->code = D.25388;
  <D.25424>:
  D.25425 = ins;
  return D.25425;
}


mono_op_is_packed_compare (int op)
{
  gboolean D.25427;
  unsigned int op.37;
  unsigned int D.25429;
  _Bool D.25430;

  op.37 = (unsigned int) op;
  D.25429 = op.37 + 4294966426;
  D.25430 = D.25429 <= 3;
  D.25427 = (gboolean) D.25430;
  return D.25427;
}


simd_intrinsic_emit_load_aligned (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMemPool * D.25432;
  long int D.25433;
  struct MonoInst * D.25434;
  int D.25435;
  int D.25436;
  const unsigned char * D.25437;
  struct MonoClass * D.25438;
  struct MonoInst * D.25439;
  int D.25440;
  unsigned int D.25441;
  int D.25442;
  struct MonoBasicBlock * D.25443;
  struct MonoInst * D.25444;
  struct MonoInst * D.25448;
  struct MonoInst * ins;

  D.25432 = cfg->mempool;
  ins = mono_mempool_alloc (D.25432, 80);
  ins->data.op[1].const_val = 0;
  D.25433 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25433;
  ins->prev = 0B;
  D.25434 = ins->prev;
  ins->next = D.25434;
  ins->opcode = 402;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25435 = ins->sreg3;
  ins->sreg2 = D.25435;
  D.25436 = ins->sreg2;
  ins->sreg1 = D.25436;
  D.25437 = cfg->ip;
  ins->cil_code = D.25437;
  D.25438 = cmethod->klass;
  ins->klass = D.25438;
  D.25439 = *args;
  D.25440 = D.25439->dreg;
  ins->sreg1 = D.25440;
  ins->type = 7;
  D.25441 = alloc_ireg (cfg);
  D.25442 = (int) D.25441;
  ins->dreg = D.25442;
  D.25443 = cfg->cbb;
  D.25444 = D.25443->last_ins;
  if (D.25444 != 0B) goto <D.25445>; else goto <D.25446>;
  <D.25445>:
  D.25443 = cfg->cbb;
  D.25444 = D.25443->last_ins;
  D.25444->next = ins;
  D.25443 = cfg->cbb;
  D.25444 = D.25443->last_ins;
  ins->prev = D.25444;
  D.25443 = cfg->cbb;
  D.25443->last_ins = ins;
  goto <D.25447>;
  <D.25446>:
  D.25443 = cfg->cbb;
  D.25443 = cfg->cbb;
  D.25443->last_ins = ins;
  D.25444 = D.25443->last_ins;
  D.25443->code = D.25444;
  <D.25447>:
  D.25448 = ins;
  return D.25448;
}


simd_intrinsic_emit_store (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * * D.25450;
  struct MonoInst * D.25451;
  struct MonoMemPool * D.25452;
  long int D.25453;
  struct MonoInst * D.25454;
  short unsigned int D.25455;
  int D.25456;
  int D.25457;
  const unsigned char * D.25458;
  struct MonoClass * D.25459;
  struct MonoInst * D.25460;
  int D.25461;
  struct MonoBasicBlock * D.25462;
  struct MonoInst * D.25463;
  struct MonoInst * D.25467;
  struct MonoInst * ins;
  int vreg;

  D.25450 = args + 8;
  D.25451 = *D.25450;
  vreg = get_simd_vreg (cfg, cmethod, D.25451);
  D.25452 = cfg->mempool;
  ins = mono_mempool_alloc (D.25452, 80);
  ins->data.op[1].const_val = 0;
  D.25453 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25453;
  ins->prev = 0B;
  D.25454 = ins->prev;
  ins->next = D.25454;
  D.25455 = intrinsic->opcode;
  ins->opcode = D.25455;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25456 = ins->sreg3;
  ins->sreg2 = D.25456;
  D.25457 = ins->sreg2;
  ins->sreg1 = D.25457;
  D.25458 = cfg->ip;
  ins->cil_code = D.25458;
  D.25459 = cmethod->klass;
  ins->klass = D.25459;
  D.25460 = *args;
  D.25461 = D.25460->dreg;
  ins->dreg = D.25461;
  ins->sreg1 = vreg;
  ins->type = 7;
  D.25462 = cfg->cbb;
  D.25463 = D.25462->last_ins;
  if (D.25463 != 0B) goto <D.25464>; else goto <D.25465>;
  <D.25464>:
  D.25462 = cfg->cbb;
  D.25463 = D.25462->last_ins;
  D.25463->next = ins;
  D.25462 = cfg->cbb;
  D.25463 = D.25462->last_ins;
  ins->prev = D.25463;
  D.25462 = cfg->cbb;
  D.25462->last_ins = ins;
  goto <D.25466>;
  <D.25465>:
  D.25462 = cfg->cbb;
  D.25462 = cfg->cbb;
  D.25462->last_ins = ins;
  D.25463 = D.25462->last_ins;
  D.25462->code = D.25463;
  <D.25466>:
  D.25467 = ins;
  return D.25467;
}


simd_intrinsic_emit_extract_mask (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.25469;
  struct MonoMemPool * D.25470;
  long int D.25471;
  struct MonoInst * D.25472;
  int D.25473;
  int D.25474;
  const unsigned char * D.25475;
  struct MonoClass * D.25476;
  unsigned int D.25477;
  int D.25478;
  struct MonoBasicBlock * D.25479;
  struct MonoInst * D.25480;
  struct MonoInst * D.25484;
  struct MonoInst * ins;
  int vreg;

  D.25469 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.25469);
  D.25470 = cfg->mempool;
  ins = mono_mempool_alloc (D.25470, 80);
  ins->data.op[1].const_val = 0;
  D.25471 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25471;
  ins->prev = 0B;
  D.25472 = ins->prev;
  ins->next = D.25472;
  ins->opcode = 844;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25473 = ins->sreg3;
  ins->sreg2 = D.25473;
  D.25474 = ins->sreg2;
  ins->sreg1 = D.25474;
  D.25475 = cfg->ip;
  ins->cil_code = D.25475;
  D.25476 = cmethod->klass;
  ins->klass = D.25476;
  ins->sreg1 = vreg;
  ins->type = 1;
  D.25477 = alloc_ireg (cfg);
  D.25478 = (int) D.25477;
  ins->dreg = D.25478;
  D.25479 = cfg->cbb;
  D.25480 = D.25479->last_ins;
  if (D.25480 != 0B) goto <D.25481>; else goto <D.25482>;
  <D.25481>:
  D.25479 = cfg->cbb;
  D.25480 = D.25479->last_ins;
  D.25480->next = ins;
  D.25479 = cfg->cbb;
  D.25480 = D.25479->last_ins;
  ins->prev = D.25480;
  D.25479 = cfg->cbb;
  D.25479->last_ins = ins;
  goto <D.25483>;
  <D.25482>:
  D.25479 = cfg->cbb;
  D.25479 = cfg->cbb;
  D.25479->last_ins = ins;
  D.25480 = D.25479->last_ins;
  D.25479->code = D.25480;
  <D.25483>:
  D.25484 = ins;
  return D.25484;
}


simd_intrinsic_emit_prefetch (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMemPool * D.25486;
  long int D.25487;
  struct MonoInst * D.25488;
  int D.25489;
  int D.25490;
  const unsigned char * D.25491;
  struct MonoClass * D.25492;
  struct MonoInst * D.25493;
  int D.25494;
  <unnamed-unsigned:4> D.25495;
  int D.25496;
  struct MonoBasicBlock * D.25497;
  struct MonoInst * D.25498;
  struct MonoInst * D.25502;
  struct MonoInst * ins;

  D.25486 = cfg->mempool;
  ins = mono_mempool_alloc (D.25486, 80);
  ins->data.op[1].const_val = 0;
  D.25487 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25487;
  ins->prev = 0B;
  D.25488 = ins->prev;
  ins->next = D.25488;
  ins->opcode = 953;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25489 = ins->sreg3;
  ins->sreg2 = D.25489;
  D.25490 = ins->sreg2;
  ins->sreg1 = D.25490;
  D.25491 = cfg->ip;
  ins->cil_code = D.25491;
  D.25492 = cmethod->klass;
  ins->klass = D.25492;
  D.25493 = *args;
  D.25494 = D.25493->dreg;
  ins->sreg1 = D.25494;
  D.25495 = intrinsic->flags;
  D.25496 = (int) D.25495;
  ins->backend.arg_info = D.25496;
  D.25497 = cfg->cbb;
  D.25498 = D.25497->last_ins;
  if (D.25498 != 0B) goto <D.25499>; else goto <D.25500>;
  <D.25499>:
  D.25497 = cfg->cbb;
  D.25498 = D.25497->last_ins;
  D.25498->next = ins;
  D.25497 = cfg->cbb;
  D.25498 = D.25497->last_ins;
  ins->prev = D.25498;
  D.25497 = cfg->cbb;
  D.25497->last_ins = ins;
  goto <D.25501>;
  <D.25500>:
  D.25497 = cfg->cbb;
  D.25497 = cfg->cbb;
  D.25497->last_ins = ins;
  D.25498 = D.25497->last_ins;
  D.25497->code = D.25498;
  <D.25501>:
  D.25502 = ins;
  return D.25502;
}


