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.22739;
  unsigned int i.1;
  unsigned int D.22741;
  struct MonoInst * * D.22742;
  struct MonoClass * D.22743;
  unsigned char D.22744;
  unsigned char D.22745;
  unsigned char D.22748;
  unsigned char D.22749;
  int D.22750;
  unsigned int i.2;
  unsigned int D.22752;
  struct MonoInst * D.22755;
  short unsigned int D.22758;
  struct MonoClass * D.22761;
  unsigned char D.22762;
  unsigned char D.22763;
  unsigned char D.22766;
  unsigned char D.22767;
  unsigned int D.22768;
  int D.22771;
  unsigned int D.22772;
  unsigned int D.22773;
  unsigned int D.22774;
  struct MonoClass * D.22775;
  unsigned char D.22776;
  unsigned char D.22777;
  unsigned char D.22780;
  int D.22781;
  int D.22782;
  int D.22785;
  sizetype D.22786;
  char * D.22787;
  int D.22792;
  sizetype D.22793;
  char * D.22794;
  char D.22795;
  int D.22796;
  int D.22797;
  signed char D.22802;
  void * D.22805;
  int D.22806;
  int D.22807;
  int D.22810;
  int D.22813;
  int D.22814;
  int D.22815;
  int D.22816;
  int D.22817;
  signed char D.22818;
  int D.22819;
  int D.22820;
  struct MonoClass * D.22824;
  unsigned char D.22825;
  unsigned char D.22826;
  int D.22829;
  sizetype D.22830;
  char * D.22831;
  char D.22832;
  int D.22833;
  int D.22834;
  int D.22839;
  int D.22846;
  int D.22849;
  int D.22852;
  int D.22853;
  struct MonoClass * D.22856;
  unsigned char D.22857;
  unsigned char D.22858;
  int D.22861;
  sizetype D.22862;
  char * D.22863;
  char D.22864;
  int D.22865;
  int D.22866;
  int D.22871;
  unsigned int D.22878;
  unsigned int D.22879;
  struct MonoBasicBlock * * D.22880;
  struct MonoBasicBlock * D.22881;
  int D.22882;
  struct MonoMemPool * D.22890;
  int D.22891;
  struct MonoInst * D.22892;
  int D.22893;
  int D.22894;
  const unsigned char * D.22895;
  int D.22898;
  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.22121>;
  <D.22120>:
  {
    struct MonoInst * var;

    D.22739 = cfg->varinfo;
    i.1 = (unsigned int) i;
    D.22741 = i.1 * 4;
    D.22742 = D.22739 + D.22741;
    var = *D.22742;
    D.22743 = var->klass;
    D.22744 = BIT_FIELD_REF <*D.22743, 8, 192>;
    D.22745 = D.22744 & 2;
    if (D.22745 != 0) goto <D.22746>; else goto <D.22747>;
    <D.22746>:
    D.22748 = var->flags;
    D.22749 = D.22748 & 239;
    var->flags = D.22749;
    D.22750 = var->dreg;
    max_vreg = MAX_EXPR <D.22750, max_vreg>;
    <D.22747>:
  }
  i = i + 1;
  <D.22121>:
  i.2 = (unsigned int) i;
  D.22752 = cfg->num_varinfo;
  if (i.2 < D.22752) goto <D.22120>; else goto <D.22122>;
  <D.22122>:
  bb = cfg->bb_entry;
  goto <D.22128>;
  <D.22127>:
  if (first_bb == 0B) goto <D.22753>; else goto <D.22754>;
  <D.22753>:
  D.22755 = bb->code;
  if (D.22755 != 0B) goto <D.22756>; else goto <D.22757>;
  <D.22756>:
  first_bb = bb;
  <D.22757>:
  <D.22754>:
  ins = bb->code;
  goto <D.22125>;
  <D.22124>:
  D.22758 = ins->opcode;
  if (D.22758 == 314) goto <D.22759>; else goto <D.22760>;
  <D.22759>:
  {
    struct MonoInst * var;

    var = ins->data.op[0].p;
    D.22761 = var->klass;
    D.22762 = BIT_FIELD_REF <*D.22761, 8, 192>;
    D.22763 = D.22762 & 2;
    if (D.22763 != 0) goto <D.22764>; else goto <D.22765>;
    <D.22764>:
    D.22766 = var->flags;
    D.22767 = D.22766 | 16;
    var->flags = D.22767;
    <D.22765>:
  }
  <D.22760>:
  ins = ins->next;
  <D.22125>:
  if (ins != 0B) goto <D.22124>; else goto <D.22126>;
  <D.22126>:
  bb = bb->next_bb;
  <D.22128>:
  if (bb != 0B) goto <D.22127>; else goto <D.22129>;
  <D.22129>:
  D.22768 = cfg->verbose_level;
  if (D.22768 > 2) goto <D.22769>; else goto <D.22770>;
  <D.22769>:
  printf ("[simd-simplify] max vreg is %d\n", max_vreg);
  <D.22770>:
  D.22771 = max_vreg + 1;
  D.22772 = (unsigned int) D.22771;
  vreg_flags = monoeg_malloc0 (D.22772);
  D.22771 = max_vreg + 1;
  D.22773 = (unsigned int) D.22771;
  D.22774 = D.22773 * 4;
  target_bb = monoeg_malloc0 (D.22774);
  i = 0;
  goto <D.22132>;
  <D.22131>:
  {
    struct MonoInst * var;

    D.22739 = cfg->varinfo;
    i.1 = (unsigned int) i;
    D.22741 = i.1 * 4;
    D.22742 = D.22739 + D.22741;
    var = *D.22742;
    D.22775 = var->klass;
    D.22776 = BIT_FIELD_REF <*D.22775, 8, 192>;
    D.22777 = D.22776 & 2;
    if (D.22777 != 0) goto <D.22778>; else goto <D.22779>;
    <D.22778>:
    D.22780 = var->flags;
    D.22781 = (int) D.22780;
    D.22782 = D.22781 & 20;
    if (D.22782 == 0) goto <D.22783>; else goto <D.22784>;
    <D.22783>:
    D.22785 = var->dreg;
    D.22786 = (sizetype) D.22785;
    D.22787 = vreg_flags + D.22786;
    *D.22787 = 1;
    D.22768 = cfg->verbose_level;
    if (D.22768 > 2) goto <D.22788>; else goto <D.22789>;
    <D.22788>:
    D.22785 = var->dreg;
    printf ("[simd-simplify] processing var %d with vreg %d\n", i, D.22785);
    <D.22789>:
    <D.22784>:
    <D.22779>:
  }
  i = i + 1;
  <D.22132>:
  i.2 = (unsigned int) i;
  D.22752 = cfg->num_varinfo;
  if (i.2 < D.22752) goto <D.22131>; else goto <D.22133>;
  <D.22133>:
  ins = first_bb->code;
  goto <D.22141>;
  <D.22140>:
  {
    int num_sregs;
    int sregs[3];

    try
      {
        D.22758 = ins->opcode;
        if (D.22758 == 963) goto <D.22790>; else goto <D.22791>;
        <D.22790>:
        D.22792 = ins->dreg;
        D.22793 = (sizetype) D.22792;
        D.22794 = vreg_flags + D.22793;
        D.22795 = *D.22794;
        D.22796 = (int) D.22795;
        D.22797 = D.22796 & 4;
        if (D.22797 == 0) goto <D.22798>; else goto <D.22799>;
        <D.22798>:
        D.22768 = cfg->verbose_level;
        if (D.22768 > 2) goto <D.22800>; else goto <D.22801>;
        <D.22800>:
        D.22792 = ins->dreg;
        printf ("[simd-simplify] R%d has vzero: ", D.22792);
        mono_print_ins (ins);
        <D.22801>:
        D.22792 = ins->dreg;
        D.22793 = (sizetype) D.22792;
        D.22794 = vreg_flags + D.22793;
        D.22792 = ins->dreg;
        D.22793 = (sizetype) D.22792;
        D.22794 = vreg_flags + D.22793;
        D.22795 = *D.22794;
        D.22802 = D.22795 | 2;
        *D.22794 = D.22802;
        <D.22799>:
        // predicted unlikely by continue predictor.
        goto <D.22136>;
        <D.22791>:
        D.22758 = ins->opcode;
        if (D.22758 == 314) goto <D.22803>; else goto <D.22804>;
        <D.22803>:
        D.22805 = ins->data.op[0].p;
        D.22806 = MEM[(struct MonoInst *)D.22805].dreg;
        D.22807 = apply_vreg_first_block_interference (cfg, ins, D.22806, max_vreg, vreg_flags);
        if (D.22807 != 0) goto <D.22808>; else goto <D.22809>;
        <D.22808>:
        // predicted unlikely by continue predictor.
        goto <D.22136>;
        <D.22809>:
        <D.22804>:
        D.22792 = ins->dreg;
        D.22810 = apply_vreg_first_block_interference (cfg, ins, D.22792, max_vreg, vreg_flags);
        if (D.22810 != 0) goto <D.22811>; else goto <D.22812>;
        <D.22811>:
        // predicted unlikely by continue predictor.
        goto <D.22136>;
        <D.22812>:
        D.22813 = ins->sreg1;
        sregs[0] = D.22813;
        D.22814 = ins->sreg2;
        sregs[1] = D.22814;
        D.22815 = ins->sreg3;
        sregs[2] = D.22815;
        D.22758 = ins->opcode;
        D.22816 = (int) D.22758;
        D.22817 = D.22816 + -313;
        D.22818 = ins_sreg_counts[D.22817];
        num_sregs = (int) D.22818;
        i = 0;
        goto <D.22139>;
        <D.22138>:
        D.22819 = sregs[i];
        D.22820 = apply_vreg_first_block_interference (cfg, ins, D.22819, max_vreg, vreg_flags);
        if (D.22820 != 0) goto <D.22137>; else goto <D.22821>;
        <D.22821>:
        i = i + 1;
        <D.22139>:
        if (i < num_sregs) goto <D.22138>; else goto <D.22137>;
        <D.22137>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22136>:
  ins = ins->next;
  <D.22141>:
  if (ins != 0B) goto <D.22140>; else goto <D.22142>;
  <D.22142>:
  D.22768 = cfg->verbose_level;
  if (D.22768 > 2) goto <D.22822>; else goto <D.22823>;
  <D.22822>:
  i = 0;
  goto <D.22145>;
  <D.22144>:
  {
    struct MonoInst * var;

    D.22739 = cfg->varinfo;
    i.1 = (unsigned int) i;
    D.22741 = i.1 * 4;
    D.22742 = D.22739 + D.22741;
    var = *D.22742;
    D.22824 = var->klass;
    D.22825 = BIT_FIELD_REF <*D.22824, 8, 192>;
    D.22826 = D.22825 & 2;
    if (D.22826 != 0) goto <D.22827>; else goto <D.22828>;
    <D.22827>:
    D.22829 = var->dreg;
    D.22830 = (sizetype) D.22829;
    D.22831 = vreg_flags + D.22830;
    D.22832 = *D.22831;
    D.22833 = (int) D.22832;
    D.22834 = D.22833 & 2;
    if (D.22834 != 0) goto <D.22835>; else goto <D.22836>;
    <D.22835>:
    D.22768 = cfg->verbose_level;
    if (D.22768 > 2) goto <D.22837>; else goto <D.22838>;
    <D.22837>:
    D.22829 = var->dreg;
    printf ("[simd-simplify] R%d has xzero only\n", D.22829);
    <D.22838>:
    <D.22836>:
    D.22829 = var->dreg;
    D.22830 = (sizetype) D.22829;
    D.22831 = vreg_flags + D.22830;
    D.22832 = *D.22831;
    D.22833 = (int) D.22832;
    D.22839 = D.22833 & 4;
    if (D.22839 != 0) goto <D.22840>; else goto <D.22841>;
    <D.22840>:
    D.22768 = cfg->verbose_level;
    if (D.22768 > 2) goto <D.22842>; else goto <D.22843>;
    <D.22842>:
    D.22829 = var->dreg;
    printf ("[simd-simplify] R%d has other ops on bb0\n", D.22829);
    <D.22843>:
    <D.22841>:
    <D.22828>:
  }
  i = i + 1;
  <D.22145>:
  i.2 = (unsigned int) i;
  D.22752 = cfg->num_varinfo;
  if (i.2 < D.22752) goto <D.22144>; else goto <D.22146>;
  <D.22146>:
  <D.22823>:
  bb = first_bb->next_bb;
  goto <D.22158>;
  <D.22157>:
  ins = bb->code;
  goto <D.22155>;
  <D.22154>:
  {
    int num_sregs;
    int sregs[3];

    try
      {
        D.22758 = ins->opcode;
        if (D.22758 == 314) goto <D.22844>; else goto <D.22845>;
        <D.22844>:
        D.22805 = ins->data.op[0].p;
        D.22806 = MEM[(struct MonoInst *)D.22805].dreg;
        D.22846 = apply_vreg_following_block_interference (cfg, ins, D.22806, bb, max_vreg, vreg_flags, target_bb);
        if (D.22846 != 0) goto <D.22847>; else goto <D.22848>;
        <D.22847>:
        // predicted unlikely by continue predictor.
        goto <D.22149>;
        <D.22848>:
        <D.22845>:
        D.22792 = ins->dreg;
        D.22849 = apply_vreg_following_block_interference (cfg, ins, D.22792, bb, max_vreg, vreg_flags, target_bb);
        if (D.22849 != 0) goto <D.22850>; else goto <D.22851>;
        <D.22850>:
        // predicted unlikely by continue predictor.
        goto <D.22149>;
        <D.22851>:
        D.22813 = ins->sreg1;
        sregs[0] = D.22813;
        D.22814 = ins->sreg2;
        sregs[1] = D.22814;
        D.22815 = ins->sreg3;
        sregs[2] = D.22815;
        D.22758 = ins->opcode;
        D.22816 = (int) D.22758;
        D.22817 = D.22816 + -313;
        D.22818 = ins_sreg_counts[D.22817];
        num_sregs = (int) D.22818;
        i = 0;
        goto <D.22152>;
        <D.22151>:
        D.22852 = sregs[i];
        D.22853 = apply_vreg_following_block_interference (cfg, ins, D.22852, bb, max_vreg, vreg_flags, target_bb);
        if (D.22853 != 0) goto <D.22854>; else goto <D.22855>;
        <D.22854>:
        // predicted unlikely by continue predictor.
        goto <D.22150>;
        <D.22855>:
        <D.22150>:
        i = i + 1;
        <D.22152>:
        if (i < num_sregs) goto <D.22151>; else goto <D.22153>;
        <D.22153>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22149>:
  ins = ins->next;
  <D.22155>:
  if (ins != 0B) goto <D.22154>; else goto <D.22156>;
  <D.22156>:
  bb = bb->next_bb;
  <D.22158>:
  if (bb != 0B) goto <D.22157>; else goto <D.22159>;
  <D.22159>:
  i = 0;
  goto <D.22174>;
  <D.22173>:
  {
    struct MonoInst * var;

    D.22739 = cfg->varinfo;
    i.1 = (unsigned int) i;
    D.22741 = i.1 * 4;
    D.22742 = D.22739 + D.22741;
    var = *D.22742;
    D.22856 = var->klass;
    D.22857 = BIT_FIELD_REF <*D.22856, 8, 192>;
    D.22858 = D.22857 & 2;
    if (D.22858 == 0) goto <D.22859>; else goto <D.22860>;
    <D.22859>:
    // predicted unlikely by continue predictor.
    goto <D.22161>;
    <D.22860>:
    D.22861 = var->dreg;
    D.22862 = (sizetype) D.22861;
    D.22863 = vreg_flags + D.22862;
    D.22864 = *D.22863;
    D.22865 = (int) D.22864;
    D.22866 = D.22865 & 8;
    if (D.22866 != 0) goto <D.22867>; else goto <D.22868>;
    <D.22867>:
    D.22768 = cfg->verbose_level;
    if (D.22768 > 2) goto <D.22869>; else goto <D.22870>;
    <D.22869>:
    D.22861 = var->dreg;
    printf ("[simd-simplify] R%d has single bb use\n", D.22861);
    <D.22870>:
    <D.22868>:
    D.22861 = var->dreg;
    D.22862 = (sizetype) D.22861;
    D.22863 = vreg_flags + D.22862;
    D.22864 = *D.22863;
    D.22865 = (int) D.22864;
    D.22871 = D.22865 & 16;
    if (D.22871 != 0) goto <D.22872>; else goto <D.22873>;
    <D.22872>:
    D.22768 = cfg->verbose_level;
    if (D.22768 > 2) goto <D.22874>; else goto <D.22875>;
    <D.22874>:
    D.22861 = var->dreg;
    printf ("[simd-simplify] R%d has many bb in use\n", D.22861);
    <D.22875>:
    <D.22873>:
    D.22861 = var->dreg;
    D.22862 = (sizetype) D.22861;
    D.22863 = vreg_flags + D.22862;
    D.22864 = *D.22863;
    D.22865 = (int) D.22864;
    D.22866 = D.22865 & 8;
    if (D.22866 == 0) goto <D.22876>; else goto <D.22877>;
    <D.22876>:
    // predicted unlikely by continue predictor.
    goto <D.22161>;
    <D.22877>:
    D.22861 = var->dreg;
    D.22878 = (unsigned int) D.22861;
    D.22879 = D.22878 * 4;
    D.22880 = target_bb + D.22879;
    D.22881 = *D.22880;
    ins = D.22881->code;
    goto <D.22172>;
    <D.22171>:
    {
      int num_sregs;
      int j;
      int sregs[3];
      gboolean found;

      try
        {
          found = 0;
          D.22813 = ins->sreg1;
          sregs[0] = D.22813;
          D.22814 = ins->sreg2;
          sregs[1] = D.22814;
          D.22815 = ins->sreg3;
          sregs[2] = D.22815;
          D.22758 = ins->opcode;
          D.22816 = (int) D.22758;
          D.22817 = D.22816 + -313;
          D.22818 = ins_sreg_counts[D.22817];
          num_sregs = (int) D.22818;
          j = 0;
          goto <D.22167>;
          <D.22166>:
          D.22882 = sregs[i];
          D.22861 = var->dreg;
          if (D.22882 == D.22861) goto <D.22883>; else goto <D.22884>;
          <D.22883>:
          found = 1;
          <D.22884>:
          j = j + 1;
          <D.22167>:
          if (j < num_sregs) goto <D.22166>; else goto <D.22168>;
          <D.22168>:
          D.22792 = ins->dreg;
          D.22861 = var->dreg;
          if (D.22792 == D.22861) goto <D.22887>; else goto <D.22885>;
          <D.22887>:
          if (found == 0) goto <D.22169>; else goto <D.22885>;
          goto <D.22886>;
          <D.22885>:
          if (found != 0) goto <D.22888>; else goto <D.22889>;
          <D.22888>:
          {
            struct MonoInst * tmp;

            D.22890 = cfg->mempool;
            tmp = mono_mempool_alloc (D.22890, 48);
            tmp->data.op[1].const_val = 0;
            D.22891 = tmp->data.op[1].const_val;
            tmp->data.op[0].const_val = D.22891;
            tmp->prev = 0B;
            D.22892 = tmp->prev;
            tmp->next = D.22892;
            tmp->opcode = 963;
            tmp->flags = 0;
            tmp->type = 0;
            tmp->dreg = -1;
            tmp->sreg3 = -1;
            D.22893 = tmp->sreg3;
            tmp->sreg2 = D.22893;
            D.22894 = tmp->sreg2;
            tmp->sreg1 = D.22894;
            D.22895 = cfg->ip;
            tmp->cil_code = D.22895;
            D.22861 = var->dreg;
            tmp->dreg = D.22861;
            tmp->type = 7;
            D.22856 = var->klass;
            tmp->klass = D.22856;
            D.22861 = var->dreg;
            D.22878 = (unsigned int) D.22861;
            D.22879 = D.22878 * 4;
            D.22880 = target_bb + D.22879;
            D.22881 = *D.22880;
            mono_bblock_insert_before_ins (D.22881, ins, tmp);
            goto <D.22169>;
          }
          <D.22889>:
          <D.22886>:
        }
      finally
        {
          sregs = {CLOBBER};
        }
    }
    ins = ins->next;
    <D.22172>:
    if (ins != 0B) goto <D.22171>; else goto <D.22169>;
    <D.22169>:
  }
  <D.22161>:
  i = i + 1;
  <D.22174>:
  i.2 = (unsigned int) i;
  D.22752 = cfg->num_varinfo;
  if (i.2 < D.22752) goto <D.22173>; else goto <D.22175>;
  <D.22175>:
  ins = first_bb->code;
  goto <D.22177>;
  <D.22176>:
  D.22758 = ins->opcode;
  if (D.22758 == 963) goto <D.22896>; else goto <D.22897>;
  <D.22896>:
  D.22792 = ins->dreg;
  D.22793 = (sizetype) D.22792;
  D.22794 = vreg_flags + D.22793;
  D.22795 = *D.22794;
  D.22796 = (int) D.22795;
  D.22898 = D.22796 & 8;
  if (D.22898 != 0) goto <D.22899>; else goto <D.22900>;
  <D.22899>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.22815 = ins->sreg3;
  ins->sreg2 = D.22815;
  D.22814 = ins->sreg2;
  ins->sreg1 = D.22814;
  <D.22900>:
  <D.22897>:
  ins = ins->next;
  <D.22177>:
  if (ins != 0B) goto <D.22176>; else goto <D.22178>;
  <D.22178>:
  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.22907;
  _Bool D.22908;
  _Bool D.22909;
  sizetype reg.3;
  char * D.22913;
  char D.22914;
  char D.22917;
  signed char D.22918;
  unsigned int D.22919;
  gboolean D.22922;

  D.22907 = reg != -1;
  D.22908 = reg <= max_vreg;
  D.22909 = D.22907 & D.22908;
  if (D.22909 != 0) goto <D.22910>; else goto <D.22911>;
  <D.22910>:
  reg.3 = (sizetype) reg;
  D.22913 = vreg_flags + reg.3;
  D.22914 = *D.22913;
  if (D.22914 != 0) goto <D.22915>; else goto <D.22916>;
  <D.22915>:
  reg.3 = (sizetype) reg;
  D.22913 = vreg_flags + reg.3;
  reg.3 = (sizetype) reg;
  D.22913 = vreg_flags + reg.3;
  D.22914 = *D.22913;
  D.22917 = D.22914 & -3;
  *D.22913 = D.22917;
  reg.3 = (sizetype) reg;
  D.22913 = vreg_flags + reg.3;
  reg.3 = (sizetype) reg;
  D.22913 = vreg_flags + reg.3;
  D.22914 = *D.22913;
  D.22918 = D.22914 | 4;
  *D.22913 = D.22918;
  D.22919 = cfg->verbose_level;
  if (D.22919 > 2) goto <D.22920>; else goto <D.22921>;
  <D.22920>:
  printf ("[simd-simplify] R%d used: ", reg);
  mono_print_ins (ins);
  <D.22921>:
  D.22922 = 1;
  return D.22922;
  <D.22916>:
  <D.22911>:
  D.22922 = 0;
  return D.22922;
}


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.22926;
  _Bool D.22927;
  _Bool D.22928;
  sizetype reg.4;
  char * D.22931;
  char D.22932;
  int D.22933;
  int D.22934;
  unsigned int reg.5;
  unsigned int D.22937;
  struct MonoBasicBlock * * D.22938;
  struct MonoBasicBlock * D.22939;
  gboolean D.22940;
  int D.22941;
  char D.22944;
  signed char D.22945;
  unsigned int D.22946;
  int D.22949;
  signed char D.22952;

  D.22926 = reg == -1;
  D.22927 = reg > max_vreg;
  D.22928 = D.22926 | D.22927;
  if (D.22928 != 0) goto <D.22924>; else goto <D.22929>;
  <D.22929>:
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  D.22932 = *D.22931;
  D.22933 = (int) D.22932;
  D.22934 = D.22933 & 2;
  if (D.22934 == 0) goto <D.22924>; else goto <D.22935>;
  <D.22935>:
  reg.5 = (unsigned int) reg;
  D.22937 = reg.5 * 4;
  D.22938 = target_bb + D.22937;
  D.22939 = *D.22938;
  if (D.22939 == bb) goto <D.22924>; else goto <D.22925>;
  <D.22924>:
  D.22940 = 0;
  return D.22940;
  <D.22925>:
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  D.22932 = *D.22931;
  D.22933 = (int) D.22932;
  D.22941 = D.22933 & 8;
  if (D.22941 != 0) goto <D.22942>; else goto <D.22943>;
  <D.22942>:
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  D.22932 = *D.22931;
  D.22944 = D.22932 & -9;
  *D.22931 = D.22944;
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  D.22932 = *D.22931;
  D.22945 = D.22932 | 16;
  *D.22931 = D.22945;
  D.22946 = cfg->verbose_level;
  if (D.22946 > 2) goto <D.22947>; else goto <D.22948>;
  <D.22947>:
  printf ("[simd-simplify] R%d used by many bb: ", reg);
  mono_print_ins (ins);
  <D.22948>:
  D.22940 = 1;
  return D.22940;
  <D.22943>:
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  D.22932 = *D.22931;
  D.22933 = (int) D.22932;
  D.22949 = D.22933 & 16;
  if (D.22949 == 0) goto <D.22950>; else goto <D.22951>;
  <D.22950>:
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  reg.4 = (sizetype) reg;
  D.22931 = vreg_flags + reg.4;
  D.22932 = *D.22931;
  D.22952 = D.22932 | 8;
  *D.22931 = D.22952;
  reg.5 = (unsigned int) reg;
  D.22937 = reg.5 * 4;
  D.22938 = target_bb + D.22937;
  *D.22938 = bb;
  D.22946 = cfg->verbose_level;
  if (D.22946 > 2) goto <D.22953>; else goto <D.22954>;
  <D.22953>:
  printf ("[simd-simplify] R%d first used by: ", reg);
  mono_print_ins (ins);
  <D.22954>:
  D.22940 = 1;
  return D.22940;
  <D.22951>:
  D.22940 = 0;
  return D.22940;
}


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

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


mono_emit_simd_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  int D.22619;
  int iftmp.6;
  int D.22615;
  struct MonoClass * D.22961;
  const char[10] * D.22962;
  unsigned char D.22963;
  int D.22964;
  unsigned char D.22965;
  int D.22966;
  _Bool D.22967;
  _Bool D.22968;
  _Bool D.22969;
  const unsigned char * D.22972;
  unsigned char D.22973;
  int D.22974;
  const unsigned char * D.22975;
  unsigned char D.22976;
  int D.22977;
  _Bool D.22978;
  _Bool D.22979;
  const unsigned char * D.22982;
  unsigned char D.22983;
  int D.22984;
  const unsigned char * D.22985;
  unsigned char D.22986;
  int D.22987;
  _Bool D.22988;
  _Bool D.22989;
  const unsigned char * D.22992;
  unsigned char D.22993;
  int D.22994;
  const unsigned char * D.22995;
  unsigned char D.22996;
  int D.22997;
  const char * D.22999;
  struct MonoInst * D.23002;
  int D.22628;
  int iftmp.7;
  int D.22624;
  const char[12] * D.23006;
  unsigned char D.23007;
  int D.23008;
  unsigned char D.23009;
  int D.23010;
  _Bool D.23011;
  _Bool D.23012;
  _Bool D.23013;
  const unsigned char * D.23016;
  unsigned char D.23017;
  int D.23018;
  const unsigned char * D.23019;
  unsigned char D.23020;
  int D.23021;
  _Bool D.23022;
  _Bool D.23023;
  const unsigned char * D.23026;
  unsigned char D.23027;
  int D.23028;
  const unsigned char * D.23029;
  unsigned char D.23030;
  int D.23031;
  _Bool D.23032;
  _Bool D.23033;
  const unsigned char * D.23036;
  unsigned char D.23037;
  int D.23038;
  const unsigned char * D.23039;
  unsigned char D.23040;
  int D.23041;
  int D.22637;
  int iftmp.8;
  int D.22633;
  const char[16] * D.23048;
  unsigned char D.23049;
  int D.23050;
  unsigned char D.23051;
  int D.23052;
  _Bool D.23053;
  _Bool D.23054;
  _Bool D.23055;
  const unsigned char * D.23058;
  unsigned char D.23059;
  int D.23060;
  const unsigned char * D.23061;
  unsigned char D.23062;
  int D.23063;
  _Bool D.23064;
  _Bool D.23065;
  const unsigned char * D.23068;
  unsigned char D.23069;
  int D.23070;
  const unsigned char * D.23071;
  unsigned char D.23072;
  int D.23073;
  _Bool D.23074;
  _Bool D.23075;
  const unsigned char * D.23078;
  unsigned char D.23079;
  int D.23080;
  const unsigned char * D.23081;
  unsigned char D.23082;
  int D.23083;
  int D.22646;
  int iftmp.9;
  int D.22642;
  const char[17] * D.23090;
  unsigned char D.23091;
  int D.23092;
  unsigned char D.23093;
  int D.23094;
  _Bool D.23095;
  _Bool D.23096;
  _Bool D.23097;
  const unsigned char * D.23100;
  unsigned char D.23101;
  int D.23102;
  const unsigned char * D.23103;
  unsigned char D.23104;
  int D.23105;
  _Bool D.23106;
  _Bool D.23107;
  const unsigned char * D.23110;
  unsigned char D.23111;
  int D.23112;
  const unsigned char * D.23113;
  unsigned char D.23114;
  int D.23115;
  _Bool D.23116;
  _Bool D.23117;
  const unsigned char * D.23120;
  unsigned char D.23121;
  int D.23122;
  const unsigned char * D.23123;
  unsigned char D.23124;
  int D.23125;
  short unsigned int D.23129;
  int D.23130;
  int D.23131;
  struct MonoMethodSignature * D.23134;
  struct MonoType * D.23135;
  struct MonoClass * D.23136;
  unsigned char D.23138;
  unsigned char D.23139;
  int D.22655;
  int iftmp.10;
  int D.22651;
  const char[9] * D.23145;
  unsigned char D.23146;
  int D.23147;
  unsigned char D.23148;
  int D.23149;
  _Bool D.23150;
  _Bool D.23151;
  _Bool D.23152;
  const unsigned char * D.23155;
  unsigned char D.23156;
  int D.23157;
  const unsigned char * D.23158;
  unsigned char D.23159;
  int D.23160;
  _Bool D.23161;
  _Bool D.23162;
  const unsigned char * D.23165;
  unsigned char D.23166;
  int D.23167;
  const unsigned char * D.23168;
  unsigned char D.23169;
  int D.23170;
  _Bool D.23171;
  _Bool D.23172;
  const unsigned char * D.23175;
  unsigned char D.23176;
  int D.23177;
  const unsigned char * D.23178;
  unsigned char D.23179;
  int D.23180;
  int D.22664;
  int iftmp.11;
  int D.22660;
  const char[9] * D.23187;
  unsigned char D.23188;
  int D.23189;
  unsigned char D.23190;
  int D.23191;
  _Bool D.23192;
  _Bool D.23193;
  _Bool D.23194;
  const unsigned char * D.23197;
  unsigned char D.23198;
  int D.23199;
  const unsigned char * D.23200;
  unsigned char D.23201;
  int D.23202;
  _Bool D.23203;
  _Bool D.23204;
  const unsigned char * D.23207;
  unsigned char D.23208;
  int D.23209;
  const unsigned char * D.23210;
  unsigned char D.23211;
  int D.23212;
  _Bool D.23213;
  _Bool D.23214;
  const unsigned char * D.23217;
  unsigned char D.23218;
  int D.23219;
  const unsigned char * D.23220;
  unsigned char D.23221;
  int D.23222;
  int D.22673;
  int iftmp.12;
  int D.22669;
  const char[10] * D.23229;
  unsigned char D.23230;
  int D.23231;
  unsigned char D.23232;
  int D.23233;
  _Bool D.23234;
  _Bool D.23235;
  _Bool D.23236;
  const unsigned char * D.23239;
  unsigned char D.23240;
  int D.23241;
  const unsigned char * D.23242;
  unsigned char D.23243;
  int D.23244;
  _Bool D.23245;
  _Bool D.23246;
  const unsigned char * D.23249;
  unsigned char D.23250;
  int D.23251;
  const unsigned char * D.23252;
  unsigned char D.23253;
  int D.23254;
  _Bool D.23255;
  _Bool D.23256;
  const unsigned char * D.23259;
  unsigned char D.23260;
  int D.23261;
  const unsigned char * D.23262;
  unsigned char D.23263;
  int D.23264;
  int D.22682;
  int iftmp.13;
  int D.22678;
  const char[9] * D.23271;
  unsigned char D.23272;
  int D.23273;
  unsigned char D.23274;
  int D.23275;
  _Bool D.23276;
  _Bool D.23277;
  _Bool D.23278;
  const unsigned char * D.23281;
  unsigned char D.23282;
  int D.23283;
  const unsigned char * D.23284;
  unsigned char D.23285;
  int D.23286;
  _Bool D.23287;
  _Bool D.23288;
  const unsigned char * D.23291;
  unsigned char D.23292;
  int D.23293;
  const unsigned char * D.23294;
  unsigned char D.23295;
  int D.23296;
  _Bool D.23297;
  _Bool D.23298;
  const unsigned char * D.23301;
  unsigned char D.23302;
  int D.23303;
  const unsigned char * D.23304;
  unsigned char D.23305;
  int D.23306;
  int D.22691;
  int iftmp.14;
  int D.22687;
  const char[10] * D.23313;
  unsigned char D.23314;
  int D.23315;
  unsigned char D.23316;
  int D.23317;
  _Bool D.23318;
  _Bool D.23319;
  _Bool D.23320;
  const unsigned char * D.23323;
  unsigned char D.23324;
  int D.23325;
  const unsigned char * D.23326;
  unsigned char D.23327;
  int D.23328;
  _Bool D.23329;
  _Bool D.23330;
  const unsigned char * D.23333;
  unsigned char D.23334;
  int D.23335;
  const unsigned char * D.23336;
  unsigned char D.23337;
  int D.23338;
  _Bool D.23339;
  _Bool D.23340;
  const unsigned char * D.23343;
  unsigned char D.23344;
  int D.23345;
  const unsigned char * D.23346;
  unsigned char D.23347;
  int D.23348;
  int D.22700;
  int iftmp.15;
  int D.22696;
  const char[9] * D.23355;
  unsigned char D.23356;
  int D.23357;
  unsigned char D.23358;
  int D.23359;
  _Bool D.23360;
  _Bool D.23361;
  _Bool D.23362;
  const unsigned char * D.23365;
  unsigned char D.23366;
  int D.23367;
  const unsigned char * D.23368;
  unsigned char D.23369;
  int D.23370;
  _Bool D.23371;
  _Bool D.23372;
  const unsigned char * D.23375;
  unsigned char D.23376;
  int D.23377;
  const unsigned char * D.23378;
  unsigned char D.23379;
  int D.23380;
  _Bool D.23381;
  _Bool D.23382;
  const unsigned char * D.23385;
  unsigned char D.23386;
  int D.23387;
  const unsigned char * D.23388;
  unsigned char D.23389;
  int D.23390;
  int D.22709;
  int iftmp.16;
  int D.22705;
  const char[10] * D.23397;
  unsigned char D.23398;
  int D.23399;
  unsigned char D.23400;
  int D.23401;
  _Bool D.23402;
  _Bool D.23403;
  _Bool D.23404;
  const unsigned char * D.23407;
  unsigned char D.23408;
  int D.23409;
  const unsigned char * D.23410;
  unsigned char D.23411;
  int D.23412;
  _Bool D.23413;
  _Bool D.23414;
  const unsigned char * D.23417;
  unsigned char D.23418;
  int D.23419;
  const unsigned char * D.23420;
  unsigned char D.23421;
  int D.23422;
  _Bool D.23423;
  _Bool D.23424;
  const unsigned char * D.23427;
  unsigned char D.23428;
  int D.23429;
  const unsigned char * D.23430;
  unsigned char D.23431;
  int D.23432;
  int D.22718;
  int iftmp.17;
  int D.22714;
  const char[9] * D.23439;
  unsigned char D.23440;
  int D.23441;
  unsigned char D.23442;
  int D.23443;
  _Bool D.23444;
  _Bool D.23445;
  _Bool D.23446;
  const unsigned char * D.23449;
  unsigned char D.23450;
  int D.23451;
  const unsigned char * D.23452;
  unsigned char D.23453;
  int D.23454;
  _Bool D.23455;
  _Bool D.23456;
  const unsigned char * D.23459;
  unsigned char D.23460;
  int D.23461;
  const unsigned char * D.23462;
  unsigned char D.23463;
  int D.23464;
  _Bool D.23465;
  _Bool D.23466;
  const unsigned char * D.23469;
  unsigned char D.23470;
  int D.23471;
  const unsigned char * D.23472;
  unsigned char D.23473;
  int D.23474;
  int D.22727;
  int iftmp.18;
  int D.22723;
  const char[10] * D.23481;
  unsigned char D.23482;
  int D.23483;
  unsigned char D.23484;
  int D.23485;
  _Bool D.23486;
  _Bool D.23487;
  _Bool D.23488;
  const unsigned char * D.23491;
  unsigned char D.23492;
  int D.23493;
  const unsigned char * D.23494;
  unsigned char D.23495;
  int D.23496;
  _Bool D.23497;
  _Bool D.23498;
  const unsigned char * D.23501;
  unsigned char D.23502;
  int D.23503;
  const unsigned char * D.23504;
  unsigned char D.23505;
  int D.23506;
  _Bool D.23507;
  _Bool D.23508;
  const unsigned char * D.23511;
  unsigned char D.23512;
  int D.23513;
  const unsigned char * D.23514;
  unsigned char D.23515;
  int D.23516;
  int D.22736;
  int iftmp.19;
  int D.22732;
  const char[11] * D.23523;
  unsigned char D.23524;
  int D.23525;
  unsigned char D.23526;
  int D.23527;
  _Bool D.23528;
  _Bool D.23529;
  _Bool D.23530;
  const unsigned char * D.23533;
  unsigned char D.23534;
  int D.23535;
  const unsigned char * D.23536;
  unsigned char D.23537;
  int D.23538;
  _Bool D.23539;
  _Bool D.23540;
  const unsigned char * D.23543;
  unsigned char D.23544;
  int D.23545;
  const unsigned char * D.23546;
  unsigned char D.23547;
  int D.23548;
  _Bool D.23549;
  _Bool D.23550;
  const unsigned char * D.23553;
  unsigned char D.23554;
  int D.23555;
  const unsigned char * D.23556;
  unsigned char D.23557;
  int D.23558;
  const char * class_name;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.22961 = cmethod->klass;
      __s2 = D.22961->name_space;
      D.22962 = "Mono.Simd";
      D.22963 = MEM[(const unsigned char *)D.22962];
      D.22964 = (int) D.22963;
      D.22965 = *__s2;
      D.22966 = (int) D.22965;
      __result = D.22964 - D.22966;
      {
        D.22967 = __s1_len != 0;
        D.22968 = __result == 0;
        D.22969 = D.22967 & D.22968;
        if (D.22969 != 0) goto <D.22970>; else goto <D.22971>;
        <D.22970>:
        D.22972 = &MEM[(void *)"Mono.Simd" + 1B];
        D.22973 = *D.22972;
        D.22974 = (int) D.22973;
        D.22975 = __s2 + 1;
        D.22976 = *D.22975;
        D.22977 = (int) D.22976;
        __result = D.22974 - D.22977;
        D.22978 = __s1_len > 1;
        D.22968 = __result == 0;
        D.22979 = D.22978 & D.22968;
        if (D.22979 != 0) goto <D.22980>; else goto <D.22981>;
        <D.22980>:
        D.22982 = &MEM[(void *)"Mono.Simd" + 2B];
        D.22983 = *D.22982;
        D.22984 = (int) D.22983;
        D.22985 = __s2 + 2;
        D.22986 = *D.22985;
        D.22987 = (int) D.22986;
        __result = D.22984 - D.22987;
        D.22988 = __s1_len > 2;
        D.22968 = __result == 0;
        D.22989 = D.22988 & D.22968;
        if (D.22989 != 0) goto <D.22990>; else goto <D.22991>;
        <D.22990>:
        D.22992 = &MEM[(void *)"Mono.Simd" + 3B];
        D.22993 = *D.22992;
        D.22994 = (int) D.22993;
        D.22995 = __s2 + 3;
        D.22996 = *D.22995;
        D.22997 = (int) D.22996;
        __result = D.22994 - D.22997;
        <D.22991>:
        <D.22981>:
        <D.22971>:
      }
      D.22615 = __result;
    }
    iftmp.6 = D.22615;
    goto <D.22998>;
    <D.22960>:
    D.22961 = cmethod->klass;
    D.22999 = D.22961->name_space;
    iftmp.6 = __builtin_strcmp ("Mono.Simd", D.22999);
    <D.22998>:
    D.22619 = iftmp.6;
  }
  if (D.22619 != 0) goto <D.23000>; else goto <D.23001>;
  <D.23000>:
  D.23002 = 0B;
  return D.23002;
  <D.23001>:
  D.22961 = cmethod->klass;
  class_name = D.22961->name;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23006 = "SimdRuntime";
      D.23007 = MEM[(const unsigned char *)D.23006];
      D.23008 = (int) D.23007;
      D.23009 = *__s2;
      D.23010 = (int) D.23009;
      __result = D.23008 - D.23010;
      {
        D.23011 = __s1_len != 0;
        D.23012 = __result == 0;
        D.23013 = D.23011 & D.23012;
        if (D.23013 != 0) goto <D.23014>; else goto <D.23015>;
        <D.23014>:
        D.23016 = &MEM[(void *)"SimdRuntime" + 1B];
        D.23017 = *D.23016;
        D.23018 = (int) D.23017;
        D.23019 = __s2 + 1;
        D.23020 = *D.23019;
        D.23021 = (int) D.23020;
        __result = D.23018 - D.23021;
        D.23022 = __s1_len > 1;
        D.23012 = __result == 0;
        D.23023 = D.23022 & D.23012;
        if (D.23023 != 0) goto <D.23024>; else goto <D.23025>;
        <D.23024>:
        D.23026 = &MEM[(void *)"SimdRuntime" + 2B];
        D.23027 = *D.23026;
        D.23028 = (int) D.23027;
        D.23029 = __s2 + 2;
        D.23030 = *D.23029;
        D.23031 = (int) D.23030;
        __result = D.23028 - D.23031;
        D.23032 = __s1_len > 2;
        D.23012 = __result == 0;
        D.23033 = D.23032 & D.23012;
        if (D.23033 != 0) goto <D.23034>; else goto <D.23035>;
        <D.23034>:
        D.23036 = &MEM[(void *)"SimdRuntime" + 3B];
        D.23037 = *D.23036;
        D.23038 = (int) D.23037;
        D.23039 = __s2 + 3;
        D.23040 = *D.23039;
        D.23041 = (int) D.23040;
        __result = D.23038 - D.23041;
        <D.23035>:
        <D.23025>:
        <D.23015>:
      }
      D.22624 = __result;
    }
    iftmp.7 = D.22624;
    goto <D.23042>;
    <D.23005>:
    iftmp.7 = __builtin_strcmp ("SimdRuntime", class_name);
    <D.23042>:
    D.22628 = iftmp.7;
  }
  if (D.22628 == 0) goto <D.23043>; else goto <D.23044>;
  <D.23043>:
  D.23002 = emit_simd_runtime_intrinsics (cfg, cmethod, fsig, args);
  return D.23002;
  <D.23044>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23048 = "ArrayExtensions";
      D.23049 = MEM[(const unsigned char *)D.23048];
      D.23050 = (int) D.23049;
      D.23051 = *__s2;
      D.23052 = (int) D.23051;
      __result = D.23050 - D.23052;
      {
        D.23053 = __s1_len != 0;
        D.23054 = __result == 0;
        D.23055 = D.23053 & D.23054;
        if (D.23055 != 0) goto <D.23056>; else goto <D.23057>;
        <D.23056>:
        D.23058 = &MEM[(void *)"ArrayExtensions" + 1B];
        D.23059 = *D.23058;
        D.23060 = (int) D.23059;
        D.23061 = __s2 + 1;
        D.23062 = *D.23061;
        D.23063 = (int) D.23062;
        __result = D.23060 - D.23063;
        D.23064 = __s1_len > 1;
        D.23054 = __result == 0;
        D.23065 = D.23064 & D.23054;
        if (D.23065 != 0) goto <D.23066>; else goto <D.23067>;
        <D.23066>:
        D.23068 = &MEM[(void *)"ArrayExtensions" + 2B];
        D.23069 = *D.23068;
        D.23070 = (int) D.23069;
        D.23071 = __s2 + 2;
        D.23072 = *D.23071;
        D.23073 = (int) D.23072;
        __result = D.23070 - D.23073;
        D.23074 = __s1_len > 2;
        D.23054 = __result == 0;
        D.23075 = D.23074 & D.23054;
        if (D.23075 != 0) goto <D.23076>; else goto <D.23077>;
        <D.23076>:
        D.23078 = &MEM[(void *)"ArrayExtensions" + 3B];
        D.23079 = *D.23078;
        D.23080 = (int) D.23079;
        D.23081 = __s2 + 3;
        D.23082 = *D.23081;
        D.23083 = (int) D.23082;
        __result = D.23080 - D.23083;
        <D.23077>:
        <D.23067>:
        <D.23057>:
      }
      D.22633 = __result;
    }
    iftmp.8 = D.22633;
    goto <D.23084>;
    <D.23047>:
    iftmp.8 = __builtin_strcmp ("ArrayExtensions", class_name);
    <D.23084>:
    D.22637 = iftmp.8;
  }
  if (D.22637 == 0) goto <D.23085>; else goto <D.23086>;
  <D.23085>:
  D.23002 = emit_array_extension_intrinsics (cfg, cmethod, fsig, args);
  return D.23002;
  <D.23086>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23090 = "VectorOperations";
      D.23091 = MEM[(const unsigned char *)D.23090];
      D.23092 = (int) D.23091;
      D.23093 = *__s2;
      D.23094 = (int) D.23093;
      __result = D.23092 - D.23094;
      {
        D.23095 = __s1_len != 0;
        D.23096 = __result == 0;
        D.23097 = D.23095 & D.23096;
        if (D.23097 != 0) goto <D.23098>; else goto <D.23099>;
        <D.23098>:
        D.23100 = &MEM[(void *)"VectorOperations" + 1B];
        D.23101 = *D.23100;
        D.23102 = (int) D.23101;
        D.23103 = __s2 + 1;
        D.23104 = *D.23103;
        D.23105 = (int) D.23104;
        __result = D.23102 - D.23105;
        D.23106 = __s1_len > 1;
        D.23096 = __result == 0;
        D.23107 = D.23106 & D.23096;
        if (D.23107 != 0) goto <D.23108>; else goto <D.23109>;
        <D.23108>:
        D.23110 = &MEM[(void *)"VectorOperations" + 2B];
        D.23111 = *D.23110;
        D.23112 = (int) D.23111;
        D.23113 = __s2 + 2;
        D.23114 = *D.23113;
        D.23115 = (int) D.23114;
        __result = D.23112 - D.23115;
        D.23116 = __s1_len > 2;
        D.23096 = __result == 0;
        D.23117 = D.23116 & D.23096;
        if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
        <D.23118>:
        D.23120 = &MEM[(void *)"VectorOperations" + 3B];
        D.23121 = *D.23120;
        D.23122 = (int) D.23121;
        D.23123 = __s2 + 3;
        D.23124 = *D.23123;
        D.23125 = (int) D.23124;
        __result = D.23122 - D.23125;
        <D.23119>:
        <D.23109>:
        <D.23099>:
      }
      D.22642 = __result;
    }
    iftmp.9 = D.22642;
    goto <D.23126>;
    <D.23089>:
    iftmp.9 = __builtin_strcmp ("VectorOperations", class_name);
    <D.23126>:
    D.22646 = iftmp.9;
  }
  if (D.22646 == 0) goto <D.23127>; else goto <D.23128>;
  <D.23127>:
  D.23129 = cmethod->flags;
  D.23130 = (int) D.23129;
  D.23131 = D.23130 & 16;
  if (D.23131 == 0) goto <D.23132>; else goto <D.23133>;
  <D.23132>:
  D.23002 = 0B;
  return D.23002;
  <D.23133>:
  D.23134 = mono_method_signature (cmethod);
  D.23135 = D.23134->params[0];
  D.23136 = mono_class_from_mono_type (D.23135);
  class_name = D.23136->name;
  goto <D.23137>;
  <D.23128>:
  D.22961 = cmethod->klass;
  D.23138 = BIT_FIELD_REF <*D.22961, 8, 192>;
  D.23139 = D.23138 & 2;
  if (D.23139 == 0) goto <D.23140>; else goto <D.23141>;
  <D.23140>:
  D.23002 = 0B;
  return D.23002;
  <D.23141>:
  <D.23137>:
  cfg->uses_simd_intrinsics = 1;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23145 = "Vector2d";
      D.23146 = MEM[(const unsigned char *)D.23145];
      D.23147 = (int) D.23146;
      D.23148 = *__s2;
      D.23149 = (int) D.23148;
      __result = D.23147 - D.23149;
      {
        D.23150 = __s1_len != 0;
        D.23151 = __result == 0;
        D.23152 = D.23150 & D.23151;
        if (D.23152 != 0) goto <D.23153>; else goto <D.23154>;
        <D.23153>:
        D.23155 = &MEM[(void *)"Vector2d" + 1B];
        D.23156 = *D.23155;
        D.23157 = (int) D.23156;
        D.23158 = __s2 + 1;
        D.23159 = *D.23158;
        D.23160 = (int) D.23159;
        __result = D.23157 - D.23160;
        D.23161 = __s1_len > 1;
        D.23151 = __result == 0;
        D.23162 = D.23161 & D.23151;
        if (D.23162 != 0) goto <D.23163>; else goto <D.23164>;
        <D.23163>:
        D.23165 = &MEM[(void *)"Vector2d" + 2B];
        D.23166 = *D.23165;
        D.23167 = (int) D.23166;
        D.23168 = __s2 + 2;
        D.23169 = *D.23168;
        D.23170 = (int) D.23169;
        __result = D.23167 - D.23170;
        D.23171 = __s1_len > 2;
        D.23151 = __result == 0;
        D.23172 = D.23171 & D.23151;
        if (D.23172 != 0) goto <D.23173>; else goto <D.23174>;
        <D.23173>:
        D.23175 = &MEM[(void *)"Vector2d" + 3B];
        D.23176 = *D.23175;
        D.23177 = (int) D.23176;
        D.23178 = __s2 + 3;
        D.23179 = *D.23178;
        D.23180 = (int) D.23179;
        __result = D.23177 - D.23180;
        <D.23174>:
        <D.23164>:
        <D.23154>:
      }
      D.22651 = __result;
    }
    iftmp.10 = D.22651;
    goto <D.23181>;
    <D.23144>:
    iftmp.10 = __builtin_strcmp ("Vector2d", class_name);
    <D.23181>:
    D.22655 = iftmp.10;
  }
  if (D.22655 == 0) goto <D.23182>; else goto <D.23183>;
  <D.23182>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector2d_intrinsics, 41);
  return D.23002;
  <D.23183>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23187 = "Vector4f";
      D.23188 = MEM[(const unsigned char *)D.23187];
      D.23189 = (int) D.23188;
      D.23190 = *__s2;
      D.23191 = (int) D.23190;
      __result = D.23189 - D.23191;
      {
        D.23192 = __s1_len != 0;
        D.23193 = __result == 0;
        D.23194 = D.23192 & D.23193;
        if (D.23194 != 0) goto <D.23195>; else goto <D.23196>;
        <D.23195>:
        D.23197 = &MEM[(void *)"Vector4f" + 1B];
        D.23198 = *D.23197;
        D.23199 = (int) D.23198;
        D.23200 = __s2 + 1;
        D.23201 = *D.23200;
        D.23202 = (int) D.23201;
        __result = D.23199 - D.23202;
        D.23203 = __s1_len > 1;
        D.23193 = __result == 0;
        D.23204 = D.23203 & D.23193;
        if (D.23204 != 0) goto <D.23205>; else goto <D.23206>;
        <D.23205>:
        D.23207 = &MEM[(void *)"Vector4f" + 2B];
        D.23208 = *D.23207;
        D.23209 = (int) D.23208;
        D.23210 = __s2 + 2;
        D.23211 = *D.23210;
        D.23212 = (int) D.23211;
        __result = D.23209 - D.23212;
        D.23213 = __s1_len > 2;
        D.23193 = __result == 0;
        D.23214 = D.23213 & D.23193;
        if (D.23214 != 0) goto <D.23215>; else goto <D.23216>;
        <D.23215>:
        D.23217 = &MEM[(void *)"Vector4f" + 3B];
        D.23218 = *D.23217;
        D.23219 = (int) D.23218;
        D.23220 = __s2 + 3;
        D.23221 = *D.23220;
        D.23222 = (int) D.23221;
        __result = D.23219 - D.23222;
        <D.23216>:
        <D.23206>:
        <D.23196>:
      }
      D.22660 = __result;
    }
    iftmp.11 = D.22660;
    goto <D.23223>;
    <D.23186>:
    iftmp.11 = __builtin_strcmp ("Vector4f", class_name);
    <D.23223>:
    D.22664 = iftmp.11;
  }
  if (D.22664 == 0) goto <D.23224>; else goto <D.23225>;
  <D.23224>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector4f_intrinsics, 51);
  return D.23002;
  <D.23225>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23229 = "Vector2ul";
      D.23230 = MEM[(const unsigned char *)D.23229];
      D.23231 = (int) D.23230;
      D.23232 = *__s2;
      D.23233 = (int) D.23232;
      __result = D.23231 - D.23233;
      {
        D.23234 = __s1_len != 0;
        D.23235 = __result == 0;
        D.23236 = D.23234 & D.23235;
        if (D.23236 != 0) goto <D.23237>; else goto <D.23238>;
        <D.23237>:
        D.23239 = &MEM[(void *)"Vector2ul" + 1B];
        D.23240 = *D.23239;
        D.23241 = (int) D.23240;
        D.23242 = __s2 + 1;
        D.23243 = *D.23242;
        D.23244 = (int) D.23243;
        __result = D.23241 - D.23244;
        D.23245 = __s1_len > 1;
        D.23235 = __result == 0;
        D.23246 = D.23245 & D.23235;
        if (D.23246 != 0) goto <D.23247>; else goto <D.23248>;
        <D.23247>:
        D.23249 = &MEM[(void *)"Vector2ul" + 2B];
        D.23250 = *D.23249;
        D.23251 = (int) D.23250;
        D.23252 = __s2 + 2;
        D.23253 = *D.23252;
        D.23254 = (int) D.23253;
        __result = D.23251 - D.23254;
        D.23255 = __s1_len > 2;
        D.23235 = __result == 0;
        D.23256 = D.23255 & D.23235;
        if (D.23256 != 0) goto <D.23257>; else goto <D.23258>;
        <D.23257>:
        D.23259 = &MEM[(void *)"Vector2ul" + 3B];
        D.23260 = *D.23259;
        D.23261 = (int) D.23260;
        D.23262 = __s2 + 3;
        D.23263 = *D.23262;
        D.23264 = (int) D.23263;
        __result = D.23261 - D.23264;
        <D.23258>:
        <D.23248>:
        <D.23238>:
      }
      D.22669 = __result;
    }
    iftmp.12 = D.22669;
    goto <D.23265>;
    <D.23228>:
    iftmp.12 = __builtin_strcmp ("Vector2ul", class_name);
    <D.23265>:
    D.22673 = iftmp.12;
  }
  if (D.22673 == 0) goto <D.23266>; else goto <D.23267>;
  <D.23266>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector2ul_intrinsics, 24);
  return D.23002;
  <D.23267>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23271 = "Vector2l";
      D.23272 = MEM[(const unsigned char *)D.23271];
      D.23273 = (int) D.23272;
      D.23274 = *__s2;
      D.23275 = (int) D.23274;
      __result = D.23273 - D.23275;
      {
        D.23276 = __s1_len != 0;
        D.23277 = __result == 0;
        D.23278 = D.23276 & D.23277;
        if (D.23278 != 0) goto <D.23279>; else goto <D.23280>;
        <D.23279>:
        D.23281 = &MEM[(void *)"Vector2l" + 1B];
        D.23282 = *D.23281;
        D.23283 = (int) D.23282;
        D.23284 = __s2 + 1;
        D.23285 = *D.23284;
        D.23286 = (int) D.23285;
        __result = D.23283 - D.23286;
        D.23287 = __s1_len > 1;
        D.23277 = __result == 0;
        D.23288 = D.23287 & D.23277;
        if (D.23288 != 0) goto <D.23289>; else goto <D.23290>;
        <D.23289>:
        D.23291 = &MEM[(void *)"Vector2l" + 2B];
        D.23292 = *D.23291;
        D.23293 = (int) D.23292;
        D.23294 = __s2 + 2;
        D.23295 = *D.23294;
        D.23296 = (int) D.23295;
        __result = D.23293 - D.23296;
        D.23297 = __s1_len > 2;
        D.23277 = __result == 0;
        D.23298 = D.23297 & D.23277;
        if (D.23298 != 0) goto <D.23299>; else goto <D.23300>;
        <D.23299>:
        D.23301 = &MEM[(void *)"Vector2l" + 3B];
        D.23302 = *D.23301;
        D.23303 = (int) D.23302;
        D.23304 = __s2 + 3;
        D.23305 = *D.23304;
        D.23306 = (int) D.23305;
        __result = D.23303 - D.23306;
        <D.23300>:
        <D.23290>:
        <D.23280>:
      }
      D.22678 = __result;
    }
    iftmp.13 = D.22678;
    goto <D.23307>;
    <D.23270>:
    iftmp.13 = __builtin_strcmp ("Vector2l", class_name);
    <D.23307>:
    D.22682 = iftmp.13;
  }
  if (D.22682 == 0) goto <D.23308>; else goto <D.23309>;
  <D.23308>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector2l_intrinsics, 25);
  return D.23002;
  <D.23309>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23313 = "Vector4ui";
      D.23314 = MEM[(const unsigned char *)D.23313];
      D.23315 = (int) D.23314;
      D.23316 = *__s2;
      D.23317 = (int) D.23316;
      __result = D.23315 - D.23317;
      {
        D.23318 = __s1_len != 0;
        D.23319 = __result == 0;
        D.23320 = D.23318 & D.23319;
        if (D.23320 != 0) goto <D.23321>; else goto <D.23322>;
        <D.23321>:
        D.23323 = &MEM[(void *)"Vector4ui" + 1B];
        D.23324 = *D.23323;
        D.23325 = (int) D.23324;
        D.23326 = __s2 + 1;
        D.23327 = *D.23326;
        D.23328 = (int) D.23327;
        __result = D.23325 - D.23328;
        D.23329 = __s1_len > 1;
        D.23319 = __result == 0;
        D.23330 = D.23329 & D.23319;
        if (D.23330 != 0) goto <D.23331>; else goto <D.23332>;
        <D.23331>:
        D.23333 = &MEM[(void *)"Vector4ui" + 2B];
        D.23334 = *D.23333;
        D.23335 = (int) D.23334;
        D.23336 = __s2 + 2;
        D.23337 = *D.23336;
        D.23338 = (int) D.23337;
        __result = D.23335 - D.23338;
        D.23339 = __s1_len > 2;
        D.23319 = __result == 0;
        D.23340 = D.23339 & D.23319;
        if (D.23340 != 0) goto <D.23341>; else goto <D.23342>;
        <D.23341>:
        D.23343 = &MEM[(void *)"Vector4ui" + 3B];
        D.23344 = *D.23343;
        D.23345 = (int) D.23344;
        D.23346 = __s2 + 3;
        D.23347 = *D.23346;
        D.23348 = (int) D.23347;
        __result = D.23345 - D.23348;
        <D.23342>:
        <D.23332>:
        <D.23322>:
      }
      D.22687 = __result;
    }
    iftmp.14 = D.22687;
    goto <D.23349>;
    <D.23312>:
    iftmp.14 = __builtin_strcmp ("Vector4ui", class_name);
    <D.23349>:
    D.22691 = iftmp.14;
  }
  if (D.22691 == 0) goto <D.23350>; else goto <D.23351>;
  <D.23350>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector4ui_intrinsics, 35);
  return D.23002;
  <D.23351>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23355 = "Vector4i";
      D.23356 = MEM[(const unsigned char *)D.23355];
      D.23357 = (int) D.23356;
      D.23358 = *__s2;
      D.23359 = (int) D.23358;
      __result = D.23357 - D.23359;
      {
        D.23360 = __s1_len != 0;
        D.23361 = __result == 0;
        D.23362 = D.23360 & D.23361;
        if (D.23362 != 0) goto <D.23363>; else goto <D.23364>;
        <D.23363>:
        D.23365 = &MEM[(void *)"Vector4i" + 1B];
        D.23366 = *D.23365;
        D.23367 = (int) D.23366;
        D.23368 = __s2 + 1;
        D.23369 = *D.23368;
        D.23370 = (int) D.23369;
        __result = D.23367 - D.23370;
        D.23371 = __s1_len > 1;
        D.23361 = __result == 0;
        D.23372 = D.23371 & D.23361;
        if (D.23372 != 0) goto <D.23373>; else goto <D.23374>;
        <D.23373>:
        D.23375 = &MEM[(void *)"Vector4i" + 2B];
        D.23376 = *D.23375;
        D.23377 = (int) D.23376;
        D.23378 = __s2 + 2;
        D.23379 = *D.23378;
        D.23380 = (int) D.23379;
        __result = D.23377 - D.23380;
        D.23381 = __s1_len > 2;
        D.23361 = __result == 0;
        D.23382 = D.23381 & D.23361;
        if (D.23382 != 0) goto <D.23383>; else goto <D.23384>;
        <D.23383>:
        D.23385 = &MEM[(void *)"Vector4i" + 3B];
        D.23386 = *D.23385;
        D.23387 = (int) D.23386;
        D.23388 = __s2 + 3;
        D.23389 = *D.23388;
        D.23390 = (int) D.23389;
        __result = D.23387 - D.23390;
        <D.23384>:
        <D.23374>:
        <D.23364>:
      }
      D.22696 = __result;
    }
    iftmp.15 = D.22696;
    goto <D.23391>;
    <D.23354>:
    iftmp.15 = __builtin_strcmp ("Vector4i", class_name);
    <D.23391>:
    D.22700 = iftmp.15;
  }
  if (D.22700 == 0) goto <D.23392>; else goto <D.23393>;
  <D.23392>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector4i_intrinsics, 38);
  return D.23002;
  <D.23393>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23397 = "Vector8us";
      D.23398 = MEM[(const unsigned char *)D.23397];
      D.23399 = (int) D.23398;
      D.23400 = *__s2;
      D.23401 = (int) D.23400;
      __result = D.23399 - D.23401;
      {
        D.23402 = __s1_len != 0;
        D.23403 = __result == 0;
        D.23404 = D.23402 & D.23403;
        if (D.23404 != 0) goto <D.23405>; else goto <D.23406>;
        <D.23405>:
        D.23407 = &MEM[(void *)"Vector8us" + 1B];
        D.23408 = *D.23407;
        D.23409 = (int) D.23408;
        D.23410 = __s2 + 1;
        D.23411 = *D.23410;
        D.23412 = (int) D.23411;
        __result = D.23409 - D.23412;
        D.23413 = __s1_len > 1;
        D.23403 = __result == 0;
        D.23414 = D.23413 & D.23403;
        if (D.23414 != 0) goto <D.23415>; else goto <D.23416>;
        <D.23415>:
        D.23417 = &MEM[(void *)"Vector8us" + 2B];
        D.23418 = *D.23417;
        D.23419 = (int) D.23418;
        D.23420 = __s2 + 2;
        D.23421 = *D.23420;
        D.23422 = (int) D.23421;
        __result = D.23419 - D.23422;
        D.23423 = __s1_len > 2;
        D.23403 = __result == 0;
        D.23424 = D.23423 & D.23403;
        if (D.23424 != 0) goto <D.23425>; else goto <D.23426>;
        <D.23425>:
        D.23427 = &MEM[(void *)"Vector8us" + 3B];
        D.23428 = *D.23427;
        D.23429 = (int) D.23428;
        D.23430 = __s2 + 3;
        D.23431 = *D.23430;
        D.23432 = (int) D.23431;
        __result = D.23429 - D.23432;
        <D.23426>:
        <D.23416>:
        <D.23406>:
      }
      D.22705 = __result;
    }
    iftmp.16 = D.22705;
    goto <D.23433>;
    <D.23396>:
    iftmp.16 = __builtin_strcmp ("Vector8us", class_name);
    <D.23433>:
    D.22709 = iftmp.16;
  }
  if (D.22709 == 0) goto <D.23434>; else goto <D.23435>;
  <D.23434>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector8us_intrinsics, 48);
  return D.23002;
  <D.23435>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23439 = "Vector8s";
      D.23440 = MEM[(const unsigned char *)D.23439];
      D.23441 = (int) D.23440;
      D.23442 = *__s2;
      D.23443 = (int) D.23442;
      __result = D.23441 - D.23443;
      {
        D.23444 = __s1_len != 0;
        D.23445 = __result == 0;
        D.23446 = D.23444 & D.23445;
        if (D.23446 != 0) goto <D.23447>; else goto <D.23448>;
        <D.23447>:
        D.23449 = &MEM[(void *)"Vector8s" + 1B];
        D.23450 = *D.23449;
        D.23451 = (int) D.23450;
        D.23452 = __s2 + 1;
        D.23453 = *D.23452;
        D.23454 = (int) D.23453;
        __result = D.23451 - D.23454;
        D.23455 = __s1_len > 1;
        D.23445 = __result == 0;
        D.23456 = D.23455 & D.23445;
        if (D.23456 != 0) goto <D.23457>; else goto <D.23458>;
        <D.23457>:
        D.23459 = &MEM[(void *)"Vector8s" + 2B];
        D.23460 = *D.23459;
        D.23461 = (int) D.23460;
        D.23462 = __s2 + 2;
        D.23463 = *D.23462;
        D.23464 = (int) D.23463;
        __result = D.23461 - D.23464;
        D.23465 = __s1_len > 2;
        D.23445 = __result == 0;
        D.23466 = D.23465 & D.23445;
        if (D.23466 != 0) goto <D.23467>; else goto <D.23468>;
        <D.23467>:
        D.23469 = &MEM[(void *)"Vector8s" + 3B];
        D.23470 = *D.23469;
        D.23471 = (int) D.23470;
        D.23472 = __s2 + 3;
        D.23473 = *D.23472;
        D.23474 = (int) D.23473;
        __result = D.23471 - D.23474;
        <D.23468>:
        <D.23458>:
        <D.23448>:
      }
      D.22714 = __result;
    }
    iftmp.17 = D.22714;
    goto <D.23475>;
    <D.23438>:
    iftmp.17 = __builtin_strcmp ("Vector8s", class_name);
    <D.23475>:
    D.22718 = iftmp.17;
  }
  if (D.22718 == 0) goto <D.23476>; else goto <D.23477>;
  <D.23476>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector8s_intrinsics, 48);
  return D.23002;
  <D.23477>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23481 = "Vector16b";
      D.23482 = MEM[(const unsigned char *)D.23481];
      D.23483 = (int) D.23482;
      D.23484 = *__s2;
      D.23485 = (int) D.23484;
      __result = D.23483 - D.23485;
      {
        D.23486 = __s1_len != 0;
        D.23487 = __result == 0;
        D.23488 = D.23486 & D.23487;
        if (D.23488 != 0) goto <D.23489>; else goto <D.23490>;
        <D.23489>:
        D.23491 = &MEM[(void *)"Vector16b" + 1B];
        D.23492 = *D.23491;
        D.23493 = (int) D.23492;
        D.23494 = __s2 + 1;
        D.23495 = *D.23494;
        D.23496 = (int) D.23495;
        __result = D.23493 - D.23496;
        D.23497 = __s1_len > 1;
        D.23487 = __result == 0;
        D.23498 = D.23497 & D.23487;
        if (D.23498 != 0) goto <D.23499>; else goto <D.23500>;
        <D.23499>:
        D.23501 = &MEM[(void *)"Vector16b" + 2B];
        D.23502 = *D.23501;
        D.23503 = (int) D.23502;
        D.23504 = __s2 + 2;
        D.23505 = *D.23504;
        D.23506 = (int) D.23505;
        __result = D.23503 - D.23506;
        D.23507 = __s1_len > 2;
        D.23487 = __result == 0;
        D.23508 = D.23507 & D.23487;
        if (D.23508 != 0) goto <D.23509>; else goto <D.23510>;
        <D.23509>:
        D.23511 = &MEM[(void *)"Vector16b" + 3B];
        D.23512 = *D.23511;
        D.23513 = (int) D.23512;
        D.23514 = __s2 + 3;
        D.23515 = *D.23514;
        D.23516 = (int) D.23515;
        __result = D.23513 - D.23516;
        <D.23510>:
        <D.23500>:
        <D.23490>:
      }
      D.22723 = __result;
    }
    iftmp.18 = D.22723;
    goto <D.23517>;
    <D.23480>:
    iftmp.18 = __builtin_strcmp ("Vector16b", class_name);
    <D.23517>:
    D.22727 = iftmp.18;
  }
  if (D.22727 == 0) goto <D.23518>; else goto <D.23519>;
  <D.23518>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector16b_intrinsics, 57);
  return D.23002;
  <D.23519>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class_name;
      D.23523 = "Vector16sb";
      D.23524 = MEM[(const unsigned char *)D.23523];
      D.23525 = (int) D.23524;
      D.23526 = *__s2;
      D.23527 = (int) D.23526;
      __result = D.23525 - D.23527;
      {
        D.23528 = __s1_len != 0;
        D.23529 = __result == 0;
        D.23530 = D.23528 & D.23529;
        if (D.23530 != 0) goto <D.23531>; else goto <D.23532>;
        <D.23531>:
        D.23533 = &MEM[(void *)"Vector16sb" + 1B];
        D.23534 = *D.23533;
        D.23535 = (int) D.23534;
        D.23536 = __s2 + 1;
        D.23537 = *D.23536;
        D.23538 = (int) D.23537;
        __result = D.23535 - D.23538;
        D.23539 = __s1_len > 1;
        D.23529 = __result == 0;
        D.23540 = D.23539 & D.23529;
        if (D.23540 != 0) goto <D.23541>; else goto <D.23542>;
        <D.23541>:
        D.23543 = &MEM[(void *)"Vector16sb" + 2B];
        D.23544 = *D.23543;
        D.23545 = (int) D.23544;
        D.23546 = __s2 + 2;
        D.23547 = *D.23546;
        D.23548 = (int) D.23547;
        __result = D.23545 - D.23548;
        D.23549 = __s1_len > 2;
        D.23529 = __result == 0;
        D.23550 = D.23549 & D.23529;
        if (D.23550 != 0) goto <D.23551>; else goto <D.23552>;
        <D.23551>:
        D.23553 = &MEM[(void *)"Vector16sb" + 3B];
        D.23554 = *D.23553;
        D.23555 = (int) D.23554;
        D.23556 = __s2 + 3;
        D.23557 = *D.23556;
        D.23558 = (int) D.23557;
        __result = D.23555 - D.23558;
        <D.23552>:
        <D.23542>:
        <D.23532>:
      }
      D.22732 = __result;
    }
    iftmp.19 = D.22732;
    goto <D.23559>;
    <D.23522>:
    iftmp.19 = __builtin_strcmp ("Vector16sb", class_name);
    <D.23559>:
    D.22736 = iftmp.19;
  }
  if (D.22736 == 0) goto <D.23560>; else goto <D.23561>;
  <D.23560>:
  D.23002 = emit_intrinsics (cfg, cmethod, fsig, args, &vector16sb_intrinsics, 56);
  return D.23002;
  <D.23561>:
  D.23002 = 0B;
  return D.23002;
}


emit_simd_runtime_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  int D.22602;
  int iftmp.20;
  int D.22598;
  const char[14] * D.23566;
  unsigned char D.23567;
  int D.23568;
  unsigned char D.23569;
  int D.23570;
  _Bool D.23571;
  _Bool D.23572;
  _Bool D.23573;
  const unsigned char * D.23576;
  unsigned char D.23577;
  int D.23578;
  const unsigned char * D.23579;
  unsigned char D.23580;
  int D.23581;
  _Bool D.23582;
  _Bool D.23583;
  const unsigned char * D.23586;
  unsigned char D.23587;
  int D.23588;
  const unsigned char * D.23589;
  unsigned char D.23590;
  int D.23591;
  _Bool D.23592;
  _Bool D.23593;
  const unsigned char * D.23596;
  unsigned char D.23597;
  int D.23598;
  const unsigned char * D.23599;
  unsigned char D.23600;
  int D.23601;
  const char * D.23603;
  struct MonoMemPool * D.23606;
  int D.23607;
  struct MonoInst * D.23608;
  int D.23609;
  int D.23610;
  const unsigned char * D.23611;
  unsigned int simd_supported_versions.21;
  int simd_supported_versions.22;
  unsigned int D.23614;
  int D.23615;
  struct MonoBasicBlock * D.23616;
  struct MonoInst * D.23617;
  struct MonoInst * D.23621;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.23566 = "get_AccelMode";
      D.23567 = MEM[(const unsigned char *)D.23566];
      D.23568 = (int) D.23567;
      D.23569 = *__s2;
      D.23570 = (int) D.23569;
      __result = D.23568 - D.23570;
      {
        D.23571 = __s1_len != 0;
        D.23572 = __result == 0;
        D.23573 = D.23571 & D.23572;
        if (D.23573 != 0) goto <D.23574>; else goto <D.23575>;
        <D.23574>:
        D.23576 = &MEM[(void *)"get_AccelMode" + 1B];
        D.23577 = *D.23576;
        D.23578 = (int) D.23577;
        D.23579 = __s2 + 1;
        D.23580 = *D.23579;
        D.23581 = (int) D.23580;
        __result = D.23578 - D.23581;
        D.23582 = __s1_len > 1;
        D.23572 = __result == 0;
        D.23583 = D.23582 & D.23572;
        if (D.23583 != 0) goto <D.23584>; else goto <D.23585>;
        <D.23584>:
        D.23586 = &MEM[(void *)"get_AccelMode" + 2B];
        D.23587 = *D.23586;
        D.23588 = (int) D.23587;
        D.23589 = __s2 + 2;
        D.23590 = *D.23589;
        D.23591 = (int) D.23590;
        __result = D.23588 - D.23591;
        D.23592 = __s1_len > 2;
        D.23572 = __result == 0;
        D.23593 = D.23592 & D.23572;
        if (D.23593 != 0) goto <D.23594>; else goto <D.23595>;
        <D.23594>:
        D.23596 = &MEM[(void *)"get_AccelMode" + 3B];
        D.23597 = *D.23596;
        D.23598 = (int) D.23597;
        D.23599 = __s2 + 3;
        D.23600 = *D.23599;
        D.23601 = (int) D.23600;
        __result = D.23598 - D.23601;
        <D.23595>:
        <D.23585>:
        <D.23575>:
      }
      D.22598 = __result;
    }
    iftmp.20 = D.22598;
    goto <D.23602>;
    <D.23565>:
    D.23603 = cmethod->name;
    iftmp.20 = __builtin_strcmp ("get_AccelMode", D.23603);
    <D.23602>:
    D.22602 = iftmp.20;
  }
  if (D.22602 == 0) goto <D.23604>; else goto <D.23605>;
  <D.23604>:
  {
    struct MonoInst * ins;

    D.23606 = cfg->mempool;
    ins = mono_mempool_alloc (D.23606, 48);
    ins->data.op[1].const_val = 0;
    D.23607 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.23607;
    ins->prev = 0B;
    D.23608 = ins->prev;
    ins->next = D.23608;
    ins->opcode = 362;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.23609 = ins->sreg3;
    ins->sreg2 = D.23609;
    D.23610 = ins->sreg2;
    ins->sreg1 = D.23610;
    D.23611 = cfg->ip;
    ins->cil_code = D.23611;
    simd_supported_versions.21 = simd_supported_versions;
    simd_supported_versions.22 = (int) simd_supported_versions.21;
    ins->data.op[0].const_val = simd_supported_versions.22;
    ins->type = 1;
    D.23614 = alloc_dreg (cfg, 1);
    D.23615 = (int) D.23614;
    ins->dreg = D.23615;
    D.23616 = cfg->cbb;
    D.23617 = D.23616->last_ins;
    if (D.23617 != 0B) goto <D.23618>; else goto <D.23619>;
    <D.23618>:
    D.23616 = cfg->cbb;
    D.23617 = D.23616->last_ins;
    D.23617->next = ins;
    D.23616 = cfg->cbb;
    D.23617 = D.23616->last_ins;
    ins->prev = D.23617;
    D.23616 = cfg->cbb;
    D.23616->last_ins = ins;
    goto <D.23620>;
    <D.23619>:
    D.23616 = cfg->cbb;
    D.23616 = cfg->cbb;
    D.23616->last_ins = ins;
    D.23617 = D.23616->last_ins;
    D.23616->code = D.23617;
    <D.23620>:
    D.23621 = ins;
    return D.23621;
  }
  <D.23605>:
  D.23621 = 0B;
  return D.23621;
}


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

  switch (stack_type) <default: <D.21811>, case 1: <D.21804>, case 2: <D.21809>, case 3: <D.21805>, case 4: <D.21808>, case 5: <D.21806>, case 6: <D.21807>, case 7: <D.21810>>
  <D.21804>:
  <D.21805>:
  D.23623 = alloc_ireg (cfg);
  return D.23623;
  <D.21806>:
  D.23623 = alloc_ireg_mp (cfg);
  return D.23623;
  <D.21807>:
  D.23623 = alloc_ireg_ref (cfg);
  return D.23623;
  <D.21808>:
  D.23623 = alloc_freg (cfg);
  return D.23623;
  <D.21809>:
  D.23623 = alloc_lreg (cfg);
  return D.23623;
  <D.21810>:
  D.23623 = alloc_ireg (cfg);
  return D.23623;
  <D.21811>:
  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.23623 = 4294967295;
  return D.23623;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.23625;
  unsigned char D.23626;
  unsigned char D.23627;
  guint32 D.23630;
  int vreg;

  D.23625 = alloc_ireg (cfg);
  vreg = (int) D.23625;
  D.23626 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.23627 = D.23626 & 128;
  if (D.23627 != 0) goto <D.23628>; else goto <D.23629>;
  <D.23628>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.23629>:
  D.23630 = (guint32) vreg;
  return D.23630;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.23632;
  unsigned char D.23633;
  unsigned char D.23634;
  guint32 D.23637;
  int vreg;

  D.23632 = alloc_ireg (cfg);
  vreg = (int) D.23632;
  D.23633 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.23634 = D.23633 & 128;
  if (D.23634 != 0) goto <D.23635>; else goto <D.23636>;
  <D.23635>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.23636>:
  D.23637 = (guint32) vreg;
  return D.23637;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.23639;
  guint32 D.23642;
  unsigned int D.23643;
  unsigned int D.23644;
  unsigned int D.23645;

  D.23639 = mono_arch_is_soft_float ();
  if (D.23639 != 0) goto <D.23640>; else goto <D.23641>;
  <D.23640>:
  D.23642 = alloc_lreg (cfg);
  return D.23642;
  <D.23641>:
  D.23643 = cfg->next_vreg;
  D.23644 = D.23643;
  D.23645 = D.23644 + 1;
  cfg->next_vreg = D.23645;
  D.23642 = D.23644;
  return D.23642;
}


mono_arch_is_soft_float ()
{
  gboolean D.23647;

  D.23647 = 0;
  return D.23647;
}


alloc_lreg (struct MonoCompile * cfg)
{
  unsigned int D.23649;
  unsigned int D.23650;
  guint32 D.23651;
  guint32 res;

  res = cfg->next_vreg;
  D.23649 = cfg->next_vreg;
  D.23650 = D.23649 + 3;
  cfg->next_vreg = D.23650;
  D.23651 = res;
  return D.23651;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.23653;
  unsigned int D.23654;
  unsigned int D.23655;
  unsigned int D.23656;

  D.23654 = cfg->next_vreg;
  D.23655 = D.23654;
  D.23656 = D.23655 + 1;
  cfg->next_vreg = D.23656;
  D.23653 = D.23655;
  return D.23653;
}


emit_array_extension_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  int D.22524;
  int iftmp.23;
  int D.22520;
  const char[10] * D.23663;
  unsigned char D.23664;
  int D.23665;
  unsigned char D.23666;
  int D.23667;
  _Bool D.23668;
  _Bool D.23669;
  _Bool D.23670;
  const unsigned char * D.23673;
  unsigned char D.23674;
  int D.23675;
  const unsigned char * D.23676;
  unsigned char D.23677;
  int D.23678;
  _Bool D.23679;
  _Bool D.23680;
  const unsigned char * D.23683;
  unsigned char D.23684;
  int D.23685;
  const unsigned char * D.23686;
  unsigned char D.23687;
  int D.23688;
  _Bool D.23689;
  _Bool D.23690;
  const unsigned char * D.23693;
  unsigned char D.23694;
  int D.23695;
  const unsigned char * D.23696;
  unsigned char D.23697;
  int D.23698;
  const char * D.23700;
  int D.22533;
  int iftmp.24;
  int D.22529;
  const char[17] * D.23705;
  unsigned char D.23706;
  int D.23707;
  unsigned char D.23708;
  int D.23709;
  _Bool D.23710;
  _Bool D.23711;
  _Bool D.23712;
  const unsigned char * D.23715;
  unsigned char D.23716;
  int D.23717;
  const unsigned char * D.23718;
  unsigned char D.23719;
  int D.23720;
  _Bool D.23721;
  _Bool D.23722;
  const unsigned char * D.23725;
  unsigned char D.23726;
  int D.23727;
  const unsigned char * D.23728;
  unsigned char D.23729;
  int D.23730;
  _Bool D.23731;
  _Bool D.23732;
  const unsigned char * D.23735;
  unsigned char D.23736;
  int D.23737;
  const unsigned char * D.23738;
  unsigned char D.23739;
  int D.23740;
  struct MonoInst * * D.23742;
  struct MonoInst * D.23743;
  struct MonoInst * D.23744;
  struct MonoType * D.23745;
  struct MonoMemPool * D.23746;
  int D.23747;
  struct MonoInst * D.23748;
  guint16 iftmp.25;
  int D.22544;
  int iftmp.26;
  int D.22540;
  unsigned char D.23753;
  int D.23754;
  _Bool D.23755;
  _Bool D.23756;
  _Bool D.23757;
  const unsigned char * D.23760;
  unsigned char D.23761;
  int D.23762;
  _Bool D.23763;
  _Bool D.23764;
  const unsigned char * D.23767;
  unsigned char D.23768;
  int D.23769;
  _Bool D.23770;
  _Bool D.23771;
  const unsigned char * D.23774;
  unsigned char D.23775;
  int D.23776;
  int D.23781;
  int D.23782;
  const unsigned char * D.23783;
  struct MonoClass * D.23784;
  unsigned int D.23785;
  int D.23786;
  struct MonoBasicBlock * D.23787;
  struct MonoInst * D.23788;
  struct MonoInst * D.23792;
  int D.22553;
  int iftmp.27;
  int D.22549;
  const char[10] * D.23798;
  unsigned char D.23799;
  int D.23800;
  unsigned char D.23801;
  int D.23802;
  _Bool D.23803;
  _Bool D.23804;
  _Bool D.23805;
  const unsigned char * D.23808;
  unsigned char D.23809;
  int D.23810;
  const unsigned char * D.23811;
  unsigned char D.23812;
  int D.23813;
  _Bool D.23814;
  _Bool D.23815;
  const unsigned char * D.23818;
  unsigned char D.23819;
  int D.23820;
  const unsigned char * D.23821;
  unsigned char D.23822;
  int D.23823;
  _Bool D.23824;
  _Bool D.23825;
  const unsigned char * D.23828;
  unsigned char D.23829;
  int D.23830;
  const unsigned char * D.23831;
  unsigned char D.23832;
  int D.23833;
  int D.22562;
  int iftmp.28;
  int D.22558;
  const char[17] * D.23839;
  unsigned char D.23840;
  int D.23841;
  unsigned char D.23842;
  int D.23843;
  _Bool D.23844;
  _Bool D.23845;
  _Bool D.23846;
  const unsigned char * D.23849;
  unsigned char D.23850;
  int D.23851;
  const unsigned char * D.23852;
  unsigned char D.23853;
  int D.23854;
  _Bool D.23855;
  _Bool D.23856;
  const unsigned char * D.23859;
  unsigned char D.23860;
  int D.23861;
  const unsigned char * D.23862;
  unsigned char D.23863;
  int D.23864;
  _Bool D.23865;
  _Bool D.23866;
  const unsigned char * D.23869;
  unsigned char D.23870;
  int D.23871;
  const unsigned char * D.23872;
  unsigned char D.23873;
  int D.23874;
  struct MonoInst * * D.23876;
  struct MonoInst * D.23877;
  int D.23878;
  struct MonoInst * D.23879;
  guint16 iftmp.29;
  int D.22574;
  int iftmp.30;
  int D.22570;
  unsigned char D.23884;
  int D.23885;
  _Bool D.23886;
  _Bool D.23887;
  _Bool D.23888;
  const unsigned char * D.23891;
  unsigned char D.23892;
  int D.23893;
  _Bool D.23894;
  _Bool D.23895;
  const unsigned char * D.23898;
  unsigned char D.23899;
  int D.23900;
  _Bool D.23901;
  _Bool D.23902;
  const unsigned char * D.23905;
  unsigned char D.23906;
  int D.23907;
  int D.23912;
  int D.23913;
  int D.22583;
  int iftmp.31;
  int D.22579;
  const char[10] * D.23920;
  unsigned char D.23921;
  int D.23922;
  unsigned char D.23923;
  int D.23924;
  _Bool D.23925;
  _Bool D.23926;
  _Bool D.23927;
  const unsigned char * D.23930;
  unsigned char D.23931;
  int D.23932;
  const unsigned char * D.23933;
  unsigned char D.23934;
  int D.23935;
  _Bool D.23936;
  _Bool D.23937;
  const unsigned char * D.23940;
  unsigned char D.23941;
  int D.23942;
  const unsigned char * D.23943;
  unsigned char D.23944;
  int D.23945;
  _Bool D.23946;
  _Bool D.23947;
  const unsigned char * D.23950;
  unsigned char D.23951;
  int D.23952;
  const unsigned char * D.23953;
  unsigned char D.23954;
  int D.23955;
  int D.23959;
  struct MonoInst * D.23960;
  int D.23961;
  int D.23962;
  int D.23966;
  struct MonoInst * D.23967;
  int D.23968;
  int D.23969;
  int D.23973;
  struct MonoInst * D.23974;
  int D.23975;
  int D.23976;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.23663 = "GetVector";
      D.23664 = MEM[(const unsigned char *)D.23663];
      D.23665 = (int) D.23664;
      D.23666 = *__s2;
      D.23667 = (int) D.23666;
      __result = D.23665 - D.23667;
      {
        D.23668 = __s1_len != 0;
        D.23669 = __result == 0;
        D.23670 = D.23668 & D.23669;
        if (D.23670 != 0) goto <D.23671>; else goto <D.23672>;
        <D.23671>:
        D.23673 = &MEM[(void *)"GetVector" + 1B];
        D.23674 = *D.23673;
        D.23675 = (int) D.23674;
        D.23676 = __s2 + 1;
        D.23677 = *D.23676;
        D.23678 = (int) D.23677;
        __result = D.23675 - D.23678;
        D.23679 = __s1_len > 1;
        D.23669 = __result == 0;
        D.23680 = D.23679 & D.23669;
        if (D.23680 != 0) goto <D.23681>; else goto <D.23682>;
        <D.23681>:
        D.23683 = &MEM[(void *)"GetVector" + 2B];
        D.23684 = *D.23683;
        D.23685 = (int) D.23684;
        D.23686 = __s2 + 2;
        D.23687 = *D.23686;
        D.23688 = (int) D.23687;
        __result = D.23685 - D.23688;
        D.23689 = __s1_len > 2;
        D.23669 = __result == 0;
        D.23690 = D.23689 & D.23669;
        if (D.23690 != 0) goto <D.23691>; else goto <D.23692>;
        <D.23691>:
        D.23693 = &MEM[(void *)"GetVector" + 3B];
        D.23694 = *D.23693;
        D.23695 = (int) D.23694;
        D.23696 = __s2 + 3;
        D.23697 = *D.23696;
        D.23698 = (int) D.23697;
        __result = D.23695 - D.23698;
        <D.23692>:
        <D.23682>:
        <D.23672>:
      }
      D.22520 = __result;
    }
    iftmp.23 = D.22520;
    goto <D.23699>;
    <D.23662>:
    D.23700 = cmethod->name;
    iftmp.23 = __builtin_strcmp ("GetVector", D.23700);
    <D.23699>:
    D.22524 = iftmp.23;
  }
  if (D.22524 == 0) goto <D.23658>; else goto <D.23701>;
  <D.23701>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.23705 = "GetVectorAligned";
      D.23706 = MEM[(const unsigned char *)D.23705];
      D.23707 = (int) D.23706;
      D.23708 = *__s2;
      D.23709 = (int) D.23708;
      __result = D.23707 - D.23709;
      {
        D.23710 = __s1_len != 0;
        D.23711 = __result == 0;
        D.23712 = D.23710 & D.23711;
        if (D.23712 != 0) goto <D.23713>; else goto <D.23714>;
        <D.23713>:
        D.23715 = &MEM[(void *)"GetVectorAligned" + 1B];
        D.23716 = *D.23715;
        D.23717 = (int) D.23716;
        D.23718 = __s2 + 1;
        D.23719 = *D.23718;
        D.23720 = (int) D.23719;
        __result = D.23717 - D.23720;
        D.23721 = __s1_len > 1;
        D.23711 = __result == 0;
        D.23722 = D.23721 & D.23711;
        if (D.23722 != 0) goto <D.23723>; else goto <D.23724>;
        <D.23723>:
        D.23725 = &MEM[(void *)"GetVectorAligned" + 2B];
        D.23726 = *D.23725;
        D.23727 = (int) D.23726;
        D.23728 = __s2 + 2;
        D.23729 = *D.23728;
        D.23730 = (int) D.23729;
        __result = D.23727 - D.23730;
        D.23731 = __s1_len > 2;
        D.23711 = __result == 0;
        D.23732 = D.23731 & D.23711;
        if (D.23732 != 0) goto <D.23733>; else goto <D.23734>;
        <D.23733>:
        D.23735 = &MEM[(void *)"GetVectorAligned" + 3B];
        D.23736 = *D.23735;
        D.23737 = (int) D.23736;
        D.23738 = __s2 + 3;
        D.23739 = *D.23738;
        D.23740 = (int) D.23739;
        __result = D.23737 - D.23740;
        <D.23734>:
        <D.23724>:
        <D.23714>:
      }
      D.22529 = __result;
    }
    iftmp.24 = D.22529;
    goto <D.23741>;
    <D.23704>:
    D.23700 = cmethod->name;
    iftmp.24 = __builtin_strcmp ("GetVectorAligned", D.23700);
    <D.23741>:
    D.22533 = iftmp.24;
  }
  if (D.22533 == 0) goto <D.23658>; else goto <D.23659>;
  <D.23658>:
  {
    struct MonoInst * load;
    int addr;

    D.23742 = args + 4;
    D.23743 = *D.23742;
    D.23744 = *args;
    D.23745 = fsig->params[0];
    addr = mono_emit_vector_ldelema (cfg, D.23745, D.23744, D.23743, 1);
    D.23746 = cfg->mempool;
    load = mono_mempool_alloc (D.23746, 48);
    load->data.op[1].const_val = 0;
    D.23747 = load->data.op[1].const_val;
    load->data.op[0].const_val = D.23747;
    load->prev = 0B;
    D.23748 = load->prev;
    load->next = D.23748;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = cmethod->name;
        D.23705 = "GetVectorAligned";
        D.23706 = MEM[(const unsigned char *)D.23705];
        D.23707 = (int) D.23706;
        D.23753 = *__s2;
        D.23754 = (int) D.23753;
        __result = D.23707 - D.23754;
        {
          D.23755 = __s1_len != 0;
          D.23756 = __result == 0;
          D.23757 = D.23755 & D.23756;
          if (D.23757 != 0) goto <D.23758>; else goto <D.23759>;
          <D.23758>:
          D.23715 = &MEM[(void *)"GetVectorAligned" + 1B];
          D.23716 = *D.23715;
          D.23717 = (int) D.23716;
          D.23760 = __s2 + 1;
          D.23761 = *D.23760;
          D.23762 = (int) D.23761;
          __result = D.23717 - D.23762;
          D.23763 = __s1_len > 1;
          D.23756 = __result == 0;
          D.23764 = D.23763 & D.23756;
          if (D.23764 != 0) goto <D.23765>; else goto <D.23766>;
          <D.23765>:
          D.23725 = &MEM[(void *)"GetVectorAligned" + 2B];
          D.23726 = *D.23725;
          D.23727 = (int) D.23726;
          D.23767 = __s2 + 2;
          D.23768 = *D.23767;
          D.23769 = (int) D.23768;
          __result = D.23727 - D.23769;
          D.23770 = __s1_len > 2;
          D.23756 = __result == 0;
          D.23771 = D.23770 & D.23756;
          if (D.23771 != 0) goto <D.23772>; else goto <D.23773>;
          <D.23772>:
          D.23735 = &MEM[(void *)"GetVectorAligned" + 3B];
          D.23736 = *D.23735;
          D.23737 = (int) D.23736;
          D.23774 = __s2 + 3;
          D.23775 = *D.23774;
          D.23776 = (int) D.23775;
          __result = D.23737 - D.23776;
          <D.23773>:
          <D.23766>:
          <D.23759>:
        }
        D.22540 = __result;
      }
      iftmp.26 = D.22540;
      goto <D.23777>;
      <D.23752>:
      D.23700 = cmethod->name;
      iftmp.26 = __builtin_strcmp ("GetVectorAligned", D.23700);
      <D.23777>:
      D.22544 = iftmp.26;
    }
    if (D.22544 == 0) goto <D.23778>; else goto <D.23779>;
    <D.23778>:
    iftmp.25 = 402;
    goto <D.23780>;
    <D.23779>:
    iftmp.25 = 401;
    <D.23780>:
    load->opcode = iftmp.25;
    load->flags = 0;
    load->type = 0;
    load->dreg = -1;
    load->sreg3 = -1;
    D.23781 = load->sreg3;
    load->sreg2 = D.23781;
    D.23782 = load->sreg2;
    load->sreg1 = D.23782;
    D.23783 = cfg->ip;
    load->cil_code = D.23783;
    D.23784 = cmethod->klass;
    load->klass = D.23784;
    load->sreg1 = addr;
    load->type = 7;
    D.23785 = alloc_ireg (cfg);
    D.23786 = (int) D.23785;
    load->dreg = D.23786;
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    if (D.23788 != 0B) goto <D.23789>; else goto <D.23790>;
    <D.23789>:
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    D.23788->next = load;
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    load->prev = D.23788;
    D.23787 = cfg->cbb;
    D.23787->last_ins = load;
    goto <D.23791>;
    <D.23790>:
    D.23787 = cfg->cbb;
    D.23787 = cfg->cbb;
    D.23787->last_ins = load;
    D.23788 = D.23787->last_ins;
    D.23787->code = D.23788;
    <D.23791>:
    D.23792 = load;
    return D.23792;
  }
  <D.23659>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.23798 = "SetVector";
      D.23799 = MEM[(const unsigned char *)D.23798];
      D.23800 = (int) D.23799;
      D.23801 = *__s2;
      D.23802 = (int) D.23801;
      __result = D.23800 - D.23802;
      {
        D.23803 = __s1_len != 0;
        D.23804 = __result == 0;
        D.23805 = D.23803 & D.23804;
        if (D.23805 != 0) goto <D.23806>; else goto <D.23807>;
        <D.23806>:
        D.23808 = &MEM[(void *)"SetVector" + 1B];
        D.23809 = *D.23808;
        D.23810 = (int) D.23809;
        D.23811 = __s2 + 1;
        D.23812 = *D.23811;
        D.23813 = (int) D.23812;
        __result = D.23810 - D.23813;
        D.23814 = __s1_len > 1;
        D.23804 = __result == 0;
        D.23815 = D.23814 & D.23804;
        if (D.23815 != 0) goto <D.23816>; else goto <D.23817>;
        <D.23816>:
        D.23818 = &MEM[(void *)"SetVector" + 2B];
        D.23819 = *D.23818;
        D.23820 = (int) D.23819;
        D.23821 = __s2 + 2;
        D.23822 = *D.23821;
        D.23823 = (int) D.23822;
        __result = D.23820 - D.23823;
        D.23824 = __s1_len > 2;
        D.23804 = __result == 0;
        D.23825 = D.23824 & D.23804;
        if (D.23825 != 0) goto <D.23826>; else goto <D.23827>;
        <D.23826>:
        D.23828 = &MEM[(void *)"SetVector" + 3B];
        D.23829 = *D.23828;
        D.23830 = (int) D.23829;
        D.23831 = __s2 + 3;
        D.23832 = *D.23831;
        D.23833 = (int) D.23832;
        __result = D.23830 - D.23833;
        <D.23827>:
        <D.23817>:
        <D.23807>:
      }
      D.22549 = __result;
    }
    iftmp.27 = D.22549;
    goto <D.23834>;
    <D.23797>:
    D.23700 = cmethod->name;
    iftmp.27 = __builtin_strcmp ("SetVector", D.23700);
    <D.23834>:
    D.22553 = iftmp.27;
  }
  if (D.22553 == 0) goto <D.23793>; else goto <D.23835>;
  <D.23835>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.23839 = "SetVectorAligned";
      D.23840 = MEM[(const unsigned char *)D.23839];
      D.23841 = (int) D.23840;
      D.23842 = *__s2;
      D.23843 = (int) D.23842;
      __result = D.23841 - D.23843;
      {
        D.23844 = __s1_len != 0;
        D.23845 = __result == 0;
        D.23846 = D.23844 & D.23845;
        if (D.23846 != 0) goto <D.23847>; else goto <D.23848>;
        <D.23847>:
        D.23849 = &MEM[(void *)"SetVectorAligned" + 1B];
        D.23850 = *D.23849;
        D.23851 = (int) D.23850;
        D.23852 = __s2 + 1;
        D.23853 = *D.23852;
        D.23854 = (int) D.23853;
        __result = D.23851 - D.23854;
        D.23855 = __s1_len > 1;
        D.23845 = __result == 0;
        D.23856 = D.23855 & D.23845;
        if (D.23856 != 0) goto <D.23857>; else goto <D.23858>;
        <D.23857>:
        D.23859 = &MEM[(void *)"SetVectorAligned" + 2B];
        D.23860 = *D.23859;
        D.23861 = (int) D.23860;
        D.23862 = __s2 + 2;
        D.23863 = *D.23862;
        D.23864 = (int) D.23863;
        __result = D.23861 - D.23864;
        D.23865 = __s1_len > 2;
        D.23845 = __result == 0;
        D.23866 = D.23865 & D.23845;
        if (D.23866 != 0) goto <D.23867>; else goto <D.23868>;
        <D.23867>:
        D.23869 = &MEM[(void *)"SetVectorAligned" + 3B];
        D.23870 = *D.23869;
        D.23871 = (int) D.23870;
        D.23872 = __s2 + 3;
        D.23873 = *D.23872;
        D.23874 = (int) D.23873;
        __result = D.23871 - D.23874;
        <D.23868>:
        <D.23858>:
        <D.23848>:
      }
      D.22558 = __result;
    }
    iftmp.28 = D.22558;
    goto <D.23875>;
    <D.23838>:
    D.23700 = cmethod->name;
    iftmp.28 = __builtin_strcmp ("SetVectorAligned", D.23700);
    <D.23875>:
    D.22562 = iftmp.28;
  }
  if (D.22562 == 0) goto <D.23793>; else goto <D.23794>;
  <D.23793>:
  {
    struct MonoInst * store;
    int vreg;
    int addr;

    D.23742 = args + 4;
    D.23743 = *D.23742;
    vreg = get_simd_vreg (cfg, cmethod, D.23743);
    D.23876 = args + 8;
    D.23877 = *D.23876;
    D.23744 = *args;
    D.23745 = fsig->params[0];
    addr = mono_emit_vector_ldelema (cfg, D.23745, D.23744, D.23877, 1);
    D.23746 = cfg->mempool;
    store = mono_mempool_alloc (D.23746, 48);
    store->data.op[1].const_val = 0;
    D.23878 = store->data.op[1].const_val;
    store->data.op[0].const_val = D.23878;
    store->prev = 0B;
    D.23879 = store->prev;
    store->next = D.23879;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = cmethod->name;
        D.23839 = "SetVectorAligned";
        D.23840 = MEM[(const unsigned char *)D.23839];
        D.23841 = (int) D.23840;
        D.23884 = *__s2;
        D.23885 = (int) D.23884;
        __result = D.23841 - D.23885;
        {
          D.23886 = __s1_len != 0;
          D.23887 = __result == 0;
          D.23888 = D.23886 & D.23887;
          if (D.23888 != 0) goto <D.23889>; else goto <D.23890>;
          <D.23889>:
          D.23849 = &MEM[(void *)"SetVectorAligned" + 1B];
          D.23850 = *D.23849;
          D.23851 = (int) D.23850;
          D.23891 = __s2 + 1;
          D.23892 = *D.23891;
          D.23893 = (int) D.23892;
          __result = D.23851 - D.23893;
          D.23894 = __s1_len > 1;
          D.23887 = __result == 0;
          D.23895 = D.23894 & D.23887;
          if (D.23895 != 0) goto <D.23896>; else goto <D.23897>;
          <D.23896>:
          D.23859 = &MEM[(void *)"SetVectorAligned" + 2B];
          D.23860 = *D.23859;
          D.23861 = (int) D.23860;
          D.23898 = __s2 + 2;
          D.23899 = *D.23898;
          D.23900 = (int) D.23899;
          __result = D.23861 - D.23900;
          D.23901 = __s1_len > 2;
          D.23887 = __result == 0;
          D.23902 = D.23901 & D.23887;
          if (D.23902 != 0) goto <D.23903>; else goto <D.23904>;
          <D.23903>:
          D.23869 = &MEM[(void *)"SetVectorAligned" + 3B];
          D.23870 = *D.23869;
          D.23871 = (int) D.23870;
          D.23905 = __s2 + 3;
          D.23906 = *D.23905;
          D.23907 = (int) D.23906;
          __result = D.23871 - D.23907;
          <D.23904>:
          <D.23897>:
          <D.23890>:
        }
        D.22570 = __result;
      }
      iftmp.30 = D.22570;
      goto <D.23908>;
      <D.23883>:
      D.23700 = cmethod->name;
      iftmp.30 = __builtin_strcmp ("SetVectorAligned", D.23700);
      <D.23908>:
      D.22574 = iftmp.30;
    }
    if (D.22574 == 0) goto <D.23909>; else goto <D.23910>;
    <D.23909>:
    iftmp.29 = 382;
    goto <D.23911>;
    <D.23910>:
    iftmp.29 = 389;
    <D.23911>:
    store->opcode = iftmp.29;
    store->flags = 0;
    store->type = 0;
    store->dreg = -1;
    store->sreg3 = -1;
    D.23912 = store->sreg3;
    store->sreg2 = D.23912;
    D.23913 = store->sreg2;
    store->sreg1 = D.23913;
    D.23783 = cfg->ip;
    store->cil_code = D.23783;
    D.23784 = cmethod->klass;
    store->klass = D.23784;
    store->dreg = addr;
    store->sreg1 = vreg;
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    if (D.23788 != 0B) goto <D.23914>; else goto <D.23915>;
    <D.23914>:
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    D.23788->next = store;
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    store->prev = D.23788;
    D.23787 = cfg->cbb;
    D.23787->last_ins = store;
    goto <D.23916>;
    <D.23915>:
    D.23787 = cfg->cbb;
    D.23787 = cfg->cbb;
    D.23787->last_ins = store;
    D.23788 = D.23787->last_ins;
    D.23787->code = D.23788;
    <D.23916>:
    D.23792 = store;
    return D.23792;
  }
  <D.23794>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cmethod->name;
      D.23920 = "IsAligned";
      D.23921 = MEM[(const unsigned char *)D.23920];
      D.23922 = (int) D.23921;
      D.23923 = *__s2;
      D.23924 = (int) D.23923;
      __result = D.23922 - D.23924;
      {
        D.23925 = __s1_len != 0;
        D.23926 = __result == 0;
        D.23927 = D.23925 & D.23926;
        if (D.23927 != 0) goto <D.23928>; else goto <D.23929>;
        <D.23928>:
        D.23930 = &MEM[(void *)"IsAligned" + 1B];
        D.23931 = *D.23930;
        D.23932 = (int) D.23931;
        D.23933 = __s2 + 1;
        D.23934 = *D.23933;
        D.23935 = (int) D.23934;
        __result = D.23932 - D.23935;
        D.23936 = __s1_len > 1;
        D.23926 = __result == 0;
        D.23937 = D.23936 & D.23926;
        if (D.23937 != 0) goto <D.23938>; else goto <D.23939>;
        <D.23938>:
        D.23940 = &MEM[(void *)"IsAligned" + 2B];
        D.23941 = *D.23940;
        D.23942 = (int) D.23941;
        D.23943 = __s2 + 2;
        D.23944 = *D.23943;
        D.23945 = (int) D.23944;
        __result = D.23942 - D.23945;
        D.23946 = __s1_len > 2;
        D.23926 = __result == 0;
        D.23947 = D.23946 & D.23926;
        if (D.23947 != 0) goto <D.23948>; else goto <D.23949>;
        <D.23948>:
        D.23950 = &MEM[(void *)"IsAligned" + 3B];
        D.23951 = *D.23950;
        D.23952 = (int) D.23951;
        D.23953 = __s2 + 3;
        D.23954 = *D.23953;
        D.23955 = (int) D.23954;
        __result = D.23952 - D.23955;
        <D.23949>:
        <D.23939>:
        <D.23929>:
      }
      D.22579 = __result;
    }
    iftmp.31 = D.22579;
    goto <D.23956>;
    <D.23919>:
    D.23700 = cmethod->name;
    iftmp.31 = __builtin_strcmp ("IsAligned", D.23700);
    <D.23956>:
    D.22583 = iftmp.31;
  }
  if (D.22583 == 0) goto <D.23957>; else goto <D.23958>;
  <D.23957>:
  {
    struct MonoInst * ins;
    int addr;

    D.23742 = args + 4;
    D.23743 = *D.23742;
    D.23744 = *args;
    D.23745 = fsig->params[0];
    addr = mono_emit_vector_ldelema (cfg, D.23745, D.23744, D.23743, 0);
    {
      struct MonoInst * inst;

      D.23746 = cfg->mempool;
      inst = mono_mempool_alloc (D.23746, 48);
      inst->data.op[1].const_val = 0;
      D.23959 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.23959;
      inst->prev = 0B;
      D.23960 = inst->prev;
      inst->next = D.23960;
      inst->opcode = 440;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.23961 = inst->sreg3;
      inst->sreg2 = D.23961;
      D.23962 = inst->sreg2;
      inst->sreg1 = D.23962;
      D.23783 = cfg->ip;
      inst->cil_code = D.23783;
      inst->dreg = addr;
      inst->sreg1 = addr;
      inst->data.op[1].const_val = 15;
      D.23787 = cfg->cbb;
      D.23788 = D.23787->last_ins;
      if (D.23788 != 0B) goto <D.23963>; else goto <D.23964>;
      <D.23963>:
      D.23787 = cfg->cbb;
      D.23788 = D.23787->last_ins;
      D.23788->next = inst;
      D.23787 = cfg->cbb;
      D.23788 = D.23787->last_ins;
      inst->prev = D.23788;
      D.23787 = cfg->cbb;
      D.23787->last_ins = inst;
      goto <D.23965>;
      <D.23964>:
      D.23787 = cfg->cbb;
      D.23787 = cfg->cbb;
      D.23787->last_ins = inst;
      D.23788 = D.23787->last_ins;
      D.23787->code = D.23788;
      <D.23965>:
    }
    {
      struct MonoInst * inst;

      D.23746 = cfg->mempool;
      inst = mono_mempool_alloc (D.23746, 48);
      inst->data.op[1].const_val = 0;
      D.23966 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.23966;
      inst->prev = 0B;
      D.23967 = inst->prev;
      inst->next = D.23967;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.23968 = inst->sreg3;
      inst->sreg2 = D.23968;
      D.23969 = inst->sreg2;
      inst->sreg1 = D.23969;
      D.23783 = cfg->ip;
      inst->cil_code = D.23783;
      inst->dreg = -1;
      inst->sreg1 = addr;
      inst->data.op[1].const_val = 0;
      D.23787 = cfg->cbb;
      D.23788 = D.23787->last_ins;
      if (D.23788 != 0B) goto <D.23970>; else goto <D.23971>;
      <D.23970>:
      D.23787 = cfg->cbb;
      D.23788 = D.23787->last_ins;
      D.23788->next = inst;
      D.23787 = cfg->cbb;
      D.23788 = D.23787->last_ins;
      inst->prev = D.23788;
      D.23787 = cfg->cbb;
      D.23787->last_ins = inst;
      goto <D.23972>;
      <D.23971>:
      D.23787 = cfg->cbb;
      D.23787 = cfg->cbb;
      D.23787->last_ins = inst;
      D.23788 = D.23787->last_ins;
      D.23787->code = D.23788;
      <D.23972>:
    }
    D.23746 = cfg->mempool;
    ins = mono_mempool_alloc (D.23746, 48);
    ins->data.op[1].const_val = 0;
    D.23973 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.23973;
    ins->prev = 0B;
    D.23974 = ins->prev;
    ins->next = D.23974;
    ins->opcode = 450;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.23975 = ins->sreg3;
    ins->sreg2 = D.23975;
    D.23976 = ins->sreg2;
    ins->sreg1 = D.23976;
    D.23783 = cfg->ip;
    ins->cil_code = D.23783;
    ins->dreg = addr;
    ins->sreg1 = -1;
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    if (D.23788 != 0B) goto <D.23977>; else goto <D.23978>;
    <D.23977>:
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    D.23788->next = ins;
    D.23787 = cfg->cbb;
    D.23788 = D.23787->last_ins;
    ins->prev = D.23788;
    D.23787 = cfg->cbb;
    D.23787->last_ins = ins;
    goto <D.23979>;
    <D.23978>:
    D.23787 = cfg->cbb;
    D.23787 = cfg->cbb;
    D.23787->last_ins = ins;
    D.23788 = D.23787->last_ins;
    D.23787->code = D.23788;
    <D.23979>:
    D.23792 = ins;
    return D.23792;
  }
  <D.23958>:
  D.23792 = 0B;
  return D.23792;
}


get_simd_vreg (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * src)
{
  short unsigned int D.23981;
  int D.23984;
  unsigned char D.23985;

  D.23981 = src->opcode;
  if (D.23981 == 962) goto <D.23982>; else goto <D.23983>;
  <D.23982>:
  D.23984 = src->sreg1;
  return D.23984;
  <D.23983>:
  D.23985 = src->type;
  if (D.23985 == 7) goto <D.23986>; else goto <D.23987>;
  <D.23986>:
  D.23984 = src->dreg;
  return D.23984;
  <D.23987>:
  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.23989;
  int D.23990;
  unsigned int D.23991;
  unsigned int D.23992;
  unsigned int D.23995;
  unsigned int D.23996;
  unsigned int D.23999;
  unsigned char D.24002;
  unsigned char D.24003;
  struct MonoMemPool * D.24006;
  int D.24007;
  struct MonoInst * D.24008;
  int D.24009;
  int D.24010;
  const unsigned char * D.24011;
  struct MonoBasicBlock * D.24012;
  struct MonoInst * D.24013;
  int D.24017;
  struct MonoInst * D.24018;
  int D.24019;
  int D.24020;
  unsigned int D.24027;
  int D.24030;
  int D.24035;
  struct MonoInst * D.24036;
  int D.24037;
  int D.24038;
  int D.24042;
  struct MonoInst * D.24043;
  int D.24044;
  int D.24045;
  int D.24050;
  struct MonoInst * D.24051;
  int D.24052;
  int D.24053;
  unsigned char D.24054;
  int D.24059;
  int D.24064;
  struct MonoInst * D.24065;
  int D.24066;
  int D.24067;
  int D.24071;
  struct MonoInst * D.24072;
  int D.24073;
  int D.24074;
  int D.24079;
  struct MonoInst * D.24080;
  int D.24081;
  int D.24082;
  unsigned char D.24083;
  int D.24087;
  struct MonoInst * D.24088;
  int D.24089;
  int D.24090;
  int D.24094;
  struct MonoInst * D.24095;
  int D.24096;
  int D.24097;
  int D.24102;
  struct MonoInst * D.24103;
  int D.24104;
  int D.24105;
  int D.24109;
  struct MonoInst * D.24110;
  int D.24111;
  int D.24112;
  int D.24117;
  struct MonoInst * D.24118;
  int D.24119;
  int D.24120;
  unsigned char D.24121;
  unsigned char D.24122;
  unsigned int D.24126;
  unsigned int D.24127;
  int D.24128;
  struct MonoInst * D.24129;
  int D.24130;
  int D.24131;
  unsigned int D.24132;
  unsigned int D.24133;
  int D.24134;
  int D.24144;
  struct MonoInst * D.24145;
  int D.24146;
  int D.24147;
  int D.24151;
  struct MonoInst * D.24152;
  int D.24153;
  int D.24154;
  unsigned int D.24161;
  int D.24164;
  int D.24169;
  struct MonoInst * D.24170;
  int D.24171;
  int D.24172;
  int D.24176;
  struct MonoInst * D.24177;
  int D.24178;
  int D.24179;
  int D.24184;
  struct MonoInst * D.24185;
  int D.24186;
  int D.24187;
  unsigned char D.24188;
  int D.24193;
  int D.24198;
  struct MonoInst * D.24199;
  int D.24200;
  int D.24201;
  int D.24205;
  struct MonoInst * D.24206;
  int D.24207;
  int D.24208;
  int D.24213;
  struct MonoInst * D.24214;
  int D.24215;
  int D.24216;
  unsigned char D.24217;
  int D.24221;
  struct MonoInst * D.24222;
  int D.24223;
  int D.24224;
  int D.24228;
  struct MonoInst * D.24229;
  int D.24230;
  int D.24231;
  int D.24236;
  struct MonoInst * D.24237;
  int D.24238;
  int D.24239;
  int D.24243;
  struct MonoInst * D.24244;
  int D.24245;
  int D.24246;
  int D.24251;
  struct MonoInst * D.24252;
  int D.24253;
  int D.24254;
  unsigned char D.24255;
  unsigned char D.24256;
  unsigned int D.24260;
  int D.24261;
  struct MonoInst * D.24262;
  int D.24263;
  int D.24264;
  int size.32;
  int D.24269;
  struct MonoInst * D.24270;
  int D.24271;
  int D.24272;
  int D.24276;
  struct MonoInst * D.24277;
  int D.24278;
  int D.24279;
  int D.24283;
  struct MonoInst * ins;
  guint32 size;
  int mult_reg;
  int add_reg;
  int array_reg;
  int index_reg;
  int index2_reg;
  int index3_reg;

  D.23989 = mono_class_from_mono_type (array_type);
  D.23990 = mono_array_element_size (D.23989);
  size = (guint32) D.23990;
  D.23991 = alloc_preg (cfg);
  mult_reg = (int) D.23991;
  array_reg = arr->dreg;
  index_reg = index->dreg;
  index2_reg = index_reg;
  D.23992 = alloc_preg (cfg);
  index3_reg = (int) D.23992;
  if (check_bounds != 0) goto <D.23993>; else goto <D.23994>;
  <D.23993>:
  D.23995 = cfg->opt;
  D.23996 = D.23995 & 134217728;
  if (D.23996 == 0) goto <D.23997>; else goto <D.23998>;
  <D.23997>:
  D.23995 = cfg->opt;
  D.23999 = D.23995 & 262144;
  if (D.23999 == 0) goto <D.24000>; else goto <D.24001>;
  <D.24000>:
  D.24002 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.24003 = D.24002 & 64;
  if (D.24003 != 0) goto <D.24004>; else goto <D.24005>;
  <D.24004>:
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24007 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24007;
    inst->prev = 0B;
    D.24008 = inst->prev;
    inst->next = D.24008;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24009 = inst->sreg3;
    inst->sreg2 = D.24009;
    D.24010 = inst->sreg2;
    inst->sreg1 = D.24010;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->dreg = -1;
    inst->sreg1 = array_reg;
    inst->data.op[1].const_val = 0;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24014>; else goto <D.24015>;
    <D.24014>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24016>;
    <D.24015>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24016>:
  }
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24017 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24017;
    inst->prev = 0B;
    D.24018 = inst->prev;
    inst->next = D.24018;
    inst->opcode = 455;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24019 = inst->sreg3;
    inst->sreg2 = D.24019;
    D.24020 = inst->sreg2;
    inst->sreg1 = D.24020;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->data.op[1].p = "NullReferenceException";
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24021>; else goto <D.24022>;
    <D.24021>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24023>;
    <D.24022>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24023>:
  }
  goto <D.24024>;
  <D.24005>:
  <D.24024>:
  if (0 != 0) goto <D.24025>; else goto <D.24026>;
  <D.24025>:
  {
    int _length_reg;

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

      __ins_flags = 32;
      D.24030 = __ins_flags & 32;
      if (D.24030 != 0) goto <D.24031>; else goto <D.24032>;
      <D.24031>:
      D.24002 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.24003 = D.24002 & 64;
      if (D.24003 != 0) goto <D.24033>; else goto <D.24034>;
      <D.24033>:
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24035 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24035;
        inst->prev = 0B;
        D.24036 = inst->prev;
        inst->next = D.24036;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24037 = inst->sreg3;
        inst->sreg2 = D.24037;
        D.24038 = inst->sreg2;
        inst->sreg1 = D.24038;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24039>; else goto <D.24040>;
        <D.24039>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24041>;
        <D.24040>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24041>:
      }
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24042 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24042;
        inst->prev = 0B;
        D.24043 = inst->prev;
        inst->next = D.24043;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24044 = inst->sreg3;
        inst->sreg2 = D.24044;
        D.24045 = inst->sreg2;
        inst->sreg1 = D.24045;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->data.op[1].p = "NullReferenceException";
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24046>; else goto <D.24047>;
        <D.24046>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24048>;
        <D.24047>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24048>:
      }
      goto <D.24049>;
      <D.24034>:
      <D.24049>:
      <D.24032>:
      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24050 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24050;
      inst->prev = 0B;
      D.24051 = inst->prev;
      inst->next = D.24051;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24052 = inst->sreg3;
      inst->sreg2 = D.24052;
      D.24053 = inst->sreg2;
      inst->sreg1 = D.24053;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 12;
      inst->type = 1;
      D.24054 = (unsigned char) __ins_flags;
      inst->flags = D.24054;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24055>; else goto <D.24056>;
      <D.24055>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24057>;
      <D.24056>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24057>:
    }
    goto <D.24058>;
    <D.24029>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.24059 = __ins_flags & 32;
      if (D.24059 != 0) goto <D.24060>; else goto <D.24061>;
      <D.24060>:
      D.24002 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.24003 = D.24002 & 64;
      if (D.24003 != 0) goto <D.24062>; else goto <D.24063>;
      <D.24062>:
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24064 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24064;
        inst->prev = 0B;
        D.24065 = inst->prev;
        inst->next = D.24065;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24066 = inst->sreg3;
        inst->sreg2 = D.24066;
        D.24067 = inst->sreg2;
        inst->sreg1 = D.24067;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24068>; else goto <D.24069>;
        <D.24068>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24070>;
        <D.24069>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24070>:
      }
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24071 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24071;
        inst->prev = 0B;
        D.24072 = inst->prev;
        inst->next = D.24072;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24073 = inst->sreg3;
        inst->sreg2 = D.24073;
        D.24074 = inst->sreg2;
        inst->sreg1 = D.24074;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->data.op[1].p = "NullReferenceException";
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24075>; else goto <D.24076>;
        <D.24075>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24077>;
        <D.24076>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24077>:
      }
      goto <D.24078>;
      <D.24063>:
      <D.24078>:
      <D.24061>:
      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24079 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24079;
      inst->prev = 0B;
      D.24080 = inst->prev;
      inst->next = D.24080;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24081 = inst->sreg3;
      inst->sreg2 = D.24081;
      D.24082 = inst->sreg2;
      inst->sreg1 = D.24082;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 12;
      inst->type = 1;
      D.24083 = (unsigned char) __ins_flags;
      inst->flags = D.24083;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24084>; else goto <D.24085>;
      <D.24084>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24086>;
      <D.24085>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24086>:
    }
    <D.24058>:
    {
      struct MonoInst * inst;

      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24087 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24087;
      inst->prev = 0B;
      D.24088 = inst->prev;
      inst->next = D.24088;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24089 = inst->sreg3;
      inst->sreg2 = D.24089;
      D.24090 = inst->sreg2;
      inst->sreg1 = D.24090;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index2_reg;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24091>; else goto <D.24092>;
      <D.24091>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24093>;
      <D.24092>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24093>:
    }
    {
      struct MonoInst * inst;

      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24094 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24094;
      inst->prev = 0B;
      D.24095 = inst->prev;
      inst->next = D.24095;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24096 = inst->sreg3;
      inst->sreg2 = D.24096;
      D.24097 = inst->sreg2;
      inst->sreg1 = D.24097;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24098>; else goto <D.24099>;
      <D.24098>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24100>;
      <D.24099>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24100>:
    }
  }
  goto <D.24101>;
  <D.24026>:
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24102 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24102;
    inst->prev = 0B;
    D.24103 = inst->prev;
    inst->next = D.24103;
    inst->opcode = 1006;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24104 = inst->sreg3;
    inst->sreg2 = D.24104;
    D.24105 = inst->sreg2;
    inst->sreg1 = D.24105;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->sreg1 = array_reg;
    inst->data.op[0].const_val = 12;
    inst->sreg2 = index2_reg;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24106>; else goto <D.24107>;
    <D.24106>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24108>;
    <D.24107>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24108>:
    {
      struct MonoInst * inst;

      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24109 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24109;
      inst->prev = 0B;
      D.24110 = inst->prev;
      inst->next = D.24110;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24111 = inst->sreg3;
      inst->sreg2 = D.24111;
      D.24112 = inst->sreg2;
      inst->sreg1 = D.24112;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24113>; else goto <D.24114>;
      <D.24113>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24115>;
      <D.24114>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24115>:
    }
  }
  <D.24101>:
  goto <D.24116>;
  <D.24001>:
  {
    struct MonoInst * ins;

    D.24006 = cfg->mempool;
    ins = mono_mempool_alloc (D.24006, 48);
    ins->data.op[1].const_val = 0;
    D.24117 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24117;
    ins->prev = 0B;
    D.24118 = ins->prev;
    ins->next = D.24118;
    ins->opcode = 788;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24119 = ins->sreg3;
    ins->sreg2 = D.24119;
    D.24120 = ins->sreg2;
    ins->sreg1 = D.24120;
    D.24011 = cfg->ip;
    ins->cil_code = D.24011;
    ins->sreg1 = array_reg;
    ins->sreg2 = index2_reg;
    ins->data.op[1].const_val = 12;
    D.24121 = ins->flags;
    D.24122 = D.24121 | 32;
    ins->flags = D.24122;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24123>; else goto <D.24124>;
    <D.24123>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = ins;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    ins->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = ins;
    goto <D.24125>;
    <D.24124>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = ins;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24125>:
    D.24126 = cfg->flags;
    D.24127 = D.24126 | 256;
    cfg->flags = D.24127;
    D.24012 = cfg->cbb;
    D.24012->has_array_access = 1;
  }
  <D.24116>:
  <D.23998>:
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24128 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24128;
    inst->prev = 0B;
    D.24129 = inst->prev;
    inst->next = D.24129;
    inst->opcode = 629;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24130 = inst->sreg3;
    inst->sreg2 = D.24130;
    D.24131 = inst->sreg2;
    inst->sreg1 = D.24131;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->dreg = index3_reg;
    inst->sreg1 = index2_reg;
    D.24132 = 16 / size;
    D.24133 = D.24132 + 4294967295;
    D.24134 = (int) D.24133;
    inst->data.op[1].const_val = D.24134;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24135>; else goto <D.24136>;
    <D.24135>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24137>;
    <D.24136>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24137>:
  }
  D.23995 = cfg->opt;
  D.23996 = D.23995 & 134217728;
  if (D.23996 == 0) goto <D.24138>; else goto <D.24139>;
  <D.24138>:
  D.23995 = cfg->opt;
  D.23999 = D.23995 & 262144;
  if (D.23999 == 0) goto <D.24140>; else goto <D.24141>;
  <D.24140>:
  D.24002 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.24003 = D.24002 & 64;
  if (D.24003 != 0) goto <D.24142>; else goto <D.24143>;
  <D.24142>:
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24144 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24144;
    inst->prev = 0B;
    D.24145 = inst->prev;
    inst->next = D.24145;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24146 = inst->sreg3;
    inst->sreg2 = D.24146;
    D.24147 = inst->sreg2;
    inst->sreg1 = D.24147;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->dreg = -1;
    inst->sreg1 = array_reg;
    inst->data.op[1].const_val = 0;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24148>; else goto <D.24149>;
    <D.24148>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24150>;
    <D.24149>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24150>:
  }
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24151 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24151;
    inst->prev = 0B;
    D.24152 = inst->prev;
    inst->next = D.24152;
    inst->opcode = 455;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24153 = inst->sreg3;
    inst->sreg2 = D.24153;
    D.24154 = inst->sreg2;
    inst->sreg1 = D.24154;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->data.op[1].p = "NullReferenceException";
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24155>; else goto <D.24156>;
    <D.24155>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24157>;
    <D.24156>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24157>:
  }
  goto <D.24158>;
  <D.24143>:
  <D.24158>:
  if (0 != 0) goto <D.24159>; else goto <D.24160>;
  <D.24159>:
  {
    int _length_reg;

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

      __ins_flags = 32;
      D.24164 = __ins_flags & 32;
      if (D.24164 != 0) goto <D.24165>; else goto <D.24166>;
      <D.24165>:
      D.24002 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.24003 = D.24002 & 64;
      if (D.24003 != 0) goto <D.24167>; else goto <D.24168>;
      <D.24167>:
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24169 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24169;
        inst->prev = 0B;
        D.24170 = inst->prev;
        inst->next = D.24170;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24171 = inst->sreg3;
        inst->sreg2 = D.24171;
        D.24172 = inst->sreg2;
        inst->sreg1 = D.24172;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24173>; else goto <D.24174>;
        <D.24173>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24175>;
        <D.24174>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24175>:
      }
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24176 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24176;
        inst->prev = 0B;
        D.24177 = inst->prev;
        inst->next = D.24177;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24178 = inst->sreg3;
        inst->sreg2 = D.24178;
        D.24179 = inst->sreg2;
        inst->sreg1 = D.24179;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->data.op[1].p = "NullReferenceException";
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24180>; else goto <D.24181>;
        <D.24180>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24182>;
        <D.24181>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24182>:
      }
      goto <D.24183>;
      <D.24168>:
      <D.24183>:
      <D.24166>:
      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24184 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24184;
      inst->prev = 0B;
      D.24185 = inst->prev;
      inst->next = D.24185;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24186 = inst->sreg3;
      inst->sreg2 = D.24186;
      D.24187 = inst->sreg2;
      inst->sreg1 = D.24187;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 12;
      inst->type = 1;
      D.24188 = (unsigned char) __ins_flags;
      inst->flags = D.24188;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24189>; else goto <D.24190>;
      <D.24189>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24191>;
      <D.24190>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24191>:
    }
    goto <D.24192>;
    <D.24163>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.24193 = __ins_flags & 32;
      if (D.24193 != 0) goto <D.24194>; else goto <D.24195>;
      <D.24194>:
      D.24002 = BIT_FIELD_REF <*cfg, 8, 3424>;
      D.24003 = D.24002 & 64;
      if (D.24003 != 0) goto <D.24196>; else goto <D.24197>;
      <D.24196>:
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24198 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24198;
        inst->prev = 0B;
        D.24199 = inst->prev;
        inst->next = D.24199;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24200 = inst->sreg3;
        inst->sreg2 = D.24200;
        D.24201 = inst->sreg2;
        inst->sreg1 = D.24201;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24202>; else goto <D.24203>;
        <D.24202>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24204>;
        <D.24203>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24204>:
      }
      {
        struct MonoInst * inst;

        D.24006 = cfg->mempool;
        inst = mono_mempool_alloc (D.24006, 48);
        inst->data.op[1].const_val = 0;
        D.24205 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24205;
        inst->prev = 0B;
        D.24206 = inst->prev;
        inst->next = D.24206;
        inst->opcode = 455;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24207 = inst->sreg3;
        inst->sreg2 = D.24207;
        D.24208 = inst->sreg2;
        inst->sreg1 = D.24208;
        D.24011 = cfg->ip;
        inst->cil_code = D.24011;
        inst->data.op[1].p = "NullReferenceException";
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        if (D.24013 != 0B) goto <D.24209>; else goto <D.24210>;
        <D.24209>:
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        D.24013->next = inst;
        D.24012 = cfg->cbb;
        D.24013 = D.24012->last_ins;
        inst->prev = D.24013;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        goto <D.24211>;
        <D.24210>:
        D.24012 = cfg->cbb;
        D.24012 = cfg->cbb;
        D.24012->last_ins = inst;
        D.24013 = D.24012->last_ins;
        D.24012->code = D.24013;
        <D.24211>:
      }
      goto <D.24212>;
      <D.24197>:
      <D.24212>:
      <D.24195>:
      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24213 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24213;
      inst->prev = 0B;
      D.24214 = inst->prev;
      inst->next = D.24214;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24215 = inst->sreg3;
      inst->sreg2 = D.24215;
      D.24216 = inst->sreg2;
      inst->sreg1 = D.24216;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 12;
      inst->type = 1;
      D.24217 = (unsigned char) __ins_flags;
      inst->flags = D.24217;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24218>; else goto <D.24219>;
      <D.24218>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24220>;
      <D.24219>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24220>:
    }
    <D.24192>:
    {
      struct MonoInst * inst;

      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24221 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24221;
      inst->prev = 0B;
      D.24222 = inst->prev;
      inst->next = D.24222;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24223 = inst->sreg3;
      inst->sreg2 = D.24223;
      D.24224 = inst->sreg2;
      inst->sreg1 = D.24224;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index3_reg;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24225>; else goto <D.24226>;
      <D.24225>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24227>;
      <D.24226>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24227>:
    }
    {
      struct MonoInst * inst;

      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24228 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24228;
      inst->prev = 0B;
      D.24229 = inst->prev;
      inst->next = D.24229;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24230 = inst->sreg3;
      inst->sreg2 = D.24230;
      D.24231 = inst->sreg2;
      inst->sreg1 = D.24231;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24232>; else goto <D.24233>;
      <D.24232>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24234>;
      <D.24233>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24234>:
    }
  }
  goto <D.24235>;
  <D.24160>:
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24236 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24236;
    inst->prev = 0B;
    D.24237 = inst->prev;
    inst->next = D.24237;
    inst->opcode = 1006;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24238 = inst->sreg3;
    inst->sreg2 = D.24238;
    D.24239 = inst->sreg2;
    inst->sreg1 = D.24239;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->sreg1 = array_reg;
    inst->data.op[0].const_val = 12;
    inst->sreg2 = index3_reg;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24240>; else goto <D.24241>;
    <D.24240>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24242>;
    <D.24241>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24242>:
    {
      struct MonoInst * inst;

      D.24006 = cfg->mempool;
      inst = mono_mempool_alloc (D.24006, 48);
      inst->data.op[1].const_val = 0;
      D.24243 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24243;
      inst->prev = 0B;
      D.24244 = inst->prev;
      inst->next = D.24244;
      inst->opcode = 463;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24245 = inst->sreg3;
      inst->sreg2 = D.24245;
      D.24246 = inst->sreg2;
      inst->sreg1 = D.24246;
      D.24011 = cfg->ip;
      inst->cil_code = D.24011;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      if (D.24013 != 0B) goto <D.24247>; else goto <D.24248>;
      <D.24247>:
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      D.24013->next = inst;
      D.24012 = cfg->cbb;
      D.24013 = D.24012->last_ins;
      inst->prev = D.24013;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      goto <D.24249>;
      <D.24248>:
      D.24012 = cfg->cbb;
      D.24012 = cfg->cbb;
      D.24012->last_ins = inst;
      D.24013 = D.24012->last_ins;
      D.24012->code = D.24013;
      <D.24249>:
    }
  }
  <D.24235>:
  goto <D.24250>;
  <D.24141>:
  {
    struct MonoInst * ins;

    D.24006 = cfg->mempool;
    ins = mono_mempool_alloc (D.24006, 48);
    ins->data.op[1].const_val = 0;
    D.24251 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24251;
    ins->prev = 0B;
    D.24252 = ins->prev;
    ins->next = D.24252;
    ins->opcode = 788;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24253 = ins->sreg3;
    ins->sreg2 = D.24253;
    D.24254 = ins->sreg2;
    ins->sreg1 = D.24254;
    D.24011 = cfg->ip;
    ins->cil_code = D.24011;
    ins->sreg1 = array_reg;
    ins->sreg2 = index3_reg;
    ins->data.op[1].const_val = 12;
    D.24255 = ins->flags;
    D.24256 = D.24255 | 32;
    ins->flags = D.24256;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24257>; else goto <D.24258>;
    <D.24257>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = ins;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    ins->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = ins;
    goto <D.24259>;
    <D.24258>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = ins;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24259>:
    D.24126 = cfg->flags;
    D.24127 = D.24126 | 256;
    cfg->flags = D.24127;
    D.24012 = cfg->cbb;
    D.24012->has_array_access = 1;
  }
  <D.24250>:
  <D.24139>:
  <D.23994>:
  D.24260 = alloc_preg (cfg);
  add_reg = (int) D.24260;
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24261 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24261;
    inst->prev = 0B;
    D.24262 = inst->prev;
    inst->next = D.24262;
    inst->opcode = 435;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24263 = inst->sreg3;
    inst->sreg2 = D.24263;
    D.24264 = inst->sreg2;
    inst->sreg1 = D.24264;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->dreg = mult_reg;
    inst->sreg1 = index2_reg;
    size.32 = (int) size;
    inst->data.op[1].const_val = size.32;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24266>; else goto <D.24267>;
    <D.24266>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24268>;
    <D.24267>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24268>:
  }
  {
    struct MonoInst * inst;

    D.24006 = cfg->mempool;
    inst = mono_mempool_alloc (D.24006, 48);
    inst->data.op[1].const_val = 0;
    D.24269 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24269;
    inst->prev = 0B;
    D.24270 = inst->prev;
    inst->next = D.24270;
    inst->opcode = 569;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24271 = inst->sreg3;
    inst->sreg2 = D.24271;
    D.24272 = inst->sreg2;
    inst->sreg1 = D.24272;
    D.24011 = cfg->ip;
    inst->cil_code = D.24011;
    inst->dreg = add_reg;
    inst->sreg1 = array_reg;
    inst->sreg2 = mult_reg;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    if (D.24013 != 0B) goto <D.24273>; else goto <D.24274>;
    <D.24273>:
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    D.24013->next = inst;
    D.24012 = cfg->cbb;
    D.24013 = D.24012->last_ins;
    inst->prev = D.24013;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    goto <D.24275>;
    <D.24274>:
    D.24012 = cfg->cbb;
    D.24012 = cfg->cbb;
    D.24012->last_ins = inst;
    D.24013 = D.24012->last_ins;
    D.24012->code = D.24013;
    <D.24275>:
  }
  D.24006 = cfg->mempool;
  ins = mono_mempool_alloc (D.24006, 48);
  ins->data.op[1].const_val = 0;
  D.24276 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24276;
  ins->prev = 0B;
  D.24277 = ins->prev;
  ins->next = D.24277;
  ins->opcode = 629;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24278 = ins->sreg3;
  ins->sreg2 = D.24278;
  D.24279 = ins->sreg2;
  ins->sreg1 = D.24279;
  D.24011 = cfg->ip;
  ins->cil_code = D.24011;
  ins->dreg = add_reg;
  ins->sreg1 = add_reg;
  ins->data.op[1].const_val = 16;
  ins->type = 3;
  D.24012 = cfg->cbb;
  D.24013 = D.24012->last_ins;
  if (D.24013 != 0B) goto <D.24280>; else goto <D.24281>;
  <D.24280>:
  D.24012 = cfg->cbb;
  D.24013 = D.24012->last_ins;
  D.24013->next = ins;
  D.24012 = cfg->cbb;
  D.24013 = D.24012->last_ins;
  ins->prev = D.24013;
  D.24012 = cfg->cbb;
  D.24012->last_ins = ins;
  goto <D.24282>;
  <D.24281>:
  D.24012 = cfg->cbb;
  D.24012 = cfg->cbb;
  D.24012->last_ins = ins;
  D.24013 = D.24012->last_ins;
  D.24012->code = D.24013;
  <D.24282>:
  D.24283 = add_reg;
  return D.24283;
}


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

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


emit_intrinsics (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args, const struct SimdIntrinsc * intrinsics, guint32 size)
{
  const char * D.24287;
  unsigned int D.24290;
  short unsigned int D.24293;
  int D.24294;
  struct MonoClass * D.24295;
  const char * D.24296;
  struct MonoInst * D.24297;
  short unsigned int D.24300;
  sizetype D.24301;
  const char * D.24302;
  <unnamed-unsigned:1> D.24303;
  int D.24304;
  unsigned int i.33;
  unsigned int D.24306;
  struct MonoInst * * D.24307;
  struct MonoInst * D.24308;
  unsigned char D.24309;
  unsigned int D.24312;
  unsigned int simd_supported_versions.34;
  unsigned int D.24314;
  int D.24319;
  int D.24320;
  int D.24321;
  int D.24324;
  unsigned int D.24325;
  const char * D.24326;
  <unnamed-unsigned:4> D.24327;
  int D.24328;
  const struct SimdIntrinsc * result;

  D.24287 = cmethod->name;
  result = mono_binary_search (D.24287, intrinsics, size, 6, simd_intrinsic_compare_by_name);
  if (result == 0B) goto <D.24288>; else goto <D.24289>;
  <D.24288>:
  D.24290 = cfg->verbose_level;
  if (D.24290 > 2) goto <D.24291>; else goto <D.24292>;
  <D.24291>:
  D.24293 = fsig->param_count;
  D.24294 = (int) D.24293;
  D.24287 = cmethod->name;
  D.24295 = cmethod->klass;
  D.24296 = D.24295->name;
  printf ("function doesn\'t have a simd intrinsic %s::%s/%d\n", D.24296, D.24287, D.24294);
  <D.24292>:
  D.24297 = 0B;
  return D.24297;
  <D.24289>:
  D.24290 = cfg->verbose_level;
  if (D.24290 > 2) goto <D.24298>; else goto <D.24299>;
  <D.24298>:
  {
    int i;
    int max;

    D.24300 = result->name;
    D.24301 = (sizetype) D.24300;
    D.24302 = &method_names + D.24301;
    D.24293 = fsig->param_count;
    D.24294 = (int) D.24293;
    D.24287 = cmethod->name;
    D.24295 = cmethod->klass;
    D.24296 = D.24295->name;
    printf ("found call to intrinsic %s::%s/%d -> %s\n", D.24296, D.24287, D.24294, D.24302);
    D.24293 = fsig->param_count;
    D.24294 = (int) D.24293;
    D.24303 = fsig->hasthis;
    D.24304 = (int) D.24303;
    max = D.24294 + D.24304;
    i = 0;
    goto <D.22440>;
    <D.22439>:
    printf ("param %d:  ", i);
    i.33 = (unsigned int) i;
    D.24306 = i.33 * 4;
    D.24307 = args + D.24306;
    D.24308 = *D.24307;
    mono_print_ins (D.24308);
    i = i + 1;
    <D.22440>:
    if (i < max) goto <D.22439>; else goto <D.22441>;
    <D.22441>:
  }
  <D.24299>:
  D.24309 = result->simd_version_flags;
  if (D.24309 != 0) goto <D.24310>; else goto <D.24311>;
  <D.24310>:
  D.24309 = result->simd_version_flags;
  D.24312 = (unsigned int) D.24309;
  simd_supported_versions.34 = simd_supported_versions;
  D.24314 = D.24312 & simd_supported_versions.34;
  if (D.24314 == 0) goto <D.24315>; else goto <D.24316>;
  <D.24315>:
  D.24290 = cfg->verbose_level;
  if (D.24290 > 2) goto <D.24317>; else goto <D.24318>;
  <D.24317>:
  {
    int x;

    D.24293 = fsig->param_count;
    D.24294 = (int) D.24293;
    D.24287 = cmethod->name;
    D.24295 = cmethod->klass;
    D.24296 = D.24295->name;
    printf ("function %s::%s/%d requires one of unsuported SIMD instruction set(s): ", D.24296, D.24287, D.24294);
    x = 1;
    goto <D.22444>;
    <D.22443>:
    D.24309 = result->simd_version_flags;
    D.24319 = (int) D.24309;
    D.24320 = D.24319 >> x;
    D.24321 = D.24320 & 1;
    if (D.24321 != 0) goto <D.24322>; else goto <D.24323>;
    <D.24322>:
    D.24324 = 1 << x;
    D.24325 = (unsigned int) D.24324;
    D.24326 = simd_version_name (D.24325);
    printf ("%s ", D.24326);
    <D.24323>:
    x = x + 1;
    <D.22444>:
    if (x <= 6) goto <D.22443>; else goto <D.22445>;
    <D.22445>:
    printf ("\n");
  }
  <D.24318>:
  D.24297 = 0B;
  return D.24297;
  <D.24316>:
  <D.24311>:
  D.24327 = result->simd_emit_mode;
  D.24328 = (int) D.24327;
  switch (D.24328) <default: <D.24329>, case 0: <D.22446>, case 1: <D.22447>, case 2: <D.22448>, case 3: <D.22449>, case 4: <D.22450>, case 5: <D.22451>, case 6: <D.22452>, case 7: <D.22453>, case 8: <D.22454>, case 9: <D.22455>, case 10: <D.22456>, case 11: <D.22457>, case 12: <D.22458>, case 13: <D.22459>>
  <D.22446>:
  D.24297 = simd_intrinsic_emit_binary (result, cfg, cmethod, args);
  return D.24297;
  <D.22447>:
  D.24297 = simd_intrinsic_emit_unary (result, cfg, cmethod, args);
  return D.24297;
  <D.22448>:
  D.24297 = simd_intrinsic_emit_setter (result, cfg, cmethod, args);
  return D.24297;
  <D.22449>:
  D.24297 = simd_intrinsic_emit_getter (result, cfg, cmethod, args);
  return D.24297;
  <D.22450>:
  D.24297 = simd_intrinsic_emit_long_getter (result, cfg, cmethod, args);
  return D.24297;
  <D.22451>:
  D.24297 = simd_intrinsic_emit_ctor (result, cfg, cmethod, args);
  return D.24297;
  <D.22452>:
  D.24297 = simd_intrinsic_emit_cast (result, cfg, cmethod, args);
  return D.24297;
  <D.22453>:
  D.24297 = simd_intrinsic_emit_shuffle (result, cfg, cmethod, args);
  return D.24297;
  <D.22454>:
  D.24297 = simd_intrinsic_emit_shift (result, cfg, cmethod, args);
  return D.24297;
  <D.22455>:
  D.24297 = simd_intrinsic_emit_equality (result, cfg, cmethod, args);
  return D.24297;
  <D.22456>:
  D.24297 = simd_intrinsic_emit_load_aligned (result, cfg, cmethod, args);
  return D.24297;
  <D.22457>:
  D.24297 = simd_intrinsic_emit_store (result, cfg, cmethod, args);
  return D.24297;
  <D.22458>:
  D.24297 = simd_intrinsic_emit_extract_mask (result, cfg, cmethod, args);
  return D.24297;
  <D.22459>:
  D.24297 = simd_intrinsic_emit_prefetch (result, cfg, cmethod, args);
  return D.24297;
  <D.24329>:
  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.24331;
  int D.22082;
  short unsigned int D.24332;
  sizetype D.24333;
  const char * D.24334;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.24332 = MEM[(struct SimdIntrinsc *)value].name;
    D.24333 = (sizetype) D.24332;
    D.24334 = &method_names + D.24333;
    D.22082 = __builtin_strcmp (key, D.24334);
  }
  D.24331 = D.22082;
  return D.24331;
}


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

  switch (version) <default: <D.24337>, case 1: <D.22421>, case 2: <D.22422>, case 4: <D.22423>, case 8: <D.22424>, case 16: <D.22425>, case 32: <D.22426>, case 64: <D.22427>>
  <D.22421>:
  D.24336 = "sse1";
  return D.24336;
  <D.22422>:
  D.24336 = "sse2";
  return D.24336;
  <D.22423>:
  D.24336 = "sse3";
  return D.24336;
  <D.22424>:
  D.24336 = "ssse3";
  return D.24336;
  <D.22425>:
  D.24336 = "sse41";
  return D.24336;
  <D.22426>:
  D.24336 = "sse42";
  return D.24336;
  <D.22427>:
  D.24336 = "sse4a";
  return D.24336;
  <D.24337>:
  D.24336 = "n/a";
  return D.24336;
}


simd_intrinsic_emit_binary (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24339;
  struct MonoInst * * D.24340;
  struct MonoInst * D.24341;
  struct MonoMemPool * D.24342;
  int D.24343;
  struct MonoInst * D.24344;
  short unsigned int D.24345;
  int D.24346;
  int D.24347;
  const unsigned char * D.24348;
  struct MonoClass * D.24349;
  unsigned int D.24350;
  int D.24351;
  <unnamed-unsigned:4> D.24352;
  int D.24353;
  struct MonoBasicBlock * D.24354;
  struct MonoInst * D.24355;
  struct MonoInst * D.24359;
  struct MonoInst * ins;
  int left_vreg;
  int right_vreg;

  D.24339 = *args;
  left_vreg = get_simd_vreg_or_expanded_scalar (cfg, cmethod, D.24339, 0);
  D.24340 = args + 4;
  D.24341 = *D.24340;
  right_vreg = get_simd_vreg_or_expanded_scalar (cfg, cmethod, D.24341, 1);
  D.24342 = cfg->mempool;
  ins = mono_mempool_alloc (D.24342, 48);
  ins->data.op[1].const_val = 0;
  D.24343 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24343;
  ins->prev = 0B;
  D.24344 = ins->prev;
  ins->next = D.24344;
  D.24345 = intrinsic->opcode;
  ins->opcode = D.24345;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24346 = ins->sreg3;
  ins->sreg2 = D.24346;
  D.24347 = ins->sreg2;
  ins->sreg1 = D.24347;
  D.24348 = cfg->ip;
  ins->cil_code = D.24348;
  D.24349 = cmethod->klass;
  ins->klass = D.24349;
  ins->sreg1 = left_vreg;
  ins->sreg2 = right_vreg;
  ins->type = 7;
  D.24350 = alloc_ireg (cfg);
  D.24351 = (int) D.24350;
  ins->dreg = D.24351;
  D.24352 = intrinsic->flags;
  D.24353 = (int) D.24352;
  ins->data.op[0].const_val = D.24353;
  D.24354 = cfg->cbb;
  D.24355 = D.24354->last_ins;
  if (D.24355 != 0B) goto <D.24356>; else goto <D.24357>;
  <D.24356>:
  D.24354 = cfg->cbb;
  D.24355 = D.24354->last_ins;
  D.24355->next = ins;
  D.24354 = cfg->cbb;
  D.24355 = D.24354->last_ins;
  ins->prev = D.24355;
  D.24354 = cfg->cbb;
  D.24354->last_ins = ins;
  goto <D.24358>;
  <D.24357>:
  D.24354 = cfg->cbb;
  D.24354 = cfg->cbb;
  D.24354->last_ins = ins;
  D.24355 = D.24354->last_ins;
  D.24354->code = D.24355;
  <D.24358>:
  D.24359 = ins;
  return D.24359;
}


get_simd_vreg_or_expanded_scalar (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * src, int position)
{
  short unsigned int D.24361;
  _Bool D.24362;
  long int D.24363;
  long int D.24364;
  unsigned int position.35;
  _Bool D.24368;
  long int D.24369;
  long int D.24370;
  struct MonoType * D.24373;
  struct MonoClass * D.24374;
  unsigned char D.24375;
  unsigned char D.24376;
  int D.24379;
  struct MonoMemPool * D.24380;
  int D.24381;
  struct MonoInst * D.24382;
  short unsigned int D.24383;
  int D.24384;
  int D.24385;
  const unsigned char * D.24386;
  struct MonoClass * D.24387;
  int D.24388;
  unsigned int D.24389;
  int D.24390;
  struct MonoBasicBlock * D.24391;
  struct MonoInst * D.24392;
  struct MonoInst * D.24398;
  struct MonoInst * D.24402;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int expand_op;

  sig = mono_method_signature (cmethod);
  D.24361 = sig->param_count;
  D.24362 = D.24361 != 2;
  D.24363 = (long int) D.24362;
  D.24364 = __builtin_expect (D.24363, 0);
  if (D.24364 != 0) goto <D.24365>; else goto <D.24366>;
  <D.24365>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 913, "sig->param_count == 2");
  <D.24366>:
  position.35 = (unsigned int) position;
  D.24368 = position.35 > 1;
  D.24369 = (long int) D.24368;
  D.24370 = __builtin_expect (D.24369, 0);
  if (D.24370 != 0) goto <D.24371>; else goto <D.24372>;
  <D.24371>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 914, "position == 0 || position == 1");
  <D.24372>:
  D.24373 = sig->params[position];
  D.24374 = mono_class_from_mono_type (D.24373);
  D.24375 = BIT_FIELD_REF <*D.24374, 8, 192>;
  D.24376 = D.24375 & 2;
  if (D.24376 != 0) goto <D.24377>; else goto <D.24378>;
  <D.24377>:
  D.24379 = get_simd_vreg (cfg, cmethod, src);
  return D.24379;
  <D.24378>:
  D.24373 = sig->params[position];
  expand_op = mono_type_to_expand_op (D.24373);
  D.24380 = cfg->mempool;
  ins = mono_mempool_alloc (D.24380, 48);
  ins->data.op[1].const_val = 0;
  D.24381 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24381;
  ins->prev = 0B;
  D.24382 = ins->prev;
  ins->next = D.24382;
  D.24383 = (short unsigned int) expand_op;
  ins->opcode = D.24383;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24384 = ins->sreg3;
  ins->sreg2 = D.24384;
  D.24385 = ins->sreg2;
  ins->sreg1 = D.24385;
  D.24386 = cfg->ip;
  ins->cil_code = D.24386;
  D.24387 = cmethod->klass;
  ins->klass = D.24387;
  D.24388 = src->dreg;
  ins->sreg1 = D.24388;
  ins->type = 7;
  D.24389 = alloc_ireg (cfg);
  D.24390 = (int) D.24389;
  ins->dreg = D.24390;
  D.24391 = cfg->cbb;
  D.24392 = D.24391->last_ins;
  if (D.24392 != 0B) goto <D.24393>; else goto <D.24394>;
  <D.24393>:
  D.24391 = cfg->cbb;
  D.24392 = D.24391->last_ins;
  D.24392->next = ins;
  D.24391 = cfg->cbb;
  D.24392 = D.24391->last_ins;
  ins->prev = D.24392;
  D.24391 = cfg->cbb;
  D.24391->last_ins = ins;
  goto <D.24395>;
  <D.24394>:
  D.24391 = cfg->cbb;
  D.24391 = cfg->cbb;
  D.24391->last_ins = ins;
  D.24392 = D.24391->last_ins;
  D.24391->code = D.24392;
  <D.24395>:
  if (expand_op == 950) goto <D.24396>; else goto <D.24397>;
  <D.24396>:
  D.24398 = get_int_to_float_spill_area (cfg);
  ins->backend.spill_var = D.24398;
  goto <D.24399>;
  <D.24397>:
  if (expand_op == 952) goto <D.24400>; else goto <D.24401>;
  <D.24400>:
  D.24402 = get_double_spill_area (cfg);
  ins->backend.spill_var = D.24402;
  <D.24401>:
  <D.24399>:
  D.24379 = ins->dreg;
  return D.24379;
}


mono_type_to_expand_op (struct MonoType * type)
{
  unsigned char D.24404;
  int D.24405;
  int D.24406;

  D.24404 = type->type;
  D.24405 = (int) D.24404;
  switch (D.24405) <default: <D.22215>, case 4: <D.22205>, case 5: <D.22206>, case 6: <D.22207>, case 7: <D.22208>, case 8: <D.22209>, case 9: <D.22210>, case 10: <D.22211>, case 11: <D.22212>, case 12: <D.22213>, case 13: <D.22214>>
  <D.22205>:
  <D.22206>:
  D.24406 = 947;
  return D.24406;
  <D.22207>:
  <D.22208>:
  D.24406 = 948;
  return D.24406;
  <D.22209>:
  <D.22210>:
  D.24406 = 949;
  return D.24406;
  <D.22211>:
  <D.22212>:
  D.24406 = 951;
  return D.24406;
  <D.22213>:
  D.24406 = 950;
  return D.24406;
  <D.22214>:
  D.24406 = 952;
  return D.24406;
  <D.22215>:
  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.24408;
  struct MonoClass * D.24411;
  struct MonoType * D.24412;
  struct MonoInst * D.24413;
  unsigned char D.24414;
  unsigned char D.24415;
  struct MonoInst * D.24416;

  D.24408 = cfg->iconv_raw_var;
  if (D.24408 == 0B) goto <D.24409>; else goto <D.24410>;
  <D.24409>:
  D.24411 = mono_defaults.int32_class;
  D.24412 = &D.24411->byval_arg;
  D.24413 = mono_compile_create_var (cfg, D.24412, 329);
  cfg->iconv_raw_var = D.24413;
  D.24408 = cfg->iconv_raw_var;
  D.24408 = cfg->iconv_raw_var;
  D.24414 = D.24408->flags;
  D.24415 = D.24414 | 4;
  D.24408->flags = D.24415;
  <D.24410>:
  D.24416 = cfg->iconv_raw_var;
  return D.24416;
}


get_double_spill_area (struct MonoCompile * cfg)
{
  struct MonoInst * D.24418;
  struct MonoClass * D.24421;
  struct MonoType * D.24422;
  struct MonoInst * D.24423;
  unsigned char D.24424;
  unsigned char D.24425;
  struct MonoInst * D.24426;

  D.24418 = cfg->fconv_to_r8_x_var;
  if (D.24418 == 0B) goto <D.24419>; else goto <D.24420>;
  <D.24419>:
  D.24421 = mono_defaults.double_class;
  D.24422 = &D.24421->byval_arg;
  D.24423 = mono_compile_create_var (cfg, D.24422, 329);
  cfg->fconv_to_r8_x_var = D.24423;
  D.24418 = cfg->fconv_to_r8_x_var;
  D.24418 = cfg->fconv_to_r8_x_var;
  D.24424 = D.24418->flags;
  D.24425 = D.24424 | 4;
  D.24418->flags = D.24425;
  <D.24420>:
  D.24426 = cfg->fconv_to_r8_x_var;
  return D.24426;
}


simd_intrinsic_emit_unary (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24428;
  struct MonoMemPool * D.24429;
  int D.24430;
  struct MonoInst * D.24431;
  short unsigned int D.24432;
  int D.24433;
  int D.24434;
  const unsigned char * D.24435;
  struct MonoClass * D.24436;
  unsigned int D.24437;
  int D.24438;
  struct MonoBasicBlock * D.24439;
  struct MonoInst * D.24440;
  struct MonoInst * D.24444;
  struct MonoInst * ins;
  int vreg;

  D.24428 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.24428);
  D.24429 = cfg->mempool;
  ins = mono_mempool_alloc (D.24429, 48);
  ins->data.op[1].const_val = 0;
  D.24430 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24430;
  ins->prev = 0B;
  D.24431 = ins->prev;
  ins->next = D.24431;
  D.24432 = intrinsic->opcode;
  ins->opcode = D.24432;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24433 = ins->sreg3;
  ins->sreg2 = D.24433;
  D.24434 = ins->sreg2;
  ins->sreg1 = D.24434;
  D.24435 = cfg->ip;
  ins->cil_code = D.24435;
  D.24436 = cmethod->klass;
  ins->klass = D.24436;
  ins->sreg1 = vreg;
  ins->type = 7;
  D.24437 = alloc_ireg (cfg);
  D.24438 = (int) D.24437;
  ins->dreg = D.24438;
  D.24439 = cfg->cbb;
  D.24440 = D.24439->last_ins;
  if (D.24440 != 0B) goto <D.24441>; else goto <D.24442>;
  <D.24441>:
  D.24439 = cfg->cbb;
  D.24440 = D.24439->last_ins;
  D.24440->next = ins;
  D.24439 = cfg->cbb;
  D.24440 = D.24439->last_ins;
  ins->prev = D.24440;
  D.24439 = cfg->cbb;
  D.24439->last_ins = ins;
  goto <D.24443>;
  <D.24442>:
  D.24439 = cfg->cbb;
  D.24439 = cfg->cbb;
  D.24439->last_ins = ins;
  D.24440 = D.24439->last_ins;
  D.24439->code = D.24440;
  <D.24443>:
  D.24444 = ins;
  return D.24444;
}


simd_intrinsic_emit_setter (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoType * D.24446;
  struct MonoMemPool * D.24449;
  int D.24450;
  struct MonoInst * D.24451;
  int D.24452;
  short unsigned int D.24453;
  int D.24454;
  int D.24455;
  const unsigned char * D.24456;
  struct MonoClass * D.24457;
  struct MonoInst * D.24458;
  int D.24459;
  struct MonoInst * * D.24460;
  struct MonoInst * D.24461;
  int D.24462;
  short unsigned int D.24463;
  int D.24464;
  struct MonoBasicBlock * D.24465;
  struct MonoInst * D.24466;
  _Bool D.24474;
  _Bool D.24475;
  _Bool D.24476;
  int D.24478;
  short unsigned int D.24479;
  unsigned char D.24480;
  struct MonoInst * D.24483;
  struct MonoInst * D.24487;
  unsigned int D.24491;
  short unsigned int D.24492;
  int D.24493;
  int indirect.36;
  int D.24503;
  struct MonoInst * D.24507;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int size;
  int align;
  gboolean indirect;
  int dreg;

  try
    {
      sig = mono_method_signature (cmethod);
      D.24446 = sig->params[0];
      size = mono_type_size (D.24446, &align);
      if (0 != 0) goto <D.24447>; else goto <D.24448>;
      <D.24447>:
      D.24449 = cfg->mempool;
      ins = mono_mempool_alloc (D.24449, 48);
      ins->data.op[1].const_val = 0;
      D.24450 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24450;
      ins->prev = 0B;
      D.24451 = ins->prev;
      ins->next = D.24451;
      D.24446 = sig->params[0];
      D.24452 = mono_type_to_insert_op (D.24446);
      D.24453 = (short unsigned int) D.24452;
      ins->opcode = D.24453;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24454 = ins->sreg3;
      ins->sreg2 = D.24454;
      D.24455 = ins->sreg2;
      ins->sreg1 = D.24455;
      D.24456 = cfg->ip;
      ins->cil_code = D.24456;
      D.24457 = cmethod->klass;
      ins->klass = D.24457;
      D.24458 = *args;
      dreg = load_simd_vreg (cfg, cmethod, D.24458, &indirect);
      ins->sreg1 = dreg;
      D.24459 = ins->sreg1;
      ins->dreg = D.24459;
      D.24460 = args + 4;
      D.24461 = *D.24460;
      D.24462 = D.24461->dreg;
      ins->sreg2 = D.24462;
      D.24463 = intrinsic->opcode;
      D.24464 = (int) D.24463;
      ins->data.op[0].const_val = D.24464;
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      if (D.24466 != 0B) goto <D.24467>; else goto <D.24468>;
      <D.24467>:
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      D.24466->next = ins;
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      ins->prev = D.24466;
      D.24465 = cfg->cbb;
      D.24465->last_ins = ins;
      goto <D.24469>;
      <D.24468>:
      D.24465 = cfg->cbb;
      D.24465 = cfg->cbb;
      D.24465->last_ins = ins;
      D.24466 = D.24465->last_ins;
      D.24465->code = D.24466;
      <D.24469>:
      goto <D.24470>;
      <D.24448>:
      D.24474 = size == 2;
      D.24475 = size == 4;
      D.24476 = D.24474 | D.24475;
      if (D.24476 != 0) goto <D.24471>; else goto <D.24477>;
      <D.24477>:
      if (size == 8) goto <D.24471>; else goto <D.24472>;
      <D.24471>:
      D.24449 = cfg->mempool;
      ins = mono_mempool_alloc (D.24449, 48);
      ins->data.op[1].const_val = 0;
      D.24450 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24450;
      ins->prev = 0B;
      D.24451 = ins->prev;
      ins->next = D.24451;
      D.24446 = sig->params[0];
      D.24478 = mono_type_to_slow_insert_op (D.24446);
      D.24479 = (short unsigned int) D.24478;
      ins->opcode = D.24479;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24454 = ins->sreg3;
      ins->sreg2 = D.24454;
      D.24455 = ins->sreg2;
      ins->sreg1 = D.24455;
      D.24456 = cfg->ip;
      ins->cil_code = D.24456;
      D.24457 = cmethod->klass;
      ins->klass = D.24457;
      D.24458 = *args;
      dreg = load_simd_vreg (cfg, cmethod, D.24458, &indirect);
      ins->sreg1 = dreg;
      D.24459 = ins->sreg1;
      ins->dreg = D.24459;
      D.24460 = args + 4;
      D.24461 = *D.24460;
      D.24462 = D.24461->dreg;
      ins->sreg2 = D.24462;
      D.24463 = intrinsic->opcode;
      D.24464 = (int) D.24463;
      ins->data.op[0].const_val = D.24464;
      D.24446 = sig->params[0];
      D.24480 = D.24446->type;
      if (D.24480 == 12) goto <D.24481>; else goto <D.24482>;
      <D.24481>:
      D.24483 = get_int_to_float_spill_area (cfg);
      ins->backend.spill_var = D.24483;
      goto <D.24484>;
      <D.24482>:
      D.24446 = sig->params[0];
      D.24480 = D.24446->type;
      if (D.24480 == 13) goto <D.24485>; else goto <D.24486>;
      <D.24485>:
      D.24487 = get_double_spill_area (cfg);
      ins->backend.spill_var = D.24487;
      <D.24486>:
      <D.24484>:
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      if (D.24466 != 0B) goto <D.24488>; else goto <D.24489>;
      <D.24488>:
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      D.24466->next = ins;
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      ins->prev = D.24466;
      D.24465 = cfg->cbb;
      D.24465->last_ins = ins;
      goto <D.24490>;
      <D.24489>:
      D.24465 = cfg->cbb;
      D.24465 = cfg->cbb;
      D.24465->last_ins = ins;
      D.24466 = D.24465->last_ins;
      D.24465->code = D.24466;
      <D.24490>:
      goto <D.24473>;
      <D.24472>:
      {
        int vreg;
        int sreg;

        D.24449 = cfg->mempool;
        ins = mono_mempool_alloc (D.24449, 48);
        ins->data.op[1].const_val = 0;
        D.24450 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24450;
        ins->prev = 0B;
        D.24451 = ins->prev;
        ins->next = D.24451;
        ins->opcode = 938;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24454 = ins->sreg3;
        ins->sreg2 = D.24454;
        D.24455 = ins->sreg2;
        ins->sreg1 = D.24455;
        D.24456 = cfg->ip;
        ins->cil_code = D.24456;
        D.24457 = cmethod->klass;
        ins->klass = D.24457;
        D.24458 = *args;
        dreg = load_simd_vreg (cfg, cmethod, D.24458, &indirect);
        sreg = dreg;
        ins->sreg1 = sreg;
        ins->type = 1;
        D.24491 = alloc_ireg (cfg);
        vreg = (int) D.24491;
        ins->dreg = vreg;
        D.24463 = intrinsic->opcode;
        D.24492 = D.24463 / 2;
        D.24493 = (int) D.24492;
        ins->data.op[0].const_val = D.24493;
        D.24465 = cfg->cbb;
        D.24466 = D.24465->last_ins;
        if (D.24466 != 0B) goto <D.24494>; else goto <D.24495>;
        <D.24494>:
        D.24465 = cfg->cbb;
        D.24466 = D.24465->last_ins;
        D.24466->next = ins;
        D.24465 = cfg->cbb;
        D.24466 = D.24465->last_ins;
        ins->prev = D.24466;
        D.24465 = cfg->cbb;
        D.24465->last_ins = ins;
        goto <D.24496>;
        <D.24495>:
        D.24465 = cfg->cbb;
        D.24465 = cfg->cbb;
        D.24465->last_ins = ins;
        D.24466 = D.24465->last_ins;
        D.24465->code = D.24466;
        <D.24496>:
        D.24449 = cfg->mempool;
        ins = mono_mempool_alloc (D.24449, 48);
        ins->data.op[1].const_val = 0;
        D.24450 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24450;
        ins->prev = 0B;
        D.24451 = ins->prev;
        ins->next = D.24451;
        ins->opcode = 939;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24454 = ins->sreg3;
        ins->sreg2 = D.24454;
        D.24455 = ins->sreg2;
        ins->sreg1 = D.24455;
        D.24456 = cfg->ip;
        ins->cil_code = D.24456;
        D.24457 = cmethod->klass;
        ins->klass = D.24457;
        ins->sreg1 = vreg;
        D.24460 = args + 4;
        D.24461 = *D.24460;
        D.24462 = D.24461->dreg;
        ins->sreg2 = D.24462;
        ins->dreg = sreg;
        D.24463 = intrinsic->opcode;
        D.24464 = (int) D.24463;
        ins->data.op[0].const_val = D.24464;
        D.24465 = cfg->cbb;
        D.24466 = D.24465->last_ins;
        if (D.24466 != 0B) goto <D.24497>; else goto <D.24498>;
        <D.24497>:
        D.24465 = cfg->cbb;
        D.24466 = D.24465->last_ins;
        D.24466->next = ins;
        D.24465 = cfg->cbb;
        D.24466 = D.24465->last_ins;
        ins->prev = D.24466;
        D.24465 = cfg->cbb;
        D.24465->last_ins = ins;
        goto <D.24499>;
        <D.24498>:
        D.24465 = cfg->cbb;
        D.24465 = cfg->cbb;
        D.24465->last_ins = ins;
        D.24466 = D.24465->last_ins;
        D.24465->code = D.24466;
        <D.24499>:
      }
      <D.24473>:
      <D.24470>:
      indirect.36 = indirect;
      if (indirect.36 != 0) goto <D.24501>; else goto <D.24502>;
      <D.24501>:
      D.24449 = cfg->mempool;
      ins = mono_mempool_alloc (D.24449, 48);
      ins->data.op[1].const_val = 0;
      D.24450 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24450;
      ins->prev = 0B;
      D.24451 = ins->prev;
      ins->next = D.24451;
      ins->opcode = 389;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24454 = ins->sreg3;
      ins->sreg2 = D.24454;
      D.24455 = ins->sreg2;
      ins->sreg1 = D.24455;
      D.24456 = cfg->ip;
      ins->cil_code = D.24456;
      D.24457 = cmethod->klass;
      ins->klass = D.24457;
      D.24458 = *args;
      D.24503 = D.24458->dreg;
      ins->dreg = D.24503;
      ins->sreg1 = dreg;
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      if (D.24466 != 0B) goto <D.24504>; else goto <D.24505>;
      <D.24504>:
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      D.24466->next = ins;
      D.24465 = cfg->cbb;
      D.24466 = D.24465->last_ins;
      ins->prev = D.24466;
      D.24465 = cfg->cbb;
      D.24465->last_ins = ins;
      goto <D.24506>;
      <D.24505>:
      D.24465 = cfg->cbb;
      D.24465 = cfg->cbb;
      D.24465->last_ins = ins;
      D.24466 = D.24465->last_ins;
      D.24465->code = D.24466;
      <D.24506>:
      <D.24502>:
      D.24507 = ins;
      return D.24507;
    }
  finally
    {
      align = {CLOBBER};
      indirect = {CLOBBER};
    }
}


mono_type_to_slow_insert_op (struct MonoType * type)
{
  unsigned char D.24510;
  int D.24511;
  int D.24512;

  D.24510 = type->type;
  D.24511 = (int) D.24510;
  switch (D.24511) <default: <D.22291>, case 4: <D.22281>, case 5: <D.22282>, case 6: <D.22283>, case 7: <D.22284>, case 8: <D.22285>, case 9: <D.22286>, case 10: <D.22287>, case 11: <D.22288>, case 12: <D.22289>, case 13: <D.22290>>
  <D.22281>:
  <D.22282>:
  D.24512 = 939;
  return D.24512;
  <D.22283>:
  <D.22284>:
  D.24512 = 937;
  return D.24512;
  <D.22285>:
  <D.22286>:
  D.24512 = 940;
  return D.24512;
  <D.22287>:
  <D.22288>:
  D.24512 = 943;
  return D.24512;
  <D.22289>:
  D.24512 = 941;
  return D.24512;
  <D.22290>:
  D.24512 = 942;
  return D.24512;
  <D.22291>:
  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.24516;
  int D.24519;
  void * D.24522;
  int D.24523;
  int D.24524;
  unsigned char D.24525;
  unsigned char D.24528;
  _Bool D.24529;
  _Bool D.24530;
  _Bool D.24531;
  struct MonoMemPool * D.24536;
  int D.24537;
  struct MonoInst * D.24538;
  int D.24539;
  int D.24540;
  const unsigned char * D.24541;
  struct MonoClass * D.24542;
  int D.24543;
  unsigned int D.24544;
  int D.24545;
  struct MonoBasicBlock * D.24546;
  struct MonoInst * D.24547;
  int D.24551;

  if (indirect != 0B) goto <D.24514>; else goto <D.24515>;
  <D.24514>:
  *indirect = 0;
  <D.24515>:
  D.24516 = src->opcode;
  if (D.24516 == 962) goto <D.24517>; else goto <D.24518>;
  <D.24517>:
  D.24519 = src->sreg1;
  return D.24519;
  <D.24518>:
  D.24516 = src->opcode;
  if (D.24516 == 314) goto <D.24520>; else goto <D.24521>;
  <D.24520>:
  {
    int res;

    D.24522 = src->data.op[0].p;
    res = MEM[(struct MonoInst *)D.24522].dreg;
    src->opcode = 316;
    src->dreg = -1;
    src->sreg3 = -1;
    D.24523 = src->sreg3;
    src->sreg2 = D.24523;
    D.24524 = src->sreg2;
    src->sreg1 = D.24524;
    D.24519 = res;
    return D.24519;
  }
  <D.24521>:
  D.24525 = src->type;
  if (D.24525 == 7) goto <D.24526>; else goto <D.24527>;
  <D.24526>:
  D.24519 = src->dreg;
  return D.24519;
  <D.24527>:
  D.24528 = src->type;
  D.24529 = D.24528 == 3;
  D.24530 = D.24528 == 5;
  D.24531 = D.24529 | D.24530;
  if (D.24531 != 0) goto <D.24532>; else goto <D.24533>;
  <D.24532>:
  {
    struct MonoInst * ins;

    if (indirect != 0B) goto <D.24534>; else goto <D.24535>;
    <D.24534>:
    *indirect = 1;
    <D.24535>:
    D.24536 = cfg->mempool;
    ins = mono_mempool_alloc (D.24536, 48);
    ins->data.op[1].const_val = 0;
    D.24537 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24537;
    ins->prev = 0B;
    D.24538 = ins->prev;
    ins->next = D.24538;
    ins->opcode = 401;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24539 = ins->sreg3;
    ins->sreg2 = D.24539;
    D.24540 = ins->sreg2;
    ins->sreg1 = D.24540;
    D.24541 = cfg->ip;
    ins->cil_code = D.24541;
    D.24542 = cmethod->klass;
    ins->klass = D.24542;
    D.24543 = src->dreg;
    ins->sreg1 = D.24543;
    ins->type = 7;
    D.24544 = alloc_ireg (cfg);
    D.24545 = (int) D.24544;
    ins->dreg = D.24545;
    D.24546 = cfg->cbb;
    D.24547 = D.24546->last_ins;
    if (D.24547 != 0B) goto <D.24548>; else goto <D.24549>;
    <D.24548>:
    D.24546 = cfg->cbb;
    D.24547 = D.24546->last_ins;
    D.24547->next = ins;
    D.24546 = cfg->cbb;
    D.24547 = D.24546->last_ins;
    ins->prev = D.24547;
    D.24546 = cfg->cbb;
    D.24546->last_ins = ins;
    goto <D.24550>;
    <D.24549>:
    D.24546 = cfg->cbb;
    D.24546 = cfg->cbb;
    D.24546->last_ins = ins;
    D.24547 = D.24546->last_ins;
    D.24546->code = D.24547;
    <D.24550>:
    D.24519 = ins->dreg;
    return D.24519;
  }
  <D.24533>:
  D.24525 = src->type;
  D.24551 = (int) D.24525;
  monoeg_g_log (0B, 16, "load_simd_vreg:: could not infer source simd (%d) vreg for op", D.24551);
  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.24553;
  struct MonoInst * D.24554;
  short unsigned int D.24555;
  int D.24556;
  int D.24557;
  unsigned char D.24560;
  unsigned char D.24561;
  struct MonoMemPool * D.24564;
  int D.24565;
  struct MonoInst * D.24566;
  int D.24567;
  int D.24568;
  const unsigned char * D.24569;
  struct MonoClass * D.24570;
  unsigned int D.24571;
  struct MonoBasicBlock * D.24572;
  struct MonoInst * D.24573;
  int D.24577;
  short unsigned int D.24578;
  unsigned int D.24579;
  int D.24582;
  int D.24584;
  int D.24585;
  int D.24586;
  unsigned char D.24590;
  struct MonoClass * D.24593;
  unsigned int D.24594;
  int D.24595;
  struct MonoInst * D.24596;
  struct MonoInst * D.24600;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int vreg;
  int shift_bits;

  sig = mono_method_signature (cmethod);
  D.24553 = sig->ret;
  shift_bits = mono_type_elements_shift_bits (D.24553);
  D.24554 = *args;
  vreg = load_simd_vreg (cfg, cmethod, D.24554, 0B);
  D.24555 = intrinsic->opcode;
  D.24556 = (int) D.24555;
  D.24557 = D.24556 >> shift_bits;
  if (D.24557 != 0) goto <D.24558>; else goto <D.24559>;
  <D.24558>:
  D.24560 = BIT_FIELD_REF <*cfg, 8, 3400>;
  D.24561 = D.24560 & 1;
  if (D.24561 == 0) goto <D.24562>; else goto <D.24563>;
  <D.24562>:
  D.24564 = cfg->mempool;
  ins = mono_mempool_alloc (D.24564, 48);
  ins->data.op[1].const_val = 0;
  D.24565 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24565;
  ins->prev = 0B;
  D.24566 = ins->prev;
  ins->next = D.24566;
  ins->opcode = 825;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24567 = ins->sreg3;
  ins->sreg2 = D.24567;
  D.24568 = ins->sreg2;
  ins->sreg1 = D.24568;
  D.24569 = cfg->ip;
  ins->cil_code = D.24569;
  D.24570 = cmethod->klass;
  ins->klass = D.24570;
  ins->sreg1 = vreg;
  D.24555 = intrinsic->opcode;
  D.24556 = (int) D.24555;
  D.24557 = D.24556 >> shift_bits;
  ins->data.op[0].const_val = D.24557;
  ins->type = 7;
  D.24571 = alloc_ireg (cfg);
  vreg = (int) D.24571;
  ins->dreg = vreg;
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  if (D.24573 != 0B) goto <D.24574>; else goto <D.24575>;
  <D.24574>:
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  D.24573->next = ins;
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  ins->prev = D.24573;
  D.24572 = cfg->cbb;
  D.24572->last_ins = ins;
  goto <D.24576>;
  <D.24575>:
  D.24572 = cfg->cbb;
  D.24572 = cfg->cbb;
  D.24572->last_ins = ins;
  D.24573 = D.24572->last_ins;
  D.24572->code = D.24573;
  <D.24576>:
  <D.24563>:
  <D.24559>:
  D.24564 = cfg->mempool;
  ins = mono_mempool_alloc (D.24564, 48);
  ins->data.op[1].const_val = 0;
  D.24565 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24565;
  ins->prev = 0B;
  D.24566 = ins->prev;
  ins->next = D.24566;
  D.24553 = sig->ret;
  D.24577 = mono_type_to_extract_op (D.24553);
  D.24578 = (short unsigned int) D.24577;
  ins->opcode = D.24578;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24567 = ins->sreg3;
  ins->sreg2 = D.24567;
  D.24568 = ins->sreg2;
  ins->sreg1 = D.24568;
  D.24569 = cfg->ip;
  ins->cil_code = D.24569;
  D.24570 = cmethod->klass;
  ins->klass = D.24570;
  ins->sreg1 = vreg;
  ins->type = 1;
  D.24579 = alloc_ireg (cfg);
  vreg = (int) D.24579;
  ins->dreg = vreg;
  D.24560 = BIT_FIELD_REF <*cfg, 8, 3400>;
  D.24561 = D.24560 & 1;
  if (D.24561 != 0) goto <D.24580>; else goto <D.24581>;
  <D.24580>:
  D.24555 = intrinsic->opcode;
  D.24582 = (int) D.24555;
  ins->data.op[0].const_val = D.24582;
  goto <D.24583>;
  <D.24581>:
  D.24555 = intrinsic->opcode;
  D.24556 = (int) D.24555;
  D.24584 = 1 << shift_bits;
  D.24585 = D.24584 + -1;
  D.24586 = D.24556 & D.24585;
  ins->data.op[0].const_val = D.24586;
  <D.24583>:
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  if (D.24573 != 0B) goto <D.24587>; else goto <D.24588>;
  <D.24587>:
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  D.24573->next = ins;
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  ins->prev = D.24573;
  D.24572 = cfg->cbb;
  D.24572->last_ins = ins;
  goto <D.24589>;
  <D.24588>:
  D.24572 = cfg->cbb;
  D.24572 = cfg->cbb;
  D.24572->last_ins = ins;
  D.24573 = D.24572->last_ins;
  D.24572->code = D.24573;
  <D.24589>:
  D.24553 = sig->ret;
  D.24590 = D.24553->type;
  if (D.24590 == 12) goto <D.24591>; else goto <D.24592>;
  <D.24591>:
  D.24564 = cfg->mempool;
  ins = mono_mempool_alloc (D.24564, 48);
  ins->data.op[1].const_val = 0;
  D.24565 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24565;
  ins->prev = 0B;
  D.24566 = ins->prev;
  ins->next = D.24566;
  ins->opcode = 925;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24567 = ins->sreg3;
  ins->sreg2 = D.24567;
  D.24568 = ins->sreg2;
  ins->sreg1 = D.24568;
  D.24569 = cfg->ip;
  ins->cil_code = D.24569;
  D.24593 = mono_defaults.single_class;
  ins->klass = D.24593;
  ins->sreg1 = vreg;
  ins->type = 4;
  D.24594 = alloc_freg (cfg);
  D.24595 = (int) D.24594;
  ins->dreg = D.24595;
  D.24596 = get_int_to_float_spill_area (cfg);
  ins->backend.spill_var = D.24596;
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  if (D.24573 != 0B) goto <D.24597>; else goto <D.24598>;
  <D.24597>:
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  D.24573->next = ins;
  D.24572 = cfg->cbb;
  D.24573 = D.24572->last_ins;
  ins->prev = D.24573;
  D.24572 = cfg->cbb;
  D.24572->last_ins = ins;
  goto <D.24599>;
  <D.24598>:
  D.24572 = cfg->cbb;
  D.24572 = cfg->cbb;
  D.24572->last_ins = ins;
  D.24573 = D.24572->last_ins;
  D.24572->code = D.24573;
  <D.24599>:
  <D.24592>:
  D.24600 = ins;
  return D.24600;
}


mono_type_elements_shift_bits (struct MonoType * type)
{
  unsigned char D.24602;
  int D.24603;
  int D.24604;

  D.24602 = type->type;
  D.24603 = (int) D.24602;
  switch (D.24603) <default: <D.22263>, case 4: <D.22256>, case 5: <D.22257>, case 6: <D.22258>, case 7: <D.22259>, case 8: <D.22260>, case 9: <D.22261>, case 12: <D.22262>>
  <D.22256>:
  <D.22257>:
  D.24604 = 2;
  return D.24604;
  <D.22258>:
  <D.22259>:
  D.24604 = 1;
  return D.24604;
  <D.22260>:
  <D.22261>:
  <D.22262>:
  D.24604 = 0;
  return D.24604;
  <D.22263>:
  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.24606;
  int D.24607;
  int D.24608;

  D.24606 = type->type;
  D.24607 = (int) D.24606;
  switch (D.24607) <default: <D.22252>, case 4: <D.22245>, case 5: <D.22246>, case 6: <D.22247>, case 7: <D.22248>, case 8: <D.22249>, case 9: <D.22250>, case 12: <D.22251>>
  <D.22245>:
  D.24608 = 928;
  return D.24608;
  <D.22246>:
  D.24608 = 929;
  return D.24608;
  <D.22247>:
  D.24608 = 926;
  return D.24608;
  <D.22248>:
  D.24608 = 927;
  return D.24608;
  <D.22249>:
  <D.22250>:
  <D.22251>:
  D.24608 = 924;
  return D.24608;
  <D.22252>:
  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.24610;
  struct MonoType * D.24611;
  unsigned char D.24612;
  _Bool D.24613;
  struct MonoInst * D.24614;
  struct MonoMemPool * D.24615;
  int D.24616;
  struct MonoInst * D.24617;
  guint16 iftmp.37;
  int D.24622;
  int D.24623;
  const unsigned char * D.24624;
  struct MonoClass * D.24625;
  short unsigned int D.24626;
  int D.24627;
  unsigned int D.24630;
  int D.24631;
  struct MonoInst * D.24632;
  unsigned int D.24634;
  int D.24635;
  struct MonoBasicBlock * D.24636;
  struct MonoInst * D.24637;
  struct MonoInst * D.24641;
  struct MonoInst * ins;
  int vreg;
  gboolean is_r8;

  D.24610 = mono_method_signature (cmethod);
  D.24611 = D.24610->ret;
  D.24612 = D.24611->type;
  D.24613 = D.24612 == 13;
  is_r8 = (gboolean) D.24613;
  D.24614 = *args;
  vreg = load_simd_vreg (cfg, cmethod, D.24614, 0B);
  D.24615 = cfg->mempool;
  ins = mono_mempool_alloc (D.24615, 48);
  ins->data.op[1].const_val = 0;
  D.24616 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24616;
  ins->prev = 0B;
  D.24617 = ins->prev;
  ins->next = D.24617;
  if (is_r8 != 0) goto <D.24619>; else goto <D.24620>;
  <D.24619>:
  iftmp.37 = 930;
  goto <D.24621>;
  <D.24620>:
  iftmp.37 = 931;
  <D.24621>:
  ins->opcode = iftmp.37;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24622 = ins->sreg3;
  ins->sreg2 = D.24622;
  D.24623 = ins->sreg2;
  ins->sreg1 = D.24623;
  D.24624 = cfg->ip;
  ins->cil_code = D.24624;
  D.24625 = cmethod->klass;
  ins->klass = D.24625;
  ins->sreg1 = vreg;
  D.24626 = intrinsic->opcode;
  D.24627 = (int) D.24626;
  ins->data.op[0].const_val = D.24627;
  if (is_r8 != 0) goto <D.24628>; else goto <D.24629>;
  <D.24628>:
  ins->type = 4;
  D.24630 = alloc_freg (cfg);
  D.24631 = (int) D.24630;
  ins->dreg = D.24631;
  D.24632 = get_double_spill_area (cfg);
  ins->backend.spill_var = D.24632;
  goto <D.24633>;
  <D.24629>:
  ins->type = 2;
  D.24634 = alloc_lreg (cfg);
  D.24635 = (int) D.24634;
  ins->dreg = D.24635;
  <D.24633>:
  D.24636 = cfg->cbb;
  D.24637 = D.24636->last_ins;
  if (D.24637 != 0B) goto <D.24638>; else goto <D.24639>;
  <D.24638>:
  D.24636 = cfg->cbb;
  D.24637 = D.24636->last_ins;
  D.24637->next = ins;
  D.24636 = cfg->cbb;
  D.24637 = D.24636->last_ins;
  ins->prev = D.24637;
  D.24636 = cfg->cbb;
  D.24636->last_ins = ins;
  goto <D.24640>;
  <D.24639>:
  D.24636 = cfg->cbb;
  D.24636 = cfg->cbb;
  D.24636->last_ins = ins;
  D.24637 = D.24636->last_ins;
  D.24636->code = D.24637;
  <D.24640>:
  D.24641 = ins;
  return D.24641;
}


simd_intrinsic_emit_ctor (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24643;
  short unsigned int D.24644;
  _Bool D.24645;
  struct MonoType * D.24646;
  unsigned int D.24647;
  short unsigned int D.24648;
  struct MonoInst * D.24653;
  int D.24654;
  int D.24655;
  unsigned char D.24657;
  _Bool D.24658;
  _Bool D.24659;
  _Bool D.24660;
  int D.24661;
  _Bool D.24662;
  long int D.24663;
  long int D.24664;
  unsigned int D.24667;
  struct MonoMemPool * D.24668;
  int D.24669;
  struct MonoInst * D.24670;
  short unsigned int D.24671;
  int D.24672;
  int D.24673;
  const unsigned char * D.24674;
  struct MonoClass * D.24675;
  struct MonoInst * * D.24676;
  struct MonoInst * D.24677;
  int D.24678;
  struct MonoBasicBlock * D.24679;
  struct MonoInst * D.24680;
  unsigned char D.24684;
  struct MonoInst * D.24687;
  struct MonoInst * D.24691;
  int D.24694;
  struct MonoInst * D.24698;
  struct MonoInst * D.24701;
  struct MonoInst * D.24702;
  unsigned char D.24703;
  unsigned char D.24704;
  struct MonoInst * D.24705;
  struct MonoClass * D.24706;
  unsigned int D.24707;
  int D.24708;
  int D.24709;
  _Bool D.24710;
  long int D.24711;
  long int D.24712;
  struct MonoInst * D.24715;
  struct MonoType * D.24716;
  int D.24717;
  _Bool iftmp.38;
  int D.24721;
  int iftmp.39;
  struct MonoInst * D.24728;
  unsigned char D.24729;
  struct MonoInst * D.24731;
  unsigned char D.24732;
  struct MonoInst * D.24734;
  unsigned char D.24735;
  struct MonoInst * iftmp.40;
  struct MonoInst * D.24739;
  int D.24740;
  int D.24741;
  unsigned int D.24742;
  unsigned int D.24743;
  struct MonoInst * * D.24746;
  struct MonoInst * D.24747;
  int D.24748;
  sizetype D.24749;
  sizetype D.24750;
  sizetype D.24751;
  struct MonoInst * * D.24752;
  struct MonoInst * iftmp.41;
  struct MonoInst * D.24755;
  int D.24756;
  int D.24757;
  unsigned int D.24758;
  struct MonoInst * D.24761;
  int D.24762;
  sizetype D.24763;
  sizetype D.24764;
  sizetype D.24765;
  struct MonoInst * * D.24766;
  _Bool D.24768;
  long int D.24769;
  long int D.24770;
  _Bool D.24773;
  long int D.24774;
  long int D.24775;
  unsigned char D.24778;
  unsigned char D.24779;
  unsigned char D.24780;
  unsigned char D.24781;
  unsigned char D.24786;
  _Bool D.24787;
  _Bool D.24788;
  _Bool D.24789;
  int D.24790;
  _Bool D.24791;
  long int D.24792;
  long int D.24793;
  int D.24796;
  int i.42;
  short unsigned int D.24798;
  int i.43;
  sizetype i.44;
  sizetype D.24801;
  sizetype D.24802;
  struct MonoInst * * D.24803;
  struct MonoInst * D.24804;
  int D.24805;
  int D.24806;
  int i.45;
  void * D.24813;
  struct MonoInst * ins;
  int i;
  int addr_reg;
  gboolean is_ldaddr;
  struct MonoMethodSignature * sig;
  int store_op;
  int arg_size;

  try
    {
      ins = 0B;
      D.24643 = *args;
      D.24644 = D.24643->opcode;
      D.24645 = D.24644 == 314;
      is_ldaddr = (gboolean) D.24645;
      sig = mono_method_signature (cmethod);
      D.24646 = sig->params[0];
      D.24647 = mono_type_to_store_membase (cfg, D.24646);
      store_op = (int) D.24647;
      D.24646 = sig->params[0];
      arg_size = mono_type_size (D.24646, &i);
      D.24648 = sig->param_count;
      if (D.24648 == 1) goto <D.24649>; else goto <D.24650>;
      <D.24649>:
      {
        int dreg;

        if (is_ldaddr != 0) goto <D.24651>; else goto <D.24652>;
        <D.24651>:
        D.24643 = *args;
        D.24653 = D.24643->data.op[0].src;
        dreg = D.24653->dreg;
        D.24643 = *args;
        D.24643->opcode = 316;
        D.24643 = *args;
        D.24643->dreg = -1;
        D.24643 = *args;
        D.24643 = *args;
        D.24643 = *args;
        D.24643->sreg3 = -1;
        D.24654 = D.24643->sreg3;
        D.24643->sreg2 = D.24654;
        D.24655 = D.24643->sreg2;
        D.24643->sreg1 = D.24655;
        goto <D.24656>;
        <D.24652>:
        D.24643 = *args;
        D.24657 = D.24643->type;
        D.24658 = D.24657 != 5;
        D.24659 = D.24657 != 3;
        D.24660 = D.24658 & D.24659;
        D.24661 = (int) D.24660;
        D.24662 = D.24661 != 0;
        D.24663 = (long int) D.24662;
        D.24664 = __builtin_expect (D.24663, 0);
        if (D.24664 != 0) goto <D.24665>; else goto <D.24666>;
        <D.24665>:
        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.24666>:
        D.24667 = alloc_ireg (cfg);
        dreg = (int) D.24667;
        <D.24656>:
        D.24668 = cfg->mempool;
        ins = mono_mempool_alloc (D.24668, 48);
        ins->data.op[1].const_val = 0;
        D.24669 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24669;
        ins->prev = 0B;
        D.24670 = ins->prev;
        ins->next = D.24670;
        D.24671 = intrinsic->opcode;
        ins->opcode = D.24671;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24672 = ins->sreg3;
        ins->sreg2 = D.24672;
        D.24673 = ins->sreg2;
        ins->sreg1 = D.24673;
        D.24674 = cfg->ip;
        ins->cil_code = D.24674;
        D.24675 = cmethod->klass;
        ins->klass = D.24675;
        D.24676 = args + 4;
        D.24677 = *D.24676;
        D.24678 = D.24677->dreg;
        ins->sreg1 = D.24678;
        ins->type = 7;
        ins->dreg = dreg;
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        if (D.24680 != 0B) goto <D.24681>; else goto <D.24682>;
        <D.24681>:
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        D.24680->next = ins;
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        ins->prev = D.24680;
        D.24679 = cfg->cbb;
        D.24679->last_ins = ins;
        goto <D.24683>;
        <D.24682>:
        D.24679 = cfg->cbb;
        D.24679 = cfg->cbb;
        D.24679->last_ins = ins;
        D.24680 = D.24679->last_ins;
        D.24679->code = D.24680;
        <D.24683>:
        D.24646 = sig->params[0];
        D.24684 = D.24646->type;
        if (D.24684 == 12) goto <D.24685>; else goto <D.24686>;
        <D.24685>:
        D.24687 = get_int_to_float_spill_area (cfg);
        ins->backend.spill_var = D.24687;
        goto <D.24688>;
        <D.24686>:
        D.24646 = sig->params[0];
        D.24684 = D.24646->type;
        if (D.24684 == 13) goto <D.24689>; else goto <D.24690>;
        <D.24689>:
        D.24691 = get_double_spill_area (cfg);
        ins->backend.spill_var = D.24691;
        <D.24690>:
        <D.24688>:
        if (is_ldaddr == 0) goto <D.24692>; else goto <D.24693>;
        <D.24692>:
        D.24668 = cfg->mempool;
        ins = mono_mempool_alloc (D.24668, 48);
        ins->data.op[1].const_val = 0;
        D.24669 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24669;
        ins->prev = 0B;
        D.24670 = ins->prev;
        ins->next = D.24670;
        ins->opcode = 389;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24672 = ins->sreg3;
        ins->sreg2 = D.24672;
        D.24673 = ins->sreg2;
        ins->sreg1 = D.24673;
        D.24674 = cfg->ip;
        ins->cil_code = D.24674;
        D.24643 = *args;
        D.24694 = D.24643->dreg;
        ins->dreg = D.24694;
        ins->sreg1 = dreg;
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        if (D.24680 != 0B) goto <D.24695>; else goto <D.24696>;
        <D.24695>:
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        D.24680->next = ins;
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        ins->prev = D.24680;
        D.24679 = cfg->cbb;
        D.24679->last_ins = ins;
        goto <D.24697>;
        <D.24696>:
        D.24679 = cfg->cbb;
        D.24679 = cfg->cbb;
        D.24679->last_ins = ins;
        D.24680 = D.24679->last_ins;
        D.24679->code = D.24680;
        <D.24697>:
        <D.24693>:
        D.24698 = ins;
        return D.24698;
      }
      <D.24650>:
      if (is_ldaddr != 0) goto <D.24699>; else goto <D.24700>;
      <D.24699>:
      D.24668 = cfg->mempool;
      ins = mono_mempool_alloc (D.24668, 48);
      ins->data.op[1].const_val = 0;
      D.24669 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24669;
      ins->prev = 0B;
      D.24670 = ins->prev;
      ins->next = D.24670;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24672 = ins->sreg3;
      ins->sreg2 = D.24672;
      D.24673 = ins->sreg2;
      ins->sreg1 = D.24673;
      D.24674 = cfg->ip;
      ins->cil_code = D.24674;
      D.24675 = cmethod->klass;
      D.24701 = get_simd_ctor_spill_area (cfg, D.24675);
      ins->data.op[0].p = D.24701;
      D.24675 = cmethod->klass;
      D.24702 = get_simd_ctor_spill_area (cfg, D.24675);
      D.24703 = D.24702->flags;
      D.24704 = D.24703 | 16;
      D.24702->flags = D.24704;
      ins->type = 5;
      D.24675 = cmethod->klass;
      D.24705 = get_simd_ctor_spill_area (cfg, D.24675);
      D.24706 = D.24705->klass;
      ins->klass = D.24706;
      D.24707 = alloc_dreg (cfg, 5);
      D.24708 = (int) D.24707;
      ins->dreg = D.24708;
      cfg->has_indirection = 1;
      D.24709 = cfg->gsharedvt;
      D.24710 = D.24709 != 0;
      D.24711 = (long int) D.24710;
      D.24712 = __builtin_expect (D.24711, 0);
      if (D.24712 != 0) goto <D.24713>; else goto <D.24714>;
      <D.24713>:
      D.24675 = cmethod->klass;
      D.24715 = get_simd_ctor_spill_area (cfg, D.24675);
      D.24716 = D.24715->data.op[1].vtype;
      D.24717 = mini_is_gsharedvt_variable_type (cfg, D.24716);
      if (D.24717 != 0) goto <D.24718>; else goto <D.24719>;
      <D.24718>:
      handle_gsharedvt_ldaddr (cfg);
      <D.24719>:
      <D.24714>:
      D.24721 = mono_arch_is_soft_float ();
      if (D.24721 != 0) goto <D.24722>; else goto <D.24723>;
      <D.24722>:
      D.24675 = cmethod->klass;
      D.24728 = get_simd_ctor_spill_area (cfg, D.24675);
      D.24729 = D.24728->type;
      if (D.24729 == 2) goto <D.24725>; else goto <D.24730>;
      <D.24730>:
      D.24675 = cmethod->klass;
      D.24731 = get_simd_ctor_spill_area (cfg, D.24675);
      D.24732 = D.24731->type;
      if (D.24732 == 4) goto <D.24725>; else goto <D.24726>;
      <D.24725>:
      iftmp.39 = 1;
      goto <D.24727>;
      <D.24726>:
      iftmp.39 = 0;
      <D.24727>:
      iftmp.38 = (_Bool) iftmp.39;
      goto <D.24733>;
      <D.24723>:
      D.24675 = cmethod->klass;
      D.24734 = get_simd_ctor_spill_area (cfg, D.24675);
      D.24735 = D.24734->type;
      iftmp.38 = D.24735 == 2;
      <D.24733>:
      if (iftmp.38 != 0) goto <D.24736>; else goto <D.24737>;
      <D.24736>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.24675 = cmethod->klass;
        D.24739 = get_simd_ctor_spill_area (cfg, D.24675);
        D.24740 = D.24739->dreg;
        D.24741 = D.24740 + 1;
        D.24742 = (unsigned int) D.24741;
        D.24743 = cfg->vreg_to_inst_len;
        if (D.24742 < D.24743) goto <D.24744>; else goto <D.24745>;
        <D.24744>:
        D.24746 = cfg->vreg_to_inst;
        D.24675 = cmethod->klass;
        D.24747 = get_simd_ctor_spill_area (cfg, D.24675);
        D.24748 = D.24747->dreg;
        D.24749 = (sizetype) D.24748;
        D.24750 = D.24749 + 1;
        D.24751 = D.24750 * 4;
        D.24752 = D.24746 + D.24751;
        iftmp.40 = *D.24752;
        goto <D.24753>;
        <D.24745>:
        iftmp.40 = 0B;
        <D.24753>:
        var1 = iftmp.40;
        D.24675 = cmethod->klass;
        D.24755 = get_simd_ctor_spill_area (cfg, D.24675);
        D.24756 = D.24755->dreg;
        D.24757 = D.24756 + 2;
        D.24758 = (unsigned int) D.24757;
        D.24743 = cfg->vreg_to_inst_len;
        if (D.24758 < D.24743) goto <D.24759>; else goto <D.24760>;
        <D.24759>:
        D.24746 = cfg->vreg_to_inst;
        D.24675 = cmethod->klass;
        D.24761 = get_simd_ctor_spill_area (cfg, D.24675);
        D.24762 = D.24761->dreg;
        D.24763 = (sizetype) D.24762;
        D.24764 = D.24763 + 2;
        D.24765 = D.24764 * 4;
        D.24766 = D.24746 + D.24765;
        iftmp.41 = *D.24766;
        goto <D.24767>;
        <D.24760>:
        iftmp.41 = 0B;
        <D.24767>:
        var2 = iftmp.41;
        D.24768 = var1 == 0B;
        D.24769 = (long int) D.24768;
        D.24770 = __builtin_expect (D.24769, 0);
        if (D.24770 != 0) goto <D.24771>; else goto <D.24772>;
        <D.24771>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 1235, "var1");
        <D.24772>:
        D.24773 = var2 == 0B;
        D.24774 = (long int) D.24773;
        D.24775 = __builtin_expect (D.24774, 0);
        if (D.24775 != 0) goto <D.24776>; else goto <D.24777>;
        <D.24776>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "simd-intrinsics.c", 1235, "var2");
        <D.24777>:
        D.24778 = var1->flags;
        D.24779 = D.24778 | 16;
        var1->flags = D.24779;
        D.24780 = var2->flags;
        D.24781 = D.24780 | 16;
        var2->flags = D.24781;
      }
      <D.24737>:
      D.24679 = cfg->cbb;
      D.24680 = D.24679->last_ins;
      if (D.24680 != 0B) goto <D.24782>; else goto <D.24783>;
      <D.24782>:
      D.24679 = cfg->cbb;
      D.24680 = D.24679->last_ins;
      D.24680->next = ins;
      D.24679 = cfg->cbb;
      D.24680 = D.24679->last_ins;
      ins->prev = D.24680;
      D.24679 = cfg->cbb;
      D.24679->last_ins = ins;
      goto <D.24784>;
      <D.24783>:
      D.24679 = cfg->cbb;
      D.24679 = cfg->cbb;
      D.24679->last_ins = ins;
      D.24680 = D.24679->last_ins;
      D.24679->code = D.24680;
      <D.24784>:
      addr_reg = ins->dreg;
      goto <D.24785>;
      <D.24700>:
      D.24643 = *args;
      D.24786 = D.24643->type;
      D.24787 = D.24786 != 5;
      D.24788 = D.24786 != 3;
      D.24789 = D.24787 & D.24788;
      D.24790 = (int) D.24789;
      D.24791 = D.24790 != 0;
      D.24792 = (long int) D.24791;
      D.24793 = __builtin_expect (D.24792, 0);
      if (D.24793 != 0) goto <D.24794>; else goto <D.24795>;
      <D.24794>:
      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.24795>:
      D.24643 = *args;
      addr_reg = D.24643->dreg;
      <D.24785>:
      D.24648 = sig->param_count;
      D.24796 = (int) D.24648;
      i.42 = D.24796 + -1;
      i = i.42;
      goto <D.22342>;
      <D.22341>:
      D.24668 = cfg->mempool;
      ins = mono_mempool_alloc (D.24668, 48);
      ins->data.op[1].const_val = 0;
      D.24669 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24669;
      ins->prev = 0B;
      D.24670 = ins->prev;
      ins->next = D.24670;
      D.24798 = (short unsigned int) store_op;
      ins->opcode = D.24798;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24672 = ins->sreg3;
      ins->sreg2 = D.24672;
      D.24673 = ins->sreg2;
      ins->sreg1 = D.24673;
      D.24674 = cfg->ip;
      ins->cil_code = D.24674;
      i.43 = i;
      i.44 = (sizetype) i.43;
      D.24801 = i.44 + 1;
      D.24802 = D.24801 * 4;
      D.24803 = args + D.24802;
      D.24804 = *D.24803;
      D.24805 = D.24804->dreg;
      ins->sreg1 = D.24805;
      ins->dreg = addr_reg;
      i.43 = i;
      D.24806 = i.43 * arg_size;
      ins->data.op[0].const_val = D.24806;
      D.24679 = cfg->cbb;
      D.24680 = D.24679->last_ins;
      if (D.24680 != 0B) goto <D.24807>; else goto <D.24808>;
      <D.24807>:
      D.24679 = cfg->cbb;
      D.24680 = D.24679->last_ins;
      D.24680->next = ins;
      D.24679 = cfg->cbb;
      D.24680 = D.24679->last_ins;
      ins->prev = D.24680;
      D.24679 = cfg->cbb;
      D.24679->last_ins = ins;
      goto <D.24809>;
      <D.24808>:
      D.24679 = cfg->cbb;
      D.24679 = cfg->cbb;
      D.24679->last_ins = ins;
      D.24680 = D.24679->last_ins;
      D.24679->code = D.24680;
      <D.24809>:
      i.43 = i;
      i.45 = i.43 + -1;
      i = i.45;
      <D.22342>:
      i.43 = i;
      if (i.43 >= 0) goto <D.22341>; else goto <D.22343>;
      <D.22343>:
      if (is_ldaddr != 0) goto <D.24811>; else goto <D.24812>;
      <D.24811>:
      {
        int vreg;

        D.24643 = *args;
        D.24813 = D.24643->data.op[0].p;
        vreg = MEM[(struct MonoInst *)D.24813].dreg;
        D.24643 = *args;
        D.24643->opcode = 316;
        D.24643 = *args;
        D.24643->dreg = -1;
        D.24643 = *args;
        D.24643 = *args;
        D.24643 = *args;
        D.24643->sreg3 = -1;
        D.24654 = D.24643->sreg3;
        D.24643->sreg2 = D.24654;
        D.24655 = D.24643->sreg2;
        D.24643->sreg1 = D.24655;
        D.24668 = cfg->mempool;
        ins = mono_mempool_alloc (D.24668, 48);
        ins->data.op[1].const_val = 0;
        D.24669 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.24669;
        ins->prev = 0B;
        D.24670 = ins->prev;
        ins->next = D.24670;
        ins->opcode = 401;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24672 = ins->sreg3;
        ins->sreg2 = D.24672;
        D.24673 = ins->sreg2;
        ins->sreg1 = D.24673;
        D.24674 = cfg->ip;
        ins->cil_code = D.24674;
        D.24675 = cmethod->klass;
        ins->klass = D.24675;
        ins->sreg1 = addr_reg;
        ins->type = 7;
        ins->dreg = vreg;
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        if (D.24680 != 0B) goto <D.24814>; else goto <D.24815>;
        <D.24814>:
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        D.24680->next = ins;
        D.24679 = cfg->cbb;
        D.24680 = D.24679->last_ins;
        ins->prev = D.24680;
        D.24679 = cfg->cbb;
        D.24679->last_ins = ins;
        goto <D.24816>;
        <D.24815>:
        D.24679 = cfg->cbb;
        D.24679 = cfg->cbb;
        D.24679->last_ins = ins;
        D.24680 = D.24679->last_ins;
        D.24679->code = D.24680;
        <D.24816>:
      }
      <D.24812>:
      D.24698 = ins;
      return D.24698;
    }
  finally
    {
      i = {CLOBBER};
    }
}


handle_gsharedvt_ldaddr (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.24819;
  int D.24820;
  struct MonoInst * D.24821;
  int D.24822;
  int D.24823;
  const unsigned char * D.24824;
  struct MonoInst * D.24825;
  int D.24826;
  struct MonoBasicBlock * D.24827;
  struct MonoInst * D.24828;
  struct MonoInst * D.24832;
  int D.24833;
  struct MonoInst * use;

  D.24819 = cfg->mempool;
  use = mono_mempool_alloc (D.24819, 48);
  use->data.op[1].const_val = 0;
  D.24820 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.24820;
  use->prev = 0B;
  D.24821 = use->prev;
  use->next = D.24821;
  use->opcode = 800;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.24822 = use->sreg3;
  use->sreg2 = D.24822;
  D.24823 = use->sreg2;
  use->sreg1 = D.24823;
  D.24824 = cfg->ip;
  use->cil_code = D.24824;
  D.24825 = cfg->gsharedvt_info_var;
  D.24826 = D.24825->dreg;
  use->sreg1 = D.24826;
  D.24827 = cfg->cbb;
  D.24828 = D.24827->last_ins;
  if (D.24828 != 0B) goto <D.24829>; else goto <D.24830>;
  <D.24829>:
  D.24827 = cfg->cbb;
  D.24828 = D.24827->last_ins;
  D.24828->next = use;
  D.24827 = cfg->cbb;
  D.24828 = D.24827->last_ins;
  use->prev = D.24828;
  D.24827 = cfg->cbb;
  D.24827->last_ins = use;
  goto <D.24831>;
  <D.24830>:
  D.24827 = cfg->cbb;
  D.24827 = cfg->cbb;
  D.24827->last_ins = use;
  D.24828 = D.24827->last_ins;
  D.24827->code = D.24828;
  <D.24831>:
  D.24819 = cfg->mempool;
  use = mono_mempool_alloc (D.24819, 48);
  use->data.op[1].const_val = 0;
  D.24820 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.24820;
  use->prev = 0B;
  D.24821 = use->prev;
  use->next = D.24821;
  use->opcode = 800;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.24822 = use->sreg3;
  use->sreg2 = D.24822;
  D.24823 = use->sreg2;
  use->sreg1 = D.24823;
  D.24824 = cfg->ip;
  use->cil_code = D.24824;
  D.24832 = cfg->gsharedvt_locals_var;
  D.24833 = D.24832->dreg;
  use->sreg1 = D.24833;
  D.24827 = cfg->cbb;
  D.24828 = D.24827->last_ins;
  if (D.24828 != 0B) goto <D.24834>; else goto <D.24835>;
  <D.24834>:
  D.24827 = cfg->cbb;
  D.24828 = D.24827->last_ins;
  D.24828->next = use;
  D.24827 = cfg->cbb;
  D.24828 = D.24827->last_ins;
  use->prev = D.24828;
  D.24827 = cfg->cbb;
  D.24827->last_ins = use;
  goto <D.24836>;
  <D.24835>:
  D.24827 = cfg->cbb;
  D.24827 = cfg->cbb;
  D.24827->last_ins = use;
  D.24828 = D.24827->last_ins;
  D.24827->code = D.24828;
  <D.24836>:
}


get_simd_ctor_spill_area (struct MonoCompile * cfg, struct MonoClass * avector_klass)
{
  struct MonoInst * D.24837;
  struct MonoType * D.24840;
  struct MonoInst * D.24841;
  unsigned char D.24842;
  unsigned char D.24843;
  struct MonoInst * D.24844;

  D.24837 = cfg->simd_ctor_var;
  if (D.24837 == 0B) goto <D.24838>; else goto <D.24839>;
  <D.24838>:
  D.24840 = &avector_klass->byval_arg;
  D.24841 = mono_compile_create_var (cfg, D.24840, 329);
  cfg->simd_ctor_var = D.24841;
  D.24837 = cfg->simd_ctor_var;
  D.24837 = cfg->simd_ctor_var;
  D.24842 = D.24837->flags;
  D.24843 = D.24842 | 4;
  D.24837->flags = D.24843;
  <D.24839>:
  D.24844 = cfg->simd_ctor_var;
  return D.24844;
}


simd_intrinsic_emit_cast (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24846;
  struct MonoMemPool * D.24847;
  int D.24848;
  struct MonoInst * D.24849;
  int D.24850;
  int D.24851;
  const unsigned char * D.24852;
  struct MonoClass * D.24853;
  unsigned int D.24854;
  int D.24855;
  struct MonoBasicBlock * D.24856;
  struct MonoInst * D.24857;
  struct MonoInst * D.24861;
  struct MonoInst * ins;
  int vreg;

  D.24846 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.24846);
  D.24847 = cfg->mempool;
  ins = mono_mempool_alloc (D.24847, 48);
  ins->data.op[1].const_val = 0;
  D.24848 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24848;
  ins->prev = 0B;
  D.24849 = ins->prev;
  ins->next = D.24849;
  ins->opcode = 962;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24850 = ins->sreg3;
  ins->sreg2 = D.24850;
  D.24851 = ins->sreg2;
  ins->sreg1 = D.24851;
  D.24852 = cfg->ip;
  ins->cil_code = D.24852;
  D.24853 = cmethod->klass;
  ins->klass = D.24853;
  ins->type = 7;
  ins->sreg1 = vreg;
  D.24854 = alloc_ireg (cfg);
  D.24855 = (int) D.24854;
  ins->dreg = D.24855;
  D.24856 = cfg->cbb;
  D.24857 = D.24856->last_ins;
  if (D.24857 != 0B) goto <D.24858>; else goto <D.24859>;
  <D.24858>:
  D.24856 = cfg->cbb;
  D.24857 = D.24856->last_ins;
  D.24857->next = ins;
  D.24856 = cfg->cbb;
  D.24857 = D.24856->last_ins;
  ins->prev = D.24857;
  D.24856 = cfg->cbb;
  D.24856->last_ins = ins;
  goto <D.24860>;
  <D.24859>:
  D.24856 = cfg->cbb;
  D.24856 = cfg->cbb;
  D.24856->last_ins = ins;
  D.24857 = D.24856->last_ins;
  D.24856->code = D.24857;
  <D.24860>:
  D.24861 = ins;
  return D.24861;
}


simd_intrinsic_emit_shuffle (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMethodSignature * D.24863;
  short unsigned int D.24864;
  sizetype param_count.46;
  sizetype D.24866;
  sizetype D.24867;
  struct MonoInst * * D.24868;
  struct MonoInst * D.24869;
  short unsigned int D.24870;
  struct MonoInst * D.24873;
  struct MonoInst * D.24874;
  struct MonoInst * * D.24877;
  struct MonoInst * D.24878;
  int D.24879;
  int D.24880;
  struct MonoMemPool * D.24881;
  int D.24882;
  struct MonoInst * D.24883;
  short unsigned int D.24884;
  int D.24885;
  int D.24886;
  const unsigned char * D.24887;
  struct MonoClass * D.24888;
  int D.24889;
  unsigned int D.24890;
  int D.24891;
  struct MonoBasicBlock * D.24892;
  struct MonoInst * D.24893;
  short unsigned int D.24899;
  struct MonoInst * ins;
  int vreg;
  int vreg2;
  int param_count;

  vreg2 = -1;
  D.24863 = mono_method_signature (cmethod);
  D.24864 = D.24863->param_count;
  param_count = (int) D.24864;
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  D.24870 = D.24869->opcode;
  if (D.24870 != 362) goto <D.24871>; else goto <D.24872>;
  <D.24871>:
  D.24873 = 0B;
  return D.24873;
  <D.24872>:
  D.24874 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.24874);
  if (param_count == 3) goto <D.24875>; else goto <D.24876>;
  <D.24875>:
  D.24877 = args + 4;
  D.24878 = *D.24877;
  vreg2 = get_simd_vreg (cfg, cmethod, D.24878);
  <D.24876>:
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  D.24869->opcode = 316;
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  D.24869->dreg = -1;
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  D.24869->sreg3 = -1;
  D.24879 = D.24869->sreg3;
  D.24869->sreg2 = D.24879;
  D.24880 = D.24869->sreg2;
  D.24869->sreg1 = D.24880;
  D.24881 = cfg->mempool;
  ins = mono_mempool_alloc (D.24881, 48);
  ins->data.op[1].const_val = 0;
  D.24882 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24882;
  ins->prev = 0B;
  D.24883 = ins->prev;
  ins->next = D.24883;
  D.24884 = intrinsic->opcode;
  ins->opcode = D.24884;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24885 = ins->sreg3;
  ins->sreg2 = D.24885;
  D.24886 = ins->sreg2;
  ins->sreg1 = D.24886;
  D.24887 = cfg->ip;
  ins->cil_code = D.24887;
  D.24888 = cmethod->klass;
  ins->klass = D.24888;
  ins->sreg1 = vreg;
  ins->sreg2 = vreg2;
  param_count.46 = (sizetype) param_count;
  D.24866 = param_count.46 + 1073741823;
  D.24867 = D.24866 * 4;
  D.24868 = args + D.24867;
  D.24869 = *D.24868;
  D.24889 = D.24869->data.op[0].const_val;
  ins->data.op[0].const_val = D.24889;
  ins->type = 7;
  D.24890 = alloc_ireg (cfg);
  D.24891 = (int) D.24890;
  ins->dreg = D.24891;
  D.24892 = cfg->cbb;
  D.24893 = D.24892->last_ins;
  if (D.24893 != 0B) goto <D.24894>; else goto <D.24895>;
  <D.24894>:
  D.24892 = cfg->cbb;
  D.24893 = D.24892->last_ins;
  D.24893->next = ins;
  D.24892 = cfg->cbb;
  D.24893 = D.24892->last_ins;
  ins->prev = D.24893;
  D.24892 = cfg->cbb;
  D.24892->last_ins = ins;
  goto <D.24896>;
  <D.24895>:
  D.24892 = cfg->cbb;
  D.24892 = cfg->cbb;
  D.24892->last_ins = ins;
  D.24893 = D.24892->last_ins;
  D.24892->code = D.24893;
  <D.24896>:
  if (param_count == 3) goto <D.24897>; else goto <D.24898>;
  <D.24897>:
  D.24899 = ins->opcode;
  if (D.24899 == 825) goto <D.24900>; else goto <D.24901>;
  <D.24900>:
  ins->opcode = 826;
  <D.24901>:
  <D.24898>:
  D.24873 = ins;
  return D.24873;
}


simd_intrinsic_emit_shift (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  short unsigned int D.24903;
  struct MonoInst * D.24904;
  struct MonoInst * * D.24905;
  struct MonoInst * D.24906;
  short unsigned int D.24907;
  struct MonoMemPool * D.24910;
  int D.24911;
  struct MonoInst * D.24912;
  int D.24913;
  int D.24914;
  const unsigned char * D.24915;
  struct MonoClass * D.24916;
  int D.24917;
  unsigned int D.24918;
  struct MonoBasicBlock * D.24919;
  struct MonoInst * D.24920;
  short unsigned int D.24924;
  struct MonoClass * D.24925;
  int D.24928;
  int D.24929;
  int D.24930;
  unsigned int D.24931;
  int D.24932;
  struct MonoInst * D.24936;
  struct MonoInst * ins;
  int vreg;
  int vreg2;
  int opcode;

  vreg2 = -1;
  D.24903 = intrinsic->opcode;
  opcode = (int) D.24903;
  D.24904 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.24904);
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24907 = D.24906->opcode;
  if (D.24907 != 362) goto <D.24908>; else goto <D.24909>;
  <D.24908>:
  D.24910 = cfg->mempool;
  ins = mono_mempool_alloc (D.24910, 48);
  ins->data.op[1].const_val = 0;
  D.24911 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24911;
  ins->prev = 0B;
  D.24912 = ins->prev;
  ins->next = D.24912;
  ins->opcode = 946;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24913 = ins->sreg3;
  ins->sreg2 = D.24913;
  D.24914 = ins->sreg2;
  ins->sreg1 = D.24914;
  D.24915 = cfg->ip;
  ins->cil_code = D.24915;
  D.24916 = mono_defaults.int32_class;
  ins->klass = D.24916;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24917 = D.24906->dreg;
  ins->sreg1 = D.24917;
  ins->type = 1;
  D.24918 = alloc_ireg (cfg);
  vreg2 = (int) D.24918;
  ins->dreg = vreg2;
  D.24919 = cfg->cbb;
  D.24920 = D.24919->last_ins;
  if (D.24920 != 0B) goto <D.24921>; else goto <D.24922>;
  <D.24921>:
  D.24919 = cfg->cbb;
  D.24920 = D.24919->last_ins;
  D.24920->next = ins;
  D.24919 = cfg->cbb;
  D.24920 = D.24919->last_ins;
  ins->prev = D.24920;
  D.24919 = cfg->cbb;
  D.24919->last_ins = ins;
  goto <D.24923>;
  <D.24922>:
  D.24919 = cfg->cbb;
  D.24919 = cfg->cbb;
  D.24919->last_ins = ins;
  D.24920 = D.24919->last_ins;
  D.24919->code = D.24920;
  <D.24923>:
  opcode = opcode + 1;
  <D.24909>:
  D.24910 = cfg->mempool;
  ins = mono_mempool_alloc (D.24910, 48);
  ins->data.op[1].const_val = 0;
  D.24911 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24911;
  ins->prev = 0B;
  D.24912 = ins->prev;
  ins->next = D.24912;
  D.24924 = (short unsigned int) opcode;
  ins->opcode = D.24924;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24913 = ins->sreg3;
  ins->sreg2 = D.24913;
  D.24914 = ins->sreg2;
  ins->sreg1 = D.24914;
  D.24915 = cfg->ip;
  ins->cil_code = D.24915;
  D.24925 = cmethod->klass;
  ins->klass = D.24925;
  ins->sreg1 = vreg;
  ins->sreg2 = vreg2;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24907 = D.24906->opcode;
  if (D.24907 == 362) goto <D.24926>; else goto <D.24927>;
  <D.24926>:
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24928 = D.24906->data.op[0].const_val;
  ins->data.op[1].const_val = D.24928;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24906->opcode = 316;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24906->dreg = -1;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24905 = args + 4;
  D.24906 = *D.24905;
  D.24906->sreg3 = -1;
  D.24929 = D.24906->sreg3;
  D.24906->sreg2 = D.24929;
  D.24930 = D.24906->sreg2;
  D.24906->sreg1 = D.24930;
  <D.24927>:
  ins->type = 7;
  D.24931 = alloc_ireg (cfg);
  D.24932 = (int) D.24931;
  ins->dreg = D.24932;
  D.24919 = cfg->cbb;
  D.24920 = D.24919->last_ins;
  if (D.24920 != 0B) goto <D.24933>; else goto <D.24934>;
  <D.24933>:
  D.24919 = cfg->cbb;
  D.24920 = D.24919->last_ins;
  D.24920->next = ins;
  D.24919 = cfg->cbb;
  D.24920 = D.24919->last_ins;
  ins->prev = D.24920;
  D.24919 = cfg->cbb;
  D.24919->last_ins = ins;
  goto <D.24935>;
  <D.24934>:
  D.24919 = cfg->cbb;
  D.24919 = cfg->cbb;
  D.24919->last_ins = ins;
  D.24920 = D.24919->last_ins;
  D.24919->code = D.24920;
  <D.24935>:
  D.24936 = ins;
  return D.24936;
}


simd_intrinsic_emit_equality (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.24938;
  struct MonoInst * * D.24939;
  struct MonoInst * D.24940;
  struct MonoMemPool * D.24941;
  int D.24942;
  struct MonoInst * D.24943;
  short unsigned int D.24944;
  int D.24945;
  int D.24946;
  const unsigned char * D.24947;
  struct MonoClass * D.24948;
  unsigned int D.24949;
  <unnamed-unsigned:4> D.24950;
  int D.24951;
  struct MonoBasicBlock * D.24952;
  struct MonoInst * D.24953;
  unsigned int D.24957;
  int D.24964;
  int D.24965;
  unsigned char D.24967;
  unsigned char D.24968;
  int D.24969;
  struct MonoInst * D.24970;
  int D.24971;
  int D.24972;
  guint16 iftmp.47;
  int D.24980;
  struct MonoInst * D.24981;
  int D.24982;
  int D.24983;
  struct MonoInst * D.24990;
  struct MonoInst * ins;
  int left_vreg;
  int right_vreg;
  int tmp_vreg;

  D.24938 = *args;
  left_vreg = get_simd_vreg (cfg, cmethod, D.24938);
  D.24939 = args + 4;
  D.24940 = *D.24939;
  right_vreg = get_simd_vreg (cfg, cmethod, D.24940);
  D.24941 = cfg->mempool;
  ins = mono_mempool_alloc (D.24941, 48);
  ins->data.op[1].const_val = 0;
  D.24942 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24942;
  ins->prev = 0B;
  D.24943 = ins->prev;
  ins->next = D.24943;
  D.24944 = intrinsic->opcode;
  ins->opcode = D.24944;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24945 = ins->sreg3;
  ins->sreg2 = D.24945;
  D.24946 = ins->sreg2;
  ins->sreg1 = D.24946;
  D.24947 = cfg->ip;
  ins->cil_code = D.24947;
  D.24948 = cmethod->klass;
  ins->klass = D.24948;
  ins->sreg1 = left_vreg;
  ins->sreg2 = right_vreg;
  ins->type = 7;
  D.24948 = cmethod->klass;
  ins->klass = D.24948;
  D.24949 = alloc_ireg (cfg);
  tmp_vreg = (int) D.24949;
  ins->dreg = tmp_vreg;
  D.24950 = intrinsic->flags;
  D.24951 = (int) D.24950;
  ins->data.op[0].const_val = D.24951;
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  if (D.24953 != 0B) goto <D.24954>; else goto <D.24955>;
  <D.24954>:
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  D.24953->next = ins;
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  ins->prev = D.24953;
  D.24952 = cfg->cbb;
  D.24952->last_ins = ins;
  goto <D.24956>;
  <D.24955>:
  D.24952 = cfg->cbb;
  D.24952 = cfg->cbb;
  D.24952->last_ins = ins;
  D.24953 = D.24952->last_ins;
  D.24952->code = D.24953;
  <D.24956>:
  D.24941 = cfg->mempool;
  ins = mono_mempool_alloc (D.24941, 48);
  ins->data.op[1].const_val = 0;
  D.24942 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24942;
  ins->prev = 0B;
  D.24943 = ins->prev;
  ins->next = D.24943;
  ins->opcode = 844;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24945 = ins->sreg3;
  ins->sreg2 = D.24945;
  D.24946 = ins->sreg2;
  ins->sreg1 = D.24946;
  D.24947 = cfg->ip;
  ins->cil_code = D.24947;
  D.24948 = cmethod->klass;
  ins->klass = D.24948;
  ins->sreg1 = tmp_vreg;
  ins->type = 1;
  D.24957 = alloc_ireg (cfg);
  tmp_vreg = (int) D.24957;
  ins->dreg = tmp_vreg;
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  if (D.24953 != 0B) goto <D.24958>; else goto <D.24959>;
  <D.24958>:
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  D.24953->next = ins;
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  ins->prev = D.24953;
  D.24952 = cfg->cbb;
  D.24952->last_ins = ins;
  goto <D.24960>;
  <D.24959>:
  D.24952 = cfg->cbb;
  D.24952 = cfg->cbb;
  D.24952->last_ins = ins;
  D.24953 = D.24952->last_ins;
  D.24952->code = D.24953;
  <D.24960>:
  D.24944 = intrinsic->opcode;
  D.24964 = (int) D.24944;
  D.24965 = mono_op_is_packed_compare (D.24964);
  if (D.24965 != 0) goto <D.24961>; else goto <D.24966>;
  <D.24966>:
  D.24967 = BIT_FIELD_REF <*intrinsic, 8, 40>;
  D.24968 = D.24967 & 240;
  if (D.24968 == 0) goto <D.24961>; else goto <D.24962>;
  <D.24961>:
  {
    struct MonoInst * inst;

    D.24941 = cfg->mempool;
    inst = mono_mempool_alloc (D.24941, 48);
    inst->data.op[1].const_val = 0;
    D.24969 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24969;
    inst->prev = 0B;
    D.24970 = inst->prev;
    inst->next = D.24970;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24971 = inst->sreg3;
    inst->sreg2 = D.24971;
    D.24972 = inst->sreg2;
    inst->sreg1 = D.24972;
    D.24947 = cfg->ip;
    inst->cil_code = D.24947;
    inst->dreg = -1;
    inst->sreg1 = tmp_vreg;
    inst->data.op[1].const_val = 65535;
    D.24952 = cfg->cbb;
    D.24953 = D.24952->last_ins;
    if (D.24953 != 0B) goto <D.24973>; else goto <D.24974>;
    <D.24973>:
    D.24952 = cfg->cbb;
    D.24953 = D.24952->last_ins;
    D.24953->next = inst;
    D.24952 = cfg->cbb;
    D.24953 = D.24952->last_ins;
    inst->prev = D.24953;
    D.24952 = cfg->cbb;
    D.24952->last_ins = inst;
    goto <D.24975>;
    <D.24974>:
    D.24952 = cfg->cbb;
    D.24952 = cfg->cbb;
    D.24952->last_ins = inst;
    D.24953 = D.24952->last_ins;
    D.24952->code = D.24953;
    <D.24975>:
  }
  D.24941 = cfg->mempool;
  ins = mono_mempool_alloc (D.24941, 48);
  ins->data.op[1].const_val = 0;
  D.24942 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24942;
  ins->prev = 0B;
  D.24943 = ins->prev;
  ins->next = D.24943;
  D.24967 = BIT_FIELD_REF <*intrinsic, 8, 40>;
  D.24968 = D.24967 & 240;
  if (D.24968 == 0) goto <D.24977>; else goto <D.24978>;
  <D.24977>:
  iftmp.47 = 450;
  goto <D.24979>;
  <D.24978>:
  iftmp.47 = 454;
  <D.24979>:
  ins->opcode = iftmp.47;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24945 = ins->sreg3;
  ins->sreg2 = D.24945;
  D.24946 = ins->sreg2;
  ins->sreg1 = D.24946;
  D.24947 = cfg->ip;
  ins->cil_code = D.24947;
  ins->dreg = tmp_vreg;
  ins->sreg1 = -1;
  goto <D.24963>;
  <D.24962>:
  {
    struct MonoInst * inst;

    D.24941 = cfg->mempool;
    inst = mono_mempool_alloc (D.24941, 48);
    inst->data.op[1].const_val = 0;
    D.24980 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24980;
    inst->prev = 0B;
    D.24981 = inst->prev;
    inst->next = D.24981;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24982 = inst->sreg3;
    inst->sreg2 = D.24982;
    D.24983 = inst->sreg2;
    inst->sreg1 = D.24983;
    D.24947 = cfg->ip;
    inst->cil_code = D.24947;
    inst->dreg = -1;
    inst->sreg1 = tmp_vreg;
    inst->data.op[1].const_val = 0;
    D.24952 = cfg->cbb;
    D.24953 = D.24952->last_ins;
    if (D.24953 != 0B) goto <D.24984>; else goto <D.24985>;
    <D.24984>:
    D.24952 = cfg->cbb;
    D.24953 = D.24952->last_ins;
    D.24953->next = inst;
    D.24952 = cfg->cbb;
    D.24953 = D.24952->last_ins;
    inst->prev = D.24953;
    D.24952 = cfg->cbb;
    D.24952->last_ins = inst;
    goto <D.24986>;
    <D.24985>:
    D.24952 = cfg->cbb;
    D.24952 = cfg->cbb;
    D.24952->last_ins = inst;
    D.24953 = D.24952->last_ins;
    D.24952->code = D.24953;
    <D.24986>:
  }
  D.24941 = cfg->mempool;
  ins = mono_mempool_alloc (D.24941, 48);
  ins->data.op[1].const_val = 0;
  D.24942 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24942;
  ins->prev = 0B;
  D.24943 = ins->prev;
  ins->next = D.24943;
  ins->opcode = 452;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24945 = ins->sreg3;
  ins->sreg2 = D.24945;
  D.24946 = ins->sreg2;
  ins->sreg1 = D.24946;
  D.24947 = cfg->ip;
  ins->cil_code = D.24947;
  ins->dreg = tmp_vreg;
  ins->sreg1 = -1;
  <D.24963>:
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  if (D.24953 != 0B) goto <D.24987>; else goto <D.24988>;
  <D.24987>:
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  D.24953->next = ins;
  D.24952 = cfg->cbb;
  D.24953 = D.24952->last_ins;
  ins->prev = D.24953;
  D.24952 = cfg->cbb;
  D.24952->last_ins = ins;
  goto <D.24989>;
  <D.24988>:
  D.24952 = cfg->cbb;
  D.24952 = cfg->cbb;
  D.24952->last_ins = ins;
  D.24953 = D.24952->last_ins;
  D.24952->code = D.24953;
  <D.24989>:
  D.24990 = ins;
  return D.24990;
}


mono_op_is_packed_compare (int op)
{
  gboolean D.24992;
  unsigned int op.48;
  unsigned int D.24994;
  _Bool D.24995;

  op.48 = (unsigned int) op;
  D.24994 = op.48 + 4294966426;
  D.24995 = D.24994 <= 3;
  D.24992 = (gboolean) D.24995;
  return D.24992;
}


simd_intrinsic_emit_load_aligned (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMemPool * D.24997;
  int D.24998;
  struct MonoInst * D.24999;
  int D.25000;
  int D.25001;
  const unsigned char * D.25002;
  struct MonoClass * D.25003;
  struct MonoInst * D.25004;
  int D.25005;
  unsigned int D.25006;
  int D.25007;
  struct MonoBasicBlock * D.25008;
  struct MonoInst * D.25009;
  struct MonoInst * D.25013;
  struct MonoInst * ins;

  D.24997 = cfg->mempool;
  ins = mono_mempool_alloc (D.24997, 48);
  ins->data.op[1].const_val = 0;
  D.24998 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.24998;
  ins->prev = 0B;
  D.24999 = ins->prev;
  ins->next = D.24999;
  ins->opcode = 402;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25000 = ins->sreg3;
  ins->sreg2 = D.25000;
  D.25001 = ins->sreg2;
  ins->sreg1 = D.25001;
  D.25002 = cfg->ip;
  ins->cil_code = D.25002;
  D.25003 = cmethod->klass;
  ins->klass = D.25003;
  D.25004 = *args;
  D.25005 = D.25004->dreg;
  ins->sreg1 = D.25005;
  ins->type = 7;
  D.25006 = alloc_ireg (cfg);
  D.25007 = (int) D.25006;
  ins->dreg = D.25007;
  D.25008 = cfg->cbb;
  D.25009 = D.25008->last_ins;
  if (D.25009 != 0B) goto <D.25010>; else goto <D.25011>;
  <D.25010>:
  D.25008 = cfg->cbb;
  D.25009 = D.25008->last_ins;
  D.25009->next = ins;
  D.25008 = cfg->cbb;
  D.25009 = D.25008->last_ins;
  ins->prev = D.25009;
  D.25008 = cfg->cbb;
  D.25008->last_ins = ins;
  goto <D.25012>;
  <D.25011>:
  D.25008 = cfg->cbb;
  D.25008 = cfg->cbb;
  D.25008->last_ins = ins;
  D.25009 = D.25008->last_ins;
  D.25008->code = D.25009;
  <D.25012>:
  D.25013 = ins;
  return D.25013;
}


simd_intrinsic_emit_store (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * * D.25015;
  struct MonoInst * D.25016;
  struct MonoMemPool * D.25017;
  int D.25018;
  struct MonoInst * D.25019;
  short unsigned int D.25020;
  int D.25021;
  int D.25022;
  const unsigned char * D.25023;
  struct MonoClass * D.25024;
  struct MonoInst * D.25025;
  int D.25026;
  struct MonoBasicBlock * D.25027;
  struct MonoInst * D.25028;
  struct MonoInst * D.25032;
  struct MonoInst * ins;
  int vreg;

  D.25015 = args + 4;
  D.25016 = *D.25015;
  vreg = get_simd_vreg (cfg, cmethod, D.25016);
  D.25017 = cfg->mempool;
  ins = mono_mempool_alloc (D.25017, 48);
  ins->data.op[1].const_val = 0;
  D.25018 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25018;
  ins->prev = 0B;
  D.25019 = ins->prev;
  ins->next = D.25019;
  D.25020 = intrinsic->opcode;
  ins->opcode = D.25020;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25021 = ins->sreg3;
  ins->sreg2 = D.25021;
  D.25022 = ins->sreg2;
  ins->sreg1 = D.25022;
  D.25023 = cfg->ip;
  ins->cil_code = D.25023;
  D.25024 = cmethod->klass;
  ins->klass = D.25024;
  D.25025 = *args;
  D.25026 = D.25025->dreg;
  ins->dreg = D.25026;
  ins->sreg1 = vreg;
  ins->type = 7;
  D.25027 = cfg->cbb;
  D.25028 = D.25027->last_ins;
  if (D.25028 != 0B) goto <D.25029>; else goto <D.25030>;
  <D.25029>:
  D.25027 = cfg->cbb;
  D.25028 = D.25027->last_ins;
  D.25028->next = ins;
  D.25027 = cfg->cbb;
  D.25028 = D.25027->last_ins;
  ins->prev = D.25028;
  D.25027 = cfg->cbb;
  D.25027->last_ins = ins;
  goto <D.25031>;
  <D.25030>:
  D.25027 = cfg->cbb;
  D.25027 = cfg->cbb;
  D.25027->last_ins = ins;
  D.25028 = D.25027->last_ins;
  D.25027->code = D.25028;
  <D.25031>:
  D.25032 = ins;
  return D.25032;
}


simd_intrinsic_emit_extract_mask (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoInst * D.25034;
  struct MonoMemPool * D.25035;
  int D.25036;
  struct MonoInst * D.25037;
  int D.25038;
  int D.25039;
  const unsigned char * D.25040;
  struct MonoClass * D.25041;
  unsigned int D.25042;
  int D.25043;
  struct MonoBasicBlock * D.25044;
  struct MonoInst * D.25045;
  struct MonoInst * D.25049;
  struct MonoInst * ins;
  int vreg;

  D.25034 = *args;
  vreg = get_simd_vreg (cfg, cmethod, D.25034);
  D.25035 = cfg->mempool;
  ins = mono_mempool_alloc (D.25035, 48);
  ins->data.op[1].const_val = 0;
  D.25036 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25036;
  ins->prev = 0B;
  D.25037 = ins->prev;
  ins->next = D.25037;
  ins->opcode = 844;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25038 = ins->sreg3;
  ins->sreg2 = D.25038;
  D.25039 = ins->sreg2;
  ins->sreg1 = D.25039;
  D.25040 = cfg->ip;
  ins->cil_code = D.25040;
  D.25041 = cmethod->klass;
  ins->klass = D.25041;
  ins->sreg1 = vreg;
  ins->type = 1;
  D.25042 = alloc_ireg (cfg);
  D.25043 = (int) D.25042;
  ins->dreg = D.25043;
  D.25044 = cfg->cbb;
  D.25045 = D.25044->last_ins;
  if (D.25045 != 0B) goto <D.25046>; else goto <D.25047>;
  <D.25046>:
  D.25044 = cfg->cbb;
  D.25045 = D.25044->last_ins;
  D.25045->next = ins;
  D.25044 = cfg->cbb;
  D.25045 = D.25044->last_ins;
  ins->prev = D.25045;
  D.25044 = cfg->cbb;
  D.25044->last_ins = ins;
  goto <D.25048>;
  <D.25047>:
  D.25044 = cfg->cbb;
  D.25044 = cfg->cbb;
  D.25044->last_ins = ins;
  D.25045 = D.25044->last_ins;
  D.25044->code = D.25045;
  <D.25048>:
  D.25049 = ins;
  return D.25049;
}


simd_intrinsic_emit_prefetch (const struct SimdIntrinsc * intrinsic, struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * args)
{
  struct MonoMemPool * D.25051;
  int D.25052;
  struct MonoInst * D.25053;
  int D.25054;
  int D.25055;
  const unsigned char * D.25056;
  struct MonoClass * D.25057;
  struct MonoInst * D.25058;
  int D.25059;
  <unnamed-unsigned:4> D.25060;
  int D.25061;
  struct MonoBasicBlock * D.25062;
  struct MonoInst * D.25063;
  struct MonoInst * D.25067;
  struct MonoInst * ins;

  D.25051 = cfg->mempool;
  ins = mono_mempool_alloc (D.25051, 48);
  ins->data.op[1].const_val = 0;
  D.25052 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.25052;
  ins->prev = 0B;
  D.25053 = ins->prev;
  ins->next = D.25053;
  ins->opcode = 953;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25054 = ins->sreg3;
  ins->sreg2 = D.25054;
  D.25055 = ins->sreg2;
  ins->sreg1 = D.25055;
  D.25056 = cfg->ip;
  ins->cil_code = D.25056;
  D.25057 = cmethod->klass;
  ins->klass = D.25057;
  D.25058 = *args;
  D.25059 = D.25058->dreg;
  ins->sreg1 = D.25059;
  D.25060 = intrinsic->flags;
  D.25061 = (int) D.25060;
  ins->backend.arg_info = D.25061;
  D.25062 = cfg->cbb;
  D.25063 = D.25062->last_ins;
  if (D.25063 != 0B) goto <D.25064>; else goto <D.25065>;
  <D.25064>:
  D.25062 = cfg->cbb;
  D.25063 = D.25062->last_ins;
  D.25063->next = ins;
  D.25062 = cfg->cbb;
  D.25063 = D.25062->last_ins;
  ins->prev = D.25063;
  D.25062 = cfg->cbb;
  D.25062->last_ins = ins;
  goto <D.25066>;
  <D.25065>:
  D.25062 = cfg->cbb;
  D.25062 = cfg->cbb;
  D.25062->last_ins = ins;
  D.25063 = D.25062->last_ins;
  D.25062->code = D.25063;
  <D.25066>:
  D.25067 = ins;
  return D.25067;
}


