src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System;
   6 using System.Runtime.Intrinsics;
   7
   8 namespace System.Runtime.Intrinsics.X86
   9 {
  10     /// <summary>
  11     /// This class provides access to Intel SSE2 hardware instructions via intrinsics
  12     /// </summary>
  13     [CLSCompliant(false)]
  14     public abstract class Sse2 : Sse
  15     {
  16         internal Sse2() { }
  17
  18         public new static bool IsSupported { get { return false; } }
  19
  20         public new abstract class X64 : Sse.X64
  21         {
  22             internal X64() { }
  23
  24             public new static bool IsSupported { get { return false; } }
  25
  26             /// <summary>
  27             /// __int64 _mm_cvtsd_si64 (__m128d a)
  28             ///   CVTSD2SI r64, xmm/m64
  29             /// This intrinisc is only available on 64-bit processes
  30             /// </summary>
  31             public static long ConvertToInt64(Vector128<double> value) { throw new PlatformNotSupportedException(); }
  32             /// <summary>
  33             /// __int64 _mm_cvtsi128_si64 (__m128i a)
  34             ///   MOVQ reg/m64, xmm
  35             /// This intrinisc is only available on 64-bit processes
  36             /// </summary>
  37             public static long ConvertToInt64(Vector128<long> value) { throw new PlatformNotSupportedException(); }
  38
  39             /// <summary>
  40             /// __int64 _mm_cvtsi128_si64 (__m128i a)
  41             ///   MOVQ reg/m64, xmm
  42             /// This intrinisc is only available on 64-bit processes
  43             /// </summary>
  44             public static ulong ConvertToUInt64(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
  45
  46             /// <summary>
  47             /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b)
  48             ///   CVTSI2SD xmm, reg/m64
  49             /// This intrinisc is only available on 64-bit processes
  50             /// </summary>
  51             public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, long value) { throw new PlatformNotSupportedException(); }
  52
  53             /// <summary>
  54             /// __m128i _mm_cvtsi64_si128 (__int64 a)
  55             ///   MOVQ xmm, reg/m64
  56             /// This intrinisc is only available on 64-bit processes
  57             /// </summary>
  58             public static Vector128<long> ConvertScalarToVector128Int64(long value) { throw new PlatformNotSupportedException(); }
  59
  60             /// <summary>
  61             /// __m128i _mm_cvtsi64_si128 (__int64 a)
  62             ///   MOVQ xmm, reg/m64
  63             /// This intrinisc is only available on 64-bit processes
  64             /// </summary>
  65             public static Vector128<ulong> ConvertScalarToVector128UInt64(ulong value) { throw new PlatformNotSupportedException(); }
  66
  67             /// <summary>
  68             /// __int64 _mm_cvttsd_si64 (__m128d a)
  69             ///   CVTTSD2SI reg, xmm/m64
  70             /// This intrinisc is only available on 64-bit processes
  71             /// </summary>
  72             public static long ConvertToInt64WithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
  73
  74             /// <summary>
  75             /// void _mm_stream_si64(__int64 *p, __int64 a)
  76             ///   MOVNTI m64, r64
  77             /// This intrinisc is only available on 64-bit processes
  78             /// </summary>
  79             public static unsafe void StoreNonTemporal(long* address, long value) { throw new PlatformNotSupportedException(); }
  80             /// <summary>
  81             /// void _mm_stream_si64(__int64 *p, __int64 a)
  82             ///   MOVNTI m64, r64
  83             /// This intrinisc is only available on 64-bit processes
  84             /// </summary>
  85             public static unsafe void StoreNonTemporal(ulong* address, ulong value) { throw new PlatformNotSupportedException(); }
  86         }
  87
  88         /// <summary>
  89         /// __m128i _mm_add_epi8 (__m128i a,  __m128i b)
  90         ///   PADDB xmm, xmm/m128
  91         /// </summary>
  92         public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
  93         /// <summary>
  94         /// __m128i _mm_add_epi8 (__m128i a,  __m128i b)
  95         ///   PADDB xmm, xmm/m128
  96         /// </summary>
  97         public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
  98         /// <summary>
  99         /// __m128i _mm_add_epi16 (__m128i a,  __m128i b)
 100         ///   PADDW xmm, xmm/m128
 101         /// </summary>
 102         public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 103         /// <summary>
 104         /// __m128i _mm_add_epi16 (__m128i a,  __m128i b)
 105         ///   PADDW xmm, xmm/m128
 106         /// </summary>
 107         public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 108         /// <summary>
 109         /// __m128i _mm_add_epi32 (__m128i a,  __m128i b)
 110         ///   PADDD xmm, xmm/m128
 111         /// </summary>
 112         public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 113         /// <summary>
 114         /// __m128i _mm_add_epi32 (__m128i a,  __m128i b)
 115         ///   PADDD xmm, xmm/m128
 116         /// </summary>
 117         public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 118         /// <summary>
 119         /// __m128i _mm_add_epi64 (__m128i a,  __m128i b)
 120         ///   PADDQ xmm, xmm/m128
 121         /// </summary>
 122         public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 123         /// <summary>
 124         /// __m128i _mm_add_epi64 (__m128i a,  __m128i b)
 125         ///   PADDQ xmm, xmm/m128
 126         /// </summary>
 127         public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 128         /// <summary>
 129         /// __m128d _mm_add_pd (__m128d a,  __m128d b)
 130         ///   ADDPD xmm, xmm/m128
 131         /// </summary>
 132         public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 133
 134         /// <summary>
 135         /// __m128d _mm_add_sd (__m128d a,  __m128d b)
 136         ///   ADDSD xmm, xmm/m64
 137         /// </summary>
 138         public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 139
 140         /// <summary>
 141         /// __m128i _mm_adds_epi8 (__m128i a,  __m128i b)
 142         ///   PADDSB xmm, xmm/m128
 143         /// </summary>
 144         public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 145         /// <summary>
 146         /// __m128i _mm_adds_epu8 (__m128i a,  __m128i b)
 147         ///   PADDUSB xmm, xmm/m128
 148         /// </summary>
 149         public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 150         /// <summary>
 151         /// __m128i _mm_adds_epi16 (__m128i a,  __m128i b)
 152         ///   PADDSW xmm, xmm/m128
 153         /// </summary>
 154         public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 155         /// <summary>
 156         /// __m128i _mm_adds_epu16 (__m128i a,  __m128i b)
 157         ///   PADDUSW xmm, xmm/m128
 158         /// </summary>
 159         public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 160
 161         /// <summary>
 162         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 163         ///   PAND xmm, xmm/m128
 164         /// </summary>
 165         public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 166         /// <summary>
 167         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 168         ///   PAND xmm, xmm/m128
 169         /// </summary>
 170         public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 171         /// <summary>
 172         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 173         ///   PAND xmm, xmm/m128
 174         /// </summary>
 175         public static Vector128<short> And(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 176         /// <summary>
 177         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 178         ///   PAND xmm, xmm/m128
 179         /// </summary>
 180         public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 181         /// <summary>
 182         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 183         ///   PAND xmm, xmm/m128
 184         /// </summary>
 185         public static Vector128<int> And(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 186         /// <summary>
 187         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 188         ///   PAND xmm, xmm/m128
 189         /// </summary>
 190         public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 191         /// <summary>
 192         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 193         ///   PAND xmm, xmm/m128
 194         /// </summary>
 195         public static Vector128<long> And(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 196         /// <summary>
 197         /// __m128i _mm_and_si128 (__m128i a,  __m128i b)
 198         ///   PAND xmm, xmm/m128
 199         /// </summary>
 200         public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 201         /// <summary>
 202         /// __m128d _mm_and_pd (__m128d a, __m128d b)
 203         ///   ANDPD xmm, xmm/m128
 204         /// </summary>
 205         public static Vector128<double> And(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 206
 207         /// <summary>
 208         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 209         ///   PANDN xmm, xmm/m128
 210         /// </summary>
 211         public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 212         /// <summary>
 213         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 214         ///   PANDN xmm, xmm/m128
 215         /// </summary>
 216         public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 217         /// <summary>
 218         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 219         ///   PANDN xmm, xmm/m128
 220         /// </summary>
 221         public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 222         /// <summary>
 223         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 224         ///   PANDN xmm, xmm/m128
 225         /// </summary>
 226         public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 227         /// <summary>
 228         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 229         ///   PANDN xmm, xmm/m128
 230         /// </summary>
 231         public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 232         /// <summary>
 233         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 234         ///   PANDN xmm, xmm/m128
 235         /// </summary>
 236         public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 237         /// <summary>
 238         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 239         ///   PANDN xmm, xmm/m128
 240         /// </summary>
 241         public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 242         /// <summary>
 243         /// __m128i _mm_andnot_si128 (__m128i a,  __m128i b)
 244         ///   PANDN xmm, xmm/m128
 245         /// </summary>
 246         public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 247         /// <summary>
 248         /// __m128d _mm_andnot_pd (__m128d a, __m128d b)
 249         ///   ADDNPD xmm, xmm/m128
 250         /// </summary>
 251         public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 252
 253         /// <summary>
 254         /// __m128i _mm_avg_epu8 (__m128i a,  __m128i b)
 255         ///   PAVGB xmm, xmm/m128
 256         /// </summary>
 257         public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 258         /// <summary>
 259         /// __m128i _mm_avg_epu16 (__m128i a,  __m128i b)
 260         ///   PAVGW xmm, xmm/m128
 261         /// </summary>
 262         public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 263
 264         /// <summary>
 265         /// __m128i _mm_cmpeq_epi8 (__m128i a,  __m128i b)
 266         ///   PCMPEQB xmm, xmm/m128
 267         /// </summary>
 268         public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 269         /// <summary>
 270         /// __m128i _mm_cmpeq_epi8 (__m128i a,  __m128i b)
 271         ///   PCMPEQB xmm, xmm/m128
 272         /// </summary>
 273         public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 274         /// <summary>
 275         /// __m128i _mm_cmpeq_epi16 (__m128i a,  __m128i b)
 276         ///   PCMPEQW xmm, xmm/m128
 277         /// </summary>
 278         public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 279         /// <summary>
 280         /// __m128i _mm_cmpeq_epi16 (__m128i a,  __m128i b)
 281         ///   PCMPEQW xmm, xmm/m128
 282         /// </summary>
 283         public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 284         /// <summary>
 285         /// __m128i _mm_cmpeq_epi32 (__m128i a,  __m128i b)
 286         ///   PCMPEQD xmm, xmm/m128
 287         /// </summary>
 288         public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 289         /// <summary>
 290         /// __m128i _mm_cmpeq_epi32 (__m128i a,  __m128i b)
 291         ///   PCMPEQD xmm, xmm/m128
 292         /// </summary>
 293         public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 294         /// <summary>
 295         /// __m128d _mm_cmpeq_pd (__m128d a,  __m128d b)
 296         ///   CMPPD xmm, xmm/m128, imm8(0)
 297         /// </summary>
 298         public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 299
 300         /// <summary>
 301         /// int _mm_comieq_sd (__m128d a, __m128d b)
 302         ///   COMISS xmm, xmm/m64
 303         /// </summary>
 304         public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 305
 306         /// <summary>
 307         /// int _mm_ucomieq_sd (__m128d a, __m128d b)
 308         ///   UCOMISS xmm, xmm/m64
 309         /// </summary>
 310         public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 311
 312         /// <summary>
 313         /// __m128d _mm_cmpeq_sd (__m128d a,  __m128d b)
 314         ///   CMPSD xmm, xmm/m64, imm8(0)
 315         /// </summary>
 316         public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 317
 318         /// <summary>
 319         /// __m128i _mm_cmpgt_epi8 (__m128i a,  __m128i b)
 320         ///   PCMPGTB xmm, xmm/m128
 321         /// </summary>
 322         public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 323         /// <summary>
 324         /// __m128i _mm_cmpgt_epi16 (__m128i a,  __m128i b)
 325         ///   PCMPGTW xmm, xmm/m128
 326         /// </summary>
 327         public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 328         /// <summary>
 329         /// __m128i _mm_cmpgt_epi32 (__m128i a,  __m128i b)
 330         ///   PCMPGTD xmm, xmm/m128
 331         /// </summary>
 332         public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 333         /// <summary>
 334         /// __m128d _mm_cmpgt_pd (__m128d a,  __m128d b)
 335         ///   CMPPD xmm, xmm/m128, imm8(6)
 336         /// </summary>
 337         public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 338
 339         /// <summary>
 340         /// int _mm_comigt_sd (__m128d a, __m128d b)
 341         ///   COMISS xmm, xmm/m64
 342         /// </summary>
 343         public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 344
 345         /// <summary>
 346         /// int _mm_ucomigt_sd (__m128d a, __m128d b)
 347         ///   UCOMISS xmm, xmm/m64
 348         /// </summary>
 349         public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 350
 351         /// <summary>
 352         /// __m128d _mm_cmpgt_sd (__m128d a,  __m128d b)
 353         ///   CMPSD xmm, xmm/m64, imm8(6)
 354         /// </summary>
 355         public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 356
 357         /// <summary>
 358         /// __m128d _mm_cmpge_pd (__m128d a,  __m128d b)
 359         ///   CMPPD xmm, xmm/m128, imm8(5)
 360         /// </summary>
 361         public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 362
 363         /// <summary>
 364         /// int _mm_comige_sd (__m128d a, __m128d b)
 365         ///   COMISS xmm, xmm/m64
 366         /// </summary>
 367         public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 368
 369         /// <summary>
 370         /// int _mm_ucomige_sd (__m128d a, __m128d b)
 371         ///   UCOMISS xmm, xmm/m64
 372         /// </summary>
 373         public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 374
 375         /// <summary>
 376         /// __m128d _mm_cmpge_sd (__m128d a,  __m128d b)
 377         ///   CMPSD xmm, xmm/m64, imm8(5)
 378         /// </summary>
 379         public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 380
 381         /// <summary>
 382         /// __m128i _mm_cmplt_epi8 (__m128i a,  __m128i b)
 383         ///   PCMPGTB xmm, xmm/m128
 384         /// </summary>
 385         public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 386         /// <summary>
 387         /// __m128i _mm_cmplt_epi16 (__m128i a,  __m128i b)
 388         ///   PCMPGTW xmm, xmm/m128
 389         /// </summary>
 390         public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 391         /// <summary>
 392         /// __m128i _mm_cmplt_epi32 (__m128i a,  __m128i b)
 393         ///   PCMPGTD xmm, xmm/m128
 394         /// </summary>
 395         public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 396         /// <summary>
 397         /// __m128d _mm_cmplt_pd (__m128d a,  __m128d b)
 398         ///   CMPPD xmm, xmm/m128, imm8(1)
 399         /// </summary>
 400         public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 401
 402         /// <summary>
 403         /// int _mm_comilt_sd (__m128d a, __m128d b)
 404         ///   COMISS xmm, xmm/m64
 405         /// </summary>
 406         public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 407
 408         /// <summary>
 409         /// int _mm_ucomilt_sd (__m128d a, __m128d b)
 410         ///   UCOMISS xmm, xmm/m64
 411         /// </summary>
 412         public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 413
 414         /// <summary>
 415         /// __m128d _mm_cmplt_sd (__m128d a,  __m128d b)
 416         ///   CMPSD xmm, xmm/m64, imm8(1)
 417         /// </summary>
 418         public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 419
 420         /// <summary>
 421         /// __m128d _mm_cmple_pd (__m128d a,  __m128d b)
 422         ///   CMPPD xmm, xmm/m128, imm8(2)
 423         /// </summary>
 424         public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 425
 426         /// <summary>
 427         /// int _mm_comile_sd (__m128d a, __m128d b)
 428         ///   COMISS xmm, xmm/m64
 429         /// </summary>
 430         public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 431
 432         /// <summary>
 433         /// int _mm_ucomile_sd (__m128d a, __m128d b)
 434         ///   UCOMISS xmm, xmm/m64
 435         /// </summary>
 436         public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 437
 438         /// <summary>
 439         /// __m128d _mm_cmple_sd (__m128d a,  __m128d b)
 440         ///   CMPSD xmm, xmm/m64, imm8(2)
 441         /// </summary>
 442         public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 443
 444         /// <summary>
 445         /// __m128d _mm_cmpneq_pd (__m128d a,  __m128d b)
 446         ///   CMPPD xmm, xmm/m128, imm8(4)
 447         /// </summary>
 448         public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 449
 450         /// <summary>
 451         /// int _mm_comineq_sd (__m128d a, __m128d b)
 452         ///   COMISS xmm, xmm/m64
 453         /// </summary>
 454         public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 455
 456         /// <summary>
 457         /// int _mm_ucomineq_sd (__m128d a, __m128d b)
 458         ///   UCOMISS xmm, xmm/m64
 459         /// </summary>
 460         public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 461
 462         /// <summary>
 463         /// __m128d _mm_cmpneq_sd (__m128d a,  __m128d b)
 464         ///   CMPSD xmm, xmm/m64, imm8(4)
 465         /// </summary>
 466         public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 467
 468         /// <summary>
 469         /// __m128d _mm_cmpngt_pd (__m128d a,  __m128d b)
 470         ///   CMPPD xmm, xmm/m128, imm8(2)
 471         /// </summary>
 472         public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 473
 474         /// <summary>
 475         /// __m128d _mm_cmpngt_sd (__m128d a,  __m128d b)
 476         ///   CMPSD xmm, xmm/m64, imm8(2)
 477         /// </summary>
 478         public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 479
 480         /// <summary>
 481         /// __m128d _mm_cmpnge_pd (__m128d a,  __m128d b)
 482         ///   CMPPD xmm, xmm/m128, imm8(1)
 483         /// </summary>
 484         public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 485
 486         /// <summary>
 487         /// __m128d _mm_cmpnge_sd (__m128d a,  __m128d b)
 488         ///   CMPSD xmm, xmm/m64, imm8(1)
 489         /// </summary>
 490         public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 491
 492         /// <summary>
 493         /// __m128d _mm_cmpnlt_pd (__m128d a,  __m128d b)
 494         ///   CMPPD xmm, xmm/m128, imm8(5)
 495         /// </summary>
 496         public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 497
 498         /// <summary>
 499         /// __m128d _mm_cmpnlt_sd (__m128d a,  __m128d b)
 500         ///   CMPSD xmm, xmm/m64, imm8(5)
 501         /// </summary>
 502         public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 503
 504         /// <summary>
 505         /// __m128d _mm_cmpnle_pd (__m128d a,  __m128d b)
 506         ///   CMPPD xmm, xmm/m128, imm8(6)
 507         /// </summary>
 508         public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 509
 510         /// <summary>
 511         /// __m128d _mm_cmpnle_sd (__m128d a,  __m128d b)
 512         ///   CMPSD xmm, xmm/m64, imm8(6)
 513         /// </summary>
 514         public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 515
 516         /// <summary>
 517         /// __m128d _mm_cmpord_pd (__m128d a,  __m128d b)
 518         ///   CMPPD xmm, xmm/m128, imm8(7)
 519         /// </summary>
 520         public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 521
 522         /// <summary>
 523         /// __m128d _mm_cmpord_sd (__m128d a,  __m128d b)
 524         ///   CMPSD xmm, xmm/m64, imm8(7)
 525         /// </summary>
 526         public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 527
 528         /// <summary>
 529         /// __m128d _mm_cmpunord_pd (__m128d a,  __m128d b)
 530         ///   CMPPD xmm, xmm/m128, imm8(3)
 531         /// </summary>
 532         public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 533
 534         /// <summary>
 535         /// __m128d _mm_cmpunord_sd (__m128d a,  __m128d b)
 536         ///   CMPSD xmm, xmm/m64, imm8(3)
 537         /// </summary>
 538         public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 539
 540         /// <summary>
 541         /// __m128i _mm_cvtps_epi32 (__m128 a)
 542         ///   CVTPS2DQ xmm, xmm/m128
 543         /// </summary>
 544         public static Vector128<int> ConvertToVector128Int32(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 545         /// <summary>
 546         /// __m128i _mm_cvtpd_epi32 (__m128d a)
 547         ///   CVTPD2DQ xmm, xmm/m128
 548         /// </summary>
 549         public static Vector128<int> ConvertToVector128Int32(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 550         /// <summary>
 551         /// __m128 _mm_cvtepi32_ps (__m128i a)
 552         ///   CVTDQ2PS xmm, xmm/m128
 553         /// </summary>
 554         public static Vector128<float> ConvertToVector128Single(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 555         /// <summary>
 556         /// __m128 _mm_cvtpd_ps (__m128d a)
 557         ///   CVTPD2PS xmm, xmm/m128
 558         /// </summary>
 559         public static Vector128<float> ConvertToVector128Single(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 560         /// <summary>
 561         /// __m128d _mm_cvtepi32_pd (__m128i a)
 562         ///   CVTDQ2PD xmm, xmm/m128
 563         /// </summary>
 564         public static Vector128<double> ConvertToVector128Double(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 565         /// <summary>
 566         /// __m128d _mm_cvtps_pd (__m128 a)
 567         ///   CVTPS2PD xmm, xmm/m128
 568         /// </summary>
 569         public static Vector128<double> ConvertToVector128Double(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 570
 571         /// <summary>
 572         /// int _mm_cvtsd_si32 (__m128d a)
 573         ///   CVTSD2SI r32, xmm/m64
 574         /// </summary>
 575         public static int ConvertToInt32(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 576         /// <summary>
 577         /// int _mm_cvtsi128_si32 (__m128i a)
 578         ///   MOVD reg/m32, xmm
 579         /// </summary>
 580         public static int ConvertToInt32(Vector128<int> value) { throw new PlatformNotSupportedException(); }
 581         /// <summary>
 582         /// int _mm_cvtsi128_si32 (__m128i a)
 583         ///   MOVD reg/m32, xmm
 584         /// </summary>
 585         public static uint ConvertToUInt32(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
 586
 587         /// <summary>
 588         /// __m128d _mm_cvtsi32_sd (__m128d a, int b)
 589         ///   CVTSI2SD xmm, reg/m32
 590         /// </summary>
 591         public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, int value) { throw new PlatformNotSupportedException(); }
 592         /// <summary>
 593         /// __m128d _mm_cvtss_sd (__m128d a, __m128 b)
 594         ///   CVTSS2SD xmm, xmm/m32
 595         /// </summary>
 596         public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, Vector128<float> value) { throw new PlatformNotSupportedException(); }
 597         /// <summary>
 598         /// __m128i _mm_cvtsi32_si128 (int a)
 599         ///   MOVD xmm, reg/m32
 600         /// </summary>
 601         public static Vector128<int> ConvertScalarToVector128Int32(int value) { throw new PlatformNotSupportedException(); }
 602         /// <summary>
 603         /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b)
 604         ///   CVTSD2SS xmm, xmm/m64
 605         /// </summary>
 606         public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, Vector128<double> value) { throw new PlatformNotSupportedException(); }
 607         /// <summary>
 608         /// __m128i _mm_cvtsi32_si128 (int a)
 609         ///   MOVD xmm, reg/m32
 610         /// </summary>
 611         public static Vector128<uint> ConvertScalarToVector128UInt32(uint value) { throw new PlatformNotSupportedException(); }
 612
 613         /// <summary>
 614         /// __m128i _mm_cvttps_epi32 (__m128 a)
 615         ///   CVTTPS2DQ xmm, xmm/m128
 616         /// </summary>
 617         public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<float> value) { throw new PlatformNotSupportedException(); }
 618         /// <summary>
 619         /// __m128i _mm_cvttpd_epi32 (__m128d a)
 620         ///   CVTTPD2DQ xmm, xmm/m128
 621         /// </summary>
 622         public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 623
 624         /// <summary>
 625         /// int _mm_cvttsd_si32 (__m128d a)
 626         ///   CVTTSD2SI reg, xmm/m64
 627         /// </summary>
 628         public static int ConvertToInt32WithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 629
 630         /// <summary>
 631         /// __m128d _mm_div_pd (__m128d a,  __m128d b)
 632         ///   DIVPD xmm, xmm/m128
 633         /// </summary>
 634         public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 635
 636         /// <summary>
 637         /// __m128d _mm_div_sd (__m128d a,  __m128d b)
 638         ///   DIVSD xmm, xmm/m64
 639         /// </summary>
 640         public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 641
 642         /// <summary>
 643         /// int _mm_extract_epi16 (__m128i a,  int immediate)
 644         ///   PEXTRW reg, xmm, imm8
 645         /// </summary>
 646         public static ushort Extract(Vector128<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
 647
 648         /// <summary>
 649         /// __m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
 650         ///   PINSRW xmm, reg/m16, imm8
 651         /// </summary>
 652         public static Vector128<short> Insert(Vector128<short> value, short data, byte index) { throw new PlatformNotSupportedException(); }
 653         /// <summary>
 654         /// __m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
 655         ///   PINSRW xmm, reg/m16, imm8
 656         /// </summary>
 657         public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, byte index) { throw new PlatformNotSupportedException(); }
 658
 659         /// <summary>
 660         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 661         ///   MOVDQU xmm, m128
 662         /// </summary>
 663         public static unsafe Vector128<sbyte> LoadVector128(sbyte* address) { throw new PlatformNotSupportedException(); }
 664         /// <summary>
 665         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 666         ///   MOVDQU xmm, m128
 667         /// </summary>
 668         public static unsafe Vector128<byte> LoadVector128(byte* address) { throw new PlatformNotSupportedException(); }
 669         /// <summary>
 670         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 671         ///   MOVDQU xmm, m128
 672         /// </summary>
 673         public static unsafe Vector128<short> LoadVector128(short* address) { throw new PlatformNotSupportedException(); }
 674         /// <summary>
 675         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 676         ///   MOVDQU xmm, m128
 677         /// </summary>
 678         public static unsafe Vector128<ushort> LoadVector128(ushort* address) { throw new PlatformNotSupportedException(); }
 679         /// <summary>
 680         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 681         ///   MOVDQU xmm, m128
 682         /// </summary>
 683         public static unsafe Vector128<int> LoadVector128(int* address) { throw new PlatformNotSupportedException(); }
 684         /// <summary>
 685         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 686         ///   MOVDQU xmm, m128
 687         /// </summary>
 688         public static unsafe Vector128<uint> LoadVector128(uint* address) { throw new PlatformNotSupportedException(); }
 689         /// <summary>
 690         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 691         ///   MOVDQU xmm, m128
 692         /// </summary>
 693         public static unsafe Vector128<long> LoadVector128(long* address) { throw new PlatformNotSupportedException(); }
 694         /// <summary>
 695         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
 696         ///   MOVDQU xmm, m128
 697         /// </summary>
 698         public static unsafe Vector128<ulong> LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); }
 699         /// <summary>
 700         /// __m128d _mm_loadu_pd (double const* mem_address)
 701         ///   MOVUPD xmm, m128
 702         /// </summary>
 703         public static unsafe Vector128<double> LoadVector128(double* address) { throw new PlatformNotSupportedException(); }
 704
 705         /// <summary>
 706         /// __m128d _mm_load_sd (double const* mem_address)
 707         ///   MOVSD xmm, m64
 708         /// </summary>
 709         public static unsafe Vector128<double> LoadScalarVector128(double* address) { throw new PlatformNotSupportedException(); }
 710
 711         /// <summary>
 712         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 713         ///   MOVDQA xmm, m128
 714         /// </summary>
 715         public static unsafe Vector128<sbyte> LoadAlignedVector128(sbyte* address) { throw new PlatformNotSupportedException(); }
 716         /// <summary>
 717         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 718         ///   MOVDQA xmm, m128
 719         /// </summary>
 720         public static unsafe Vector128<byte> LoadAlignedVector128(byte* address) { throw new PlatformNotSupportedException(); }
 721         /// <summary>
 722         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 723         ///   MOVDQA xmm, m128
 724         /// </summary>
 725         public static unsafe Vector128<short> LoadAlignedVector128(short* address) { throw new PlatformNotSupportedException(); }
 726         /// <summary>
 727         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 728         ///   MOVDQA xmm, m128
 729         /// </summary>
 730         public static unsafe Vector128<ushort> LoadAlignedVector128(ushort* address) { throw new PlatformNotSupportedException(); }
 731         /// <summary>
 732         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 733         ///   MOVDQA xmm, m128
 734         /// </summary>
 735         public static unsafe Vector128<int> LoadAlignedVector128(int* address) { throw new PlatformNotSupportedException(); }
 736         /// <summary>
 737         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 738         ///   MOVDQA xmm, m128
 739         /// </summary>
 740         public static unsafe Vector128<uint> LoadAlignedVector128(uint* address) { throw new PlatformNotSupportedException(); }
 741         /// <summary>
 742         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 743         ///   MOVDQA xmm, m128
 744         /// </summary>
 745         public static unsafe Vector128<long> LoadAlignedVector128(long* address) { throw new PlatformNotSupportedException(); }
 746         /// <summary>
 747         /// __m128i _mm_load_si128 (__m128i const* mem_address)
 748         ///   MOVDQA xmm, m128
 749         /// </summary>
 750         public static unsafe Vector128<ulong> LoadAlignedVector128(ulong* address) { throw new PlatformNotSupportedException(); }
 751         /// <summary>
 752         /// __m128d _mm_load_pd (double const* mem_address)
 753         ///   MOVAPD xmm, m128
 754         /// </summary>
 755         public static unsafe Vector128<double> LoadAlignedVector128(double* address) { throw new PlatformNotSupportedException(); }
 756
 757         /// <summary>
 758         /// void _mm_lfence(void)
 759         ///   LFENCE
 760         /// </summary>
 761         public static void LoadFence() { throw new PlatformNotSupportedException(); }
 762
 763         /// <summary>
 764         /// __m128d _mm_loadh_pd (__m128d a, double const* mem_addr)
 765         ///   MOVHPD xmm, m64
 766         /// </summary>
 767         public static unsafe Vector128<double> LoadHigh(Vector128<double> lower, double* address) { throw new PlatformNotSupportedException(); }
 768
 769         /// <summary>
 770         /// __m128d _mm_loadl_pd (__m128d a, double const* mem_addr)
 771         ///   MOVLPD xmm, m64
 772         /// </summary>
 773         public static unsafe Vector128<double> LoadLow(Vector128<double> upper, double* address) { throw new PlatformNotSupportedException(); }
 774
 775         /// <summary>
 776         /// __m128i _mm_loadl_epi32 (__m128i const* mem_addr)
 777         ///   MOVD xmm, reg/m64
 778         /// The above native signature does not exist. We provide this additional overload for completeness.
 779         /// </summary>
 780         public static unsafe Vector128<int> LoadScalarVector128(int* address) { throw new PlatformNotSupportedException(); }
 781         /// <summary>
 782         /// __m128i _mm_loadl_epi32 (__m128i const* mem_addr)
 783         ///   MOVD xmm, reg/m64
 784         /// The above native signature does not exist. We provide this additional overload for completeness.
 785         /// </summary>
 786         public static unsafe Vector128<uint> LoadScalarVector128(uint* address) { throw new PlatformNotSupportedException(); }
 787         /// <summary>
 788         /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr)
 789         ///   MOVQ xmm, reg/m64
 790         /// </summary>
 791         public static unsafe Vector128<long> LoadScalarVector128(long* address) { throw new PlatformNotSupportedException(); }
 792         /// <summary>
 793         /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr)
 794         ///   MOVQ xmm, reg/m64
 795         /// </summary>
 796         public static unsafe Vector128<ulong> LoadScalarVector128(ulong* address) { throw new PlatformNotSupportedException(); }
 797
 798         /// <summary>
 799         /// void _mm_maskmoveu_si128 (__m128i a,  __m128i mask, char* mem_address)
 800         ///   MASKMOVDQU xmm, xmm
 801         /// </summary>
 802         public static unsafe void MaskMove(Vector128<sbyte> source, Vector128<sbyte> mask, sbyte* address) { throw new PlatformNotSupportedException(); }
 803         /// <summary>
 804         /// void _mm_maskmoveu_si128 (__m128i a,  __m128i mask, char* mem_address)
 805         ///   MASKMOVDQU xmm, xmm
 806         /// </summary>
 807         public static unsafe void MaskMove(Vector128<byte> source, Vector128<byte> mask, byte* address) { throw new PlatformNotSupportedException(); }
 808
 809         /// <summary>
 810         /// __m128i _mm_max_epu8 (__m128i a,  __m128i b)
 811         ///   PMAXUB xmm, xmm/m128
 812         /// </summary>
 813         public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 814         /// <summary>
 815         /// __m128i _mm_max_epi16 (__m128i a,  __m128i b)
 816         ///   PMAXSW xmm, xmm/m128
 817         /// </summary>
 818         public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 819         /// <summary>
 820         /// __m128d _mm_max_pd (__m128d a,  __m128d b)
 821         ///   MAXPD xmm, xmm/m128
 822         /// </summary>
 823         public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 824
 825         /// <summary>
 826         /// __m128d _mm_max_sd (__m128d a,  __m128d b)
 827         ///   MAXSD xmm, xmm/m64
 828         /// </summary>
 829         public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 830
 831         /// <summary>
 832         /// void _mm_mfence(void)
 833         ///   MFENCE
 834         /// </summary>
 835         public static void MemoryFence() { throw new PlatformNotSupportedException(); }
 836
 837         /// <summary>
 838         /// __m128i _mm_min_epu8 (__m128i a,  __m128i b)
 839         ///   PMINUB xmm, xmm/m128
 840         /// </summary>
 841         public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 842         /// <summary>
 843         /// __m128i _mm_min_epi16 (__m128i a,  __m128i b)
 844         ///   PMINSW xmm, xmm/m128
 845         /// </summary>
 846         public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 847         /// <summary>
 848         /// __m128d _mm_min_pd (__m128d a,  __m128d b)
 849         ///   MINPD xmm, xmm/m128
 850         /// </summary>
 851         public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 852
 853         /// <summary>
 854         /// __m128d _mm_min_sd (__m128d a,  __m128d b)
 855         ///   MINSD xmm, xmm/m64
 856         /// </summary>
 857         public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 858
 859         /// <summary>
 860         /// __m128d _mm_move_sd (__m128d a, __m128d b)
 861         ///   MOVSD xmm, xmm
 862         /// </summary>
 863         public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value) { throw new PlatformNotSupportedException(); }
 864
 865         /// <summary>
 866         /// int _mm_movemask_epi8 (__m128i a)
 867         ///   PMOVMSKB reg, xmm
 868         /// </summary>
 869         public static int MoveMask(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 870         /// <summary>
 871         /// int _mm_movemask_epi8 (__m128i a)
 872         ///   PMOVMSKB reg, xmm
 873         /// </summary>
 874         public static int MoveMask(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
 875         /// <summary>
 876         /// int _mm_movemask_pd (__m128d a)
 877         ///   MOVMSKPD reg, xmm
 878         /// </summary>
 879         public static int MoveMask(Vector128<double> value) { throw new PlatformNotSupportedException(); }
 880
 881         /// <summary>
 882         /// __m128i _mm_move_epi64 (__m128i a)
 883         ///   MOVQ xmm, xmm
 884         /// </summary>
 885         public static Vector128<long> MoveScalar(Vector128<long> value) { throw new PlatformNotSupportedException(); }
 886         /// <summary>
 887         /// __m128i _mm_move_epi64 (__m128i a)
 888         ///   MOVQ xmm, xmm
 889         /// </summary>
 890         public static Vector128<ulong> MoveScalar(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
 891
 892         /// <summary>
 893         /// __m128i _mm_mul_epu32 (__m128i a,  __m128i b)
 894         ///   PMULUDQ xmm, xmm/m128
 895         /// </summary>
 896         public static Vector128<ulong> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 897         /// <summary>
 898         /// __m128d _mm_mul_pd (__m128d a,  __m128d b)
 899         ///   MULPD xmm, xmm/m128
 900         /// </summary>
 901         public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 902
 903         /// <summary>
 904         /// __m128d _mm_mul_sd (__m128d a,  __m128d b)
 905         ///   MULSD xmm, xmm/m64
 906         /// </summary>
 907         public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 908
 909         /// <summary>
 910         /// __m128i _mm_mulhi_epi16 (__m128i a,  __m128i b)
 911         ///   PMULHW xmm, xmm/m128
 912         /// </summary>
 913         public static Vector128<short> MultiplyHigh(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 914         /// <summary>
 915         /// __m128i _mm_mulhi_epu16 (__m128i a,  __m128i b)
 916         ///   PMULHUW xmm, xmm/m128
 917         /// </summary>
 918         public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 919
 920         /// <summary>
 921         /// __m128i _mm_madd_epi16 (__m128i a,  __m128i b)
 922         ///   PMADDWD xmm, xmm/m128
 923         /// </summary>
 924         public static Vector128<int> MultiplyAddAdjacent(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 925
 926         /// <summary>
 927         /// __m128i _mm_mullo_epi16 (__m128i a,  __m128i b)
 928         ///   PMULLW xmm, xmm/m128
 929         /// </summary>
 930         public static Vector128<short> MultiplyLow(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 931         /// <summary>
 932         /// __m128i _mm_mullo_epi16 (__m128i a,  __m128i b)
 933         ///   PMULLW xmm, xmm/m128
 934         /// </summary>
 935         public static Vector128<ushort> MultiplyLow(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 936
 937         /// <summary>
 938         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 939         ///   POR xmm, xmm/m128
 940         /// </summary>
 941         public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
 942         /// <summary>
 943         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 944         ///   POR xmm, xmm/m128
 945         /// </summary>
 946         public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 947         /// <summary>
 948         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 949         ///   POR xmm, xmm/m128
 950         /// </summary>
 951         public static Vector128<short> Or(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 952         /// <summary>
 953         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 954         ///   POR xmm, xmm/m128
 955         /// </summary>
 956         public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 957         /// <summary>
 958         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 959         ///   POR xmm, xmm/m128
 960         /// </summary>
 961         public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 962         /// <summary>
 963         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 964         ///   POR xmm, xmm/m128
 965         /// </summary>
 966         public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 967         /// <summary>
 968         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 969         ///   POR xmm, xmm/m128
 970         /// </summary>
 971         public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
 972         /// <summary>
 973         /// __m128i _mm_or_si128 (__m128i a,  __m128i b)
 974         ///   POR xmm, xmm/m128
 975         /// </summary>
 976         public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 977         /// <summary>
 978         /// __m128d _mm_or_pd (__m128d a,  __m128d b)
 979         ///   ORPD xmm, xmm/m128
 980         /// </summary>
 981         public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
 982
 983         /// <summary>
 984         /// __m128i _mm_packs_epi16 (__m128i a,  __m128i b)
 985         ///   PACKSSWB xmm, xmm/m128
 986         /// </summary>
 987         public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 988         /// <summary>
 989         /// __m128i _mm_packs_epi32 (__m128i a,  __m128i b)
 990         ///   PACKSSDW xmm, xmm/m128
 991         /// </summary>
 992         public static Vector128<short> PackSignedSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
 993
 994         /// <summary>
 995         /// __m128i _mm_packus_epi16 (__m128i a,  __m128i b)
 996         ///   PACKUSWB xmm, xmm/m128
 997         /// </summary>
 998         public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
 999
1000         /// <summary>
1001         /// __m128i _mm_sad_epu8 (__m128i a,  __m128i b)
1002         ///   PSADBW xmm, xmm/m128
1003         /// </summary>
1004         public static Vector128<ushort> SumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
1005
1006         /// <summary>
1007         /// __m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
1008         ///   PSHUFD xmm, xmm/m128, imm8
1009         /// </summary>
1010         public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw new PlatformNotSupportedException(); }
1011         /// <summary>
1012         /// __m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
1013         ///   PSHUFD xmm, xmm/m128, imm8
1014         /// </summary>
1015         public static Vector128<uint> Shuffle(Vector128<uint> value, byte control) { throw new PlatformNotSupportedException(); }
1016         /// <summary>
1017         /// __m128d _mm_shuffle_pd (__m128d a,  __m128d b, int immediate)
1018         ///   SHUFPD xmm, xmm/m128, imm8
1019         /// </summary>
1020         public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) { throw new PlatformNotSupportedException(); }
1021
1022         /// <summary>
1023         /// __m128i _mm_shufflehi_epi16 (__m128i a,  int immediate)
1024         ///   PSHUFHW xmm, xmm/m128, imm8
1025         /// </summary>
1026         public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) { throw new PlatformNotSupportedException(); }
1027         /// <summary>
1028         /// __m128i _mm_shufflehi_epi16 (__m128i a,  int control)
1029         ///   PSHUFHW xmm, xmm/m128, imm8
1030         /// </summary>
1031         public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
1032
1033         /// <summary>
1034         /// __m128i _mm_shufflelo_epi16 (__m128i a,  int control)
1035         ///   PSHUFLW xmm, xmm/m128, imm8
1036         /// </summary>
1037         public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) { throw new PlatformNotSupportedException(); }
1038         /// <summary>
1039         /// __m128i _mm_shufflelo_epi16 (__m128i a,  int control)
1040         ///   PSHUFLW xmm, xmm/m128, imm8
1041         /// </summary>
1042         public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
1043
1044         /// <summary>
1045         /// __m128i _mm_sll_epi16 (__m128i a, __m128i count)
1046         ///   PSLLW xmm, xmm/m128
1047         /// </summary>
1048         public static Vector128<short> ShiftLeftLogical(Vector128<short> value, Vector128<short> count) { throw new PlatformNotSupportedException(); }
1049         /// <summary>
1050         /// __m128i _mm_sll_epi16 (__m128i a,  __m128i count)
1051         ///   PSLLW xmm, xmm/m128
1052         /// </summary>
1053         public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, Vector128<ushort> count) { throw new PlatformNotSupportedException(); }
1054         /// <summary>
1055         /// __m128i _mm_sll_epi32 (__m128i a, __m128i count)
1056         ///   PSLLD xmm, xmm/m128
1057         /// </summary>
1058         public static Vector128<int> ShiftLeftLogical(Vector128<int> value, Vector128<int> count) { throw new PlatformNotSupportedException(); }
1059         /// <summary>
1060         /// __m128i _mm_sll_epi32 (__m128i a, __m128i count)
1061         ///   PSLLD xmm, xmm/m128
1062         /// </summary>
1063         public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> count) { throw new PlatformNotSupportedException(); }
1064         /// <summary>
1065         /// __m128i _mm_sll_epi64 (__m128i a, __m128i count)
1066         ///   PSLLQ xmm, xmm/m128
1067         /// </summary>
1068         public static Vector128<long> ShiftLeftLogical(Vector128<long> value, Vector128<long> count) { throw new PlatformNotSupportedException(); }
1069         /// <summary>
1070         /// __m128i _mm_sll_epi64 (__m128i a, __m128i count)
1071         ///   PSLLQ xmm, xmm/m128
1072         /// </summary>
1073         public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, Vector128<ulong> count) { throw new PlatformNotSupportedException(); }
1074
1075         /// <summary>
1076         /// __m128i _mm_slli_epi16 (__m128i a,  int immediate)
1077         ///   PSLLW xmm, imm8
1078         /// </summary>
1079         public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
1080         /// <summary>
1081         /// __m128i _mm_slli_epi16 (__m128i a,  int immediate)
1082         ///   PSLLW xmm, imm8
1083         /// </summary>
1084         public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
1085         /// <summary>
1086         /// __m128i _mm_slli_epi32 (__m128i a,  int immediate)
1087         ///   PSLLD xmm, imm8
1088         /// </summary>
1089         public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
1090         /// <summary>
1091         /// __m128i _mm_slli_epi32 (__m128i a,  int immediate)
1092         ///   PSLLD xmm, imm8
1093         /// </summary>
1094         public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
1095         /// <summary>
1096         /// __m128i _mm_slli_epi64 (__m128i a,  int immediate)
1097         ///   PSLLQ xmm, imm8
1098         /// </summary>
1099         public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
1100         /// <summary>
1101         /// __m128i _mm_slli_epi64 (__m128i a,  int immediate)
1102         ///   PSLLQ xmm, imm8
1103         /// </summary>
1104         public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
1105
1106         /// <summary>
1107         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1108         ///   PSLLDQ xmm, imm8
1109         /// </summary>
1110         public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1111         /// <summary>
1112         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1113         ///   PSLLDQ xmm, imm8
1114         /// </summary>
1115         public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1116         /// <summary>
1117         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1118         ///   PSLLDQ xmm, imm8
1119         /// </summary>
1120         public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1121         /// <summary>
1122         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1123         ///   PSLLDQ xmm, imm8
1124         /// </summary>
1125         public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1126         /// <summary>
1127         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1128         ///   PSLLDQ xmm, imm8
1129         /// </summary>
1130         public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1131         /// <summary>
1132         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1133         ///   PSLLDQ xmm, imm8
1134         /// </summary>
1135         public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1136         /// <summary>
1137         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1138         ///   PSLLDQ xmm, imm8
1139         /// </summary>
1140         public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1141         /// <summary>
1142         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
1143         ///   PSLLDQ xmm, imm8
1144         /// </summary>
1145         public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1146
1147         /// <summary>
1148         /// __m128i _mm_sra_epi16 (__m128i a, __m128i count)
1149         ///   PSRAW xmm, xmm/m128
1150         /// </summary>
1151         public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, Vector128<short> count) { throw new PlatformNotSupportedException(); }
1152         /// <summary>
1153         /// __m128i _mm_sra_epi32 (__m128i a, __m128i count)
1154         ///   PSRAD xmm, xmm/m128
1155         /// </summary>
1156         public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> count) { throw new PlatformNotSupportedException(); }
1157
1158         /// <summary>
1159         /// __m128i _mm_srai_epi16 (__m128i a,  int immediate)
1160         ///   PSRAW xmm, imm8
1161         /// </summary>
1162         public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
1163         /// <summary>
1164         /// __m128i _mm_srai_epi32 (__m128i a,  int immediate)
1165         ///   PSRAD xmm, imm8
1166         /// </summary>
1167         public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
1168
1169         /// <summary>
1170         /// __m128i _mm_srl_epi16 (__m128i a, __m128i count)
1171         ///   PSRLW xmm, xmm/m128
1172         /// </summary>
1173         public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> count) { throw new PlatformNotSupportedException(); }
1174         /// <summary>
1175         /// __m128i _mm_srl_epi16 (__m128i a, __m128i count)
1176         ///   PSRLW xmm, xmm/m128
1177         /// </summary>
1178         public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, Vector128<ushort> count) { throw new PlatformNotSupportedException(); }
1179         /// <summary>
1180         /// __m128i _mm_srl_epi32 (__m128i a, __m128i count)
1181         ///   PSRLD xmm, xmm/m128
1182         /// </summary>
1183         public static Vector128<int> ShiftRightLogical(Vector128<int> value, Vector128<int> count) { throw new PlatformNotSupportedException(); }
1184         /// <summary>
1185         /// __m128i _mm_srl_epi32 (__m128i a, __m128i count)
1186         ///   PSRLD xmm, xmm/m128
1187         /// </summary>
1188         public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, Vector128<uint> count) { throw new PlatformNotSupportedException(); }
1189         /// <summary>
1190         /// __m128i _mm_srl_epi64 (__m128i a, __m128i count)
1191         ///   PSRLQ xmm, xmm/m128
1192         /// </summary>
1193         public static Vector128<long> ShiftRightLogical(Vector128<long> value, Vector128<long> count) { throw new PlatformNotSupportedException(); }
1194         /// <summary>
1195         /// __m128i _mm_srl_epi64 (__m128i a, __m128i count)
1196         ///   PSRLQ xmm, xmm/m128
1197         /// </summary>
1198         public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, Vector128<ulong> count) { throw new PlatformNotSupportedException(); }
1199
1200         /// <summary>
1201         /// __m128i _mm_srli_epi16 (__m128i a,  int immediate)
1202         ///   PSRLW xmm, imm8
1203         /// </summary>
1204         public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
1205         /// <summary>
1206         /// __m128i _mm_srli_epi16 (__m128i a,  int immediate)
1207         ///   PSRLW xmm, imm8
1208         /// </summary>
1209         public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
1210         /// <summary>
1211         /// __m128i _mm_srli_epi32 (__m128i a,  int immediate)
1212         ///   PSRLD xmm, imm8
1213         /// </summary>
1214         public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
1215         /// <summary>
1216         /// __m128i _mm_srli_epi32 (__m128i a,  int immediate)
1217         ///   PSRLD xmm, imm8
1218         /// </summary>
1219         public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
1220         /// <summary>
1221         /// __m128i _mm_srli_epi64 (__m128i a,  int immediate)
1222         ///   PSRLQ xmm, imm8
1223         /// </summary>
1224         public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
1225         /// <summary>
1226         /// __m128i _mm_srli_epi64 (__m128i a,  int immediate)
1227         ///   PSRLQ xmm, imm8
1228         /// </summary>
1229         public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
1230
1231         /// <summary>
1232         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1233         ///   PSRLDQ xmm, imm8
1234         /// </summary>
1235         public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1236         /// <summary>
1237         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1238         ///   PSRLDQ xmm, imm8
1239         /// </summary>
1240         public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1241         /// <summary>
1242         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1243         ///   PSRLDQ xmm, imm8
1244         /// </summary>
1245         public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1246         /// <summary>
1247         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1248         ///   PSRLDQ xmm, imm8
1249         /// </summary>
1250         public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1251         /// <summary>
1252         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1253         ///   PSRLDQ xmm, imm8
1254         /// </summary>
1255         public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1256         /// <summary>
1257         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1258         ///   PSRLDQ xmm, imm8
1259         /// </summary>
1260         public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1261         /// <summary>
1262         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1263         ///   PSRLDQ xmm, imm8
1264         /// </summary>
1265         public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1266         /// <summary>
1267         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
1268         ///   PSRLDQ xmm, imm8
1269         /// </summary>
1270         public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
1271
1272         /// <summary>
1273         /// __m128d _mm_sqrt_pd (__m128d a)
1274         ///   SQRTPD xmm, xmm/m128
1275         /// </summary>
1276         public static Vector128<double> Sqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
1277
1278         /// <summary>
1279         /// __m128d _mm_sqrt_sd (__m128d a)
1280         ///   SQRTSD xmm, xmm/64
1281         /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic.
1282         /// </summary>
1283         public static Vector128<double> SqrtScalar(Vector128<double> value) { throw new PlatformNotSupportedException(); }
1284
1285         /// <summary>
1286         /// __m128d _mm_sqrt_sd (__m128d a, __m128d b)
1287         ///   SQRTSD xmm, xmm/64
1288         /// </summary>
1289         public static Vector128<double> SqrtScalar(Vector128<double> upper, Vector128<double> value) { throw new PlatformNotSupportedException(); }
1290
1291         /// <summary>
1292         /// void _mm_store_sd (double* mem_addr, __m128d a)
1293         ///   MOVSD m64, xmm
1294         /// </summary>
1295         public static unsafe void StoreScalar(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
1296
1297         /// <summary>
1298         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1299         ///   MOVDQA m128, xmm
1300         /// </summary>
1301         public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
1302         /// <summary>
1303         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1304         ///   MOVDQA m128, xmm
1305         /// </summary>
1306         public static unsafe void StoreAligned(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
1307         /// <summary>
1308         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1309         ///   MOVDQA m128, xmm
1310         /// </summary>
1311         public static unsafe void StoreAligned(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
1312         /// <summary>
1313         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1314         ///   MOVDQA m128, xmm
1315         /// </summary>
1316         public static unsafe void StoreAligned(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
1317         /// <summary>
1318         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1319         ///   MOVDQA m128, xmm
1320         /// </summary>
1321         public static unsafe void StoreAligned(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
1322         /// <summary>
1323         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1324         ///   MOVDQA m128, xmm
1325         /// </summary>
1326         public static unsafe void StoreAligned(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
1327         /// <summary>
1328         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1329         ///   MOVDQA m128, xmm
1330         /// </summary>
1331         public static unsafe void StoreAligned(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
1332         /// <summary>
1333         /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
1334         ///   MOVDQA m128, xmm
1335         /// </summary>
1336         public static unsafe void StoreAligned(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
1337         /// <summary>
1338         /// void _mm_store_pd (double* mem_addr, __m128d a)
1339         ///   MOVAPD m128, xmm
1340         /// </summary>
1341         public static unsafe void StoreAligned(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
1342
1343         /// <summary>
1344         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1345         ///   MOVNTDQ m128, xmm
1346         /// </summary>
1347         public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
1348         /// <summary>
1349         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1350         ///   MOVNTDQ m128, xmm
1351         /// </summary>
1352         public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
1353         /// <summary>
1354         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1355         ///   MOVNTDQ m128, xmm
1356         /// </summary>
1357         public static unsafe void StoreAlignedNonTemporal(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
1358         /// <summary>
1359         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1360         ///   MOVNTDQ m128, xmm
1361         /// </summary>
1362         public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
1363         /// <summary>
1364         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1365         ///   MOVNTDQ m128, xmm
1366         /// </summary>
1367         public static unsafe void StoreAlignedNonTemporal(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
1368         /// <summary>
1369         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1370         ///   MOVNTDQ m128, xmm
1371         /// </summary>
1372         public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
1373         /// <summary>
1374         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1375         ///   MOVNTDQ m128, xmm
1376         /// </summary>
1377         public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
1378         /// <summary>
1379         /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
1380         ///   MOVNTDQ m128, xmm
1381         /// </summary>
1382         public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
1383         /// <summary>
1384         /// void _mm_stream_pd (double* mem_addr, __m128d a)
1385         ///   MOVNTPD m128, xmm
1386         /// </summary>
1387         public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
1388
1389         /// <summary>
1390         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1391         ///   MOVDQU m128, xmm
1392         /// </summary>
1393         public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
1394         /// <summary>
1395         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1396         ///   MOVDQU m128, xmm
1397         /// </summary>
1398         public static unsafe void Store(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
1399         /// <summary>
1400         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1401         ///   MOVDQU m128, xmm
1402         /// </summary>
1403         public static unsafe void Store(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
1404         /// <summary>
1405         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1406         ///   MOVDQU m128, xmm
1407         /// </summary>
1408         public static unsafe void Store(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
1409         /// <summary>
1410         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1411         ///   MOVDQU m128, xmm
1412         /// </summary>
1413         public static unsafe void Store(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
1414         /// <summary>
1415         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1416         ///   MOVDQU m128, xmm
1417         /// </summary>
1418         public static unsafe void Store(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
1419         /// <summary>
1420         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1421         ///   MOVDQU m128, xmm
1422         /// </summary>
1423         public static unsafe void Store(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
1424         /// <summary>
1425         /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
1426         ///   MOVDQU m128, xmm
1427         /// </summary>
1428         public static unsafe void Store(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
1429         /// <summary>
1430         /// void _mm_storeu_pd (double* mem_addr, __m128d a)
1431         ///   MOVUPD m128, xmm
1432         /// </summary>
1433         public static unsafe void Store(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
1434
1435         /// <summary>
1436         /// void _mm_storeh_pd (double* mem_addr, __m128d a)
1437         ///   MOVHPD m64, xmm
1438         /// </summary>
1439         public static unsafe void StoreHigh(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
1440
1441         /// <summary>
1442         /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
1443         ///   MOVQ m64, xmm
1444         /// </summary>
1445         public static unsafe void StoreLow(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
1446         /// <summary>
1447         /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
1448         ///   MOVQ m64, xmm
1449         /// </summary>
1450         public static unsafe void StoreLow(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
1451         /// <summary>
1452         /// void _mm_storel_pd (double* mem_addr, __m128d a)
1453         ///   MOVLPD m64, xmm
1454         /// </summary>
1455         public static unsafe void StoreLow(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
1456
1457         /// <summary>
1458         /// void _mm_stream_si32(int *p, int a)
1459         ///   MOVNTI m32, r32
1460         /// </summary>
1461         public static unsafe void StoreNonTemporal(int* address, int value) { throw new PlatformNotSupportedException(); }
1462         /// <summary>
1463         /// void _mm_stream_si32(int *p, int a)
1464         ///   MOVNTI m32, r32
1465         /// </summary>
1466         public static unsafe void StoreNonTemporal(uint* address, uint value) { throw new PlatformNotSupportedException(); }
1467
1468         /// <summary>
1469         /// __m128i _mm_sub_epi8 (__m128i a,  __m128i b)
1470         ///   PSUBB xmm, xmm/m128
1471         /// </summary>
1472         public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
1473         /// <summary>
1474         /// __m128i _mm_sub_epi8 (__m128i a,  __m128i b)
1475         ///   PSUBB xmm, xmm/m128
1476         /// </summary>
1477         public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
1478         /// <summary>
1479         /// __m128i _mm_sub_epi16 (__m128i a,  __m128i b)
1480         ///   PSUBW xmm, xmm/m128
1481         /// </summary>
1482         public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
1483         /// <summary>
1484         /// __m128i _mm_sub_epi16 (__m128i a,  __m128i b)
1485         ///   PSUBW xmm, xmm/m128
1486         /// </summary>
1487         public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
1488         /// <summary>
1489         /// __m128i _mm_sub_epi32 (__m128i a,  __m128i b)
1490         ///   PSUBD xmm, xmm/m128
1491         /// </summary>
1492         public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
1493         /// <summary>
1494         /// __m128i _mm_sub_epi32 (__m128i a,  __m128i b)
1495         ///   PSUBD xmm, xmm/m128
1496         /// </summary>
1497         public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
1498         /// <summary>
1499         /// __m128i _mm_sub_epi64 (__m128i a,  __m128i b)
1500         ///   PSUBQ xmm, xmm/m128
1501         /// </summary>
1502         public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
1503         /// <summary>
1504         /// __m128i _mm_sub_epi64 (__m128i a,  __m128i b)
1505         ///   PSUBQ xmm, xmm/m128
1506         /// </summary>
1507         public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
1508         /// <summary>
1509         /// __m128d _mm_sub_pd (__m128d a, __m128d b)
1510         ///   SUBPD xmm, xmm/m128
1511         /// </summary>
1512         public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
1513
1514         /// <summary>
1515         /// __m128d _mm_sub_sd (__m128d a, __m128d b)
1516         ///   SUBSD xmm, xmm/m64
1517         /// </summary>
1518         public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
1519
1520         /// <summary>
1521         /// __m128i _mm_subs_epi8 (__m128i a,  __m128i b)
1522         ///   PSUBSB xmm, xmm/m128
1523         /// </summary>
1524         public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
1525         /// <summary>
1526         /// __m128i _mm_subs_epi16 (__m128i a,  __m128i b)
1527         ///   PSUBSW xmm, xmm/m128
1528         /// </summary>
1529         public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
1530         /// <summary>
1531         /// __m128i _mm_subs_epu8 (__m128i a,  __m128i b)
1532         ///   PSUBUSB xmm, xmm/m128
1533         /// </summary>
1534         public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
1535         /// <summary>
1536         /// __m128i _mm_subs_epu16 (__m128i a,  __m128i b)
1537         ///   PSUBUSW xmm, xmm/m128
1538         /// </summary>
1539         public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
1540
1541         /// <summary>
1542         /// __m128i _mm_unpackhi_epi8 (__m128i a,  __m128i b)
1543         ///   PUNPCKHBW xmm, xmm/m128
1544         /// </summary>
1545         public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
1546         /// <summary>
1547         /// __m128i _mm_unpackhi_epi8 (__m128i a,  __m128i b)
1548         ///   PUNPCKHBW xmm, xmm/m128
1549         /// </summary>
1550         public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
1551         /// <summary>
1552         /// __m128i _mm_unpackhi_epi16 (__m128i a,  __m128i b)
1553         ///   PUNPCKHWD xmm, xmm/m128
1554         /// </summary>
1555         public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
1556         /// <summary>
1557         /// __m128i _mm_unpackhi_epi16 (__m128i a,  __m128i b)
1558         ///   PUNPCKHWD xmm, xmm/m128
1559         /// </summary
1560         public static Vector128<ushort> UnpackHigh(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
1561         /// <summary>
1562         /// __m128i _mm_unpackhi_epi32 (__m128i a,  __m128i b)
1563         ///   PUNPCKHDQ xmm, xmm/m128
1564         /// </summary>
1565         public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
1566         /// <summary>
1567         /// __m128i _mm_unpackhi_epi32 (__m128i a,  __m128i b)
1568         ///   PUNPCKHDQ xmm, xmm/m128
1569         /// </summary>
1570         public static Vector128<uint> UnpackHigh(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
1571         /// <summary>
1572         /// __m128i _mm_unpackhi_epi64 (__m128i a,  __m128i b)
1573         ///   PUNPCKHQDQ xmm, xmm/m128
1574         /// </summary>
1575         public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
1576         /// <summary>
1577         /// __m128i _mm_unpackhi_epi64 (__m128i a,  __m128i b)
1578         ///   PUNPCKHQDQ xmm, xmm/m128
1579         /// </summary>
1580         public static Vector128<ulong> UnpackHigh(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
1581         /// <summary>
1582         /// __m128d _mm_unpackhi_pd (__m128d a,  __m128d b)
1583         ///   UNPCKHPD xmm, xmm/m128
1584         /// </summary>
1585         public static Vector128<double> UnpackHigh(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
1586
1587         /// <summary>
1588         /// __m128i _mm_unpacklo_epi8 (__m128i a,  __m128i b)
1589         ///   PUNPCKLBW xmm, xmm/m128
1590         /// </summary>
1591         public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
1592         /// <summary>
1593         /// __m128i _mm_unpacklo_epi8 (__m128i a,  __m128i b)
1594         ///   PUNPCKLBW xmm, xmm/m128
1595         /// </summary>
1596         public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
1597         /// <summary>
1598         /// __m128i _mm_unpacklo_epi16 (__m128i a,  __m128i b)
1599         ///   PUNPCKLWD xmm, xmm/m128
1600         /// </summary>
1601         public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
1602         /// <summary>
1603         /// __m128i _mm_unpacklo_epi16 (__m128i a,  __m128i b)
1604         ///   PUNPCKLWD xmm, xmm/m128
1605         /// </summary>
1606         public static Vector128<ushort> UnpackLow(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
1607         /// <summary>
1608         /// __m128i _mm_unpacklo_epi32 (__m128i a,  __m128i b)
1609         ///   PUNPCKLDQ xmm, xmm/m128
1610         /// </summary>
1611         public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
1612         /// <summary>
1613         /// __m128i _mm_unpacklo_epi32 (__m128i a,  __m128i b)
1614         ///   PUNPCKLDQ xmm, xmm/m128
1615         /// </summary>
1616         public static Vector128<uint> UnpackLow(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
1617         /// <summary>
1618         /// __m128i _mm_unpacklo_epi64 (__m128i a,  __m128i b)
1619         ///   PUNPCKLQDQ xmm, xmm/m128
1620         /// </summary>
1621         public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
1622         /// <summary>
1623         /// __m128i _mm_unpacklo_epi64 (__m128i a,  __m128i b)
1624         ///   PUNPCKLQDQ xmm, xmm/m128
1625         /// </summary>
1626         public static Vector128<ulong> UnpackLow(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
1627         /// <summary>
1628         /// __m128d _mm_unpacklo_pd (__m128d a,  __m128d b)
1629         ///   UNPCKLPD xmm, xmm/m128
1630         /// </summary>
1631         public static Vector128<double> UnpackLow(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
1632
1633         /// <summary>
1634         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1635         ///   PXOR xmm, xmm/m128
1636         /// </summary>
1637         public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
1638         /// <summary>
1639         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1640         ///   PXOR xmm, xmm/m128
1641         /// </summary>
1642         public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
1643         /// <summary>
1644         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1645         ///   PXOR xmm, xmm/m128
1646         /// </summary>
1647         public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
1648         /// <summary>
1649         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1650         ///   PXOR xmm, xmm/m128
1651         /// </summary>
1652         public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
1653         /// <summary>
1654         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1655         ///   PXOR xmm, xmm/m128
1656         /// </summary>
1657         public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
1658         /// <summary>
1659         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1660         ///   PXOR xmm, xmm/m128
1661         /// </summary>
1662         public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
1663         /// <summary>
1664         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1665         ///   PXOR xmm, xmm/m128
1666         /// </summary>
1667         public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
1668         /// <summary>
1669         /// __m128i _mm_xor_si128 (__m128i a,  __m128i b)
1670         ///   PXOR xmm, xmm/m128
1671         /// </summary>
1672         public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
1673         /// <summary>
1674         /// __m128d _mm_xor_pd (__m128d a,  __m128d b)
1675         ///   XORPD xmm, xmm/m128
1676         /// </summary>
1677         public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
1678     }
1679 }