diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp
index 02bb832c24a4f2..94fdcbfb814bc0 100644
--- a/src/coreclr/jit/fgbasic.cpp
+++ b/src/coreclr/jit/fgbasic.cpp
@@ -1483,18 +1483,54 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
 #if defined(FEATURE_HW_INTRINSICS)
 #if defined(TARGET_ARM64)
                             case NI_Vector64_get_AllBitsSet:
+                            case NI_Vector64_get_E:
+                            case NI_Vector64_get_Epsilon:
+                            case NI_Vector64_get_NaN:
+                            case NI_Vector64_get_NegativeInfinity:
+                            case NI_Vector64_get_NegativeOne:
+                            case NI_Vector64_get_NegativeZero:
                             case NI_Vector64_get_One:
+                            case NI_Vector64_get_Pi:
+                            case NI_Vector64_get_PositiveInfinity:
+                            case NI_Vector64_get_Tau:
                             case NI_Vector64_get_Zero:
 #endif // TARGET_ARM64
                             case NI_Vector128_get_AllBitsSet:
+                            case NI_Vector128_get_E:
+                            case NI_Vector128_get_Epsilon:
+                            case NI_Vector128_get_NaN:
+                            case NI_Vector128_get_NegativeInfinity:
+                            case NI_Vector128_get_NegativeOne:
+                            case NI_Vector128_get_NegativeZero:
                             case NI_Vector128_get_One:
+                            case NI_Vector128_get_Pi:
+                            case NI_Vector128_get_PositiveInfinity:
+                            case NI_Vector128_get_Tau:
                             case NI_Vector128_get_Zero:
 #if defined(TARGET_XARCH)
                             case NI_Vector256_get_AllBitsSet:
+                            case NI_Vector256_get_E:
+                            case NI_Vector256_get_Epsilon:
+                            case NI_Vector256_get_NaN:
+                            case NI_Vector256_get_NegativeInfinity:
+                            case NI_Vector256_get_NegativeOne:
+                            case NI_Vector256_get_NegativeZero:
                             case NI_Vector256_get_One:
+                            case NI_Vector256_get_Pi:
+                            case NI_Vector256_get_PositiveInfinity:
+                            case NI_Vector256_get_Tau:
                             case NI_Vector256_get_Zero:
                             case NI_Vector512_get_AllBitsSet:
+                            case NI_Vector512_get_E:
+                            case NI_Vector512_get_Epsilon:
+                            case NI_Vector512_get_NaN:
+                            case NI_Vector512_get_NegativeInfinity:
+                            case NI_Vector512_get_NegativeOne:
+                            case NI_Vector512_get_NegativeZero:
                             case NI_Vector512_get_One:
+                            case NI_Vector512_get_Pi:
+                            case NI_Vector512_get_PositiveInfinity:
+                            case NI_Vector512_get_Tau:
                             case NI_Vector512_get_Zero:
 #endif // TARGET_XARCH
 #endif // FEATURE_HW_INTRINSICS
diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp
index 650919f3934e23..a41e6219c20f84 100644
--- a/src/coreclr/jit/hwintrinsicarm64.cpp
+++ b/src/coreclr/jit/hwintrinsicarm64.cpp
@@ -1439,6 +1439,40 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector64_get_E:
+        case NI_Vector128_get_E:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, 2.718281828459045);
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector64_get_Epsilon:
+        case NI_Vector128_get_Epsilon:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0x00000001));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0x0000000000000001));
+                retNode = vecCns;
+            }
+            break;
+        }
+
         case NI_Vector64_get_Indices:
         case NI_Vector128_get_Indices:
         {
@@ -1447,6 +1481,80 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector64_get_NaN:
+        case NI_Vector128_get_NaN:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0x7FC00000));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0x7FF8000000000000));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector64_get_NegativeInfinity:
+        case NI_Vector128_get_NegativeInfinity:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0xFF800000));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0xFFF0000000000000));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector64_get_NegativeOne:
+        case NI_Vector128_get_NegativeOne:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, -1.0);
+                retNode = vecCns;
+            }
+            else if (varTypeIsSigned(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, static_cast<int64_t>(-1));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector64_get_NegativeZero:
+        case NI_Vector128_get_NegativeZero:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, -0.0);
+                retNode = vecCns;
+            }
+            break;
+        }
+
         case NI_Vector64_get_One:
         case NI_Vector128_get_One:
         {
@@ -1455,6 +1563,54 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector64_get_Pi:
+        case NI_Vector128_get_Pi:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, 3.141592653589793);
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector64_get_PositiveInfinity:
+        case NI_Vector128_get_PositiveInfinity:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0x7F800000));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0x7FF0000000000000));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector64_get_Tau:
+        case NI_Vector128_get_Tau:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, 6.283185307179586);
+                retNode = vecCns;
+            }
+            break;
+        }
+
         case NI_Vector64_get_Zero:
         case NI_Vector128_get_Zero:
         {
diff --git a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp
index 9dc8a978174c9d..598c4342d1a60f 100644
--- a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp
+++ b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp
@@ -2346,7 +2346,7 @@ void CodeGen::genBaseIntrinsic(GenTreeHWIntrinsic* node, insOpts instOptions)
             //
             //      Vector128<int> overflowMask =
             //          Vector128.Equals(op1, Vector128.Create(int.MinValue)
-            //          & Vector128.Equals(op2, Vector128.Create(-1));
+            //          & Vector128.Equals(op2, Vector128<int>.NegativeOne);
             //      if (!Vector128.EqualsAll(overflowMask, Vector128<int>.Zero))
             //      {
             //          throw new OverflowException();
diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h
index ec721f567c50f3..9e3d0a4f8fea7d 100644
--- a/src/coreclr/jit/hwintrinsiclistarm64.h
+++ b/src/coreclr/jit/hwintrinsiclistarm64.h
@@ -115,8 +115,17 @@ HARDWARE_INTRINSIC(Vector64,      WidenLower,
 HARDWARE_INTRINSIC(Vector64,      WidenUpper,                                                        8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      WithElement,                                                       8,      3,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport)
 HARDWARE_INTRINSIC(Vector64,      get_AllBitsSet,                                                    8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_E,                                                             8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_Epsilon,                                                       8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      get_Indices,                                                       8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_NaN,                                                           8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_NegativeInfinity,                                              8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_NegativeOne,                                                   8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_NegativeZero,                                                  8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      get_One,                                                           8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_Pi,                                                            8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_PositiveInfinity,                                              8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      get_Tau,                                                           8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      get_Zero,                                                          8,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      op_Addition,                                                       8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      op_BitwiseAnd,                                                     8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_Commutative)
@@ -248,8 +257,17 @@ HARDWARE_INTRINSIC(Vector128,     WithElement,
 HARDWARE_INTRINSIC(Vector128,     WithLower,                                                        16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,     WithUpper,                                                        16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector128,     get_AllBitsSet,                                                   16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_E,                                                            16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_Epsilon,                                                      16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     get_Indices,                                                      16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_NaN,                                                          16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_NegativeInfinity,                                             16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_NegativeOne,                                                  16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_NegativeZero,                                                 16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     get_One,                                                          16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_Pi,                                                           16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_PositiveInfinity,                                             16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     get_Tau,                                                          16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     get_Zero,                                                         16,      0,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     op_Addition,                                                      16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     op_BitwiseAnd,                                                    16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_Commutative)
diff --git a/src/coreclr/jit/hwintrinsiclistxarch.h b/src/coreclr/jit/hwintrinsiclistxarch.h
index be680becff0b52..406c0de231a15a 100644
--- a/src/coreclr/jit/hwintrinsiclistxarch.h
+++ b/src/coreclr/jit/hwintrinsiclistxarch.h
@@ -134,8 +134,17 @@ HARDWARE_INTRINSIC(Vector128,       WidenLower,
 HARDWARE_INTRINSIC(Vector128,       WidenUpper,                                 16,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       WithElement,                                16,             3,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoContainment|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       get_AllBitsSet,                             16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_E,                                      16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_Epsilon,                                16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       get_Indices,                                16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_NaN,                                    16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_NegativeInfinity,                       16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_NegativeOne,                            16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_NegativeZero,                           16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       get_One,                                    16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_Pi,                                     16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_PositiveInfinity,                       16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       get_Tau,                                    16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       get_Zero,                                   16,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       op_Addition,                                16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       op_BitwiseAnd,                              16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
@@ -264,10 +273,19 @@ HARDWARE_INTRINSIC(Vector256,       WidenUpper,
 HARDWARE_INTRINSIC(Vector256,       WithElement,                                32,             3,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoContainment|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       WithLower,                                  32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       WithUpper,                                  32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_AvxOnlyCompatible)
-HARDWARE_INTRINSIC(Vector256,       get_AllBitsSet,                             32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible)
+HARDWARE_INTRINSIC(Vector256,       get_AllBitsSet,                             32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_E,                                      32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_Epsilon,                                32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector256,       get_Indices,                                32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_NaN,                                    32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_NegativeInfinity,                       32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_NegativeOne,                            32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_NegativeZero,                           32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector256,       get_One,                                    32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
-HARDWARE_INTRINSIC(Vector256,       get_Zero,                                   32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible)
+HARDWARE_INTRINSIC(Vector256,       get_Pi,                                     32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_PositiveInfinity,                       32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_Tau,                                    32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       get_Zero,                                   32,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector256,       op_Addition,                                32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector256,       op_BitwiseAnd,                              32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       op_BitwiseOr,                               32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible)
@@ -395,8 +413,17 @@ HARDWARE_INTRINSIC(Vector512,       WithElement,
 HARDWARE_INTRINSIC(Vector512,       WithLower,                                  64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector512,       WithUpper,                                  64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector512,       get_AllBitsSet,                             64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_E,                                      64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_Epsilon,                                64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       get_Indices,                                64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_NaN,                                    64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_NegativeInfinity,                       64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_NegativeOne,                            64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_NegativeZero,                           64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       get_One,                                    64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_Pi,                                     64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_PositiveInfinity,                       64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       get_Tau,                                    64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       get_Zero,                                   64,             0,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       op_Addition,                                64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       op_BitwiseAnd,                              64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp
index c614918b2074d5..04feba178f7d91 100644
--- a/src/coreclr/jit/hwintrinsicxarch.cpp
+++ b/src/coreclr/jit/hwintrinsicxarch.cpp
@@ -2528,6 +2528,42 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector128_get_E:
+        case NI_Vector256_get_E:
+        case NI_Vector512_get_E:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, 2.718281828459045);
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector128_get_Epsilon:
+        case NI_Vector256_get_Epsilon:
+        case NI_Vector512_get_Epsilon:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0x00000001));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0x0000000000000001));
+                retNode = vecCns;
+            }
+            break;
+        }
+
         case NI_Vector128_get_Indices:
         case NI_Vector256_get_Indices:
         case NI_Vector512_get_Indices:
@@ -2537,6 +2573,84 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector128_get_NaN:
+        case NI_Vector256_get_NaN:
+        case NI_Vector512_get_NaN:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0xFFC00000));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0xFFF8000000000000));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector128_get_NegativeInfinity:
+        case NI_Vector256_get_NegativeInfinity:
+        case NI_Vector512_get_NegativeInfinity:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0xFF800000));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0xFFF0000000000000));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector128_get_NegativeOne:
+        case NI_Vector256_get_NegativeOne:
+        case NI_Vector512_get_NegativeOne:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, -1.0);
+                retNode = vecCns;
+            }
+            else if (varTypeIsSigned(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, static_cast<int64_t>(-1));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector128_get_NegativeZero:
+        case NI_Vector256_get_NegativeZero:
+        case NI_Vector512_get_NegativeZero:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, -0.0);
+                retNode = vecCns;
+            }
+            break;
+        }
+
         case NI_Vector128_get_One:
         case NI_Vector256_get_One:
         case NI_Vector512_get_One:
@@ -2546,6 +2660,57 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector128_get_Pi:
+        case NI_Vector256_get_Pi:
+        case NI_Vector512_get_Pi:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, 3.141592653589793);
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector128_get_PositiveInfinity:
+        case NI_Vector256_get_PositiveInfinity:
+        case NI_Vector512_get_PositiveInfinity:
+        {
+            assert(sig->numArgs == 0);
+
+            if (simdBaseType == TYP_FLOAT)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_INT, static_cast<int64_t>(0x7F800000));
+                retNode = vecCns;
+            }
+            else if (simdBaseType == TYP_DOUBLE)
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(TYP_LONG, static_cast<int64_t>(0x7FF0000000000000));
+                retNode = vecCns;
+            }
+            break;
+        }
+
+        case NI_Vector128_get_Tau:
+        case NI_Vector256_get_Tau:
+        case NI_Vector512_get_Tau:
+        {
+            assert(sig->numArgs == 0);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                GenTreeVecCon* vecCns = gtNewVconNode(retType);
+                vecCns->EvaluateBroadcastInPlace(simdBaseType, 6.283185307179586);
+                retNode = vecCns;
+            }
+            break;
+        }
+
         case NI_Vector128_get_Zero:
         case NI_Vector256_get_Zero:
         case NI_Vector512_get_Zero:
diff --git a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
index b8643c54d9c81d..f816c820aa67e7 100644
--- a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
+++ b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
@@ -573,6 +573,24 @@ public static partial class Vector
         public static System.Numerics.Vector3 WithElement(this System.Numerics.Vector3 vector, int index, float value) { throw null; }
         public static System.Numerics.Vector4 WithElement(this System.Numerics.Vector4 vector, int index, float value) { throw null; }
         public static System.Numerics.Vector<T> Xor<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
+        extension<T>(Vector<T>) where T : System.Numerics.IFloatingPointConstants<T>
+        {
+            public static System.Numerics.Vector<T> E { get { throw null; } }
+            public static System.Numerics.Vector<T> Pi { get { throw null; } }
+            public static System.Numerics.Vector<T> Tau { get { throw null; } }
+        }
+        extension<T>(Vector<T>) where T : System.Numerics.IFloatingPointIeee754<T>
+        {
+            public static System.Numerics.Vector<T> Epsilon { get { throw null; } }
+            public static System.Numerics.Vector<T> NaN { get { throw null; } }
+            public static System.Numerics.Vector<T> NegativeInfinity { get { throw null; } }
+            public static System.Numerics.Vector<T> NegativeZero { get { throw null; } }
+            public static System.Numerics.Vector<T> PositiveInfinity { get { throw null; } }
+        }
+        extension<T>(Vector<T>) where T : System.Numerics.ISignedNumber<T>
+        {
+            public static System.Numerics.Vector<T> NegativeOne { get { throw null; } }
+        }
     }
     public partial struct Vector2 : System.IEquatable<System.Numerics.Vector2>, System.IFormattable
     {
diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
index b5f4568a628285..f18f9ff9278419 100644
--- a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
+++ b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
@@ -6079,5 +6079,113 @@ public void SubtractSaturateSByteTest()
 
         [Fact]
         public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest<nuint>(1);
+
+        [Fact]
+        public void EDoubleTest() => TestConstant(Vector<double>.E, double.E);
+
+        [Fact]
+        public void ESingleTest() => TestConstant(Vector<float>.E, float.E);
+
+        [Fact]
+        public void EpsilonDoubleTest() => TestConstant(Vector<double>.Epsilon, double.Epsilon);
+
+        [Fact]
+        public void EpsilonSingleTest() => TestConstant(Vector<float>.Epsilon, float.Epsilon);
+
+        [Fact]
+        public void NaNDoubleTest() => TestConstant(Vector<double>.NaN, double.NaN);
+
+        [Fact]
+        public void NaNSingleTest() => TestConstant(Vector<float>.NaN, float.NaN);
+
+        [Fact]
+        public void NegativeInfinityDoubleTest() => TestConstant(Vector<double>.NegativeInfinity, double.NegativeInfinity);
+
+        [Fact]
+        public void NegativeInfinitySingleTest() => TestConstant(Vector<float>.NegativeInfinity, float.NegativeInfinity);
+
+        [Fact]
+        public void NegativeOneDoubleTest() => TestConstant(Vector<double>.NegativeOne, -1.0);
+
+        [Fact]
+        public void NegativeOneInt16Test() => TestConstant<short>(Vector<short>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt32Test() => TestConstant<int>(Vector<int>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt64Test() => TestConstant<long>(Vector<long>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSByteTest() => TestConstant<sbyte>(Vector<sbyte>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSingleTest() => TestConstant(Vector<float>.NegativeOne, -1.0f);
+
+        [Fact]
+        public void NegativeZeroDoubleTest() => TestConstant(Vector<double>.NegativeZero, double.NegativeZero);
+
+        [Fact]
+        public void NegativeZeroSingleTest() => TestConstant(Vector<float>.NegativeZero, float.NegativeZero);
+
+        [Fact]
+        public void PiDoubleTest() => TestConstant(Vector<double>.Pi, double.Pi);
+
+        [Fact]
+        public void PiSingleTest() => TestConstant(Vector<float>.Pi, float.Pi);
+
+        [Fact]
+        public void PositiveInfinityDoubleTest() => TestConstant(Vector<double>.PositiveInfinity, double.PositiveInfinity);
+
+        [Fact]
+        public void PositiveInfinitySingleTest() => TestConstant(Vector<float>.PositiveInfinity, float.PositiveInfinity);
+
+        [Fact]
+        public void TauDoubleTest() => TestConstant(Vector<double>.Tau, double.Tau);
+
+        [Fact]
+        public void TauSingleTest() => TestConstant(Vector<float>.Tau, float.Tau);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector<double> actual, double expected)
+        {
+            for (int i = 0; i < Vector<double>.Count; i++)
+            {
+                if (double.IsNaN(expected))
+                {
+                    Assert.True(double.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector<float> actual, float expected)
+        {
+            for (int i = 0; i < Vector<float>.Count; i++)
+            {
+                if (float.IsNaN(expected))
+                {
+                    Assert.True(float.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant<T>(Vector<T> actual, T expected)
+            where T : IBinaryInteger<T>
+        {
+            for (int i = 0; i < Vector<T>.Count; i++)
+            {
+                Assert.Equal(expected, actual[i]);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs b/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs
index f06cc4e73dcfa8..4371b7b7b6e053 100644
--- a/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs
+++ b/src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs
@@ -1089,9 +1089,9 @@ public void Matrix3x2CreateBroadcastScalarTest()
         {
             Matrix3x2 a = Matrix3x2.Create(float.Pi);
 
-            Assert.Equal(Vector2.Create(float.Pi), a.X);
-            Assert.Equal(Vector2.Create(float.Pi), a.Y);
-            Assert.Equal(Vector2.Create(float.Pi), a.Z);
+            Assert.Equal(Vector2.Pi, a.X);
+            Assert.Equal(Vector2.Pi, a.Y);
+            Assert.Equal(Vector2.Pi, a.Z);
         }
 
         [Fact]
diff --git a/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs b/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs
index 87e035215ede69..1ae9921d78babe 100644
--- a/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs
+++ b/src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs
@@ -67,14 +67,14 @@ private static Matrix4x4 GenerateTestMatrix()
 
         // The handedness-swapped matrix of matrix M is B^-1 * M * B where B is the change of handedness matrix.
         // Since only the Z coordinate is flipped when changing handedness,
-        // 
+        //
         // B = [ 1  0  0  0
         //       0  1  0  0
         //       0  0 -1  0
         //       0  0  0  1 ]
         //
         // and B is its own inverse. So the handedness swap can be simplified to
-        // 
+        //
         // B^-1 * M * B = [  m11  m12  -m13  m14
         //                   m21  m22  -m23  m24
         //                  -m31 -m32   m33 -m34
@@ -3174,10 +3174,10 @@ public void Matrix4x4CreateBroadcastScalarTest()
         {
             Matrix4x4 a = Matrix4x4.Create(float.Pi);
 
-            Assert.Equal(Vector4.Create(float.Pi), a.X);
-            Assert.Equal(Vector4.Create(float.Pi), a.Y);
-            Assert.Equal(Vector4.Create(float.Pi), a.Z);
-            Assert.Equal(Vector4.Create(float.Pi), a.W);
+            Assert.Equal(Vector4.Pi, a.X);
+            Assert.Equal(Vector4.Pi, a.Y);
+            Assert.Equal(Vector4.Pi, a.Z);
+            Assert.Equal(Vector4.Pi, a.W);
         }
 
         [Fact]
diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs
index 37b8c4bb97cf96..8c6e002b46c800 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Helper/Base64DecoderHelper.cs
@@ -1069,7 +1069,7 @@ private static unsafe void Vector128Decode<TBase64Decoder, T>(TBase64Decoder dec
             Vector128<sbyte> packBytesMask = Vector128.Create(0x06000102, 0x090A0405, 0x0C0D0E08, 0xffffffff).AsSByte();
             Vector128<byte> mergeConstant0 = Vector128.Create(0x01400140).AsByte();
             Vector128<short> mergeConstant1 = Vector128.Create(0x00011000).AsInt16();
-            Vector128<byte> one = Vector128.Create((byte)1);
+            Vector128<byte> one = Vector128<byte>.One;
             Vector128<byte> mask2F = Vector128.Create(decoder.MaskSlashOrUnderscore);
             Vector128<byte> mask8F = Vector128.Create((byte)0x8F);
             Vector128<byte> shiftForUnderscore = Vector128.Create((byte)33);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs
index 66fe6f6c37eff6..773d178d34e1d7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/BitArray.cs
@@ -744,7 +744,7 @@ public unsafe void CopyTo(Array array, int index)
                     Vector256<byte> lowerShuffleMask_CopyToBoolArray256 = Vector256.Create(lowerShuffleMask_CopyToBoolArray, upperShuffleMask_CopyToBoolArray);
                     Vector512<byte> shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256);
                     Vector512<byte> bitMask = Vector512.Create(0x80402010_08040201).AsByte();
-                    Vector512<byte> ones = Vector512.Create((byte)1);
+                    Vector512<byte> ones = Vector512<byte>.One;
 
                     fixed (bool* destination = &boolArray[index])
                     {
@@ -766,7 +766,7 @@ public unsafe void CopyTo(Array array, int index)
                 {
                     Vector256<byte> shuffleMask = Vector256.Create(lowerShuffleMask_CopyToBoolArray, upperShuffleMask_CopyToBoolArray);
                     Vector256<byte> bitMask = Vector256.Create(0x80402010_08040201).AsByte();
-                    Vector256<byte> ones = Vector256.Create((byte)1);
+                    Vector256<byte> ones = Vector256<byte>.One;
 
                     fixed (bool* destination = &boolArray[index])
                     {
@@ -788,7 +788,7 @@ public unsafe void CopyTo(Array array, int index)
                 {
                     Vector128<byte> lowerShuffleMask = lowerShuffleMask_CopyToBoolArray;
                     Vector128<byte> upperShuffleMask = upperShuffleMask_CopyToBoolArray;
-                    Vector128<byte> ones = Vector128.Create((byte)1);
+                    Vector128<byte> ones = Vector128<byte>.One;
                     Vector128<byte> bitMask128 = Vector128.Create(0x80402010_08040201).AsByte();
 
                     fixed (bool* destination = &boolArray[index])
@@ -812,7 +812,7 @@ public unsafe void CopyTo(Array array, int index)
                 }
                 else if (AdvSimd.Arm64.IsSupported)
                 {
-                    Vector128<byte> ones = Vector128.Create((byte)1);
+                    Vector128<byte> ones = Vector128<byte>.One;
                     Vector128<byte> bitMask128 = Vector128.Create(0x80402010_08040201).AsByte();
 
                     fixed (bool* destination = &boolArray[index])
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs
index 09815c5089a570..12aed8626dd75a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.Impl.cs
@@ -357,7 +357,7 @@ public static bool Invert(in Impl matrix, out Impl result)
 
                 if (float.Abs(det) < float.Epsilon)
                 {
-                    Vector2 vNaN = Vector2.Create(float.NaN);
+                    Vector2 vNaN = Vector2.NaN;
 
                     result.X = vNaN;
                     result.Y = vNaN;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs
index 708d1e03b1b945..3ff84c8e9de3b3 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix4x4.Impl.cs
@@ -1286,7 +1286,7 @@ static bool SseImpl(in Impl matrix, out Impl result)
                     // Check determinate is not zero
                     if (float.Abs(det) < float.Epsilon)
                     {
-                        Vector4 vNaN = Vector4.Create(float.NaN);
+                        Vector4 vNaN = Vector4.NaN;
 
                         result.X = vNaN;
                         result.Y = vNaN;
@@ -1424,7 +1424,7 @@ static bool SoftwareFallback(in Impl matrix, out Impl result)
 
                     if (float.Abs(det) < float.Epsilon)
                     {
-                        Vector4 vNaN = Vector4.Create(float.NaN);
+                        Vector4 vNaN = Vector4.NaN;
 
                         result.X = vNaN;
                         result.Y = vNaN;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs
index 5e756f452c9a92..dab451045467cd 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs
@@ -133,7 +133,7 @@ public static Plane Normalize(Plane value)
 
             return Vector128.AndNot(
                 (value.AsVector128() / Vector128.Sqrt(lengthSquared)),
-                Vector128.Equals(lengthSquared, Vector128.Create(float.PositiveInfinity))
+                Vector128.Equals(lengthSquared, Vector128<float>.PositiveInfinity)
             ).AsPlane();
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
index f80cba2809dc12..ceccc9aebd9305 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
@@ -23,6 +23,84 @@ public static bool IsHardwareAccelerated
             get => IsHardwareAccelerated;
         }
 
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector<T>)
+            where T : IFloatingPointConstants<T>
+        {
+            /// <inheritdoc cref="Vector128.get_E{T}" />
+            public static Vector<T> E
+            {
+                [Intrinsic]
+                get => Create(T.E);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Pi{T}" />
+            public static Vector<T> Pi
+            {
+                [Intrinsic]
+                get => Create(T.Pi);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Tau{T}" />
+            public static Vector<T> Tau
+            {
+                [Intrinsic]
+                get => Create(T.Tau);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector<T>)
+            where T : IFloatingPointIeee754<T>
+        {
+            /// <inheritdoc cref="Vector128.get_Epsilon{T}" />
+            public static Vector<T> Epsilon
+            {
+                [Intrinsic]
+                get => Create(T.Epsilon);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NaN{T}" />
+            public static Vector<T> NaN
+            {
+                [Intrinsic]
+                get => Create(T.NaN);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeInfinity{T}" />
+            public static Vector<T> NegativeInfinity
+            {
+                [Intrinsic]
+                get => Create(T.NegativeInfinity);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeZero{T}" />
+            public static Vector<T> NegativeZero
+            {
+                [Intrinsic]
+                get => Create(T.NegativeZero);
+            }
+
+            /// <inheritdoc cref="Vector128.get_PositiveInfinity{T}" />
+            public static Vector<T> PositiveInfinity
+            {
+                [Intrinsic]
+                get => Create(T.PositiveInfinity);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector<T>)
+            where T : ISignedNumber<T>
+        {
+            /// <inheritdoc cref="Vector128.get_NegativeOne{T}" />
+            public static Vector<T> NegativeOne
+            {
+                [Intrinsic]
+                get => Create(T.NegativeOne);
+            }
+        }
+
         /// <summary>Computes the absolute value of each element in a vector.</summary>
         /// <param name="value">The vector that will have its absolute value computed.</param>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
@@ -1405,11 +1483,11 @@ public static Vector<T> IsFinite<T>(Vector<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return ~IsZero(AndNot(Create<uint>(float.PositiveInfinityBits), vector.As<T, uint>())).As<uint, T>();
+                return ~IsZero(AndNot(Vector<float>.PositiveInfinity.As<float, uint>(), vector.As<T, uint>())).As<uint, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return ~IsZero(AndNot(Create<ulong>(double.PositiveInfinityBits), vector.As<T, ulong>())).As<ulong, T>();
+                return ~IsZero(AndNot(Vector<double>.PositiveInfinity.As<double, ulong>(), vector.As<T, ulong>())).As<ulong, T>();
             }
             return Vector<T>.AllBitsSet;
         }
@@ -1484,11 +1562,11 @@ public static Vector<T> IsNegativeInfinity<T>(Vector<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.NegativeInfinity).As<float, T>());
+                return Equals(vector, Vector<float>.NegativeInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.NegativeInfinity).As<double, T>());
+                return Equals(vector, Vector<double>.NegativeInfinity.As<double, T>());
             }
             return Vector<T>.Zero;
         }
@@ -1559,11 +1637,11 @@ public static Vector<T> IsPositiveInfinity<T>(Vector<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.PositiveInfinity).As<float, T>());
+                return Equals(vector, Vector<float>.PositiveInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.PositiveInfinity).As<double, T>());
+                return Equals(vector, Vector<double>.PositiveInfinity.As<double, T>());
             }
             return Vector<T>.Zero;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
index 3cea422e72c638..9799c31049649f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
@@ -577,11 +577,11 @@ public static Vector<T> operator >>(Vector<T> value, int shiftCount)
         {
             if (typeof(T) == typeof(float))
             {
-                return value ^ Vector.Create(-0.0f).As<float, T>();
+                return value ^ Vector<float>.NegativeZero.As<float, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return value ^ Vector.Create(-0.0).As<double, T>();
+                return value ^ Vector<double>.NegativeZero.As<double, T>();
             }
             else
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs
index 74b3e7729a5d4f..666497b294eaa2 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/SimdVectorExtensions.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Numerics;
+
 namespace System.Runtime.Intrinsics
 {
     internal static unsafe class SimdVectorExtensions
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
index 6aac6ab0314a74..e26aaf0effb926 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
@@ -49,6 +49,93 @@ public static bool IsHardwareAccelerated
             get => IsHardwareAccelerated;
         }
 
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector128<T>)
+            where T : IFloatingPointConstants<T>
+        {
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointConstants{TSelf}.E" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> E
+            {
+                [Intrinsic]
+                get => Create(T.E);
+            }
+
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointConstants{TSelf}.Pi" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> Pi
+            {
+                [Intrinsic]
+                get => Create(T.Pi);
+            }
+
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointConstants{TSelf}.Tau" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> Tau
+            {
+                [Intrinsic]
+                get => Create(T.Tau);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector128<T>)
+            where T : IFloatingPointIeee754<T>
+        {
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointIeee754{TSelf}.Epsilon" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> Epsilon
+            {
+                [Intrinsic]
+                get => Create(T.Epsilon);
+            }
+
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointIeee754{TSelf}.NaN" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> NaN
+            {
+                [Intrinsic]
+                get => Create(T.NaN);
+            }
+
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> NegativeInfinity
+            {
+                [Intrinsic]
+                get => Create(T.NegativeInfinity);
+            }
+
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointIeee754{TSelf}.NegativeZero" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> NegativeZero
+            {
+                [Intrinsic]
+                get => Create(T.NegativeZero);
+            }
+
+            /// <summary>Gets a new vector with all elements initialized to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> PositiveInfinity
+            {
+                [Intrinsic]
+                get => Create(T.PositiveInfinity);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector128<T>)
+            where T : ISignedNumber<T>
+        {
+            /// <summary>Gets a new vector with all elements initialized to <see cref="ISignedNumber{TSelf}.NegativeOne" />.</summary>
+            /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
+            public static Vector128<T> NegativeOne
+            {
+                [Intrinsic]
+                get => Create(T.NegativeOne);
+            }
+        }
+
         /// <summary>Computes the absolute value of each element in a vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector that will have its absolute value computed.</param>
@@ -1970,11 +2057,11 @@ public static Vector128<T> IsNegativeInfinity<T>(Vector128<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.NegativeInfinity).As<float, T>());
+                return Equals(vector, Vector128<float>.NegativeInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.NegativeInfinity).As<double, T>());
+                return Equals(vector, Vector128<double>.NegativeInfinity.As<double, T>());
             }
             return Vector128<T>.Zero;
         }
@@ -2045,11 +2132,11 @@ public static Vector128<T> IsPositiveInfinity<T>(Vector128<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.PositiveInfinity).As<float, T>());
+                return Equals(vector, Vector128<float>.PositiveInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.PositiveInfinity).As<double, T>());
+                return Equals(vector, Vector128<double>.PositiveInfinity.As<double, T>());
             }
             return Vector128<T>.Zero;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs
index bfcf28021c5845..7c8e8a8a75073d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs
@@ -342,11 +342,11 @@ public static Vector128<T> operator >>(Vector128<T> value, int shiftCount)
         {
             if (typeof(T) == typeof(float))
             {
-                return vector ^ Vector128.Create(-0.0f).As<float, T>();
+                return vector ^ Vector128<float>.NegativeZero.As<float, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return vector ^ Vector128.Create(-0.0).As<double, T>();
+                return vector ^ Vector128<double>.NegativeZero.As<double, T>();
             }
             else
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
index 397b6428656ec3..573eb014c7051c 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
@@ -52,6 +52,84 @@ public static bool IsHardwareAccelerated
             get => IsHardwareAccelerated;
         }
 
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector256<T>)
+            where T : IFloatingPointConstants<T>
+        {
+            /// <inheritdoc cref="Vector128.get_E{T}" />
+            public static Vector256<T> E
+            {
+                [Intrinsic]
+                get => Create(T.E);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Pi{T}" />
+            public static Vector256<T> Pi
+            {
+                [Intrinsic]
+                get => Create(T.Pi);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Tau{T}" />
+            public static Vector256<T> Tau
+            {
+                [Intrinsic]
+                get => Create(T.Tau);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector256<T>)
+            where T : IFloatingPointIeee754<T>
+        {
+            /// <inheritdoc cref="Vector128.get_Epsilon{T}" />
+            public static Vector256<T> Epsilon
+            {
+                [Intrinsic]
+                get => Create(T.Epsilon);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NaN{T}" />
+            public static Vector256<T> NaN
+            {
+                [Intrinsic]
+                get => Create(T.NaN);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeInfinity{T}" />
+            public static Vector256<T> NegativeInfinity
+            {
+                [Intrinsic]
+                get => Create(T.NegativeInfinity);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeZero{T}" />
+            public static Vector256<T> NegativeZero
+            {
+                [Intrinsic]
+                get => Create(T.NegativeZero);
+            }
+
+            /// <inheritdoc cref="Vector128.get_PositiveInfinity{T}" />
+            public static Vector256<T> PositiveInfinity
+            {
+                [Intrinsic]
+                get => Create(T.PositiveInfinity);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector256<T>)
+            where T : ISignedNumber<T>
+        {
+            /// <inheritdoc cref="Vector128.get_NegativeOne{T}" />
+            public static Vector256<T> NegativeOne
+            {
+                [Intrinsic]
+                get => Create(T.NegativeOne);
+            }
+        }
+
         /// <summary>Computes the absolute value of each element in a vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector that will have its absolute value computed.</param>
@@ -1984,11 +2062,11 @@ public static Vector256<T> IsFinite<T>(Vector256<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return ~IsZero(AndNot(Create<uint>(float.PositiveInfinityBits), vector.AsUInt32())).As<uint, T>();
+                return ~IsZero(AndNot(Vector256<float>.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As<uint, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return ~IsZero(AndNot(Create<ulong>(double.PositiveInfinityBits), vector.AsUInt64())).As<ulong, T>();
+                return ~IsZero(AndNot(Vector256<double>.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As<ulong, T>();
             }
             return Vector256<T>.AllBitsSet;
         }
@@ -2063,11 +2141,11 @@ public static Vector256<T> IsNegativeInfinity<T>(Vector256<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.NegativeInfinity).As<float, T>());
+                return Equals(vector, Vector256<float>.NegativeInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.NegativeInfinity).As<double, T>());
+                return Equals(vector, Vector256<double>.NegativeInfinity.As<double, T>());
             }
             return Vector256<T>.Zero;
         }
@@ -2138,11 +2216,11 @@ public static Vector256<T> IsPositiveInfinity<T>(Vector256<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.PositiveInfinity).As<float, T>());
+                return Equals(vector, Vector256<float>.PositiveInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.PositiveInfinity).As<double, T>());
+                return Equals(vector, Vector256<double>.PositiveInfinity.As<double, T>());
             }
             return Vector256<T>.Zero;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs
index d9fdbd88f3db9d..1e1e4e713a59d0 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs
@@ -340,11 +340,11 @@ public static Vector256<T> operator >>(Vector256<T> value, int shiftCount)
         {
             if (typeof(T) == typeof(float))
             {
-                return vector ^ Vector256.Create(-0.0f).As<float, T>();
+                return vector ^ Vector256<float>.NegativeZero.As<float, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return vector ^ Vector256.Create(-0.0).As<double, T>();
+                return vector ^ Vector256<double>.NegativeZero.As<double, T>();
             }
             else
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
index 85b780a3271b66..c993d274408257 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
@@ -51,6 +51,84 @@ public static bool IsHardwareAccelerated
             get => IsHardwareAccelerated;
         }
 
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector512<T>)
+            where T : IFloatingPointConstants<T>
+        {
+            /// <inheritdoc cref="Vector128.get_E{T}" />
+            public static Vector512<T> E
+            {
+                [Intrinsic]
+                get => Create(T.E);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Pi{T}" />
+            public static Vector512<T> Pi
+            {
+                [Intrinsic]
+                get => Create(T.Pi);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Tau{T}" />
+            public static Vector512<T> Tau
+            {
+                [Intrinsic]
+                get => Create(T.Tau);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector512<T>)
+            where T : IFloatingPointIeee754<T>
+        {
+            /// <inheritdoc cref="Vector128.get_Epsilon{T}" />
+            public static Vector512<T> Epsilon
+            {
+                [Intrinsic]
+                get => Create(T.Epsilon);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NaN{T}" />
+            public static Vector512<T> NaN
+            {
+                [Intrinsic]
+                get => Create(T.NaN);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeInfinity{T}" />
+            public static Vector512<T> NegativeInfinity
+            {
+                [Intrinsic]
+                get => Create(T.NegativeInfinity);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeZero{T}" />
+            public static Vector512<T> NegativeZero
+            {
+                [Intrinsic]
+                get => Create(T.NegativeZero);
+            }
+
+            /// <inheritdoc cref="Vector128.get_PositiveInfinity{T}" />
+            public static Vector512<T> PositiveInfinity
+            {
+                [Intrinsic]
+                get => Create(T.PositiveInfinity);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector512<T>)
+            where T : ISignedNumber<T>
+        {
+            /// <inheritdoc cref="Vector128.get_NegativeOne{T}" />
+            public static Vector512<T> NegativeOne
+            {
+                [Intrinsic]
+                get => Create(T.NegativeOne);
+            }
+        }
+
         /// <summary>Computes the absolute value of each element in a vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector that will have its absolute value computed.</param>
@@ -2010,11 +2088,11 @@ public static Vector512<T> IsFinite<T>(Vector512<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return ~IsZero(AndNot(Create<uint>(float.PositiveInfinityBits), vector.AsUInt32())).As<uint, T>();
+                return ~IsZero(AndNot(Vector512<float>.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As<uint, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return ~IsZero(AndNot(Create<ulong>(double.PositiveInfinityBits), vector.AsUInt64())).As<ulong, T>();
+                return ~IsZero(AndNot(Vector512<double>.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As<ulong, T>();
             }
             return Vector512<T>.AllBitsSet;
         }
@@ -2089,11 +2167,11 @@ public static Vector512<T> IsNegativeInfinity<T>(Vector512<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.NegativeInfinity).As<float, T>());
+                return Equals(vector, Vector512<float>.NegativeInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.NegativeInfinity).As<double, T>());
+                return Equals(vector, Vector512<double>.NegativeInfinity.As<double, T>());
             }
             return Vector512<T>.Zero;
         }
@@ -2164,11 +2242,11 @@ public static Vector512<T> IsPositiveInfinity<T>(Vector512<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.PositiveInfinity).As<float, T>());
+                return Equals(vector, Vector512<float>.PositiveInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.PositiveInfinity).As<double, T>());
+                return Equals(vector, Vector512<double>.PositiveInfinity.As<double, T>());
             }
             return Vector512<T>.Zero;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs
index b1c40fcfa72c1b..eec2be8a3f79fb 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs
@@ -340,11 +340,11 @@ public static Vector512<T> operator >>(Vector512<T> value, int shiftCount)
         {
             if (typeof(T) == typeof(float))
             {
-                return vector ^ Vector512.Create(-0.0f).As<float, T>();
+                return vector ^ Vector512<float>.NegativeZero.As<float, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return vector ^ Vector512.Create(-0.0).As<double, T>();
+                return vector ^ Vector512<double>.NegativeZero.As<double, T>();
             }
             else
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
index b4bf35654517bd..7727fe68adcaf9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
@@ -24,6 +24,84 @@ public static bool IsHardwareAccelerated
             get => IsHardwareAccelerated;
         }
 
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector64<T>)
+            where T : IFloatingPointConstants<T>
+        {
+            /// <inheritdoc cref="Vector128.get_E{T}" />
+            public static Vector64<T> E
+            {
+                [Intrinsic]
+                get => Create(T.E);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Pi{T}" />
+            public static Vector64<T> Pi
+            {
+                [Intrinsic]
+                get => Create(T.Pi);
+            }
+
+            /// <inheritdoc cref="Vector128.get_Tau{T}" />
+            public static Vector64<T> Tau
+            {
+                [Intrinsic]
+                get => Create(T.Tau);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector64<T>)
+            where T : IFloatingPointIeee754<T>
+        {
+            /// <inheritdoc cref="Vector128.get_Epsilon{T}" />
+            public static Vector64<T> Epsilon
+            {
+                [Intrinsic]
+                get => Create(T.Epsilon);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NaN{T}" />
+            public static Vector64<T> NaN
+            {
+                [Intrinsic]
+                get => Create(T.NaN);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeInfinity{T}" />
+            public static Vector64<T> NegativeInfinity
+            {
+                [Intrinsic]
+                get => Create(T.NegativeInfinity);
+            }
+
+            /// <inheritdoc cref="Vector128.get_NegativeZero{T}" />
+            public static Vector64<T> NegativeZero
+            {
+                [Intrinsic]
+                get => Create(T.NegativeZero);
+            }
+
+            /// <inheritdoc cref="Vector128.get_PositiveInfinity{T}" />
+            public static Vector64<T> PositiveInfinity
+            {
+                [Intrinsic]
+                get => Create(T.PositiveInfinity);
+            }
+        }
+
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        extension<T>(Vector64<T>)
+            where T : ISignedNumber<T>
+        {
+            /// <inheritdoc cref="Vector128.get_NegativeOne{T}" />
+            public static Vector64<T> NegativeOne
+            {
+                [Intrinsic]
+                get => Create(T.NegativeOne);
+            }
+        }
+
         /// <summary>Computes the absolute value of each element in a vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector that will have its absolute value computed.</param>
@@ -1820,11 +1898,11 @@ public static Vector64<T> IsFinite<T>(Vector64<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return ~IsZero(AndNot(Create<uint>(float.PositiveInfinityBits), vector.AsUInt32())).As<uint, T>();
+                return ~IsZero(AndNot(Vector64<float>.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As<uint, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return ~IsZero(AndNot(Create<ulong>(double.PositiveInfinityBits), vector.AsUInt64())).As<ulong, T>();
+                return ~IsZero(AndNot(Vector64<double>.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As<ulong, T>();
             }
             return Vector64<T>.AllBitsSet;
         }
@@ -1899,11 +1977,11 @@ public static Vector64<T> IsNegativeInfinity<T>(Vector64<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.NegativeInfinity).As<float, T>());
+                return Equals(vector, Vector64<float>.NegativeInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.NegativeInfinity).As<double, T>());
+                return Equals(vector, Vector64<double>.NegativeInfinity.As<double, T>());
             }
             return Vector64<T>.Zero;
         }
@@ -1974,11 +2052,11 @@ public static Vector64<T> IsPositiveInfinity<T>(Vector64<T> vector)
         {
             if (typeof(T) == typeof(float))
             {
-                return Equals(vector, Create(float.PositiveInfinity).As<float, T>());
+                return Equals(vector, Vector64<float>.PositiveInfinity.As<float, T>());
             }
             else if (typeof(T) == typeof(double))
             {
-                return Equals(vector, Create(double.PositiveInfinity).As<double, T>());
+                return Equals(vector, Vector64<double>.PositiveInfinity.As<double, T>());
             }
             return Vector64<T>.Zero;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs
index 68e99650be094e..e06b50891fba28 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs
@@ -394,11 +394,11 @@ public static Vector64<T> operator >>(Vector64<T> value, int shiftCount)
         {
             if (typeof(T) == typeof(float))
             {
-                return vector ^ Vector64.Create(-0.0f).As<float, T>();
+                return vector ^ Vector64<float>.NegativeZero.As<float, T>();
             }
             else if (typeof(T) == typeof(double))
             {
-                return vector ^ Vector64.Create(-0.0).As<double, T>();
+                return vector ^ Vector64<double>.NegativeZero.As<double, T>();
             }
             else
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs
index 70f03605d66a32..7553a07cbc6a83 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Packed.cs
@@ -1301,7 +1301,7 @@ private static int ComputeFirstIndexOverlapped(ref short searchSpace, ref short
         internal static Vector256<byte> FixUpPackedVector256Result(Vector256<byte> result)
         {
             Debug.Assert(Avx2.IsSupported);
-            // Avx2.PackUnsignedSaturate(Vector256.Create((short)1), Vector256.Create((short)2)) will result in
+            // Avx2.PackUnsignedSaturate(Vector256<short>.One, Vector256.Create<short>(2)) will result in
             // 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2
             // We want to swap the X and Y bits
             // 1, 1, 1, 1, 1, 1, 1, 1, X, X, X, X, X, X, X, X, Y, Y, Y, Y, Y, Y, Y, Y, 2, 2, 2, 2, 2, 2, 2, 2
diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
index a4fd8d42365efd..0775004609bc4b 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -411,6 +411,24 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector128<T> vector,
         public static System.Runtime.Intrinsics.Vector128<T> WithLower<T>(this System.Runtime.Intrinsics.Vector128<T> vector, System.Runtime.Intrinsics.Vector64<T> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<T> WithUpper<T>(this System.Runtime.Intrinsics.Vector128<T> vector, System.Runtime.Intrinsics.Vector64<T> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<T> Xor<T>(System.Runtime.Intrinsics.Vector128<T> left, System.Runtime.Intrinsics.Vector128<T> right) { throw null; }
+        extension<T>(System.Runtime.Intrinsics.Vector128<T>) where T : System.Numerics.IFloatingPointConstants<T>
+        {
+            public static System.Runtime.Intrinsics.Vector128<T> E { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector128<T> Pi { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector128<T> Tau { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector128<T>) where T : System.Numerics.IFloatingPointIeee754<T>
+        {
+            public static System.Runtime.Intrinsics.Vector128<T> Epsilon { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector128<T> NaN { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector128<T> NegativeInfinity { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector128<T> NegativeZero { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector128<T> PositiveInfinity { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector128<T>) where T : System.Numerics.ISignedNumber<T>
+        {
+            public static System.Runtime.Intrinsics.Vector128<T> NegativeOne { get { throw null; } }
+        }
     }
     public readonly partial struct Vector128<T> : System.IEquatable<System.Runtime.Intrinsics.Vector128<T>>
     {
@@ -837,6 +855,24 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector256<T> vector,
         public static System.Runtime.Intrinsics.Vector256<T> WithLower<T>(this System.Runtime.Intrinsics.Vector256<T> vector, System.Runtime.Intrinsics.Vector128<T> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<T> WithUpper<T>(this System.Runtime.Intrinsics.Vector256<T> vector, System.Runtime.Intrinsics.Vector128<T> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<T> Xor<T>(System.Runtime.Intrinsics.Vector256<T> left, System.Runtime.Intrinsics.Vector256<T> right) { throw null; }
+        extension<T>(System.Runtime.Intrinsics.Vector256<T>) where T : System.Numerics.IFloatingPointConstants<T>
+        {
+            public static System.Runtime.Intrinsics.Vector256<T> E { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector256<T> Pi { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector256<T> Tau { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector256<T>) where T : System.Numerics.IFloatingPointIeee754<T>
+        {
+            public static System.Runtime.Intrinsics.Vector256<T> Epsilon { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector256<T> NaN { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector256<T> NegativeInfinity { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector256<T> NegativeZero { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector256<T> PositiveInfinity { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector256<T>) where T : System.Numerics.ISignedNumber<T>
+        {
+            public static System.Runtime.Intrinsics.Vector256<T> NegativeOne { get { throw null; } }
+        }
     }
     public readonly partial struct Vector256<T> : System.IEquatable<System.Runtime.Intrinsics.Vector256<T>>
     {
@@ -1262,6 +1298,24 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector512<T> vector,
         public static System.Runtime.Intrinsics.Vector512<T> WithLower<T>(this System.Runtime.Intrinsics.Vector512<T> vector, System.Runtime.Intrinsics.Vector256<T> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<T> WithUpper<T>(this System.Runtime.Intrinsics.Vector512<T> vector, System.Runtime.Intrinsics.Vector256<T> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<T> Xor<T>(System.Runtime.Intrinsics.Vector512<T> left, System.Runtime.Intrinsics.Vector512<T> right) { throw null; }
+        extension<T>(System.Runtime.Intrinsics.Vector512<T>) where T : System.Numerics.IFloatingPointConstants<T>
+        {
+            public static System.Runtime.Intrinsics.Vector512<T> E { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector512<T> Pi { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector512<T> Tau { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector512<T>) where T : System.Numerics.IFloatingPointIeee754<T>
+        {
+            public static System.Runtime.Intrinsics.Vector512<T> Epsilon { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector512<T> NaN { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector512<T> NegativeInfinity { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector512<T> NegativeZero { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector512<T> PositiveInfinity { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector512<T>) where T : System.Numerics.ISignedNumber<T>
+        {
+            public static System.Runtime.Intrinsics.Vector512<T> NegativeOne { get { throw null; } }
+        }
     }
     public readonly partial struct Vector512<T> : System.IEquatable<System.Runtime.Intrinsics.Vector512<T>>
     {
@@ -1650,6 +1704,24 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector64<T> vector,
         public static System.Runtime.Intrinsics.Vector64<ulong> WidenUpper(System.Runtime.Intrinsics.Vector64<System.UInt32> source) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<T> WithElement<T>(this System.Runtime.Intrinsics.Vector64<T> vector, int index, T value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<T> Xor<T>(System.Runtime.Intrinsics.Vector64<T> left, System.Runtime.Intrinsics.Vector64<T> right) { throw null; }
+        extension<T>(System.Runtime.Intrinsics.Vector64<T>) where T : System.Numerics.IFloatingPointConstants<T>
+        {
+            public static System.Runtime.Intrinsics.Vector64<T> E { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector64<T> Pi { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector64<T> Tau { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector64<T>) where T : System.Numerics.IFloatingPointIeee754<T>
+        {
+            public static System.Runtime.Intrinsics.Vector64<T> Epsilon { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector64<T> NaN { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector64<T> NegativeInfinity { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector64<T> NegativeZero { get { throw null; } }
+            public static System.Runtime.Intrinsics.Vector64<T> PositiveInfinity { get { throw null; } }
+        }
+        extension<T>(System.Runtime.Intrinsics.Vector64<T>) where T : System.Numerics.ISignedNumber<T>
+        {
+            public static System.Runtime.Intrinsics.Vector64<T> NegativeOne { get { throw null; } }
+        }
     }
     public readonly partial struct Vector64<T> : System.IEquatable<System.Runtime.Intrinsics.Vector64<T>>
     {
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
index cc700e2f34aa56..9414c26d4ede46 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
@@ -4962,14 +4962,14 @@ public void Vector128Int64IndexerTest(params long[] values)
         [Fact]
         public void Vector128DoubleEqualsNaNTest()
         {
-            Vector128<double> nan = Vector128.Create(double.NaN);
+            Vector128<double> nan = Vector128<double>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
         [Fact]
         public void Vector128SingleEqualsNaNTest()
         {
-            Vector128<float> nan = Vector128.Create(float.NaN);
+            Vector128<float> nan = Vector128<float>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
@@ -6935,5 +6935,113 @@ public void SubtractSaturateSByteTest()
 
         [Fact]
         public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest<nuint>(1);
+
+        [Fact]
+        public void EDoubleTest() => TestConstant(Vector128<double>.E, double.E);
+
+        [Fact]
+        public void ESingleTest() => TestConstant(Vector128<float>.E, float.E);
+
+        [Fact]
+        public void EpsilonDoubleTest() => TestConstant(Vector128<double>.Epsilon, double.Epsilon);
+
+        [Fact]
+        public void EpsilonSingleTest() => TestConstant(Vector128<float>.Epsilon, float.Epsilon);
+
+        [Fact]
+        public void NaNDoubleTest() => TestConstant(Vector128<double>.NaN, double.NaN);
+
+        [Fact]
+        public void NaNSingleTest() => TestConstant(Vector128<float>.NaN, float.NaN);
+
+        [Fact]
+        public void NegativeInfinityDoubleTest() => TestConstant(Vector128<double>.NegativeInfinity, double.NegativeInfinity);
+
+        [Fact]
+        public void NegativeInfinitySingleTest() => TestConstant(Vector128<float>.NegativeInfinity, float.NegativeInfinity);
+
+        [Fact]
+        public void NegativeOneDoubleTest() => TestConstant(Vector128<double>.NegativeOne, -1.0);
+
+        [Fact]
+        public void NegativeOneInt16Test() => TestConstant<short>(Vector128<short>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt32Test() => TestConstant<int>(Vector128<int>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt64Test() => TestConstant<long>(Vector128<long>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSByteTest() => TestConstant<sbyte>(Vector128<sbyte>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSingleTest() => TestConstant(Vector128<float>.NegativeOne, -1.0f);
+
+        [Fact]
+        public void NegativeZeroDoubleTest() => TestConstant(Vector128<double>.NegativeZero, double.NegativeZero);
+
+        [Fact]
+        public void NegativeZeroSingleTest() => TestConstant(Vector128<float>.NegativeZero, float.NegativeZero);
+
+        [Fact]
+        public void PiDoubleTest() => TestConstant(Vector128<double>.Pi, double.Pi);
+
+        [Fact]
+        public void PiSingleTest() => TestConstant(Vector128<float>.Pi, float.Pi);
+
+        [Fact]
+        public void PositiveInfinityDoubleTest() => TestConstant(Vector128<double>.PositiveInfinity, double.PositiveInfinity);
+
+        [Fact]
+        public void PositiveInfinitySingleTest() => TestConstant(Vector128<float>.PositiveInfinity, float.PositiveInfinity);
+
+        [Fact]
+        public void TauDoubleTest() => TestConstant(Vector128<double>.Tau, double.Tau);
+
+        [Fact]
+        public void TauSingleTest() => TestConstant(Vector128<float>.Tau, float.Tau);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector128<double> actual, double expected)
+        {
+            for (int i = 0; i < Vector128<double>.Count; i++)
+            {
+                if (double.IsNaN(expected))
+                {
+                    Assert.True(double.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector128<float> actual, float expected)
+        {
+            for (int i = 0; i < Vector128<float>.Count; i++)
+            {
+                if (float.IsNaN(expected))
+                {
+                    Assert.True(float.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant<T>(Vector128<T> actual, T expected)
+            where T : IBinaryInteger<T>
+        {
+            for (int i = 0; i < Vector128<T>.Count; i++)
+            {
+                Assert.Equal(expected, actual[i]);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
index 644b6fff368c1a..db022b7bb4e752 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
@@ -6145,14 +6145,14 @@ public void Vector256Int64IndexerTest(params long[] values)
         [Fact]
         public void Vector256DoubleEqualsNaNTest()
         {
-            Vector256<double> nan = Vector256.Create(double.NaN);
+            Vector256<double> nan = Vector256<double>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
         [Fact]
         public void Vector256SingleEqualsNaNTest()
         {
-            Vector256<float> nan = Vector256.Create(float.NaN);
+            Vector256<float> nan = Vector256<float>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
@@ -8111,5 +8111,113 @@ public void SubtractSaturateSByteTest()
 
         [Fact]
         public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest<nuint>(1);
+
+        [Fact]
+        public void EDoubleTest() => TestConstant(Vector256<double>.E, double.E);
+
+        [Fact]
+        public void ESingleTest() => TestConstant(Vector256<float>.E, float.E);
+
+        [Fact]
+        public void EpsilonDoubleTest() => TestConstant(Vector256<double>.Epsilon, double.Epsilon);
+
+        [Fact]
+        public void EpsilonSingleTest() => TestConstant(Vector256<float>.Epsilon, float.Epsilon);
+
+        [Fact]
+        public void NaNDoubleTest() => TestConstant(Vector256<double>.NaN, double.NaN);
+
+        [Fact]
+        public void NaNSingleTest() => TestConstant(Vector256<float>.NaN, float.NaN);
+
+        [Fact]
+        public void NegativeInfinityDoubleTest() => TestConstant(Vector256<double>.NegativeInfinity, double.NegativeInfinity);
+
+        [Fact]
+        public void NegativeInfinitySingleTest() => TestConstant(Vector256<float>.NegativeInfinity, float.NegativeInfinity);
+
+        [Fact]
+        public void NegativeOneDoubleTest() => TestConstant(Vector256<double>.NegativeOne, -1.0);
+
+        [Fact]
+        public void NegativeOneInt16Test() => TestConstant<short>(Vector256<short>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt32Test() => TestConstant<int>(Vector256<int>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt64Test() => TestConstant<long>(Vector256<long>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSByteTest() => TestConstant<sbyte>(Vector256<sbyte>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSingleTest() => TestConstant(Vector256<float>.NegativeOne, -1.0f);
+
+        [Fact]
+        public void NegativeZeroDoubleTest() => TestConstant(Vector256<double>.NegativeZero, double.NegativeZero);
+
+        [Fact]
+        public void NegativeZeroSingleTest() => TestConstant(Vector256<float>.NegativeZero, float.NegativeZero);
+
+        [Fact]
+        public void PiDoubleTest() => TestConstant(Vector256<double>.Pi, double.Pi);
+
+        [Fact]
+        public void PiSingleTest() => TestConstant(Vector256<float>.Pi, float.Pi);
+
+        [Fact]
+        public void PositiveInfinityDoubleTest() => TestConstant(Vector256<double>.PositiveInfinity, double.PositiveInfinity);
+
+        [Fact]
+        public void PositiveInfinitySingleTest() => TestConstant(Vector256<float>.PositiveInfinity, float.PositiveInfinity);
+
+        [Fact]
+        public void TauDoubleTest() => TestConstant(Vector256<double>.Tau, double.Tau);
+
+        [Fact]
+        public void TauSingleTest() => TestConstant(Vector256<float>.Tau, float.Tau);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector256<double> actual, double expected)
+        {
+            for (int i = 0; i < Vector256<double>.Count; i++)
+            {
+                if (double.IsNaN(expected))
+                {
+                    Assert.True(double.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector256<float> actual, float expected)
+        {
+            for (int i = 0; i < Vector256<float>.Count; i++)
+            {
+                if (float.IsNaN(expected))
+                {
+                    Assert.True(float.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant<T>(Vector256<T> actual, T expected)
+            where T : IBinaryInteger<T>
+        {
+            for (int i = 0; i < Vector256<T>.Count; i++)
+            {
+                Assert.Equal(expected, actual[i]);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
index 637a930e55c5e6..098e3e5cffb308 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
@@ -5973,14 +5973,14 @@ public void Vector512Int64IndexerTest(params long[] values)
         [Fact]
         public void Vector512DoubleEqualsNaNTest()
         {
-            Vector512<double> nan = Vector512.Create(double.NaN);
+            Vector512<double> nan = Vector512<double>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
         [Fact]
         public void Vector512SingleEqualsNaNTest()
         {
-            Vector512<float> nan = Vector512.Create(float.NaN);
+            Vector512<float> nan = Vector512<float>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
@@ -7894,5 +7894,113 @@ public void SubtractSaturateSByteTest()
 
         [Fact]
         public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest<nuint>(1);
+
+        [Fact]
+        public void EDoubleTest() => TestConstant(Vector512<double>.E, double.E);
+
+        [Fact]
+        public void ESingleTest() => TestConstant(Vector512<float>.E, float.E);
+
+        [Fact]
+        public void EpsilonDoubleTest() => TestConstant(Vector512<double>.Epsilon, double.Epsilon);
+
+        [Fact]
+        public void EpsilonSingleTest() => TestConstant(Vector512<float>.Epsilon, float.Epsilon);
+
+        [Fact]
+        public void NaNDoubleTest() => TestConstant(Vector512<double>.NaN, double.NaN);
+
+        [Fact]
+        public void NaNSingleTest() => TestConstant(Vector512<float>.NaN, float.NaN);
+
+        [Fact]
+        public void NegativeInfinityDoubleTest() => TestConstant(Vector512<double>.NegativeInfinity, double.NegativeInfinity);
+
+        [Fact]
+        public void NegativeInfinitySingleTest() => TestConstant(Vector512<float>.NegativeInfinity, float.NegativeInfinity);
+
+        [Fact]
+        public void NegativeOneDoubleTest() => TestConstant(Vector512<double>.NegativeOne, -1.0);
+
+        [Fact]
+        public void NegativeOneInt16Test() => TestConstant<short>(Vector512<short>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt32Test() => TestConstant<int>(Vector512<int>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt64Test() => TestConstant<long>(Vector512<long>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSByteTest() => TestConstant<sbyte>(Vector512<sbyte>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSingleTest() => TestConstant(Vector512<float>.NegativeOne, -1.0f);
+
+        [Fact]
+        public void NegativeZeroDoubleTest() => TestConstant(Vector512<double>.NegativeZero, double.NegativeZero);
+
+        [Fact]
+        public void NegativeZeroSingleTest() => TestConstant(Vector512<float>.NegativeZero, float.NegativeZero);
+
+        [Fact]
+        public void PiDoubleTest() => TestConstant(Vector512<double>.Pi, double.Pi);
+
+        [Fact]
+        public void PiSingleTest() => TestConstant(Vector512<float>.Pi, float.Pi);
+
+        [Fact]
+        public void PositiveInfinityDoubleTest() => TestConstant(Vector512<double>.PositiveInfinity, double.PositiveInfinity);
+
+        [Fact]
+        public void PositiveInfinitySingleTest() => TestConstant(Vector512<float>.PositiveInfinity, float.PositiveInfinity);
+
+        [Fact]
+        public void TauDoubleTest() => TestConstant(Vector512<double>.Tau, double.Tau);
+
+        [Fact]
+        public void TauSingleTest() => TestConstant(Vector512<float>.Tau, float.Tau);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector512<double> actual, double expected)
+        {
+            for (int i = 0; i < Vector512<double>.Count; i++)
+            {
+                if (double.IsNaN(expected))
+                {
+                    Assert.True(double.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector512<float> actual, float expected)
+        {
+            for (int i = 0; i < Vector512<float>.Count; i++)
+            {
+                if (float.IsNaN(expected))
+                {
+                    Assert.True(float.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant<T>(Vector512<T> actual, T expected)
+            where T : IBinaryInteger<T>
+        {
+            for (int i = 0; i < Vector512<T>.Count; i++)
+            {
+                Assert.Equal(expected, actual[i]);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
index 94965ae1a919a0..1184256bc4ac04 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
@@ -4243,14 +4243,14 @@ public void Vector64Int64IndexerTest(params long[] values)
         [Fact]
         public void Vector64DoubleEqualsNaNTest()
         {
-            Vector64<double> nan = Vector64.Create(double.NaN);
+            Vector64<double> nan = Vector64<double>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
         [Fact]
         public void Vector64SingleEqualsNaNTest()
         {
-            Vector64<float> nan = Vector64.Create(float.NaN);
+            Vector64<float> nan = Vector64<float>.NaN;
             Assert.True(nan.Equals(nan));
         }
 
@@ -6199,5 +6199,113 @@ public void SubtractSaturateSByteTest()
 
         [Fact]
         public void SubtractSaturateUIntPtrTest() => SubtractSaturateToMinTest<nuint>(1);
+
+        [Fact]
+        public void EDoubleTest() => TestConstant(Vector64<double>.E, double.E);
+
+        [Fact]
+        public void ESingleTest() => TestConstant(Vector64<float>.E, float.E);
+
+        [Fact]
+        public void EpsilonDoubleTest() => TestConstant(Vector64<double>.Epsilon, double.Epsilon);
+
+        [Fact]
+        public void EpsilonSingleTest() => TestConstant(Vector64<float>.Epsilon, float.Epsilon);
+
+        [Fact]
+        public void NaNDoubleTest() => TestConstant(Vector64<double>.NaN, double.NaN);
+
+        [Fact]
+        public void NaNSingleTest() => TestConstant(Vector64<float>.NaN, float.NaN);
+
+        [Fact]
+        public void NegativeInfinityDoubleTest() => TestConstant(Vector64<double>.NegativeInfinity, double.NegativeInfinity);
+
+        [Fact]
+        public void NegativeInfinitySingleTest() => TestConstant(Vector64<float>.NegativeInfinity, float.NegativeInfinity);
+
+        [Fact]
+        public void NegativeOneDoubleTest() => TestConstant(Vector64<double>.NegativeOne, -1.0);
+
+        [Fact]
+        public void NegativeOneInt16Test() => TestConstant<short>(Vector64<short>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt32Test() => TestConstant<int>(Vector64<int>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneInt64Test() => TestConstant<long>(Vector64<long>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSByteTest() => TestConstant<sbyte>(Vector64<sbyte>.NegativeOne, -1);
+
+        [Fact]
+        public void NegativeOneSingleTest() => TestConstant(Vector64<float>.NegativeOne, -1.0f);
+
+        [Fact]
+        public void NegativeZeroDoubleTest() => TestConstant(Vector64<double>.NegativeZero, double.NegativeZero);
+
+        [Fact]
+        public void NegativeZeroSingleTest() => TestConstant(Vector64<float>.NegativeZero, float.NegativeZero);
+
+        [Fact]
+        public void PiDoubleTest() => TestConstant(Vector64<double>.Pi, double.Pi);
+
+        [Fact]
+        public void PiSingleTest() => TestConstant(Vector64<float>.Pi, float.Pi);
+
+        [Fact]
+        public void PositiveInfinityDoubleTest() => TestConstant(Vector64<double>.PositiveInfinity, double.PositiveInfinity);
+
+        [Fact]
+        public void PositiveInfinitySingleTest() => TestConstant(Vector64<float>.PositiveInfinity, float.PositiveInfinity);
+
+        [Fact]
+        public void TauDoubleTest() => TestConstant(Vector64<double>.Tau, double.Tau);
+
+        [Fact]
+        public void TauSingleTest() => TestConstant(Vector64<float>.Tau, float.Tau);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector64<double> actual, double expected)
+        {
+            for (int i = 0; i < Vector64<double>.Count; i++)
+            {
+                if (double.IsNaN(expected))
+                {
+                    Assert.True(double.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.DoubleToInt64Bits(expected), BitConverter.DoubleToInt64Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant(Vector64<float> actual, float expected)
+        {
+            for (int i = 0; i < Vector64<float>.Count; i++)
+            {
+                if (float.IsNaN(expected))
+                {
+                    Assert.True(float.IsNaN(actual[i]));
+                }
+                else
+                {
+                    Assert.Equal(BitConverter.SingleToInt32Bits(expected), BitConverter.SingleToInt32Bits(actual[i]));
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void TestConstant<T>(Vector64<T> actual, T expected)
+            where T : IBinaryInteger<T>
+        {
+            for (int i = 0; i < Vector64<T>.Count; i++)
+            {
+                Assert.Equal(expected, actual[i]);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs
index d8d4cfc87d4af7..cb529221bf2e61 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Wasm/PackedSimdTests.cs
@@ -416,7 +416,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest()
             // Edge cases for signed bytes
             var sbMax = Vector128.Create(sbyte.MaxValue);
             var sbMin = Vector128.Create(sbyte.MinValue);
-            var sbOne = Vector128.Create((sbyte)1);
+            var sbOne = Vector128<sbyte>.One;
 
             var sbOverflow = PackedSimd.AddSaturate(sbMax, sbOne);
             var sbUnderflow = PackedSimd.SubtractSaturate(sbMin, sbOne);
@@ -427,7 +427,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest()
             // Edge cases for unsigned bytes
             var bMax = Vector128.Create(byte.MaxValue);
             var bMin = Vector128.Create(byte.MinValue);
-            var bOne = Vector128.Create((byte)1);
+            var bOne = Vector128<byte>.One;
 
             var bOverflow = PackedSimd.AddSaturate(bMax, bOne);
             var bUnderflow = PackedSimd.SubtractSaturate(bMin, bOne);
@@ -438,7 +438,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest()
             // Edge cases for signed shorts
             var shortMax = Vector128.Create(short.MaxValue);
             var shortMin = Vector128.Create(short.MinValue);
-            var shortOne = Vector128.Create((short)1);
+            var shortOne = Vector128<short>.One;
 
             var shortOverflow = PackedSimd.AddSaturate(shortMax, shortOne);
             var shortUnderflow = PackedSimd.SubtractSaturate(shortMin, shortOne);
@@ -449,7 +449,7 @@ public unsafe void SaturatingArithmeticEdgeCasesTest()
             // Edge cases for unsigned shorts
             var ushortMax = Vector128.Create(ushort.MaxValue);
             var ushortMin = Vector128.Create(ushort.MinValue);
-            var ushortOne = Vector128.Create((ushort)1);
+            var ushortOne = Vector128<ushort>.One;
 
             var ushortOverflow = PackedSimd.AddSaturate(ushortMax, ushortOne);
             var ushortUnderflow = PackedSimd.SubtractSaturate(ushortMin, ushortOne);
@@ -929,4 +929,4 @@ public unsafe void BitmaskTest()
             Assert.Equal(v128emsb_i, (uint)bitmask_i);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/tests/Directory.Build.props b/src/tests/Directory.Build.props
index 604e7fc6f20b0a..136b5db5ae4eb0 100644
--- a/src/tests/Directory.Build.props
+++ b/src/tests/Directory.Build.props
@@ -8,12 +8,6 @@
   <Import Project="$(MSBuildThisFileDirectory)\Common\dir.sdkbuild.props" Condition="'$(UsingMicrosoftNETSdk)' == 'true'"  />
   <Import Project="$(MSBuildThisFileDirectory)\Common\dir.common.props" Condition="'$(UsingMicrosoftNETSdk)' != 'true'"  />
 
-  <PropertyGroup>
-    <!-- Override the compiler version with a private build that supports runtime-async -->
-    <MicrosoftNetCompilersToolsetVersion>5.0.0-1.25259.6</MicrosoftNetCompilersToolsetVersion>
-    <RoslynCompilerType>Custom</RoslynCompilerType>
-  </PropertyGroup>
-
   <PropertyGroup>
     <RunningOnUnix Condition="('$(RunningOnUnix)' == '') And ('$(MSBuildRuntimeType)' == 'Core') And ('$(OS)'!='Windows_NT')">true</RunningOnUnix>
   </PropertyGroup>
diff --git a/src/tests/JIT/Directed/StructABI/structreturn.cs b/src/tests/JIT/Directed/StructABI/structreturn.cs
index 4f9108f5e29224..6807420addbc40 100644
--- a/src/tests/JIT/Directed/StructABI/structreturn.cs
+++ b/src/tests/JIT/Directed/StructABI/structreturn.cs
@@ -1411,13 +1411,13 @@ static void TestReturnVectorT()
     [MethodImpl(MethodImplOptions.NoInlining)]
     static Vector64<int> ReturnVector64Int()
     {
-        return System.Runtime.Intrinsics.Vector64.Create(1);
+        return System.Runtime.Intrinsics.Vector64<int>.One;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     static Vector64<double> ReturnVector64Double()
     {
-        return System.Runtime.Intrinsics.Vector64.Create(1.0);
+        return System.Runtime.Intrinsics.Vector64<double>.One;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -1426,9 +1426,9 @@ static Vector64<int> ReturnVector64IntWithMerge(int v)
         switch (v)
         {
             case 0:
-                return System.Runtime.Intrinsics.Vector64.Create(0);
+                return System.Runtime.Intrinsics.Vector64<int>.Zero;
             case 1:
-                return System.Runtime.Intrinsics.Vector64.Create(1);
+                return System.Runtime.Intrinsics.Vector64<int>.One;
             case 2:
                 return System.Runtime.Intrinsics.Vector64.Create(2);
             case 3:
@@ -1458,13 +1458,13 @@ static void TestReturnVector64(int v)
     [MethodImpl(MethodImplOptions.NoInlining)]
     static Vector128<int> ReturnVector128Int()
     {
-        return System.Runtime.Intrinsics.Vector128.Create(1);
+        return System.Runtime.Intrinsics.Vector128<int>.One;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     static Vector128<double> ReturnVector128Double()
     {
-        return System.Runtime.Intrinsics.Vector128.Create(1.0);
+        return System.Runtime.Intrinsics.Vector128<double>.One;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -1473,9 +1473,9 @@ static Vector128<int> ReturnVector128IntWithMerge(int v)
         switch (v)
         {
             case 0:
-                return System.Runtime.Intrinsics.Vector128.Create(0);
+                return System.Runtime.Intrinsics.Vector128<int>.Zero;
             case 1:
-                return System.Runtime.Intrinsics.Vector128.Create(1);
+                return System.Runtime.Intrinsics.Vector128<int>.One;
             case 2:
                 return System.Runtime.Intrinsics.Vector128.Create(2);
             case 3:
@@ -1505,13 +1505,13 @@ static void TestReturnVector128(int v)
     [MethodImpl(MethodImplOptions.NoInlining)]
     static Vector256<int> ReturnVector256Int()
     {
-        return System.Runtime.Intrinsics.Vector256.Create(1);
+        return System.Runtime.Intrinsics.Vector256<int>.One;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     static Vector256<double> ReturnVector256Double()
     {
-        return System.Runtime.Intrinsics.Vector256.Create(1.0);
+        return System.Runtime.Intrinsics.Vector256<double>.One;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -1520,9 +1520,9 @@ static Vector256<int> ReturnVector256IntWithMerge(int v)
         switch (v)
         {
             case 0:
-                return System.Runtime.Intrinsics.Vector256.Create(0);
+                return System.Runtime.Intrinsics.Vector256<int>.Zero;
             case 1:
-                return System.Runtime.Intrinsics.Vector256.Create(1);
+                return System.Runtime.Intrinsics.Vector256<int>.One;
             case 2:
                 return System.Runtime.Intrinsics.Vector256.Create(2);
             case 3:
diff --git a/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs b/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs
index c167bec8ae77dd..326b825a9ba809 100644
--- a/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs
+++ b/src/tests/JIT/HardwareIntrinsics/General/HwiOp/CompareVectorWithZero.cs
@@ -13,16 +13,16 @@ public class CompareVectorWithZero
     public static void TestVector64Equality()
     {
         TestEquality(Vector64.Create(0));
-        TestEquality(Vector64.Create(0.0f));
-        TestEquality(Vector64.Create(-0.0f));
-        TestEquality(Vector64.Create(0.0));
-        TestEquality(Vector64.Create(-0.0));
+        TestEquality(Vector64<float>.Zero);
+        TestEquality(Vector64<float>.NegativeZero);
+        TestEquality(Vector64<double>.Zero);
+        TestEquality(Vector64<double>.NegativeZero);
 
         TestEqualityUsingReversedInputs(Vector64.Create(0));
-        TestEqualityUsingReversedInputs(Vector64.Create(0.0f));
-        TestEqualityUsingReversedInputs(Vector64.Create(-0.0f));
-        TestEqualityUsingReversedInputs(Vector64.Create(0.0));
-        TestEqualityUsingReversedInputs(Vector64.Create(-0.0));
+        TestEqualityUsingReversedInputs(Vector64<float>.Zero);
+        TestEqualityUsingReversedInputs(Vector64<float>.NegativeZero);
+        TestEqualityUsingReversedInputs(Vector64<double>.Zero);
+        TestEqualityUsingReversedInputs(Vector64<double>.NegativeZero);
 
         TestEquality(Vector64.Create(-10));
         TestEquality(Vector64.Create(10));
@@ -32,16 +32,16 @@ public static void TestVector64Equality()
         TestEquality(Vector64.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestEqualityUsingAnd(Vector64.Create(0), Vector64.Create(0));
-        TestEqualityUsingAnd(Vector64.Create(0.0f), Vector64.Create(0.0f));
-        TestEqualityUsingAnd(Vector64.Create(-0.0f), Vector64.Create(-0.0f));
-        TestEqualityUsingAnd(Vector64.Create(0.0), Vector64.Create(0.0));
-        TestEqualityUsingAnd(Vector64.Create(-0.0), Vector64.Create(-0.0));
+        TestEqualityUsingAnd(Vector64<float>.Zero, Vector64<float>.Zero);
+        TestEqualityUsingAnd(Vector64<float>.NegativeZero, Vector64<float>.NegativeZero);
+        TestEqualityUsingAnd(Vector64<double>.Zero, Vector64<double>.Zero);
+        TestEqualityUsingAnd(Vector64<double>.NegativeZero, Vector64<double>.NegativeZero);
 
         TestEqualityUsingAndNot(Vector64.Create(0), Vector64.Create(0));
-        TestEqualityUsingAndNot(Vector64.Create(0.0f), Vector64.Create(0.0f));
-        TestEqualityUsingAndNot(Vector64.Create(-0.0f), Vector64.Create(-0.0f));
-        TestEqualityUsingAndNot(Vector64.Create(0.0), Vector64.Create(0.0));
-        TestEqualityUsingAndNot(Vector64.Create(-0.0), Vector64.Create(-0.0));
+        TestEqualityUsingAndNot(Vector64<float>.Zero, Vector64<float>.Zero);
+        TestEqualityUsingAndNot(Vector64<float>.NegativeZero, Vector64<float>.NegativeZero);
+        TestEqualityUsingAndNot(Vector64<double>.Zero, Vector64<double>.Zero);
+        TestEqualityUsingAndNot(Vector64<double>.NegativeZero, Vector64<double>.NegativeZero);
 
         TestEquality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0));
         TestEquality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0));
@@ -58,16 +58,16 @@ public static void TestVector64Equality()
     public static void TestVector128Equality()
     {
         TestEquality(Vector128.Create(0));
-        TestEquality(Vector128.Create(0.0f));
-        TestEquality(Vector128.Create(-0.0f));
-        TestEquality(Vector128.Create(0.0));
-        TestEquality(Vector128.Create(-0.0));
+        TestEquality(Vector128<float>.Zero);
+        TestEquality(Vector128<float>.NegativeZero);
+        TestEquality(Vector128<double>.Zero);
+        TestEquality(Vector128<double>.NegativeZero);
 
         TestEqualityUsingReversedInputs(Vector128.Create(0));
-        TestEqualityUsingReversedInputs(Vector128.Create(0.0f));
-        TestEqualityUsingReversedInputs(Vector128.Create(-0.0f));
-        TestEqualityUsingReversedInputs(Vector128.Create(0.0));
-        TestEqualityUsingReversedInputs(Vector128.Create(-0.0));
+        TestEqualityUsingReversedInputs(Vector128<float>.Zero);
+        TestEqualityUsingReversedInputs(Vector128<float>.NegativeZero);
+        TestEqualityUsingReversedInputs(Vector128<double>.Zero);
+        TestEqualityUsingReversedInputs(Vector128<double>.NegativeZero);
 
         TestEquality(Vector128.Create(-10));
         TestEquality(Vector128.Create(10));
@@ -77,16 +77,16 @@ public static void TestVector128Equality()
         TestEquality(Vector128.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestEqualityUsingAnd(Vector128.Create(0), Vector128.Create(0));
-        TestEqualityUsingAnd(Vector128.Create(0.0f), Vector128.Create(0.0f));
-        TestEqualityUsingAnd(Vector128.Create(-0.0f), Vector128.Create(-0.0f));
-        TestEqualityUsingAnd(Vector128.Create(0.0), Vector128.Create(0.0));
-        TestEqualityUsingAnd(Vector128.Create(-0.0), Vector128.Create(-0.0));
+        TestEqualityUsingAnd(Vector128<float>.Zero, Vector128<float>.Zero);
+        TestEqualityUsingAnd(Vector128<float>.NegativeZero, Vector128<float>.NegativeZero);
+        TestEqualityUsingAnd(Vector128<double>.Zero, Vector128<double>.Zero);
+        TestEqualityUsingAnd(Vector128<double>.NegativeZero, Vector128<double>.NegativeZero);
 
         TestEqualityUsingAndNot(Vector128.Create(0), Vector128.Create(0));
-        TestEqualityUsingAndNot(Vector128.Create(0.0f), Vector128.Create(0.0f));
-        TestEqualityUsingAndNot(Vector128.Create(-0.0f), Vector128.Create(-0.0f));
-        TestEqualityUsingAndNot(Vector128.Create(0.0), Vector128.Create(0.0));
-        TestEqualityUsingAndNot(Vector128.Create(-0.0), Vector128.Create(-0.0));
+        TestEqualityUsingAndNot(Vector128<float>.Zero, Vector128<float>.Zero);
+        TestEqualityUsingAndNot(Vector128<float>.NegativeZero, Vector128<float>.NegativeZero);
+        TestEqualityUsingAndNot(Vector128<double>.Zero, Vector128<double>.Zero);
+        TestEqualityUsingAndNot(Vector128<double>.NegativeZero, Vector128<double>.NegativeZero);
 
         TestEquality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0));
         TestEquality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0));
@@ -103,16 +103,16 @@ public static void TestVector128Equality()
     public static void TestVector256Equality()
     {
         TestEquality(Vector256.Create(0));
-        TestEquality(Vector256.Create(0.0f));
-        TestEquality(Vector256.Create(-0.0f));
-        TestEquality(Vector256.Create(0.0));
-        TestEquality(Vector256.Create(-0.0));
+        TestEquality(Vector256<float>.Zero);
+        TestEquality(Vector256<float>.NegativeZero);
+        TestEquality(Vector256<double>.Zero);
+        TestEquality(Vector256<double>.NegativeZero);
 
         TestEqualityUsingReversedInputs(Vector256.Create(0));
-        TestEqualityUsingReversedInputs(Vector256.Create(0.0f));
-        TestEqualityUsingReversedInputs(Vector256.Create(-0.0f));
-        TestEqualityUsingReversedInputs(Vector256.Create(0.0));
-        TestEqualityUsingReversedInputs(Vector256.Create(-0.0));
+        TestEqualityUsingReversedInputs(Vector256<float>.Zero);
+        TestEqualityUsingReversedInputs(Vector256<float>.NegativeZero);
+        TestEqualityUsingReversedInputs(Vector256<double>.Zero);
+        TestEqualityUsingReversedInputs(Vector256<double>.NegativeZero);
 
         TestEquality(Vector256.Create(-10));
         TestEquality(Vector256.Create(10));
@@ -122,16 +122,16 @@ public static void TestVector256Equality()
         TestEquality(Vector256.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestEqualityUsingAnd(Vector256.Create(0), Vector256.Create(0));
-        TestEqualityUsingAnd(Vector256.Create(0.0f), Vector256.Create(0.0f));
-        TestEqualityUsingAnd(Vector256.Create(-0.0f), Vector256.Create(-0.0f));
-        TestEqualityUsingAnd(Vector256.Create(0.0), Vector256.Create(0.0));
-        TestEqualityUsingAnd(Vector256.Create(-0.0), Vector256.Create(-0.0));
+        TestEqualityUsingAnd(Vector256<float>.Zero, Vector256<float>.Zero);
+        TestEqualityUsingAnd(Vector256<float>.NegativeZero, Vector256<float>.NegativeZero);
+        TestEqualityUsingAnd(Vector256<double>.Zero, Vector256<double>.Zero);
+        TestEqualityUsingAnd(Vector256<double>.NegativeZero, Vector256<double>.NegativeZero);
 
         TestEqualityUsingAndNot(Vector256.Create(0), Vector256.Create(0));
-        TestEqualityUsingAndNot(Vector256.Create(0.0f), Vector256.Create(0.0f));
-        TestEqualityUsingAndNot(Vector256.Create(-0.0f), Vector256.Create(-0.0f));
-        TestEqualityUsingAndNot(Vector256.Create(0.0), Vector256.Create(0.0));
-        TestEqualityUsingAndNot(Vector256.Create(-0.0), Vector256.Create(-0.0));
+        TestEqualityUsingAndNot(Vector256<float>.Zero, Vector256<float>.Zero);
+        TestEqualityUsingAndNot(Vector256<float>.NegativeZero, Vector256<float>.NegativeZero);
+        TestEqualityUsingAndNot(Vector256<double>.Zero, Vector256<double>.Zero);
+        TestEqualityUsingAndNot(Vector256<double>.NegativeZero, Vector256<double>.NegativeZero);
     }
 
     [ActiveIssue("https://github.com/dotnet/runtime/pull/65632#issuecomment-1046294324", TestRuntimes.Mono)]
@@ -139,16 +139,16 @@ public static void TestVector256Equality()
     public static void TestVector512Equality()
     {
         TestEquality(Vector512.Create(0));
-        TestEquality(Vector512.Create(0.0f));
-        TestEquality(Vector512.Create(-0.0f));
-        TestEquality(Vector512.Create(0.0));
-        TestEquality(Vector512.Create(-0.0));
+        TestEquality(Vector512<float>.Zero);
+        TestEquality(Vector512<float>.NegativeZero);
+        TestEquality(Vector512<double>.Zero);
+        TestEquality(Vector512<double>.NegativeZero);
 
         TestEqualityUsingReversedInputs(Vector512.Create(0));
-        TestEqualityUsingReversedInputs(Vector512.Create(0.0f));
-        TestEqualityUsingReversedInputs(Vector512.Create(-0.0f));
-        TestEqualityUsingReversedInputs(Vector512.Create(0.0));
-        TestEqualityUsingReversedInputs(Vector512.Create(-0.0));
+        TestEqualityUsingReversedInputs(Vector512<float>.Zero);
+        TestEqualityUsingReversedInputs(Vector512<float>.NegativeZero);
+        TestEqualityUsingReversedInputs(Vector512<double>.Zero);
+        TestEqualityUsingReversedInputs(Vector512<double>.NegativeZero);
 
         TestEquality(Vector512.Create(-10));
         TestEquality(Vector512.Create(10));
@@ -158,16 +158,16 @@ public static void TestVector512Equality()
         TestEquality(Vector512.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestEqualityUsingAnd(Vector512.Create(0), Vector512.Create(0));
-        TestEqualityUsingAnd(Vector512.Create(0.0f), Vector512.Create(0.0f));
-        TestEqualityUsingAnd(Vector512.Create(-0.0f), Vector512.Create(-0.0f));
-        TestEqualityUsingAnd(Vector512.Create(0.0), Vector512.Create(0.0));
-        TestEqualityUsingAnd(Vector512.Create(-0.0), Vector512.Create(-0.0));
+        TestEqualityUsingAnd(Vector512<float>.Zero, Vector512<float>.Zero);
+        TestEqualityUsingAnd(Vector512<float>.NegativeZero, Vector512<float>.NegativeZero);
+        TestEqualityUsingAnd(Vector512<double>.Zero, Vector512<double>.Zero);
+        TestEqualityUsingAnd(Vector512<double>.NegativeZero, Vector512<double>.NegativeZero);
 
         TestEqualityUsingAndNot(Vector512.Create(0), Vector512.Create(0));
-        TestEqualityUsingAndNot(Vector512.Create(0.0f), Vector512.Create(0.0f));
-        TestEqualityUsingAndNot(Vector512.Create(-0.0f), Vector512.Create(-0.0f));
-        TestEqualityUsingAndNot(Vector512.Create(0.0), Vector512.Create(0.0));
-        TestEqualityUsingAndNot(Vector512.Create(-0.0), Vector512.Create(-0.0));
+        TestEqualityUsingAndNot(Vector512<float>.Zero, Vector512<float>.Zero);
+        TestEqualityUsingAndNot(Vector512<float>.NegativeZero, Vector512<float>.NegativeZero);
+        TestEqualityUsingAndNot(Vector512<double>.Zero, Vector512<double>.Zero);
+        TestEqualityUsingAndNot(Vector512<double>.NegativeZero, Vector512<double>.NegativeZero);
     }
 
     [ActiveIssue("https://github.com/dotnet/runtime/pull/65632#issuecomment-1046294324", TestRuntimes.Mono)]
@@ -175,16 +175,16 @@ public static void TestVector512Equality()
     public static void TestVector64Inequality()
     {
         TestInequality(Vector64.Create(0));
-        TestInequality(Vector64.Create(0.0f));
-        TestInequality(Vector64.Create(-0.0f));
-        TestInequality(Vector64.Create(0.0));
-        TestInequality(Vector64.Create(-0.0));
+        TestInequality(Vector64<float>.Zero);
+        TestInequality(Vector64<float>.NegativeZero);
+        TestInequality(Vector64<double>.Zero);
+        TestInequality(Vector64<double>.NegativeZero);
 
         TestInequalityUsingReversedInputs(Vector64.Create(0));
-        TestInequalityUsingReversedInputs(Vector64.Create(0.0f));
-        TestInequalityUsingReversedInputs(Vector64.Create(-0.0f));
-        TestInequalityUsingReversedInputs(Vector64.Create(0.0));
-        TestInequalityUsingReversedInputs(Vector64.Create(-0.0));
+        TestInequalityUsingReversedInputs(Vector64<float>.Zero);
+        TestInequalityUsingReversedInputs(Vector64<float>.NegativeZero);
+        TestInequalityUsingReversedInputs(Vector64<double>.Zero);
+        TestInequalityUsingReversedInputs(Vector64<double>.NegativeZero);
 
         TestInequality(Vector64.Create(-10));
         TestInequality(Vector64.Create(10));
@@ -194,16 +194,16 @@ public static void TestVector64Inequality()
         TestInequality(Vector64.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestInequalityUsingAnd(Vector64.Create(0), Vector64.Create(0));
-        TestInequalityUsingAnd(Vector64.Create(0.0f), Vector64.Create(0.0f));
-        TestInequalityUsingAnd(Vector64.Create(-0.0f), Vector64.Create(-0.0f));
-        TestInequalityUsingAnd(Vector64.Create(0.0), Vector64.Create(0.0));
-        TestInequalityUsingAnd(Vector64.Create(-0.0), Vector64.Create(-0.0));
+        TestInequalityUsingAnd(Vector64<float>.Zero, Vector64<float>.Zero);
+        TestInequalityUsingAnd(Vector64<float>.NegativeZero, Vector64<float>.NegativeZero);
+        TestInequalityUsingAnd(Vector64<double>.Zero, Vector64<double>.Zero);
+        TestInequalityUsingAnd(Vector64<double>.NegativeZero, Vector64<double>.NegativeZero);
 
         TestInequalityUsingAndNot(Vector64.Create(0), Vector64.Create(0));
-        TestInequalityUsingAndNot(Vector64.Create(0.0f), Vector64.Create(0.0f));
-        TestInequalityUsingAndNot(Vector64.Create(-0.0f), Vector64.Create(-0.0f));
-        TestInequalityUsingAndNot(Vector64.Create(0.0), Vector64.Create(0.0));
-        TestInequalityUsingAndNot(Vector64.Create(-0.0), Vector64.Create(-0.0));
+        TestInequalityUsingAndNot(Vector64<float>.Zero, Vector64<float>.Zero);
+        TestInequalityUsingAndNot(Vector64<float>.NegativeZero, Vector64<float>.NegativeZero);
+        TestInequalityUsingAndNot(Vector64<double>.Zero, Vector64<double>.Zero);
+        TestInequalityUsingAndNot(Vector64<double>.NegativeZero, Vector64<double>.NegativeZero);
 
         TestInequality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0));
         TestInequality(Vector64.Create(0, 0, 0, 0, 0, 0, -1, 0));
@@ -220,16 +220,16 @@ public static void TestVector64Inequality()
     public static void TestVector128Inequality()
     {
         TestInequality(Vector128.Create(0));
-        TestInequality(Vector128.Create(0.0f));
-        TestInequality(Vector128.Create(-0.0f));
-        TestInequality(Vector128.Create(0.0));
-        TestInequality(Vector128.Create(-0.0));
+        TestInequality(Vector128<float>.Zero);
+        TestInequality(Vector128<float>.NegativeZero);
+        TestInequality(Vector128<double>.Zero);
+        TestInequality(Vector128<double>.NegativeZero);
 
         TestInequalityUsingReversedInputs(Vector128.Create(0));
-        TestInequalityUsingReversedInputs(Vector128.Create(0.0f));
-        TestInequalityUsingReversedInputs(Vector128.Create(-0.0f));
-        TestInequalityUsingReversedInputs(Vector128.Create(0.0));
-        TestInequalityUsingReversedInputs(Vector128.Create(-0.0));
+        TestInequalityUsingReversedInputs(Vector128<float>.Zero);
+        TestInequalityUsingReversedInputs(Vector128<float>.NegativeZero);
+        TestInequalityUsingReversedInputs(Vector128<double>.Zero);
+        TestInequalityUsingReversedInputs(Vector128<double>.NegativeZero);
 
         TestInequality(Vector128.Create(-10));
         TestInequality(Vector128.Create(10));
@@ -239,16 +239,16 @@ public static void TestVector128Inequality()
         TestInequality(Vector128.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestInequalityUsingAnd(Vector128.Create(0), Vector128.Create(0));
-        TestInequalityUsingAnd(Vector128.Create(0.0f), Vector128.Create(0.0f));
-        TestInequalityUsingAnd(Vector128.Create(-0.0f), Vector128.Create(-0.0f));
-        TestInequalityUsingAnd(Vector128.Create(0.0), Vector128.Create(0.0));
-        TestInequalityUsingAnd(Vector128.Create(-0.0), Vector128.Create(-0.0));
+        TestInequalityUsingAnd(Vector128<float>.Zero, Vector128<float>.Zero);
+        TestInequalityUsingAnd(Vector128<float>.NegativeZero, Vector128<float>.NegativeZero);
+        TestInequalityUsingAnd(Vector128<double>.Zero, Vector128<double>.Zero);
+        TestInequalityUsingAnd(Vector128<double>.NegativeZero, Vector128<double>.NegativeZero);
 
         TestInequalityUsingAndNot(Vector128.Create(0), Vector128.Create(0));
-        TestInequalityUsingAndNot(Vector128.Create(0.0f), Vector128.Create(0.0f));
-        TestInequalityUsingAndNot(Vector128.Create(-0.0f), Vector128.Create(-0.0f));
-        TestInequalityUsingAndNot(Vector128.Create(0.0), Vector128.Create(0.0));
-        TestInequalityUsingAndNot(Vector128.Create(-0.0), Vector128.Create(-0.0));
+        TestInequalityUsingAndNot(Vector128<float>.Zero, Vector128<float>.Zero);
+        TestInequalityUsingAndNot(Vector128<float>.NegativeZero, Vector128<float>.NegativeZero);
+        TestInequalityUsingAndNot(Vector128<double>.Zero, Vector128<double>.Zero);
+        TestInequalityUsingAndNot(Vector128<double>.NegativeZero, Vector128<double>.NegativeZero);
 
         TestInequality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0));
         TestInequality(Vector128.Create(0, 0, 0, 0, 0, 0, 1, 0));
@@ -265,16 +265,16 @@ public static void TestVector128Inequality()
     public static void TestVector256Inequality()
     {
         TestInequality(Vector256.Create(0));
-        TestInequality(Vector256.Create(0.0f));
-        TestInequality(Vector256.Create(-0.0f));
-        TestInequality(Vector256.Create(0.0));
-        TestInequality(Vector256.Create(-0.0));
+        TestInequality(Vector256<float>.Zero);
+        TestInequality(Vector256<float>.NegativeZero);
+        TestInequality(Vector256<double>.Zero);
+        TestInequality(Vector256<double>.NegativeZero);
 
         TestInequalityUsingReversedInputs(Vector256.Create(0));
-        TestInequalityUsingReversedInputs(Vector256.Create(0.0f));
-        TestInequalityUsingReversedInputs(Vector256.Create(-0.0f));
-        TestInequalityUsingReversedInputs(Vector256.Create(0.0));
-        TestInequalityUsingReversedInputs(Vector256.Create(-0.0));
+        TestInequalityUsingReversedInputs(Vector256<float>.Zero);
+        TestInequalityUsingReversedInputs(Vector256<float>.NegativeZero);
+        TestInequalityUsingReversedInputs(Vector256<double>.Zero);
+        TestInequalityUsingReversedInputs(Vector256<double>.NegativeZero);
 
         TestInequality(Vector256.Create(-10));
         TestInequality(Vector256.Create(10));
@@ -284,16 +284,16 @@ public static void TestVector256Inequality()
         TestInequality(Vector256.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestInequalityUsingAnd(Vector256.Create(0), Vector256.Create(0));
-        TestInequalityUsingAnd(Vector256.Create(0.0f), Vector256.Create(0.0f));
-        TestInequalityUsingAnd(Vector256.Create(-0.0f), Vector256.Create(-0.0f));
-        TestInequalityUsingAnd(Vector256.Create(0.0), Vector256.Create(0.0));
-        TestInequalityUsingAnd(Vector256.Create(-0.0), Vector256.Create(-0.0));
+        TestInequalityUsingAnd(Vector256<float>.Zero, Vector256<float>.Zero);
+        TestInequalityUsingAnd(Vector256<float>.NegativeZero, Vector256<float>.NegativeZero);
+        TestInequalityUsingAnd(Vector256<double>.Zero, Vector256<double>.Zero);
+        TestInequalityUsingAnd(Vector256<double>.NegativeZero, Vector256<double>.NegativeZero);
 
         TestInequalityUsingAndNot(Vector256.Create(0), Vector256.Create(0));
-        TestInequalityUsingAndNot(Vector256.Create(0.0f), Vector256.Create(0.0f));
-        TestInequalityUsingAndNot(Vector256.Create(-0.0f), Vector256.Create(-0.0f));
-        TestInequalityUsingAndNot(Vector256.Create(0.0), Vector256.Create(0.0));
-        TestInequalityUsingAndNot(Vector256.Create(-0.0), Vector256.Create(-0.0));
+        TestInequalityUsingAndNot(Vector256<float>.Zero, Vector256<float>.Zero);
+        TestInequalityUsingAndNot(Vector256<float>.NegativeZero, Vector256<float>.NegativeZero);
+        TestInequalityUsingAndNot(Vector256<double>.Zero, Vector256<double>.Zero);
+        TestInequalityUsingAndNot(Vector256<double>.NegativeZero, Vector256<double>.NegativeZero);
     }
 
     [ActiveIssue("https://github.com/dotnet/runtime/pull/65632#issuecomment-1046294324", TestRuntimes.Mono)]
@@ -301,16 +301,16 @@ public static void TestVector256Inequality()
     public static void TestVector512Inequality()
     {
         TestInequality(Vector512.Create(0));
-        TestInequality(Vector512.Create(0.0f));
-        TestInequality(Vector512.Create(-0.0f));
-        TestInequality(Vector512.Create(0.0));
-        TestInequality(Vector512.Create(-0.0));
+        TestInequality(Vector512<float>.Zero);
+        TestInequality(Vector512<float>.NegativeZero);
+        TestInequality(Vector512<double>.Zero);
+        TestInequality(Vector512<double>.NegativeZero);
 
         TestInequalityUsingReversedInputs(Vector512.Create(0));
-        TestInequalityUsingReversedInputs(Vector512.Create(0.0f));
-        TestInequalityUsingReversedInputs(Vector512.Create(-0.0f));
-        TestInequalityUsingReversedInputs(Vector512.Create(0.0));
-        TestInequalityUsingReversedInputs(Vector512.Create(-0.0));
+        TestInequalityUsingReversedInputs(Vector512<float>.Zero);
+        TestInequalityUsingReversedInputs(Vector512<float>.NegativeZero);
+        TestInequalityUsingReversedInputs(Vector512<double>.Zero);
+        TestInequalityUsingReversedInputs(Vector512<double>.NegativeZero);
 
         TestInequality(Vector512.Create(-10));
         TestInequality(Vector512.Create(10));
@@ -320,16 +320,16 @@ public static void TestVector512Inequality()
         TestInequality(Vector512.Create(0, 0, 0, 0, 0, 0, 0, -1));
 
         TestInequalityUsingAnd(Vector512.Create(0), Vector512.Create(0));
-        TestInequalityUsingAnd(Vector512.Create(0.0f), Vector512.Create(0.0f));
-        TestInequalityUsingAnd(Vector512.Create(-0.0f), Vector512.Create(-0.0f));
-        TestInequalityUsingAnd(Vector512.Create(0.0), Vector512.Create(0.0));
-        TestInequalityUsingAnd(Vector512.Create(-0.0), Vector512.Create(-0.0));
+        TestInequalityUsingAnd(Vector512<float>.Zero, Vector512<float>.Zero);
+        TestInequalityUsingAnd(Vector512<float>.NegativeZero, Vector512<float>.NegativeZero);
+        TestInequalityUsingAnd(Vector512<double>.Zero, Vector512<double>.Zero);
+        TestInequalityUsingAnd(Vector512<double>.NegativeZero, Vector512<double>.NegativeZero);
 
         TestInequalityUsingAndNot(Vector512.Create(0), Vector512.Create(0));
-        TestInequalityUsingAndNot(Vector512.Create(0.0f), Vector512.Create(0.0f));
-        TestInequalityUsingAndNot(Vector512.Create(-0.0f), Vector512.Create(-0.0f));
-        TestInequalityUsingAndNot(Vector512.Create(0.0), Vector512.Create(0.0));
-        TestInequalityUsingAndNot(Vector512.Create(-0.0), Vector512.Create(-0.0));
+        TestInequalityUsingAndNot(Vector512<float>.Zero, Vector512<float>.Zero);
+        TestInequalityUsingAndNot(Vector512<float>.NegativeZero, Vector512<float>.NegativeZero);
+        TestInequalityUsingAndNot(Vector512<double>.Zero, Vector512<double>.Zero);
+        TestInequalityUsingAndNot(Vector512<double>.NegativeZero, Vector512<double>.NegativeZero);
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
diff --git a/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs b/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs
index c9c68fbfcc4e68..9b57cb689cd84a 100644
--- a/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs
+++ b/src/tests/JIT/HardwareIntrinsics/X86/General/VectorRet.cs
@@ -273,7 +273,7 @@ public static unsafe int Vector128ReturnTest()
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
     public static Vector128<short> GetVector128Int16One()
     {
-        return Vector128.Create((short)1);
+        return Vector128<short>.One;
     }
 
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
@@ -350,7 +350,7 @@ public static unsafe int Vector256ReturnTest()
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
     public static Vector256<int> GetVector256Int32One()
     {
-        return Vector256.Create(1);
+        return Vector256<int>.One;
     }
 
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs
index 197151b371a241..ce42ec5eeb9f36 100644
--- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs
+++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073.cs
@@ -26,873 +26,873 @@ public static void Test()
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedNotEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedNotEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThan_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThan_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedLessThanOrEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThan_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarOrderedGreaterThanOrEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedNotEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThan_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThan_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedLessThanOrEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThan_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0f), Vector128.Create(42.0f)));
         r &= !Sse.IsSupported || Check(true, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(41.0f)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128.Create(float.NaN)));
-        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(float.NaN), Vector128.Create(float.NaN)));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0f), Vector128<float>.NaN));
+        r &= !Sse.IsSupported || Check(false, Test_Sse_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128<float>.NaN, Vector128<float>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Normal(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_LogicalNot(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(41.0), Vector128.Create(42.0)));
         r &= !Sse2.IsSupported || Check(true, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(41.0)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128.Create(double.NaN)));
-        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(double.NaN), Vector128.Create(double.NaN)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128.Create(42.0), Vector128<double>.NaN));
+        r &= !Sse2.IsSupported || Check(false, Test_Sse2_CompareScalarUnorderedGreaterThanOrEqual_Branch_Swap(Vector128<double>.NaN, Vector128<double>.NaN));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Normal(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Normal(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Normal(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Branch(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Branch(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Branch(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestZ_LogicalNot_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestZ_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Swap(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Swap(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Normal(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Normal(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Normal(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Normal(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Normal(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Normal(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Branch(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Branch(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Branch(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Branch(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Branch(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Branch(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Swap(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Normal(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Branch(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Sse41.IsSupported || Check(false, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Sse41.IsSupported || Check(true, Test_Sse41_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(0), Vector128.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(1), Vector128.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128<int>.Zero, Vector128<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128<int>.One, Vector128.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(2), Vector128.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector128.Create(3), Vector128.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(0), Vector256.Create(0)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(1), Vector256.Create(2)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256<int>.Zero, Vector256<int>.Zero));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256<int>.One, Vector256.Create(2)));
         r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(2), Vector256.Create(3)));
         r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Swap(Vector256.Create(3), Vector256.Create(2)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.Create(1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128.Create(-1.0f), Vector128.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.Create(1.0f), Vector256.Create(-1.0f)));
-        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256.Create(-1.0f), Vector256.Create(-1.0f)));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Normal(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Normal(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Branch(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Branch(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_Swap(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_Swap(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestZ_LogicalNot_Branch_Swap(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Normal(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Normal(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Branch(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Branch(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_Swap(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_Swap(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestC_LogicalNot_Branch_Swap(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128<float>.One, Vector128<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128<float>.One, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector128<float>.NegativeOne, Vector128<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Normal(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Branch(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(false, Test_Avx_TestNotZAndNotC_Swap(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256<float>.One, Vector256<float>.One));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256<float>.One, Vector256<float>.NegativeOne));
+        r &= !Avx.IsSupported || Check(true, Test_Avx_TestNotZAndNotC_LogicalNot_Branch_Swap(Vector256<float>.NegativeOne, Vector256<float>.NegativeOne));
         Assert.True(r);
     }
 
diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx
index 99f4f5cbd7d16c..3b606cef64b446 100644
--- a/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx
+++ b/src/tests/JIT/HardwareIntrinsics/X86/Regression/GitHub_17073/GitHub_17073_gen.csx
@@ -168,15 +168,25 @@ void GeneratePackedDoubleTestTests(List<Test> tests)
 static string CreateVector(int vectorSize, string vectorElementType, double value)
 {
     if (vectorElementType == "Single")
-        return double.IsNaN(value) ? $"Vector{vectorSize}.Create(float.NaN)" : $"Vector{vectorSize}.Create({value:F1}f)";
+        return double.IsNaN(value) ? $"Vector{vectorSize}<float>.NaN" :
+               (value == 0.0f) && float.IsPositive(value) ? $"Vector{vectorSize}<float>.Zero" :
+               (value == 1.0f) ? $"Vector{vectorSize}<float>.One" :
+               (value == -1.0f) ? $"Vector{vectorSize}<float>.NegativeOne" :
+               $"Vector{vectorSize}.Create({value:F1}f)";
     if (vectorElementType == "Double")
-        return double.IsNaN(value) ? $"Vector{vectorSize}.Create(double.NaN)" : $"Vector{vectorSize}.Create({value:F1})";
+        return double.IsNaN(value) ? $"Vector{vectorSize}<double>.NaN" :
+               (value == 0.0) && double.IsPositive(value) ? $"Vector{vectorSize}<double>.Zero" :
+               (value == 1.0) ? $"Vector{vectorSize}<double>.One" :
+               (value == -1.0) ? $"Vector{vectorSize}<double>.NegativeOne" :
+               $"Vector{vectorSize}.Create({value:F1})";
     throw new NotSupportedException();
 }
 
 static string CreateVector(int vectorSize, int value)
 {
-    return $"Vector{vectorSize}.Create({value})";
+    return (value == 0) ? $"Vector{vectorSize}<int>.Zero" :
+           (value == 1) ? $"Vector{vectorSize}<int>.One" :
+           $"Vector{vectorSize}.Create({value})";
 }
 
 static string CreateVector<T>(int vectorSize, string vectorElementType, T value)
diff --git a/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs b/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs
index 248adb877dd226..f023ac405e4711 100644
--- a/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs
+++ b/src/tests/JIT/Performance/CodeQuality/BilinearInterpol/BilinearInterpol.cs
@@ -35,7 +35,7 @@ public class BilinearTest
     const int lengthB = 500;
     const double deltaB = (maxXB - minXB) / (double)(lengthB - 1);
 
-    //ref values 
+    //ref values
     double[] A, B, input, output;
 
     internal void Setup()
@@ -229,7 +229,7 @@ private static unsafe double[] BilinearInterpol_AVX(
 
             Vector128<int> ALengthMinusOne = Vector128.Create(A.Length - 1);
             Vector128<int> BLengthMinusOne = Vector128.Create(B.Length - 1);
-            Vector128<int> One = Vector128.Create(1);
+            Vector128<int> One = Vector128<int>.One;
 
             for (var i = 0; i < x.Length; i += Vector256<double>.Count)
             {
diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs
index 0c73f35070df1d..31edb364ccfab0 100644
--- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs
+++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Camera.cs
@@ -18,7 +18,7 @@ internal class Camera
     public static Camera Create(VectorPacket256 pos, VectorPacket256 lookAt)
     {
         VectorPacket256 forward = (lookAt - pos).Normalize();
-        VectorPacket256 down = new VectorPacket256(Vector256<float>.Zero, Vector256.Create(-1.0f), Vector256<float>.Zero);
+        VectorPacket256 down = new VectorPacket256(Vector256<float>.Zero, Vector256<float>.NegativeOne, Vector256<float>.Zero);
         Vector256<float> OnePointFive = Vector256.Create(1.5f);
         VectorPacket256 right = OnePointFive * VectorPacket256.CrossProduct(forward, down).Normalize();
         VectorPacket256 up = OnePointFive * VectorPacket256.CrossProduct(forward, right).Normalize();
diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs
index 8feb8acdaff83a..30a5de46e307a2 100644
--- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs
+++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Intersections.cs
@@ -15,7 +15,7 @@ internal struct Intersections
     public Vector256<int> ThingIndices;
 
     public static readonly Vector256<float> NullDistance = Vector256.Create(float.MaxValue);
-    public static readonly Vector256<int> NullIndex = Vector256.Create(-1);
+    public static readonly Vector256<int> NullIndex = Vector256<int>.NegativeOne;
 
     public Intersections(Vector256<float> dis, Vector256<int> things)
     {
diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs
index 093eea990c2174..036c474a425167 100644
--- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs
+++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/PacketTracer.cs
@@ -53,7 +53,7 @@ internal unsafe void RenderVectorized(Scene scene, int* rgb)
                     Store(output + 8, intAoS.Gs);
                     Store(output + 16, intAoS.Bs);
                 }
-                
+
             }
         }
 
@@ -226,7 +226,7 @@ private static Scene CreateDefaultScene()
     {
         ObjectPacket256[] things = {
             new SpherePacket256(new VectorPacket256(-0.5f, 1f, 1.5f), Vector256.Create(0.5f), Surfaces.MatteShiny),
-            new SpherePacket256(new VectorPacket256(0f, 1f, -0.25f), Vector256.Create(1f), Surfaces.Shiny),
+            new SpherePacket256(new VectorPacket256(0f, 1f, -0.25f), Vector256<float>.One, Surfaces.Shiny),
             new PlanePacket256((new VectorPacket256(0, 1, 0)), Vector256.Create(0f), Surfaces.CheckerBoard)
         };
 
diff --git a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs
index 1bbca5db7246ed..e044ed6b47e04b 100644
--- a/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs
+++ b/src/tests/JIT/Performance/CodeQuality/HWIntrinsic/X86/PacketTracer/Surfaces.cs
@@ -20,7 +20,7 @@ internal static class Surfaces
             delegate (VectorPacket256 pos)
             {
                 var floored = ConvertToVector256Int32(Add(Floor(pos.Zs), Floor(pos.Xs)));
-                var modMask = Vector256.Create(1);
+                var modMask = Vector256<int>.One;
                 var evenMaskint = Avx2.And(floored, modMask);
                 var evenMask = Avx2.CompareEqual(evenMaskint, modMask);
 
@@ -34,7 +34,7 @@ internal static class Surfaces
             delegate (VectorPacket256 pos)
             {
                 var floored = ConvertToVector256Int32(Add(Floor(pos.Zs), Floor(pos.Xs)));
-                var modMask = Vector256.Create(1);
+                var modMask = Vector256<int>.One;
                 var evenMaskUint = Avx2.And(floored, modMask);
                 var evenMask = Avx2.CompareEqual(evenMaskUint, modMask);
 
diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs b/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs
index 0031ad6a0d7ac7..f7104c2bc3f43a 100644
--- a/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs
+++ b/src/tests/JIT/Regression/JitBlue/GitHub_19583/GitHub_19583.cs
@@ -78,7 +78,7 @@ public static unsafe int Run()
             if (!Sse2.IsSupported) return 0;
 
             vec v = new vec();
-            Vector128<int> o = Vector128.Create(1);
+            Vector128<int> o = Vector128<int>.One;
             int vr16 = v.y;
             Sse2.Store(&v.x, o);
             return vr16;
diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs b/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs
index 0c77aad1b94a82..dd9fb3a02f9b8d 100644
--- a/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs
+++ b/src/tests/JIT/Regression/JitBlue/GitHub_23530/GitHub_23530.cs
@@ -25,7 +25,7 @@ struct vec
         static unsafe float fmaTest()
         {
             vec a;
-            var b = Vector128.Create(1f);
+            var b = Vector128<float>.One;
             var c = Vector128.Create(2f);
             var d = Vector128.Create(3f);
 
diff --git a/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs b/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs
index 27fbc9ffa31b5c..ac92f6a355c7b5 100644
--- a/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs
+++ b/src/tests/JIT/Regression/JitBlue/ImageSharp_2117/ImageSharp_2117.cs
@@ -12,7 +12,7 @@ public static int TestEntryPoint()
     {
         if (Sse.IsSupported)
         {
-            Vector128<float> fnan = Vector128.Create(float.NaN);
+            Vector128<float> fnan = Vector128<float>.NaN;
             Vector128<float> res1 = Sse.Max(Sse.LoadVector128((float*)(&fnan)), Vector128<float>.Zero);
             Vector128<float> res2 = Sse.Min(Sse.LoadVector128((float*)(&fnan)), Vector128<float>.Zero);
 
@@ -24,7 +24,7 @@ public static int TestEntryPoint()
 
         if (Sse2.IsSupported)
         {
-            Vector128<double> dnan = Vector128.Create(double.NaN);
+            Vector128<double> dnan = Vector128<double>.NaN;
             Vector128<double> res3 = Sse2.Max(Sse2.LoadVector128((double*)(&dnan)), Vector128<double>.Zero);
             Vector128<double> res4 = Sse2.Min(Sse2.LoadVector128((double*)(&dnan)), Vector128<double>.Zero);
 
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs b/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs
index a92d32daed0c61..75c7df4d0af5b0 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_106546/Runtime_106546.cs
@@ -124,4 +124,4 @@ private unsafe void GatherMaskVector256()
             Console.WriteLine(Avx2.GatherMaskVector256(source, ptr, indices, mask, 7));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs b/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs
index fdbd8b2821109d..22143cef52afef 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_108609/Runtime_108609.cs
@@ -32,7 +32,7 @@ public struct S1
     static Vector128<short> s_v128_short_31 = Vector128.Create(0, 2, -5, 0, 1, 0, 2, 2);
     static Vector128<ulong> s_v128_ulong_36 = Vector128<ulong>.Zero;
     static Vector128<double> s_v128_double_38 = Vector128.Create(1.0769230769230769, 72.01666666666667);
-    static Vector<ulong> s_v_ulong_46 = Vector.Create((ulong)1);
+    static Vector<ulong> s_v_ulong_46 = Vector<ulong>.One;
     static Vector<float> s_v_float_47 = Vector<float>.Zero;
     static S1 s_s1_52 = new S1();
     char char_56 = 'K';
@@ -42,7 +42,7 @@ public struct S1
     Vector128<sbyte> v128_sbyte_80 = Vector128.Create(-2, -2, -1, 0, 5, -1, -1, -1, 1, 2, -1, 0, -1, 72, -5, 0);
     Vector128<short> v128_short_81 = Vector128.CreateScalar((short)-1);
     Vector128<ulong> v128_ulong_86 = Vector128<ulong>.AllBitsSet;
-    Vector<ulong> v_ulong_96 = Vector.Create((ulong)1);
+    Vector<ulong> v_ulong_96 = Vector<ulong>.One;
     Vector<float> v_float_97 = Vector.Create(2f);
     Vector3 v3_100 = Vector3.Create(0.09090909f, 2.4f, -0.94f);
     S1 s1_102 = new S1();
@@ -86,13 +86,13 @@ private void Method0()
             return;
         }
     }
-    
+
     [Fact]
     public static void TestEntryPoint()
     {
         Antigen();
     }
-    
+
     private static int Antigen()
     {
         new Runtime_108609().Method0();
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs
index f6f1d600fb5509..c503442ee12329 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs
@@ -686,28 +686,28 @@ static int Tests_AdvSimd()
 
         // Begin CompareGreaterThan Tests
 
-        if (!ValidateResult_Vector64<byte>(AdvSimd_CompareGreaterThan_Vector64_Byte_Zero(Vector64.Create((byte)1)), Byte.MaxValue))
+        if (!ValidateResult_Vector64<byte>(AdvSimd_CompareGreaterThan_Vector64_Byte_Zero(Vector64<byte>.One), Byte.MaxValue))
             result = -1;
 
-        if (!ValidateResult_Vector64<float>(AdvSimd_CompareGreaterThan_Vector64_Single_Zero(Vector64.Create(1.0f)), Single.NaN))
+        if (!ValidateResult_Vector64<float>(AdvSimd_CompareGreaterThan_Vector64_Single_Zero(Vector64<float>.One), Single.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector128<byte>(AdvSimd_CompareGreaterThan_Vector128_Byte_Zero(Vector128.Create((byte)1)), Byte.MaxValue))
+        if (!ValidateResult_Vector128<byte>(AdvSimd_CompareGreaterThan_Vector128_Byte_Zero(Vector128<byte>.One), Byte.MaxValue))
             result = -1;
 
-        if (!ValidateResult_Vector128<float>(AdvSimd_CompareGreaterThan_Vector128_Single_Zero(Vector128.Create(1.0f)), Single.NaN))
+        if (!ValidateResult_Vector128<float>(AdvSimd_CompareGreaterThan_Vector128_Single_Zero(Vector128<float>.One), Single.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector128<double>(AdvSimd_Arm64_CompareGreaterThan_Vector128_Double_Zero(Vector128.Create(1.0)), Double.NaN))
+        if (!ValidateResult_Vector128<double>(AdvSimd_Arm64_CompareGreaterThan_Vector128_Double_Zero(Vector128<double>.One), Double.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector128<long>(AdvSimd_Arm64_CompareGreaterThan_Vector128_Int64_Zero(Vector128.Create(1L)), -1))
+        if (!ValidateResult_Vector128<long>(AdvSimd_Arm64_CompareGreaterThan_Vector128_Int64_Zero(Vector128<long>.One), -1))
             result = -1;
 
-        if (!ValidateResult_Vector64<double>(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Double_Zero(Vector64.Create(1.0)), Double.NaN))
+        if (!ValidateResult_Vector64<double>(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Double_Zero(Vector64<double>.One), Double.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector64<long>(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Int64_Zero(Vector64.Create(1L)), -1))
+        if (!ValidateResult_Vector64<long>(AdvSimd_Arm64_CompareGreaterThanScalar_Vector64_Int64_Zero(Vector64<long>.One), -1))
             result = -1;
 
         if (ValidateResult_Vector64<byte>(AdvSimd_CompareGreaterThan_Vector64_Byte_Zero(Vector64<byte>.Zero), Byte.MaxValue))
@@ -738,28 +738,28 @@ static int Tests_AdvSimd()
 
         // Begin CompareGreaterThanOrEqual Tests
 
-        if (!ValidateResult_Vector64<byte>(AdvSimd_CompareGreaterThanOrEqual_Vector64_Byte_Zero(Vector64.Create((byte)1)), Byte.MaxValue))
+        if (!ValidateResult_Vector64<byte>(AdvSimd_CompareGreaterThanOrEqual_Vector64_Byte_Zero(Vector64<byte>.One), Byte.MaxValue))
             result = -1;
 
-        if (!ValidateResult_Vector64<float>(AdvSimd_CompareGreaterThanOrEqual_Vector64_Single_Zero(Vector64.Create(1.0f)), Single.NaN))
+        if (!ValidateResult_Vector64<float>(AdvSimd_CompareGreaterThanOrEqual_Vector64_Single_Zero(Vector64<float>.One), Single.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector128<byte>(AdvSimd_CompareGreaterThanOrEqual_Vector128_Byte_Zero(Vector128.Create((byte)1)), Byte.MaxValue))
+        if (!ValidateResult_Vector128<byte>(AdvSimd_CompareGreaterThanOrEqual_Vector128_Byte_Zero(Vector128<byte>.One), Byte.MaxValue))
             result = -1;
 
-        if (!ValidateResult_Vector128<float>(AdvSimd_CompareGreaterThanOrEqual_Vector128_Single_Zero(Vector128.Create(1.0f)), Single.NaN))
+        if (!ValidateResult_Vector128<float>(AdvSimd_CompareGreaterThanOrEqual_Vector128_Single_Zero(Vector128<float>.One), Single.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector128<double>(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Double_Zero(Vector128.Create(1.0)), Double.NaN))
+        if (!ValidateResult_Vector128<double>(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Double_Zero(Vector128<double>.One), Double.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector128<long>(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Int64_Zero(Vector128.Create(1L)), -1))
+        if (!ValidateResult_Vector128<long>(AdvSimd_Arm64_CompareGreaterThanOrEqual_Vector128_Int64_Zero(Vector128<long>.One), -1))
             result = -1;
 
-        if (!ValidateResult_Vector64<double>(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Double_Zero(Vector64.Create(1.0)), Double.NaN))
+        if (!ValidateResult_Vector64<double>(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Double_Zero(Vector64<double>.One), Double.NaN))
             result = -1;
 
-        if (!ValidateResult_Vector64<long>(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Int64_Zero(Vector64.Create(1L)), -1))
+        if (!ValidateResult_Vector64<long>(AdvSimd_Arm64_CompareGreaterThanOrEqualScalar_Vector64_Int64_Zero(Vector64<long>.One), -1))
             result = -1;
 
         if (!ValidateResult_Vector64<byte>(AdvSimd_CompareGreaterThanOrEqual_Vector64_Byte_Zero(Vector64<byte>.Zero), Byte.MaxValue))
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs b/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs
index 5754400fc5ae3c..5f6fbf9396a892 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_39737/Runtime_39737.cs
@@ -10,13 +10,13 @@
 using Xunit;
 
 public class Runtime_39403
-{ 
+{
     [Fact]
     public static void TestEntryPoint()
     {
         if (Sse41.IsSupported)
         {
-            Vector128<int> left = Vector128.Create(1);
+            Vector128<int> left = Vector128<int>.One;
             Vector128<int> right = Vector128.Create(2);
             ref var rightRef = ref right;
             Vector128<int> mask = Vector128.Create(3);
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs b/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs
index 15eaedc71b2089..9cef24567724d2 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_72506/Runtime_72506.cs
@@ -14,25 +14,25 @@ public class Runtime_72506
     public static int TestEntryPoint()
     {
         // float
-        AssertEqual(Vector256.Create(1f).ToString(), "<1, 1, 1, 1, 1, 1, 1, 1>");
+        AssertEqual(Vector256<float>.One.ToString(), "<1, 1, 1, 1, 1, 1, 1, 1>");
         AssertEqual(Vector256.CreateScalar(1f).ToString(), "<1, 0, 0, 0, 0, 0, 0, 0>");
         AssertEqual(Vector256.CreateScalarUnsafe(1f).ToScalar().ToString(), "1");
         AssertEqual(Vector256.Create(0.0f, 1, 2, 3, 4, 5, 6, 7).ToString(), "<0, 1, 2, 3, 4, 5, 6, 7>");
 
         // double
-        AssertEqual(Vector256.Create(1.0).ToString(), "<1, 1, 1, 1>");
+        AssertEqual(Vector256<double>.One.ToString(), "<1, 1, 1, 1>");
         AssertEqual(Vector256.CreateScalar(1.0).ToString(), "<1, 0, 0, 0>");
         AssertEqual(Vector256.CreateScalarUnsafe(1.0).ToScalar().ToString(), "1");
         AssertEqual(Vector256.Create(0.0, 1, 2, 3).ToString(), "<0, 1, 2, 3>");
 
         // ushort
-        AssertEqual(Vector256.Create((ushort)1).ToString(), "<1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1>");
+        AssertEqual(Vector256<ushort>.One.ToString(), "<1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1>");
         AssertEqual(Vector256.CreateScalar((ushort)1).ToString(), "<1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>");
         AssertEqual(Vector256.CreateScalarUnsafe((ushort)1).ToScalar().ToString(), "1");
         AssertEqual(Vector256.Create((ushort)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).ToString(), "<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>");
 
         // long
-        AssertEqual(Vector256.Create((long)1).ToString(), "<1, 1, 1, 1>");
+        AssertEqual(Vector256<long>.One.ToString(), "<1, 1, 1, 1>");
         AssertEqual(Vector256.CreateScalar((long)1).ToString(), "<1, 0, 0, 0>");
         AssertEqual(Vector256.CreateScalarUnsafe((long)1).ToScalar().ToString(), "1");
         AssertEqual(Vector256.Create((long)0, 1, 2, 3).ToString(), "<0, 1, 2, 3>");
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs b/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs
index ce2881a9d67185..d3d523a7f133b9 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_90508/Runtime_90508.cs
@@ -18,7 +18,7 @@ private static Vector128<double> Test2(Vector128<double> v) =>
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     private static Vector128<double> Test3(Vector128<double> v) =>
-        v + Sse3.MoveAndDuplicate(Vector128.Create(1.0));
+        v + Sse3.MoveAndDuplicate(Vector128<double>.One);
 
     [Fact]
     public static int TestEntryPoint()
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs b/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs
index d4035f3de978fc..d3720603279e16 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_91252/Runtime_91252.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 //
-// This test verifies if we correctly value number the operation of 
+// This test verifies if we correctly value number the operation of
 // x ^ x to zero.
 //
 // Found by Antigen
@@ -13,7 +13,7 @@
 public class Issue_91252
 {
     static Vector64<int> s_v64_int_22 = Vector64.Create(-5);
-    Vector64<int> v64_int_72 = Vector64.Create(-1);
+    Vector64<int> v64_int_72 = Vector64<int>.NegativeOne;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public int Repro()
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs b/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs
index 067b25abb8e826..b11b48eae7028a 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_91335/Runtime_91335.cs
@@ -28,7 +28,7 @@ public struct S2
     static Vector128<int> s_v128_int_32 = Vector128.CreateScalar(2);
     static Vector128<uint> s_v128_uint_33 = Vector128.Create((uint)1, 1, 1, 2);
     static Vector128<long> s_v128_long_34 = Vector128.Create(-2, 2);
-    static Vector128<ulong> s_v128_ulong_35 = Vector128.Create((ulong)1);
+    static Vector128<ulong> s_v128_ulong_35 = Vector128<ulong>.One;
     static Vector128<float> s_v128_float_36 = Vector128.CreateScalar(0.1f);
     static Vector128<double> s_v128_double_37 = Vector128.Create(1.0235294117647058, 2);
     static Vector256<byte> s_v256_byte_38 = Vector256.CreateScalar((byte)5);
@@ -41,7 +41,7 @@ public struct S2
     static Vector256<ulong> s_v256_ulong_45 = Vector256<ulong>.Zero;
     static Vector256<float> s_v256_float_46 = Vector256.CreateScalar(-4.969697f);
     static Vector256<double> s_v256_double_47 = Vector256.Create(97.03448275862068);
-    static Vector512<byte> s_v512_byte_48 = Vector512.Create((byte)1);
+    static Vector512<byte> s_v512_byte_48 = Vector512<byte>.One;
     static Vector512<sbyte> s_v512_sbyte_49 = Vector512.Create((sbyte)5);
     static Vector512<short> s_v512_short_50 = Vector512<short>.AllBitsSet;
     static Vector512<ushort> s_v512_ushort_51 = Vector512<ushort>.AllBitsSet;
@@ -75,7 +75,7 @@ public struct S2
     public Vector256<int> Method31()
     {
             byte byte_929 = 2;
-            return s_v256_int_42 += v256_int_101 | v256_int_101 ^ v256_int_101 | 
+            return s_v256_int_42 += v256_int_101 | v256_int_101 ^ v256_int_101 |
                 Vector256<int>.AllBitsSet & s_v256_int_42 ^ (s_v256_int_42 *= v256_int_101) - (v256_int_101 ^ Vector256<int>.Zero) & (v256_int_101 *= v256_int_101) - Avx2.ShiftRightLogical(v256_int_101, byte_929);
     }
 
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs b/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs
index 4704441bacce6c..37a9a3b8154921 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_92357/Runtime_92357.cs
@@ -20,14 +20,14 @@ public static void Problem()
 
         int y1 = 5;
 
-        Vector256<short> actual1 = Test1(Vector256.Create((short)1), ref y1);
+        Vector256<short> actual1 = Test1(Vector256<short>.One, ref y1);
         Vector256<short> expected1 = Vector256.Create(10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0);
 
         Assert.Equal(expected1, actual1);
 
         long y2 = 5;
 
-        Vector256<int> actual2 = Test2(Vector256.Create((int)1), ref y2);
+        Vector256<int> actual2 = Test2(Vector256<int>.One, ref y2);
         Vector256<int> expected2 = Vector256.Create(10, 0, 10, 0, 10, 0, 10, 0);
 
         Assert.Equal(expected2, actual2);
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs b/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs
index 99a5ef2ee5d18d..b010525c692131 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_92590/Runtime_92590.cs
@@ -13,22 +13,22 @@ public static void TestEntryPoint()
     {
         Span<byte> bytes = stackalloc byte[4];
         bytes.Fill(0xff);
-        TestByteByte(ref bytes[0], 0, Vector256.Create((byte)1));
+        TestByteByte(ref bytes[0], 0, Vector256<byte>.One);
 
         Assert.True(bytes.SequenceEqual(stackalloc byte[] { 0x2, 0xff, 0xff, 0xff }));
 
         bytes.Fill(0xff);
-        TestByteInt(ref bytes[0], 0, Vector256.Create(1));
+        TestByteInt(ref bytes[0], 0, Vector256<int>.One);
 
         Assert.True(bytes.SequenceEqual(stackalloc byte[] { 0x2, 0xff, 0xff, 0xff }));
 
         int i = int.MaxValue;
-        TestIntByte(ref i, 0, Vector256.Create((byte)1));
+        TestIntByte(ref i, 0, Vector256<byte>.One);
 
         Assert.Equal(2, i);
 
         i = int.MaxValue;
-        TestIntInt(ref i, 0, Vector256.Create(1));
+        TestIntInt(ref i, 0, Vector256<int>.One);
 
         Assert.Equal(2, i);
     }
diff --git a/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs b/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs
index 3a99365bcce6b9..a711ac9b5e8fea 100644
--- a/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs
+++ b/src/tests/JIT/opt/Loops/LoopSideEffectsForHwiStores.cs
@@ -39,7 +39,7 @@ static unsafe Vector128<int> ProblemWithSse2(ClassWithVtor a, byte* p)
     {
         Vector128<int> vtor = Vector128<int>.Zero;
 
-        a.VtorField = Vector128.Create(1);
+        a.VtorField = Vector128<int>.One;
         a.VtorField = Sse2.Add(a.VtorField, a.VtorField);
 
         for (int i = 0; i < 10; i++)
@@ -56,7 +56,7 @@ static unsafe Vector128<int> ProblemWithAdvSimd(ClassWithVtor a, byte* p)
     {
         Vector128<int> vtor = Vector128<int>.Zero;
 
-        a.VtorField = Vector128.Create(1);
+        a.VtorField = Vector128<int>.One;
         a.VtorField = AdvSimd.Add(a.VtorField, a.VtorField);
 
         for (int i = 0; i < 10; i++)
diff --git a/src/tests/async/Directory.Build.props b/src/tests/async/Directory.Build.props
index faf9886e152c5d..a1f7d48cf60a7d 100644
--- a/src/tests/async/Directory.Build.props
+++ b/src/tests/async/Directory.Build.props
@@ -9,6 +9,7 @@
     <EnableNETAnalyzers>false</EnableNETAnalyzers>
     <Features>$(Features);runtime-async=on</Features>
   </PropertyGroup>
+
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)RuntimeAsyncMethodGenerationAttribute.cs" />
   </ItemGroup>