@tsonic/dotnet 0.5.2 → 0.6.0

package/System.Runtime.Intrinsics/internal/index.d.ts

@@ -39,252 +39,260 @@ export type CLROf<T> =
     T extends string ? System_Internal.String :
     T; // Identity fallback for non-primitive types
 
-export class Vector128_1$instance<T> {
+export class Vector128_1$instance<T> implements IAdditionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IBitwiseOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IDivisionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IEqualityOperators_3<Vector128_1<T>, Vector128_1<T>, CLROf<boolean>>, IMultiplyOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IShiftOperators_3<Vector128_1<T>, CLROf<int>, Vector128_1<T>>, ISubtractionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IUnaryNegationOperators_2<Vector128_1<T>, Vector128_1<T>>, IUnaryPlusOperators_2<Vector128_1<T>, Vector128_1<T>> {
     readonly item: T;
-    equals(obj: any): boolean;
+    equals(obj: unknown): boolean;
     equals(other: Vector128_1<T>): boolean;
     getHashCode(): int;
     toString(): string;
-    static readonly AllBitsSet: unknown;
-    static readonly Count: int;
-    static readonly Indices: unknown;
-    static readonly IsSupported: boolean;
-    static readonly One: unknown;
-    static readonly Zero: unknown;
+    static readonly allBitsSet: unknown;
+    static readonly count: int;
+    static readonly indices: unknown;
+    static readonly isSupported: boolean;
+    static readonly one: unknown;
+    static readonly zero: unknown;
 }
 
 
 export interface __Vector128_1$views<T> {
-    readonly As_IEquatable_1_of_ConsoleKeyInfo: System_Internal.IEquatable_1$instance<Vector128_1<T>>;
+    As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector128_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector128_1<T>): boolean;
 }
 
+export interface Vector128_1$instance<T> extends System_Numerics_Internal.IAdditionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector128_1<T>, Vector128_1<T>, CLROf<boolean>>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector128_1<T>, CLROf<int>, Vector128_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector128_1<T>, Vector128_1<T>> {}
+
 export type Vector128_1<T> = Vector128_1$instance<T> & __Vector128_1$views<T>;
 
 
-export class Vector256_1$instance<T> {
+export class Vector256_1$instance<T> implements IAdditionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IBitwiseOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IDivisionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IEqualityOperators_3<Vector256_1<T>, Vector256_1<T>, CLROf<boolean>>, IMultiplyOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IShiftOperators_3<Vector256_1<T>, CLROf<int>, Vector256_1<T>>, ISubtractionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IUnaryNegationOperators_2<Vector256_1<T>, Vector256_1<T>>, IUnaryPlusOperators_2<Vector256_1<T>, Vector256_1<T>> {
     readonly item: T;
-    equals(obj: any): boolean;
+    equals(obj: unknown): boolean;
     equals(other: Vector256_1<T>): boolean;
     getHashCode(): int;
     toString(): string;
-    static readonly AllBitsSet: unknown;
-    static readonly Count: int;
-    static readonly Indices: unknown;
-    static readonly IsSupported: boolean;
-    static readonly One: unknown;
-    static readonly Zero: unknown;
+    static readonly allBitsSet: unknown;
+    static readonly count: int;
+    static readonly indices: unknown;
+    static readonly isSupported: boolean;
+    static readonly one: unknown;
+    static readonly zero: unknown;
 }
 
 
 export interface __Vector256_1$views<T> {
-    readonly As_IEquatable_1_of_ConsoleKeyInfo: System_Internal.IEquatable_1$instance<Vector256_1<T>>;
+    As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector256_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector256_1<T>): boolean;
 }
 
+export interface Vector256_1$instance<T> extends System_Numerics_Internal.IAdditionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector256_1<T>, Vector256_1<T>, CLROf<boolean>>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector256_1<T>, CLROf<int>, Vector256_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector256_1<T>, Vector256_1<T>> {}
+
 export type Vector256_1<T> = Vector256_1$instance<T> & __Vector256_1$views<T>;
 
 
-export class Vector512_1$instance<T> {
+export class Vector512_1$instance<T> implements IAdditionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IBitwiseOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IDivisionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IEqualityOperators_3<Vector512_1<T>, Vector512_1<T>, CLROf<boolean>>, IMultiplyOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IShiftOperators_3<Vector512_1<T>, CLROf<int>, Vector512_1<T>>, ISubtractionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IUnaryNegationOperators_2<Vector512_1<T>, Vector512_1<T>>, IUnaryPlusOperators_2<Vector512_1<T>, Vector512_1<T>> {
     readonly item: T;
-    equals(obj: any): boolean;
+    equals(obj: unknown): boolean;
     equals(other: Vector512_1<T>): boolean;
     getHashCode(): int;
     toString(): string;
-    static readonly AllBitsSet: unknown;
-    static readonly Count: int;
-    static readonly Indices: unknown;
-    static readonly IsSupported: boolean;
-    static readonly One: unknown;
-    static readonly Zero: unknown;
+    static readonly allBitsSet: unknown;
+    static readonly count: int;
+    static readonly indices: unknown;
+    static readonly isSupported: boolean;
+    static readonly one: unknown;
+    static readonly zero: unknown;
 }
 
 
 export interface __Vector512_1$views<T> {
-    readonly As_IEquatable_1_of_ConsoleKeyInfo: System_Internal.IEquatable_1$instance<Vector512_1<T>>;
+    As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector512_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector512_1<T>): boolean;
 }
 
+export interface Vector512_1$instance<T> extends System_Numerics_Internal.IAdditionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector512_1<T>, Vector512_1<T>, CLROf<boolean>>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector512_1<T>, CLROf<int>, Vector512_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector512_1<T>, Vector512_1<T>> {}
+
 export type Vector512_1<T> = Vector512_1$instance<T> & __Vector512_1$views<T>;
 
 
-export class Vector64_1$instance<T> {
+export class Vector64_1$instance<T> implements IAdditionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IBitwiseOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IDivisionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IEqualityOperators_3<Vector64_1<T>, Vector64_1<T>, CLROf<boolean>>, IMultiplyOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IShiftOperators_3<Vector64_1<T>, CLROf<int>, Vector64_1<T>>, ISubtractionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IUnaryNegationOperators_2<Vector64_1<T>, Vector64_1<T>>, IUnaryPlusOperators_2<Vector64_1<T>, Vector64_1<T>> {
     readonly item: T;
-    equals(obj: any): boolean;
+    equals(obj: unknown): boolean;
     equals(other: Vector64_1<T>): boolean;
     getHashCode(): int;
     toString(): string;
-    static readonly AllBitsSet: unknown;
-    static readonly Count: int;
-    static readonly Indices: unknown;
-    static readonly IsSupported: boolean;
-    static readonly One: unknown;
-    static readonly Zero: unknown;
+    static readonly allBitsSet: unknown;
+    static readonly count: int;
+    static readonly indices: unknown;
+    static readonly isSupported: boolean;
+    static readonly one: unknown;
+    static readonly zero: unknown;
 }
 
 
 export interface __Vector64_1$views<T> {
-    readonly As_IEquatable_1_of_ConsoleKeyInfo: System_Internal.IEquatable_1$instance<Vector64_1<T>>;
+    As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector64_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector64_1<T>): boolean;
 }
 
+export interface Vector64_1$instance<T> extends System_Numerics_Internal.IAdditionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector64_1<T>, Vector64_1<T>, CLROf<boolean>>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector64_1<T>, CLROf<int>, Vector64_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector64_1<T>, Vector64_1<T>> {}
+
 export type Vector64_1<T> = Vector64_1$instance<T> & __Vector64_1$views<T>;
 
 
 export abstract class Vector128$instance {
-    static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static Add<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static AddSaturate<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static All<T>(vector: Vector128_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
-    static AndNot<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Any<T>(vector: Vector128_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector128_1<TFrom>): Vector128_1<TTo>;
-    static AsByte<T>(vector: Vector128_1<T>): Vector128_1<CLROf<byte>>;
-    static AsDouble<T>(vector: Vector128_1<T>): Vector128_1<CLROf<double>>;
-    static AsInt16<T>(vector: Vector128_1<T>): Vector128_1<CLROf<short>>;
-    static AsInt32<T>(vector: Vector128_1<T>): Vector128_1<CLROf<int>>;
-    static AsInt64<T>(vector: Vector128_1<T>): Vector128_1<CLROf<long>>;
-    static AsNInt<T>(vector: Vector128_1<T>): Vector128_1<CLROf<nint>>;
-    static AsNUInt<T>(vector: Vector128_1<T>): Vector128_1<CLROf<nuint>>;
-    static AsPlane(value: Vector128_1<CLROf<float>>): Plane;
-    static AsQuaternion(value: Vector128_1<CLROf<float>>): Quaternion;
-    static AsSByte<T>(vector: Vector128_1<T>): Vector128_1<CLROf<sbyte>>;
-    static AsSingle<T>(vector: Vector128_1<T>): Vector128_1<CLROf<float>>;
-    static AsUInt16<T>(vector: Vector128_1<T>): Vector128_1<CLROf<ushort>>;
-    static AsUInt32<T>(vector: Vector128_1<T>): Vector128_1<CLROf<uint>>;
-    static AsUInt64<T>(vector: Vector128_1<T>): Vector128_1<CLROf<ulong>>;
-    static AsVector<T>(value: Vector128_1<T>): Vector_1<T>;
-    static AsVector128(value: Plane): Vector128_1<CLROf<float>>;
-    static AsVector128(value: Quaternion): Vector128_1<CLROf<float>>;
-    static AsVector128(value: Vector2): Vector128_1<CLROf<float>>;
-    static AsVector128(value: Vector3): Vector128_1<CLROf<float>>;
-    static AsVector128(value: Vector4): Vector128_1<CLROf<float>>;
-    static AsVector128<T>(value: Vector_1<T>): Vector128_1<T>;
-    static AsVector128Unsafe(value: Vector2): Vector128_1<CLROf<float>>;
-    static AsVector128Unsafe(value: Vector3): Vector128_1<CLROf<float>>;
-    static AsVector2(value: Vector128_1<CLROf<float>>): Vector2;
-    static AsVector3(value: Vector128_1<CLROf<float>>): Vector3;
-    static AsVector4(value: Vector128_1<CLROf<float>>): Vector4;
-    static BitwiseAnd<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static BitwiseOr<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Ceiling(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Ceiling(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Clamp<T>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
-    static ClampNative<T>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
-    static ConditionalSelect<T>(condition: Vector128_1<T>, left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static ConvertToDouble(vector: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
-    static ConvertToDouble(vector: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<double>>;
-    static ConvertToInt32(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<int>>;
-    static ConvertToInt32Native(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<int>>;
-    static ConvertToInt64(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<long>>;
-    static ConvertToInt64Native(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<long>>;
-    static ConvertToSingle(vector: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
-    static ConvertToSingle(vector: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<float>>;
-    static ConvertToUInt32(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<uint>>;
-    static ConvertToUInt32Native(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<uint>>;
-    static ConvertToUInt64(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<ulong>>;
-    static ConvertToUInt64Native(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<ulong>>;
-    static CopySign<T>(value: Vector128_1<T>, sign: Vector128_1<T>): Vector128_1<T>;
-    static CopyTo<T>(vector: Vector128_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector128_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector128_1<T>, destination: T[]): void;
-    static Cos(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Cos(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Count<T>(vector: Vector128_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector128_1<T>;
-    static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte): Vector128_1<CLROf<byte>>;
-    static Create(value: byte): Vector128_1<CLROf<byte>>;
-    static Create(e0: double, e1: double): Vector128_1<CLROf<double>>;
-    static Create(value: double): Vector128_1<CLROf<double>>;
-    static Create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short): Vector128_1<CLROf<short>>;
-    static Create(value: short): Vector128_1<CLROf<short>>;
-    static Create(e0: int, e1: int, e2: int, e3: int): Vector128_1<CLROf<int>>;
-    static Create(value: int): Vector128_1<CLROf<int>>;
-    static Create(e0: long, e1: long): Vector128_1<CLROf<long>>;
-    static Create(value: long): Vector128_1<CLROf<long>>;
-    static Create(value: nint): Vector128_1<CLROf<nint>>;
-    static Create(lower: Vector64_1<CLROf<byte>>, upper: Vector64_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
-    static Create(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Create(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector128_1<CLROf<short>>;
-    static Create(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector128_1<CLROf<int>>;
-    static Create(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector128_1<CLROf<long>>;
-    static Create(lower: Vector64_1<CLROf<nint>>, upper: Vector64_1<CLROf<nint>>): Vector128_1<CLROf<nint>>;
-    static Create(lower: Vector64_1<CLROf<sbyte>>, upper: Vector64_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
-    static Create(lower: Vector64_1<CLROf<float>>, upper: Vector64_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Create(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
-    static Create(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
-    static Create(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
-    static Create(lower: Vector64_1<CLROf<nuint>>, upper: Vector64_1<CLROf<nuint>>): Vector128_1<CLROf<nuint>>;
-    static Create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte): Vector128_1<CLROf<sbyte>>;
-    static Create(value: sbyte): Vector128_1<CLROf<sbyte>>;
-    static Create(e0: float, e1: float, e2: float, e3: float): Vector128_1<CLROf<float>>;
-    static Create(value: float): Vector128_1<CLROf<float>>;
-    static Create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort): Vector128_1<CLROf<ushort>>;
-    static Create(value: ushort): Vector128_1<CLROf<ushort>>;
-    static Create(e0: uint, e1: uint, e2: uint, e3: uint): Vector128_1<CLROf<uint>>;
-    static Create(value: uint): Vector128_1<CLROf<uint>>;
-    static Create(e0: ulong, e1: ulong): Vector128_1<CLROf<ulong>>;
-    static Create(value: ulong): Vector128_1<CLROf<ulong>>;
-    static Create(value: nuint): Vector128_1<CLROf<nuint>>;
-    static Create<T>(value: T): Vector128_1<T>;
-    static Create<T>(values: T[], index: int): Vector128_1<T>;
-    static Create<T>(values: T[]): Vector128_1<T>;
-    static Create<T>(lower: Vector64_1<T>, upper: Vector64_1<T>): Vector128_1<T>;
-    static Create<T>(value: Vector64_1<T>): Vector128_1<T>;
-    static CreateScalar(value: byte): Vector128_1<CLROf<byte>>;
-    static CreateScalar(value: double): Vector128_1<CLROf<double>>;
-    static CreateScalar(value: short): Vector128_1<CLROf<short>>;
-    static CreateScalar(value: int): Vector128_1<CLROf<int>>;
-    static CreateScalar(value: long): Vector128_1<CLROf<long>>;
-    static CreateScalar(value: nint): Vector128_1<CLROf<nint>>;
-    static CreateScalar(value: sbyte): Vector128_1<CLROf<sbyte>>;
-    static CreateScalar(value: float): Vector128_1<CLROf<float>>;
-    static CreateScalar(value: ushort): Vector128_1<CLROf<ushort>>;
-    static CreateScalar(value: uint): Vector128_1<CLROf<uint>>;
-    static CreateScalar(value: ulong): Vector128_1<CLROf<ulong>>;
-    static CreateScalar(value: nuint): Vector128_1<CLROf<nuint>>;
-    static CreateScalar<T>(value: T): Vector128_1<T>;
-    static CreateScalarUnsafe(value: byte): Vector128_1<CLROf<byte>>;
-    static CreateScalarUnsafe(value: double): Vector128_1<CLROf<double>>;
-    static CreateScalarUnsafe(value: short): Vector128_1<CLROf<short>>;
-    static CreateScalarUnsafe(value: int): Vector128_1<CLROf<int>>;
-    static CreateScalarUnsafe(value: long): Vector128_1<CLROf<long>>;
-    static CreateScalarUnsafe(value: nint): Vector128_1<CLROf<nint>>;
-    static CreateScalarUnsafe(value: sbyte): Vector128_1<CLROf<sbyte>>;
-    static CreateScalarUnsafe(value: float): Vector128_1<CLROf<float>>;
-    static CreateScalarUnsafe(value: ushort): Vector128_1<CLROf<ushort>>;
-    static CreateScalarUnsafe(value: uint): Vector128_1<CLROf<uint>>;
-    static CreateScalarUnsafe(value: ulong): Vector128_1<CLROf<ulong>>;
-    static CreateScalarUnsafe(value: nuint): Vector128_1<CLROf<nuint>>;
-    static CreateScalarUnsafe<T>(value: T): Vector128_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector128_1<T>;
-    static DegreesToRadians(degrees: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static DegreesToRadians(degrees: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Divide<T>(left: Vector128_1<T>, right: T): Vector128_1<T>;
-    static Divide<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Dot<T>(left: Vector128_1<T>, right: Vector128_1<T>): T;
-    static Equals<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static EqualsAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static EqualsAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static Exp(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Exp(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static ExtractMostSignificantBits<T>(vector: Vector128_1<T>): uint;
-    static Floor(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Floor(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static FusedMultiplyAdd(left: Vector128_1<CLROf<double>>, right: Vector128_1<CLROf<double>>, addend: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static FusedMultiplyAdd(left: Vector128_1<CLROf<float>>, right: Vector128_1<CLROf<float>>, addend: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static readonly isHardwareAccelerated: boolean;
+    static abs<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static add<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static addSaturate<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static all<T>(vector: Vector128_1<T>, value: T): boolean;
+    static allWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
+    static andNot<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static any_<T>(vector: Vector128_1<T>, value: T): boolean;
+    static anyWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
+    static as_<TFrom, TTo>(vector: Vector128_1<TFrom>): Vector128_1<TTo>;
+    static asByte<T>(vector: Vector128_1<T>): Vector128_1<CLROf<byte>>;
+    static asDouble<T>(vector: Vector128_1<T>): Vector128_1<CLROf<double>>;
+    static asInt16<T>(vector: Vector128_1<T>): Vector128_1<CLROf<short>>;
+    static asInt32<T>(vector: Vector128_1<T>): Vector128_1<CLROf<int>>;
+    static asInt64<T>(vector: Vector128_1<T>): Vector128_1<CLROf<long>>;
+    static asNInt<T>(vector: Vector128_1<T>): Vector128_1<CLROf<nint>>;
+    static asNUInt<T>(vector: Vector128_1<T>): Vector128_1<CLROf<nuint>>;
+    static asPlane(value: Vector128_1<CLROf<float>>): Plane;
+    static asQuaternion(value: Vector128_1<CLROf<float>>): Quaternion;
+    static asSByte<T>(vector: Vector128_1<T>): Vector128_1<CLROf<sbyte>>;
+    static asSingle<T>(vector: Vector128_1<T>): Vector128_1<CLROf<float>>;
+    static asUInt16<T>(vector: Vector128_1<T>): Vector128_1<CLROf<ushort>>;
+    static asUInt32<T>(vector: Vector128_1<T>): Vector128_1<CLROf<uint>>;
+    static asUInt64<T>(vector: Vector128_1<T>): Vector128_1<CLROf<ulong>>;
+    static asVector<T>(value: Vector128_1<T>): Vector_1<T>;
+    static asVector128(value: Plane): Vector128_1<CLROf<float>>;
+    static asVector128(value: Quaternion): Vector128_1<CLROf<float>>;
+    static asVector128(value: Vector2): Vector128_1<CLROf<float>>;
+    static asVector128(value: Vector3): Vector128_1<CLROf<float>>;
+    static asVector128(value: Vector4): Vector128_1<CLROf<float>>;
+    static asVector128<T>(value: Vector_1<T>): Vector128_1<T>;
+    static asVector128Unsafe(value: Vector2): Vector128_1<CLROf<float>>;
+    static asVector128Unsafe(value: Vector3): Vector128_1<CLROf<float>>;
+    static asVector2(value: Vector128_1<CLROf<float>>): Vector2;
+    static asVector3(value: Vector128_1<CLROf<float>>): Vector3;
+    static asVector4(value: Vector128_1<CLROf<float>>): Vector4;
+    static bitwiseAnd<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static bitwiseOr<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static ceiling2(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static ceiling2(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static clamp<T>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
+    static clampNative<T>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
+    static conditionalSelect<T>(condition: Vector128_1<T>, left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static convertToDouble(vector: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
+    static convertToDouble(vector: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<double>>;
+    static convertToInt32(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<int>>;
+    static convertToInt32Native(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<int>>;
+    static convertToInt64(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<long>>;
+    static convertToInt64Native(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<long>>;
+    static convertToSingle(vector: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
+    static convertToSingle(vector: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<float>>;
+    static convertToUInt32(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<uint>>;
+    static convertToUInt32Native(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<uint>>;
+    static convertToUInt64(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<ulong>>;
+    static convertToUInt64Native(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<ulong>>;
+    static copySign<T>(value: Vector128_1<T>, sign: Vector128_1<T>): Vector128_1<T>;
+    static copyTo3<T>(vector: Vector128_1<T>, destination: Span_1<T>): void;
+    static copyTo3<T>(vector: Vector128_1<T>, destination: T[], startIndex: int): void;
+    static copyTo3<T>(vector: Vector128_1<T>, destination: T[]): void;
+    static cos(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static cos(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static count<T>(vector: Vector128_1<T>, value: T): int;
+    static countWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
+    static create16<T>(values: ReadOnlySpan_1<T>): Vector128_1<T>;
+    static create16(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte): Vector128_1<CLROf<byte>>;
+    static create16(value: byte): Vector128_1<CLROf<byte>>;
+    static create16(e0: double, e1: double): Vector128_1<CLROf<double>>;
+    static create16(value: double): Vector128_1<CLROf<double>>;
+    static create16(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short): Vector128_1<CLROf<short>>;
+    static create16(value: short): Vector128_1<CLROf<short>>;
+    static create16(e0: int, e1: int, e2: int, e3: int): Vector128_1<CLROf<int>>;
+    static create16(value: int): Vector128_1<CLROf<int>>;
+    static create16(e0: long, e1: long): Vector128_1<CLROf<long>>;
+    static create16(value: long): Vector128_1<CLROf<long>>;
+    static create16(value: nint): Vector128_1<CLROf<nint>>;
+    static create16(lower: Vector64_1<CLROf<byte>>, upper: Vector64_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
+    static create16(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static create16(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector128_1<CLROf<short>>;
+    static create16(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector128_1<CLROf<int>>;
+    static create16(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector128_1<CLROf<long>>;
+    static create16(lower: Vector64_1<CLROf<nint>>, upper: Vector64_1<CLROf<nint>>): Vector128_1<CLROf<nint>>;
+    static create16(lower: Vector64_1<CLROf<sbyte>>, upper: Vector64_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
+    static create16(lower: Vector64_1<CLROf<float>>, upper: Vector64_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static create16(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
+    static create16(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
+    static create16(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
+    static create16(lower: Vector64_1<CLROf<nuint>>, upper: Vector64_1<CLROf<nuint>>): Vector128_1<CLROf<nuint>>;
+    static create16(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte): Vector128_1<CLROf<sbyte>>;
+    static create16(value: sbyte): Vector128_1<CLROf<sbyte>>;
+    static create16(e0: float, e1: float, e2: float, e3: float): Vector128_1<CLROf<float>>;
+    static create16(value: float): Vector128_1<CLROf<float>>;
+    static create16(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort): Vector128_1<CLROf<ushort>>;
+    static create16(value: ushort): Vector128_1<CLROf<ushort>>;
+    static create16(e0: uint, e1: uint, e2: uint, e3: uint): Vector128_1<CLROf<uint>>;
+    static create16(value: uint): Vector128_1<CLROf<uint>>;
+    static create16(e0: ulong, e1: ulong): Vector128_1<CLROf<ulong>>;
+    static create16(value: ulong): Vector128_1<CLROf<ulong>>;
+    static create16(value: nuint): Vector128_1<CLROf<nuint>>;
+    static create16<T>(value: T): Vector128_1<T>;
+    static create16<T>(values: T[], index: int): Vector128_1<T>;
+    static create16<T>(values: T[]): Vector128_1<T>;
+    static create16<T>(lower: Vector64_1<T>, upper: Vector64_1<T>): Vector128_1<T>;
+    static create16<T>(value: Vector64_1<T>): Vector128_1<T>;
+    static createScalar2(value: byte): Vector128_1<CLROf<byte>>;
+    static createScalar2(value: double): Vector128_1<CLROf<double>>;
+    static createScalar2(value: short): Vector128_1<CLROf<short>>;
+    static createScalar2(value: int): Vector128_1<CLROf<int>>;
+    static createScalar2(value: long): Vector128_1<CLROf<long>>;
+    static createScalar2(value: nint): Vector128_1<CLROf<nint>>;
+    static createScalar2(value: sbyte): Vector128_1<CLROf<sbyte>>;
+    static createScalar2(value: float): Vector128_1<CLROf<float>>;
+    static createScalar2(value: ushort): Vector128_1<CLROf<ushort>>;
+    static createScalar2(value: uint): Vector128_1<CLROf<uint>>;
+    static createScalar2(value: ulong): Vector128_1<CLROf<ulong>>;
+    static createScalar2(value: nuint): Vector128_1<CLROf<nuint>>;
+    static createScalar2<T>(value: T): Vector128_1<T>;
+    static createScalarUnsafe2(value: byte): Vector128_1<CLROf<byte>>;
+    static createScalarUnsafe2(value: double): Vector128_1<CLROf<double>>;
+    static createScalarUnsafe2(value: short): Vector128_1<CLROf<short>>;
+    static createScalarUnsafe2(value: int): Vector128_1<CLROf<int>>;
+    static createScalarUnsafe2(value: long): Vector128_1<CLROf<long>>;
+    static createScalarUnsafe2(value: nint): Vector128_1<CLROf<nint>>;
+    static createScalarUnsafe2(value: sbyte): Vector128_1<CLROf<sbyte>>;
+    static createScalarUnsafe2(value: float): Vector128_1<CLROf<float>>;
+    static createScalarUnsafe2(value: ushort): Vector128_1<CLROf<ushort>>;
+    static createScalarUnsafe2(value: uint): Vector128_1<CLROf<uint>>;
+    static createScalarUnsafe2(value: ulong): Vector128_1<CLROf<ulong>>;
+    static createScalarUnsafe2(value: nuint): Vector128_1<CLROf<nuint>>;
+    static createScalarUnsafe2<T>(value: T): Vector128_1<T>;
+    static createSequence<T>(start: T, step: T): Vector128_1<T>;
+    static degreesToRadians(degrees: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static degreesToRadians(degrees: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static divide2<T>(left: Vector128_1<T>, right: T): Vector128_1<T>;
+    static divide2<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static dot<T>(left: Vector128_1<T>, right: Vector128_1<T>): T;
+    static equals<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static equalsAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static equalsAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static exp(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static exp(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static extractMostSignificantBits<T>(vector: Vector128_1<T>): uint;
+    static floor2(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static floor2(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static fusedMultiplyAdd(left: Vector128_1<CLROf<double>>, right: Vector128_1<CLROf<double>>, addend: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static fusedMultiplyAdd(left: Vector128_1<CLROf<float>>, right: Vector128_1<CLROf<float>>, addend: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
     static get_E<T extends IFloatingPointConstants_1<T>>(): Vector128_1<T>;
     static get_Epsilon<T extends IFloatingPointIeee754_1<T>>(): Vector128_1<T>;
     static get_NaN<T extends IFloatingPointIeee754_1<T>>(): Vector128_1<T>;
@@ -294,319 +302,319 @@ export abstract class Vector128$instance {
     static get_Pi<T extends IFloatingPointConstants_1<T>>(): Vector128_1<T>;
     static get_PositiveInfinity<T extends IFloatingPointIeee754_1<T>>(): Vector128_1<T>;
     static get_Tau<T extends IFloatingPointConstants_1<T>>(): Vector128_1<T>;
-    static GetElement<T>(vector: Vector128_1<T>, index: int): T;
-    static GetLower<T>(vector: Vector128_1<T>): Vector64_1<T>;
-    static GetUpper<T>(vector: Vector128_1<T>): Vector64_1<T>;
-    static GreaterThan<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static GreaterThanAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static Hypot(x: Vector128_1<CLROf<double>>, y: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Hypot(x: Vector128_1<CLROf<float>>, y: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static IndexOf<T>(vector: Vector128_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsFinite<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNaN<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNegative<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNormal<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsOddInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsPositive<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsSubnormal<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsZero<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static LastIndexOf<T>(vector: Vector128_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
-    static Lerp(x: Vector128_1<CLROf<double>>, y: Vector128_1<CLROf<double>>, amount: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Lerp(x: Vector128_1<CLROf<float>>, y: Vector128_1<CLROf<float>>, amount: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static LessThan<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static LessThanAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static LessThanAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector128_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector128_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector128_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }, elementOffset: nuint): Vector128_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }): Vector128_1<T>;
-    static Log(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Log(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Log2(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Log2(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Max<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxMagnitude<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxNative<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Min<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinMagnitude<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinNative<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Multiply<T>(left: T, right: Vector128_1<T>): Vector128_1<T>;
-    static Multiply<T>(left: Vector128_1<T>, right: T): Vector128_1<T>;
-    static Multiply<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MultiplyAddEstimate(left: Vector128_1<CLROf<double>>, right: Vector128_1<CLROf<double>>, addend: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static MultiplyAddEstimate(left: Vector128_1<CLROf<float>>, right: Vector128_1<CLROf<float>>, addend: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Narrow(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector128_1<CLROf<float>>;
-    static Narrow(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector128_1<CLROf<sbyte>>;
-    static Narrow(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector128_1<CLROf<short>>;
-    static Narrow(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector128_1<CLROf<int>>;
-    static Narrow(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<byte>>;
-    static Narrow(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ushort>>;
-    static Narrow(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<uint>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector128_1<CLROf<float>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector128_1<CLROf<sbyte>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector128_1<CLROf<short>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector128_1<CLROf<int>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<byte>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ushort>>;
-    static NarrowWithSaturation(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<uint>>;
-    static Negate<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static None<T>(vector: Vector128_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static RadiansToDegrees(radians: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static RadiansToDegrees(radians: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static Round(vector: Vector128_1<CLROf<double>>, mode: MidpointRounding): Vector128_1<CLROf<double>>;
-    static Round(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Round(vector: Vector128_1<CLROf<float>>, mode: MidpointRounding): Vector128_1<CLROf<float>>;
-    static Round(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<byte>>, shiftCount: int): Vector128_1<CLROf<byte>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<ushort>>, shiftCount: int): Vector128_1<CLROf<ushort>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<uint>>, shiftCount: int): Vector128_1<CLROf<uint>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<ulong>>, shiftCount: int): Vector128_1<CLROf<ulong>>;
-    static ShiftLeft(vector: Vector128_1<CLROf<nuint>>, shiftCount: int): Vector128_1<CLROf<nuint>>;
-    static ShiftRightArithmetic(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
-    static ShiftRightArithmetic(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
-    static ShiftRightArithmetic(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
-    static ShiftRightArithmetic(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
-    static ShiftRightArithmetic(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<byte>>, shiftCount: int): Vector128_1<CLROf<byte>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<ushort>>, shiftCount: int): Vector128_1<CLROf<ushort>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<uint>>, shiftCount: int): Vector128_1<CLROf<uint>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<ulong>>, shiftCount: int): Vector128_1<CLROf<ulong>>;
-    static ShiftRightLogical(vector: Vector128_1<CLROf<nuint>>, shiftCount: int): Vector128_1<CLROf<nuint>>;
-    static Shuffle(vector: Vector128_1<CLROf<byte>>, indices: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
-    static Shuffle(vector: Vector128_1<CLROf<double>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
-    static Shuffle(vector: Vector128_1<CLROf<short>>, indices: Vector128_1<CLROf<short>>): Vector128_1<CLROf<short>>;
-    static Shuffle(vector: Vector128_1<CLROf<int>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<int>>;
-    static Shuffle(vector: Vector128_1<CLROf<long>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<long>>;
-    static Shuffle(vector: Vector128_1<CLROf<sbyte>>, indices: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
-    static Shuffle(vector: Vector128_1<CLROf<float>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
-    static Shuffle(vector: Vector128_1<CLROf<ushort>>, indices: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
-    static Shuffle(vector: Vector128_1<CLROf<uint>>, indices: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
-    static Shuffle(vector: Vector128_1<CLROf<ulong>>, indices: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<byte>>, indices: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<double>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<short>>, indices: Vector128_1<CLROf<short>>): Vector128_1<CLROf<short>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<int>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<int>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<long>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<long>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<sbyte>>, indices: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<float>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<ushort>>, indices: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<uint>>, indices: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
-    static ShuffleNative(vector: Vector128_1<CLROf<ulong>>, indices: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
-    static Sin(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Sin(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static SinCos(vector: Vector128_1<CLROf<double>>): ValueTuple_2<Vector128_1<CLROf<double>>, Vector128_1<CLROf<double>>>;
-    static SinCos(vector: Vector128_1<CLROf<float>>): ValueTuple_2<Vector128_1<CLROf<float>>, Vector128_1<CLROf<float>>>;
-    static Sqrt<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static Store<T>(source: Vector128_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector128_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector128_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector128_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector128_1<T>, destination: { value: ref<T> }): void;
-    static Subtract<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static SubtractSaturate<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Sum<T>(vector: Vector128_1<T>): T;
-    static ToScalar<T>(vector: Vector128_1<T>): T;
-    static ToVector256<T>(vector: Vector128_1<T>): Vector256_1<T>;
-    static ToVector256Unsafe<T>(vector: Vector128_1<T>): Vector256_1<T>;
-    static Truncate(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static Truncate(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static TryCopyTo<T>(vector: Vector128_1<T>, destination: Span_1<T>): boolean;
-    static Widen(source: Vector128_1<CLROf<byte>>): ValueTuple_2<Vector128_1<CLROf<ushort>>, Vector128_1<CLROf<ushort>>>;
-    static Widen(source: Vector128_1<CLROf<short>>): ValueTuple_2<Vector128_1<CLROf<int>>, Vector128_1<CLROf<int>>>;
-    static Widen(source: Vector128_1<CLROf<int>>): ValueTuple_2<Vector128_1<CLROf<long>>, Vector128_1<CLROf<long>>>;
-    static Widen(source: Vector128_1<CLROf<sbyte>>): ValueTuple_2<Vector128_1<CLROf<short>>, Vector128_1<CLROf<short>>>;
-    static Widen(source: Vector128_1<CLROf<float>>): ValueTuple_2<Vector128_1<CLROf<double>>, Vector128_1<CLROf<double>>>;
-    static Widen(source: Vector128_1<CLROf<ushort>>): ValueTuple_2<Vector128_1<CLROf<uint>>, Vector128_1<CLROf<uint>>>;
-    static Widen(source: Vector128_1<CLROf<uint>>): ValueTuple_2<Vector128_1<CLROf<ulong>>, Vector128_1<CLROf<ulong>>>;
-    static WidenLower(source: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<ushort>>;
-    static WidenLower(source: Vector128_1<CLROf<short>>): Vector128_1<CLROf<int>>;
-    static WidenLower(source: Vector128_1<CLROf<int>>): Vector128_1<CLROf<long>>;
-    static WidenLower(source: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<short>>;
-    static WidenLower(source: Vector128_1<CLROf<float>>): Vector128_1<CLROf<double>>;
-    static WidenLower(source: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<uint>>;
-    static WidenLower(source: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ulong>>;
-    static WidenUpper(source: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<ushort>>;
-    static WidenUpper(source: Vector128_1<CLROf<short>>): Vector128_1<CLROf<int>>;
-    static WidenUpper(source: Vector128_1<CLROf<int>>): Vector128_1<CLROf<long>>;
-    static WidenUpper(source: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<short>>;
-    static WidenUpper(source: Vector128_1<CLROf<float>>): Vector128_1<CLROf<double>>;
-    static WidenUpper(source: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<uint>>;
-    static WidenUpper(source: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ulong>>;
-    static WithElement<T>(vector: Vector128_1<T>, index: int, value: T): Vector128_1<T>;
-    static WithLower<T>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
-    static WithUpper<T>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
-    static Xor<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static getElement<T>(vector: Vector128_1<T>, index: int): T;
+    static getLower<T>(vector: Vector128_1<T>): Vector64_1<T>;
+    static getUpper<T>(vector: Vector128_1<T>): Vector64_1<T>;
+    static greaterThan<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static greaterThanAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static greaterThanAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static greaterThanOrEqual<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static greaterThanOrEqualAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static greaterThanOrEqualAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static hypot(x: Vector128_1<CLROf<double>>, y: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static hypot(x: Vector128_1<CLROf<float>>, y: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static indexOf<T>(vector: Vector128_1<T>, value: T): int;
+    static indexOfWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
+    static isEvenInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isFinite<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isNaN<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isNegative<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isNegativeInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isNormal<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isOddInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isPositive<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isPositiveInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isSubnormal<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static isZero<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static lastIndexOf<T>(vector: Vector128_1<T>, value: T): int;
+    static lastIndexOfWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
+    static lerp(x: Vector128_1<CLROf<double>>, y: Vector128_1<CLROf<double>>, amount: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static lerp(x: Vector128_1<CLROf<float>>, y: Vector128_1<CLROf<float>>, amount: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static lessThan<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static lessThanAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static lessThanAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static lessThanOrEqual<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static lessThanOrEqualAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static lessThanOrEqualAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static load<T>(source: ptr<T>): Vector128_1<T>;
+    static loadAligned<T>(source: ptr<T>): Vector128_1<T>;
+    static loadAlignedNonTemporal<T>(source: ptr<T>): Vector128_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }, elementOffset: nuint): Vector128_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }): Vector128_1<T>;
+    static log(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static log(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static log22(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static log22(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static max<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static maxMagnitude<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static maxMagnitudeNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static maxNative<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static maxNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static min<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static minMagnitude<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static minMagnitudeNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static minNative<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static minNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static multiply3<T>(left: T, right: Vector128_1<T>): Vector128_1<T>;
+    static multiply3<T>(left: Vector128_1<T>, right: T): Vector128_1<T>;
+    static multiply3<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static multiplyAddEstimate(left: Vector128_1<CLROf<double>>, right: Vector128_1<CLROf<double>>, addend: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static multiplyAddEstimate(left: Vector128_1<CLROf<float>>, right: Vector128_1<CLROf<float>>, addend: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static narrow(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector128_1<CLROf<float>>;
+    static narrow(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector128_1<CLROf<sbyte>>;
+    static narrow(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector128_1<CLROf<short>>;
+    static narrow(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector128_1<CLROf<int>>;
+    static narrow(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<byte>>;
+    static narrow(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ushort>>;
+    static narrow(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<uint>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector128_1<CLROf<float>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector128_1<CLROf<sbyte>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector128_1<CLROf<short>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector128_1<CLROf<int>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<byte>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ushort>>;
+    static narrowWithSaturation(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<uint>>;
+    static negate<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static none<T>(vector: Vector128_1<T>, value: T): boolean;
+    static noneWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
+    static onesComplement<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static radiansToDegrees(radians: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static radiansToDegrees(radians: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static round3(vector: Vector128_1<CLROf<double>>, mode: MidpointRounding): Vector128_1<CLROf<double>>;
+    static round3(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static round3(vector: Vector128_1<CLROf<float>>, mode: MidpointRounding): Vector128_1<CLROf<float>>;
+    static round3(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static shiftLeft(vector: Vector128_1<CLROf<byte>>, shiftCount: int): Vector128_1<CLROf<byte>>;
+    static shiftLeft(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
+    static shiftLeft(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
+    static shiftLeft(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
+    static shiftLeft(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
+    static shiftLeft(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
+    static shiftLeft(vector: Vector128_1<CLROf<ushort>>, shiftCount: int): Vector128_1<CLROf<ushort>>;
+    static shiftLeft(vector: Vector128_1<CLROf<uint>>, shiftCount: int): Vector128_1<CLROf<uint>>;
+    static shiftLeft(vector: Vector128_1<CLROf<ulong>>, shiftCount: int): Vector128_1<CLROf<ulong>>;
+    static shiftLeft(vector: Vector128_1<CLROf<nuint>>, shiftCount: int): Vector128_1<CLROf<nuint>>;
+    static shiftRightArithmetic(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
+    static shiftRightArithmetic(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
+    static shiftRightArithmetic(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
+    static shiftRightArithmetic(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
+    static shiftRightArithmetic(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<byte>>, shiftCount: int): Vector128_1<CLROf<byte>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<ushort>>, shiftCount: int): Vector128_1<CLROf<ushort>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<uint>>, shiftCount: int): Vector128_1<CLROf<uint>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<ulong>>, shiftCount: int): Vector128_1<CLROf<ulong>>;
+    static shiftRightLogical(vector: Vector128_1<CLROf<nuint>>, shiftCount: int): Vector128_1<CLROf<nuint>>;
+    static shuffle(vector: Vector128_1<CLROf<byte>>, indices: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
+    static shuffle(vector: Vector128_1<CLROf<double>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
+    static shuffle(vector: Vector128_1<CLROf<short>>, indices: Vector128_1<CLROf<short>>): Vector128_1<CLROf<short>>;
+    static shuffle(vector: Vector128_1<CLROf<int>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<int>>;
+    static shuffle(vector: Vector128_1<CLROf<long>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<long>>;
+    static shuffle(vector: Vector128_1<CLROf<sbyte>>, indices: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
+    static shuffle(vector: Vector128_1<CLROf<float>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
+    static shuffle(vector: Vector128_1<CLROf<ushort>>, indices: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
+    static shuffle(vector: Vector128_1<CLROf<uint>>, indices: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
+    static shuffle(vector: Vector128_1<CLROf<ulong>>, indices: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
+    static shuffleNative(vector: Vector128_1<CLROf<byte>>, indices: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
+    static shuffleNative(vector: Vector128_1<CLROf<double>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
+    static shuffleNative(vector: Vector128_1<CLROf<short>>, indices: Vector128_1<CLROf<short>>): Vector128_1<CLROf<short>>;
+    static shuffleNative(vector: Vector128_1<CLROf<int>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<int>>;
+    static shuffleNative(vector: Vector128_1<CLROf<long>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<long>>;
+    static shuffleNative(vector: Vector128_1<CLROf<sbyte>>, indices: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
+    static shuffleNative(vector: Vector128_1<CLROf<float>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
+    static shuffleNative(vector: Vector128_1<CLROf<ushort>>, indices: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
+    static shuffleNative(vector: Vector128_1<CLROf<uint>>, indices: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
+    static shuffleNative(vector: Vector128_1<CLROf<ulong>>, indices: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
+    static sin(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static sin(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static sinCos(vector: Vector128_1<CLROf<double>>): ValueTuple_2<Vector128_1<CLROf<double>>, Vector128_1<CLROf<double>>>;
+    static sinCos(vector: Vector128_1<CLROf<float>>): ValueTuple_2<Vector128_1<CLROf<float>>, Vector128_1<CLROf<float>>>;
+    static sqrt<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static store<T>(source: Vector128_1<T>, destination: ptr<T>): void;
+    static storeAligned<T>(source: Vector128_1<T>, destination: ptr<T>): void;
+    static storeAlignedNonTemporal<T>(source: Vector128_1<T>, destination: ptr<T>): void;
+    static storeUnsafe2<T>(source: Vector128_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
+    static storeUnsafe2<T>(source: Vector128_1<T>, destination: { value: ref<T> }): void;
+    static subtract<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static subtractSaturate<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static sum<T>(vector: Vector128_1<T>): T;
+    static toScalar<T>(vector: Vector128_1<T>): T;
+    static toVector256<T>(vector: Vector128_1<T>): Vector256_1<T>;
+    static toVector256Unsafe<T>(vector: Vector128_1<T>): Vector256_1<T>;
+    static truncate(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
+    static truncate(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static tryCopyTo<T>(vector: Vector128_1<T>, destination: Span_1<T>): boolean;
+    static widen(source: Vector128_1<CLROf<byte>>): ValueTuple_2<Vector128_1<CLROf<ushort>>, Vector128_1<CLROf<ushort>>>;
+    static widen(source: Vector128_1<CLROf<short>>): ValueTuple_2<Vector128_1<CLROf<int>>, Vector128_1<CLROf<int>>>;
+    static widen(source: Vector128_1<CLROf<int>>): ValueTuple_2<Vector128_1<CLROf<long>>, Vector128_1<CLROf<long>>>;
+    static widen(source: Vector128_1<CLROf<sbyte>>): ValueTuple_2<Vector128_1<CLROf<short>>, Vector128_1<CLROf<short>>>;
+    static widen(source: Vector128_1<CLROf<float>>): ValueTuple_2<Vector128_1<CLROf<double>>, Vector128_1<CLROf<double>>>;
+    static widen(source: Vector128_1<CLROf<ushort>>): ValueTuple_2<Vector128_1<CLROf<uint>>, Vector128_1<CLROf<uint>>>;
+    static widen(source: Vector128_1<CLROf<uint>>): ValueTuple_2<Vector128_1<CLROf<ulong>>, Vector128_1<CLROf<ulong>>>;
+    static widenLower(source: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<ushort>>;
+    static widenLower(source: Vector128_1<CLROf<short>>): Vector128_1<CLROf<int>>;
+    static widenLower(source: Vector128_1<CLROf<int>>): Vector128_1<CLROf<long>>;
+    static widenLower(source: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<short>>;
+    static widenLower(source: Vector128_1<CLROf<float>>): Vector128_1<CLROf<double>>;
+    static widenLower(source: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<uint>>;
+    static widenLower(source: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ulong>>;
+    static widenUpper(source: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<ushort>>;
+    static widenUpper(source: Vector128_1<CLROf<short>>): Vector128_1<CLROf<int>>;
+    static widenUpper(source: Vector128_1<CLROf<int>>): Vector128_1<CLROf<long>>;
+    static widenUpper(source: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<short>>;
+    static widenUpper(source: Vector128_1<CLROf<float>>): Vector128_1<CLROf<double>>;
+    static widenUpper(source: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<uint>>;
+    static widenUpper(source: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ulong>>;
+    static withElement<T>(vector: Vector128_1<T>, index: int, value: T): Vector128_1<T>;
+    static withLower<T>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
+    static withUpper<T>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
+    static xor<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
 }
 
 
 export type Vector128 = Vector128$instance;
 
 export abstract class Vector256$instance {
-    static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static Add<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static AddSaturate<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static All<T>(vector: Vector256_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
-    static AndNot<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Any<T>(vector: Vector256_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector256_1<TFrom>): Vector256_1<TTo>;
-    static AsByte<T>(vector: Vector256_1<T>): Vector256_1<CLROf<byte>>;
-    static AsDouble<T>(vector: Vector256_1<T>): Vector256_1<CLROf<double>>;
-    static AsInt16<T>(vector: Vector256_1<T>): Vector256_1<CLROf<short>>;
-    static AsInt32<T>(vector: Vector256_1<T>): Vector256_1<CLROf<int>>;
-    static AsInt64<T>(vector: Vector256_1<T>): Vector256_1<CLROf<long>>;
-    static AsNInt<T>(vector: Vector256_1<T>): Vector256_1<CLROf<nint>>;
-    static AsNUInt<T>(vector: Vector256_1<T>): Vector256_1<CLROf<nuint>>;
-    static AsSByte<T>(vector: Vector256_1<T>): Vector256_1<CLROf<sbyte>>;
-    static AsSingle<T>(vector: Vector256_1<T>): Vector256_1<CLROf<float>>;
-    static AsUInt16<T>(vector: Vector256_1<T>): Vector256_1<CLROf<ushort>>;
-    static AsUInt32<T>(vector: Vector256_1<T>): Vector256_1<CLROf<uint>>;
-    static AsUInt64<T>(vector: Vector256_1<T>): Vector256_1<CLROf<ulong>>;
-    static AsVector<T>(value: Vector256_1<T>): Vector_1<T>;
-    static AsVector256<T>(value: Vector_1<T>): Vector256_1<T>;
-    static BitwiseAnd<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static BitwiseOr<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Ceiling(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Ceiling(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Clamp<T>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
-    static ClampNative<T>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
-    static ConditionalSelect<T>(condition: Vector256_1<T>, left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static ConvertToDouble(vector: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
-    static ConvertToDouble(vector: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<double>>;
-    static ConvertToInt32(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<int>>;
-    static ConvertToInt32Native(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<int>>;
-    static ConvertToInt64(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<long>>;
-    static ConvertToInt64Native(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<long>>;
-    static ConvertToSingle(vector: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
-    static ConvertToSingle(vector: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<float>>;
-    static ConvertToUInt32(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<uint>>;
-    static ConvertToUInt32Native(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<uint>>;
-    static ConvertToUInt64(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<ulong>>;
-    static ConvertToUInt64Native(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<ulong>>;
-    static CopySign<T>(value: Vector256_1<T>, sign: Vector256_1<T>): Vector256_1<T>;
-    static CopyTo<T>(vector: Vector256_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector256_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector256_1<T>, destination: T[]): void;
-    static Cos(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Cos(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Count<T>(vector: Vector256_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector256_1<T>;
-    static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte, e16: byte, e17: byte, e18: byte, e19: byte, e20: byte, e21: byte, e22: byte, e23: byte, e24: byte, e25: byte, e26: byte, e27: byte, e28: byte, e29: byte, e30: byte, e31: byte): Vector256_1<CLROf<byte>>;
-    static Create(value: byte): Vector256_1<CLROf<byte>>;
-    static Create(e0: double, e1: double, e2: double, e3: double): Vector256_1<CLROf<double>>;
-    static Create(value: double): Vector256_1<CLROf<double>>;
-    static Create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short): Vector256_1<CLROf<short>>;
-    static Create(value: short): Vector256_1<CLROf<short>>;
-    static Create(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int): Vector256_1<CLROf<int>>;
-    static Create(value: int): Vector256_1<CLROf<int>>;
-    static Create(e0: long, e1: long, e2: long, e3: long): Vector256_1<CLROf<long>>;
-    static Create(value: long): Vector256_1<CLROf<long>>;
-    static Create(value: nint): Vector256_1<CLROf<nint>>;
-    static Create(lower: Vector128_1<CLROf<byte>>, upper: Vector128_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
-    static Create(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Create(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector256_1<CLROf<short>>;
-    static Create(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector256_1<CLROf<int>>;
-    static Create(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector256_1<CLROf<long>>;
-    static Create(lower: Vector128_1<CLROf<nint>>, upper: Vector128_1<CLROf<nint>>): Vector256_1<CLROf<nint>>;
-    static Create(lower: Vector128_1<CLROf<sbyte>>, upper: Vector128_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
-    static Create(lower: Vector128_1<CLROf<float>>, upper: Vector128_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Create(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
-    static Create(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
-    static Create(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
-    static Create(lower: Vector128_1<CLROf<nuint>>, upper: Vector128_1<CLROf<nuint>>): Vector256_1<CLROf<nuint>>;
-    static Create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte): Vector256_1<CLROf<sbyte>>;
-    static Create(value: sbyte): Vector256_1<CLROf<sbyte>>;
-    static Create(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float): Vector256_1<CLROf<float>>;
-    static Create(value: float): Vector256_1<CLROf<float>>;
-    static Create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort): Vector256_1<CLROf<ushort>>;
-    static Create(value: ushort): Vector256_1<CLROf<ushort>>;
-    static Create(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint): Vector256_1<CLROf<uint>>;
-    static Create(value: uint): Vector256_1<CLROf<uint>>;
-    static Create(e0: ulong, e1: ulong, e2: ulong, e3: ulong): Vector256_1<CLROf<ulong>>;
-    static Create(value: ulong): Vector256_1<CLROf<ulong>>;
-    static Create(value: nuint): Vector256_1<CLROf<nuint>>;
-    static Create<T>(value: T): Vector256_1<T>;
-    static Create<T>(values: T[], index: int): Vector256_1<T>;
-    static Create<T>(values: T[]): Vector256_1<T>;
-    static Create<T>(lower: Vector128_1<T>, upper: Vector128_1<T>): Vector256_1<T>;
-    static Create<T>(value: Vector128_1<T>): Vector256_1<T>;
-    static Create<T>(value: Vector64_1<T>): Vector256_1<T>;
-    static CreateScalar(value: byte): Vector256_1<CLROf<byte>>;
-    static CreateScalar(value: double): Vector256_1<CLROf<double>>;
-    static CreateScalar(value: short): Vector256_1<CLROf<short>>;
-    static CreateScalar(value: int): Vector256_1<CLROf<int>>;
-    static CreateScalar(value: long): Vector256_1<CLROf<long>>;
-    static CreateScalar(value: nint): Vector256_1<CLROf<nint>>;
-    static CreateScalar(value: sbyte): Vector256_1<CLROf<sbyte>>;
-    static CreateScalar(value: float): Vector256_1<CLROf<float>>;
-    static CreateScalar(value: ushort): Vector256_1<CLROf<ushort>>;
-    static CreateScalar(value: uint): Vector256_1<CLROf<uint>>;
-    static CreateScalar(value: ulong): Vector256_1<CLROf<ulong>>;
-    static CreateScalar(value: nuint): Vector256_1<CLROf<nuint>>;
-    static CreateScalar<T>(value: T): Vector256_1<T>;
-    static CreateScalarUnsafe(value: byte): Vector256_1<CLROf<byte>>;
-    static CreateScalarUnsafe(value: double): Vector256_1<CLROf<double>>;
-    static CreateScalarUnsafe(value: short): Vector256_1<CLROf<short>>;
-    static CreateScalarUnsafe(value: int): Vector256_1<CLROf<int>>;
-    static CreateScalarUnsafe(value: long): Vector256_1<CLROf<long>>;
-    static CreateScalarUnsafe(value: nint): Vector256_1<CLROf<nint>>;
-    static CreateScalarUnsafe(value: sbyte): Vector256_1<CLROf<sbyte>>;
-    static CreateScalarUnsafe(value: float): Vector256_1<CLROf<float>>;
-    static CreateScalarUnsafe(value: ushort): Vector256_1<CLROf<ushort>>;
-    static CreateScalarUnsafe(value: uint): Vector256_1<CLROf<uint>>;
-    static CreateScalarUnsafe(value: ulong): Vector256_1<CLROf<ulong>>;
-    static CreateScalarUnsafe(value: nuint): Vector256_1<CLROf<nuint>>;
-    static CreateScalarUnsafe<T>(value: T): Vector256_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector256_1<T>;
-    static DegreesToRadians(degrees: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static DegreesToRadians(degrees: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Divide<T>(left: Vector256_1<T>, right: T): Vector256_1<T>;
-    static Divide<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Dot<T>(left: Vector256_1<T>, right: Vector256_1<T>): T;
-    static Equals<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static EqualsAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static EqualsAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static Exp(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Exp(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static ExtractMostSignificantBits<T>(vector: Vector256_1<T>): uint;
-    static Floor(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Floor(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static FusedMultiplyAdd(left: Vector256_1<CLROf<double>>, right: Vector256_1<CLROf<double>>, addend: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static FusedMultiplyAdd(left: Vector256_1<CLROf<float>>, right: Vector256_1<CLROf<float>>, addend: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static readonly isHardwareAccelerated: boolean;
+    static abs<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static add<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static addSaturate<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static all<T>(vector: Vector256_1<T>, value: T): boolean;
+    static allWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
+    static andNot<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static any_<T>(vector: Vector256_1<T>, value: T): boolean;
+    static anyWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
+    static as_<TFrom, TTo>(vector: Vector256_1<TFrom>): Vector256_1<TTo>;
+    static asByte<T>(vector: Vector256_1<T>): Vector256_1<CLROf<byte>>;
+    static asDouble<T>(vector: Vector256_1<T>): Vector256_1<CLROf<double>>;
+    static asInt16<T>(vector: Vector256_1<T>): Vector256_1<CLROf<short>>;
+    static asInt32<T>(vector: Vector256_1<T>): Vector256_1<CLROf<int>>;
+    static asInt64<T>(vector: Vector256_1<T>): Vector256_1<CLROf<long>>;
+    static asNInt<T>(vector: Vector256_1<T>): Vector256_1<CLROf<nint>>;
+    static asNUInt<T>(vector: Vector256_1<T>): Vector256_1<CLROf<nuint>>;
+    static asSByte<T>(vector: Vector256_1<T>): Vector256_1<CLROf<sbyte>>;
+    static asSingle<T>(vector: Vector256_1<T>): Vector256_1<CLROf<float>>;
+    static asUInt16<T>(vector: Vector256_1<T>): Vector256_1<CLROf<ushort>>;
+    static asUInt32<T>(vector: Vector256_1<T>): Vector256_1<CLROf<uint>>;
+    static asUInt64<T>(vector: Vector256_1<T>): Vector256_1<CLROf<ulong>>;
+    static asVector<T>(value: Vector256_1<T>): Vector_1<T>;
+    static asVector256<T>(value: Vector_1<T>): Vector256_1<T>;
+    static bitwiseAnd<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static bitwiseOr<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static ceiling2(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static ceiling2(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static clamp<T>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
+    static clampNative<T>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
+    static conditionalSelect<T>(condition: Vector256_1<T>, left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static convertToDouble(vector: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
+    static convertToDouble(vector: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<double>>;
+    static convertToInt32(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<int>>;
+    static convertToInt32Native(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<int>>;
+    static convertToInt64(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<long>>;
+    static convertToInt64Native(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<long>>;
+    static convertToSingle(vector: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
+    static convertToSingle(vector: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<float>>;
+    static convertToUInt32(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<uint>>;
+    static convertToUInt32Native(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<uint>>;
+    static convertToUInt64(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<ulong>>;
+    static convertToUInt64Native(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<ulong>>;
+    static copySign<T>(value: Vector256_1<T>, sign: Vector256_1<T>): Vector256_1<T>;
+    static copyTo3<T>(vector: Vector256_1<T>, destination: Span_1<T>): void;
+    static copyTo3<T>(vector: Vector256_1<T>, destination: T[], startIndex: int): void;
+    static copyTo3<T>(vector: Vector256_1<T>, destination: T[]): void;
+    static cos(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static cos(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static count<T>(vector: Vector256_1<T>, value: T): int;
+    static countWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
+    static create16<T>(values: ReadOnlySpan_1<T>): Vector256_1<T>;
+    static create16(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte, e16: byte, e17: byte, e18: byte, e19: byte, e20: byte, e21: byte, e22: byte, e23: byte, e24: byte, e25: byte, e26: byte, e27: byte, e28: byte, e29: byte, e30: byte, e31: byte): Vector256_1<CLROf<byte>>;
+    static create16(value: byte): Vector256_1<CLROf<byte>>;
+    static create16(e0: double, e1: double, e2: double, e3: double): Vector256_1<CLROf<double>>;
+    static create16(value: double): Vector256_1<CLROf<double>>;
+    static create16(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short): Vector256_1<CLROf<short>>;
+    static create16(value: short): Vector256_1<CLROf<short>>;
+    static create16(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int): Vector256_1<CLROf<int>>;
+    static create16(value: int): Vector256_1<CLROf<int>>;
+    static create16(e0: long, e1: long, e2: long, e3: long): Vector256_1<CLROf<long>>;
+    static create16(value: long): Vector256_1<CLROf<long>>;
+    static create16(value: nint): Vector256_1<CLROf<nint>>;
+    static create16(lower: Vector128_1<CLROf<byte>>, upper: Vector128_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
+    static create16(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static create16(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector256_1<CLROf<short>>;
+    static create16(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector256_1<CLROf<int>>;
+    static create16(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector256_1<CLROf<long>>;
+    static create16(lower: Vector128_1<CLROf<nint>>, upper: Vector128_1<CLROf<nint>>): Vector256_1<CLROf<nint>>;
+    static create16(lower: Vector128_1<CLROf<sbyte>>, upper: Vector128_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
+    static create16(lower: Vector128_1<CLROf<float>>, upper: Vector128_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static create16(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
+    static create16(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
+    static create16(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
+    static create16(lower: Vector128_1<CLROf<nuint>>, upper: Vector128_1<CLROf<nuint>>): Vector256_1<CLROf<nuint>>;
+    static create16(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte): Vector256_1<CLROf<sbyte>>;
+    static create16(value: sbyte): Vector256_1<CLROf<sbyte>>;
+    static create16(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float): Vector256_1<CLROf<float>>;
+    static create16(value: float): Vector256_1<CLROf<float>>;
+    static create16(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort): Vector256_1<CLROf<ushort>>;
+    static create16(value: ushort): Vector256_1<CLROf<ushort>>;
+    static create16(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint): Vector256_1<CLROf<uint>>;
+    static create16(value: uint): Vector256_1<CLROf<uint>>;
+    static create16(e0: ulong, e1: ulong, e2: ulong, e3: ulong): Vector256_1<CLROf<ulong>>;
+    static create16(value: ulong): Vector256_1<CLROf<ulong>>;
+    static create16(value: nuint): Vector256_1<CLROf<nuint>>;
+    static create16<T>(value: T): Vector256_1<T>;
+    static create16<T>(values: T[], index: int): Vector256_1<T>;
+    static create16<T>(values: T[]): Vector256_1<T>;
+    static create16<T>(lower: Vector128_1<T>, upper: Vector128_1<T>): Vector256_1<T>;
+    static create16<T>(value: Vector128_1<T>): Vector256_1<T>;
+    static create16<T>(value: Vector64_1<T>): Vector256_1<T>;
+    static createScalar2(value: byte): Vector256_1<CLROf<byte>>;
+    static createScalar2(value: double): Vector256_1<CLROf<double>>;
+    static createScalar2(value: short): Vector256_1<CLROf<short>>;
+    static createScalar2(value: int): Vector256_1<CLROf<int>>;
+    static createScalar2(value: long): Vector256_1<CLROf<long>>;
+    static createScalar2(value: nint): Vector256_1<CLROf<nint>>;
+    static createScalar2(value: sbyte): Vector256_1<CLROf<sbyte>>;
+    static createScalar2(value: float): Vector256_1<CLROf<float>>;
+    static createScalar2(value: ushort): Vector256_1<CLROf<ushort>>;
+    static createScalar2(value: uint): Vector256_1<CLROf<uint>>;
+    static createScalar2(value: ulong): Vector256_1<CLROf<ulong>>;
+    static createScalar2(value: nuint): Vector256_1<CLROf<nuint>>;
+    static createScalar2<T>(value: T): Vector256_1<T>;
+    static createScalarUnsafe2(value: byte): Vector256_1<CLROf<byte>>;
+    static createScalarUnsafe2(value: double): Vector256_1<CLROf<double>>;
+    static createScalarUnsafe2(value: short): Vector256_1<CLROf<short>>;
+    static createScalarUnsafe2(value: int): Vector256_1<CLROf<int>>;
+    static createScalarUnsafe2(value: long): Vector256_1<CLROf<long>>;
+    static createScalarUnsafe2(value: nint): Vector256_1<CLROf<nint>>;
+    static createScalarUnsafe2(value: sbyte): Vector256_1<CLROf<sbyte>>;
+    static createScalarUnsafe2(value: float): Vector256_1<CLROf<float>>;
+    static createScalarUnsafe2(value: ushort): Vector256_1<CLROf<ushort>>;
+    static createScalarUnsafe2(value: uint): Vector256_1<CLROf<uint>>;
+    static createScalarUnsafe2(value: ulong): Vector256_1<CLROf<ulong>>;
+    static createScalarUnsafe2(value: nuint): Vector256_1<CLROf<nuint>>;
+    static createScalarUnsafe2<T>(value: T): Vector256_1<T>;
+    static createSequence<T>(start: T, step: T): Vector256_1<T>;
+    static degreesToRadians(degrees: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static degreesToRadians(degrees: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static divide2<T>(left: Vector256_1<T>, right: T): Vector256_1<T>;
+    static divide2<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static dot<T>(left: Vector256_1<T>, right: Vector256_1<T>): T;
+    static equals<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static equalsAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static equalsAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static exp(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static exp(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static extractMostSignificantBits<T>(vector: Vector256_1<T>): uint;
+    static floor2(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static floor2(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static fusedMultiplyAdd(left: Vector256_1<CLROf<double>>, right: Vector256_1<CLROf<double>>, addend: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static fusedMultiplyAdd(left: Vector256_1<CLROf<float>>, right: Vector256_1<CLROf<float>>, addend: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
     static get_E<T extends IFloatingPointConstants_1<T>>(): Vector256_1<T>;
     static get_Epsilon<T extends IFloatingPointIeee754_1<T>>(): Vector256_1<T>;
     static get_NaN<T extends IFloatingPointIeee754_1<T>>(): Vector256_1<T>;
@@ -616,320 +624,320 @@ export abstract class Vector256$instance {
     static get_Pi<T extends IFloatingPointConstants_1<T>>(): Vector256_1<T>;
     static get_PositiveInfinity<T extends IFloatingPointIeee754_1<T>>(): Vector256_1<T>;
     static get_Tau<T extends IFloatingPointConstants_1<T>>(): Vector256_1<T>;
-    static GetElement<T>(vector: Vector256_1<T>, index: int): T;
-    static GetLower<T>(vector: Vector256_1<T>): Vector128_1<T>;
-    static GetUpper<T>(vector: Vector256_1<T>): Vector128_1<T>;
-    static GreaterThan<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static GreaterThanAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static Hypot(x: Vector256_1<CLROf<double>>, y: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Hypot(x: Vector256_1<CLROf<float>>, y: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static IndexOf<T>(vector: Vector256_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsFinite<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNaN<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNegative<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNormal<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsOddInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsPositive<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsSubnormal<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsZero<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static LastIndexOf<T>(vector: Vector256_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
-    static Lerp(x: Vector256_1<CLROf<double>>, y: Vector256_1<CLROf<double>>, amount: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Lerp(x: Vector256_1<CLROf<float>>, y: Vector256_1<CLROf<float>>, amount: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static LessThan<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static LessThanAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static LessThanAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector256_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector256_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector256_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }, elementOffset: nuint): Vector256_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }): Vector256_1<T>;
-    static Log(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Log(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Log2(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Log2(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Max<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxMagnitude<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxNative<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Min<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinMagnitude<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinNative<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Multiply<T>(left: T, right: Vector256_1<T>): Vector256_1<T>;
-    static Multiply<T>(left: Vector256_1<T>, right: T): Vector256_1<T>;
-    static Multiply<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MultiplyAddEstimate(left: Vector256_1<CLROf<double>>, right: Vector256_1<CLROf<double>>, addend: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static MultiplyAddEstimate(left: Vector256_1<CLROf<float>>, right: Vector256_1<CLROf<float>>, addend: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Narrow(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector256_1<CLROf<float>>;
-    static Narrow(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector256_1<CLROf<sbyte>>;
-    static Narrow(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector256_1<CLROf<short>>;
-    static Narrow(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector256_1<CLROf<int>>;
-    static Narrow(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<byte>>;
-    static Narrow(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ushort>>;
-    static Narrow(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<uint>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector256_1<CLROf<float>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector256_1<CLROf<sbyte>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector256_1<CLROf<short>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector256_1<CLROf<int>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<byte>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ushort>>;
-    static NarrowWithSaturation(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<uint>>;
-    static Negate<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static None<T>(vector: Vector256_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static RadiansToDegrees(radians: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static RadiansToDegrees(radians: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static Round(vector: Vector256_1<CLROf<double>>, mode: MidpointRounding): Vector256_1<CLROf<double>>;
-    static Round(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Round(vector: Vector256_1<CLROf<float>>, mode: MidpointRounding): Vector256_1<CLROf<float>>;
-    static Round(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<byte>>, shiftCount: int): Vector256_1<CLROf<byte>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<ushort>>, shiftCount: int): Vector256_1<CLROf<ushort>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<uint>>, shiftCount: int): Vector256_1<CLROf<uint>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<ulong>>, shiftCount: int): Vector256_1<CLROf<ulong>>;
-    static ShiftLeft(vector: Vector256_1<CLROf<nuint>>, shiftCount: int): Vector256_1<CLROf<nuint>>;
-    static ShiftRightArithmetic(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
-    static ShiftRightArithmetic(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
-    static ShiftRightArithmetic(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
-    static ShiftRightArithmetic(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
-    static ShiftRightArithmetic(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<byte>>, shiftCount: int): Vector256_1<CLROf<byte>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<ushort>>, shiftCount: int): Vector256_1<CLROf<ushort>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<uint>>, shiftCount: int): Vector256_1<CLROf<uint>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<ulong>>, shiftCount: int): Vector256_1<CLROf<ulong>>;
-    static ShiftRightLogical(vector: Vector256_1<CLROf<nuint>>, shiftCount: int): Vector256_1<CLROf<nuint>>;
-    static Shuffle(vector: Vector256_1<CLROf<byte>>, indices: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
-    static Shuffle(vector: Vector256_1<CLROf<double>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
-    static Shuffle(vector: Vector256_1<CLROf<short>>, indices: Vector256_1<CLROf<short>>): Vector256_1<CLROf<short>>;
-    static Shuffle(vector: Vector256_1<CLROf<int>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<int>>;
-    static Shuffle(vector: Vector256_1<CLROf<long>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<long>>;
-    static Shuffle(vector: Vector256_1<CLROf<sbyte>>, indices: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
-    static Shuffle(vector: Vector256_1<CLROf<float>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
-    static Shuffle(vector: Vector256_1<CLROf<ushort>>, indices: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
-    static Shuffle(vector: Vector256_1<CLROf<uint>>, indices: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
-    static Shuffle(vector: Vector256_1<CLROf<ulong>>, indices: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<byte>>, indices: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<double>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<short>>, indices: Vector256_1<CLROf<short>>): Vector256_1<CLROf<short>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<int>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<int>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<long>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<long>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<sbyte>>, indices: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<float>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<ushort>>, indices: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<uint>>, indices: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
-    static ShuffleNative(vector: Vector256_1<CLROf<ulong>>, indices: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
-    static Sin(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Sin(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static SinCos(vector: Vector256_1<CLROf<double>>): ValueTuple_2<Vector256_1<CLROf<double>>, Vector256_1<CLROf<double>>>;
-    static SinCos(vector: Vector256_1<CLROf<float>>): ValueTuple_2<Vector256_1<CLROf<float>>, Vector256_1<CLROf<float>>>;
-    static Sqrt<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static Store<T>(source: Vector256_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector256_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector256_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector256_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector256_1<T>, destination: { value: ref<T> }): void;
-    static Subtract<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static SubtractSaturate<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Sum<T>(vector: Vector256_1<T>): T;
-    static ToScalar<T>(vector: Vector256_1<T>): T;
-    static ToVector512<T>(vector: Vector256_1<T>): Vector512_1<T>;
-    static ToVector512Unsafe<T>(vector: Vector256_1<T>): Vector512_1<T>;
-    static Truncate(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static Truncate(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static TryCopyTo<T>(vector: Vector256_1<T>, destination: Span_1<T>): boolean;
-    static Widen(source: Vector256_1<CLROf<byte>>): ValueTuple_2<Vector256_1<CLROf<ushort>>, Vector256_1<CLROf<ushort>>>;
-    static Widen(source: Vector256_1<CLROf<short>>): ValueTuple_2<Vector256_1<CLROf<int>>, Vector256_1<CLROf<int>>>;
-    static Widen(source: Vector256_1<CLROf<int>>): ValueTuple_2<Vector256_1<CLROf<long>>, Vector256_1<CLROf<long>>>;
-    static Widen(source: Vector256_1<CLROf<sbyte>>): ValueTuple_2<Vector256_1<CLROf<short>>, Vector256_1<CLROf<short>>>;
-    static Widen(source: Vector256_1<CLROf<float>>): ValueTuple_2<Vector256_1<CLROf<double>>, Vector256_1<CLROf<double>>>;
-    static Widen(source: Vector256_1<CLROf<ushort>>): ValueTuple_2<Vector256_1<CLROf<uint>>, Vector256_1<CLROf<uint>>>;
-    static Widen(source: Vector256_1<CLROf<uint>>): ValueTuple_2<Vector256_1<CLROf<ulong>>, Vector256_1<CLROf<ulong>>>;
-    static WidenLower(source: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<ushort>>;
-    static WidenLower(source: Vector256_1<CLROf<short>>): Vector256_1<CLROf<int>>;
-    static WidenLower(source: Vector256_1<CLROf<int>>): Vector256_1<CLROf<long>>;
-    static WidenLower(source: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<short>>;
-    static WidenLower(source: Vector256_1<CLROf<float>>): Vector256_1<CLROf<double>>;
-    static WidenLower(source: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<uint>>;
-    static WidenLower(source: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ulong>>;
-    static WidenUpper(source: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<ushort>>;
-    static WidenUpper(source: Vector256_1<CLROf<short>>): Vector256_1<CLROf<int>>;
-    static WidenUpper(source: Vector256_1<CLROf<int>>): Vector256_1<CLROf<long>>;
-    static WidenUpper(source: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<short>>;
-    static WidenUpper(source: Vector256_1<CLROf<float>>): Vector256_1<CLROf<double>>;
-    static WidenUpper(source: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<uint>>;
-    static WidenUpper(source: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ulong>>;
-    static WithElement<T>(vector: Vector256_1<T>, index: int, value: T): Vector256_1<T>;
-    static WithLower<T>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
-    static WithUpper<T>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
-    static Xor<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static getElement<T>(vector: Vector256_1<T>, index: int): T;
+    static getLower<T>(vector: Vector256_1<T>): Vector128_1<T>;
+    static getUpper<T>(vector: Vector256_1<T>): Vector128_1<T>;
+    static greaterThan<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static greaterThanAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static greaterThanAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static greaterThanOrEqual<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static greaterThanOrEqualAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static greaterThanOrEqualAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static hypot(x: Vector256_1<CLROf<double>>, y: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static hypot(x: Vector256_1<CLROf<float>>, y: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static indexOf<T>(vector: Vector256_1<T>, value: T): int;
+    static indexOfWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
+    static isEvenInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isFinite<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isNaN<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isNegative<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isNegativeInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isNormal<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isOddInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isPositive<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isPositiveInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isSubnormal<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static isZero<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static lastIndexOf<T>(vector: Vector256_1<T>, value: T): int;
+    static lastIndexOfWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
+    static lerp(x: Vector256_1<CLROf<double>>, y: Vector256_1<CLROf<double>>, amount: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static lerp(x: Vector256_1<CLROf<float>>, y: Vector256_1<CLROf<float>>, amount: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static lessThan<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static lessThanAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static lessThanAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static lessThanOrEqual<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static lessThanOrEqualAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static lessThanOrEqualAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static load<T>(source: ptr<T>): Vector256_1<T>;
+    static loadAligned<T>(source: ptr<T>): Vector256_1<T>;
+    static loadAlignedNonTemporal<T>(source: ptr<T>): Vector256_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }, elementOffset: nuint): Vector256_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }): Vector256_1<T>;
+    static log(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static log(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static log22(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static log22(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static max<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static maxMagnitude<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static maxMagnitudeNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static maxNative<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static maxNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static min<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static minMagnitude<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static minMagnitudeNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static minNative<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static minNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static multiply3<T>(left: T, right: Vector256_1<T>): Vector256_1<T>;
+    static multiply3<T>(left: Vector256_1<T>, right: T): Vector256_1<T>;
+    static multiply3<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static multiplyAddEstimate(left: Vector256_1<CLROf<double>>, right: Vector256_1<CLROf<double>>, addend: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static multiplyAddEstimate(left: Vector256_1<CLROf<float>>, right: Vector256_1<CLROf<float>>, addend: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static narrow(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector256_1<CLROf<float>>;
+    static narrow(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector256_1<CLROf<sbyte>>;
+    static narrow(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector256_1<CLROf<short>>;
+    static narrow(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector256_1<CLROf<int>>;
+    static narrow(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<byte>>;
+    static narrow(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ushort>>;
+    static narrow(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<uint>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector256_1<CLROf<float>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector256_1<CLROf<sbyte>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector256_1<CLROf<short>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector256_1<CLROf<int>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<byte>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ushort>>;
+    static narrowWithSaturation(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<uint>>;
+    static negate<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static none<T>(vector: Vector256_1<T>, value: T): boolean;
+    static noneWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
+    static onesComplement<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static radiansToDegrees(radians: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static radiansToDegrees(radians: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static round3(vector: Vector256_1<CLROf<double>>, mode: MidpointRounding): Vector256_1<CLROf<double>>;
+    static round3(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static round3(vector: Vector256_1<CLROf<float>>, mode: MidpointRounding): Vector256_1<CLROf<float>>;
+    static round3(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static shiftLeft(vector: Vector256_1<CLROf<byte>>, shiftCount: int): Vector256_1<CLROf<byte>>;
+    static shiftLeft(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
+    static shiftLeft(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
+    static shiftLeft(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
+    static shiftLeft(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
+    static shiftLeft(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
+    static shiftLeft(vector: Vector256_1<CLROf<ushort>>, shiftCount: int): Vector256_1<CLROf<ushort>>;
+    static shiftLeft(vector: Vector256_1<CLROf<uint>>, shiftCount: int): Vector256_1<CLROf<uint>>;
+    static shiftLeft(vector: Vector256_1<CLROf<ulong>>, shiftCount: int): Vector256_1<CLROf<ulong>>;
+    static shiftLeft(vector: Vector256_1<CLROf<nuint>>, shiftCount: int): Vector256_1<CLROf<nuint>>;
+    static shiftRightArithmetic(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
+    static shiftRightArithmetic(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
+    static shiftRightArithmetic(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
+    static shiftRightArithmetic(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
+    static shiftRightArithmetic(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<byte>>, shiftCount: int): Vector256_1<CLROf<byte>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<ushort>>, shiftCount: int): Vector256_1<CLROf<ushort>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<uint>>, shiftCount: int): Vector256_1<CLROf<uint>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<ulong>>, shiftCount: int): Vector256_1<CLROf<ulong>>;
+    static shiftRightLogical(vector: Vector256_1<CLROf<nuint>>, shiftCount: int): Vector256_1<CLROf<nuint>>;
+    static shuffle(vector: Vector256_1<CLROf<byte>>, indices: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
+    static shuffle(vector: Vector256_1<CLROf<double>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
+    static shuffle(vector: Vector256_1<CLROf<short>>, indices: Vector256_1<CLROf<short>>): Vector256_1<CLROf<short>>;
+    static shuffle(vector: Vector256_1<CLROf<int>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<int>>;
+    static shuffle(vector: Vector256_1<CLROf<long>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<long>>;
+    static shuffle(vector: Vector256_1<CLROf<sbyte>>, indices: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
+    static shuffle(vector: Vector256_1<CLROf<float>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
+    static shuffle(vector: Vector256_1<CLROf<ushort>>, indices: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
+    static shuffle(vector: Vector256_1<CLROf<uint>>, indices: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
+    static shuffle(vector: Vector256_1<CLROf<ulong>>, indices: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
+    static shuffleNative(vector: Vector256_1<CLROf<byte>>, indices: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
+    static shuffleNative(vector: Vector256_1<CLROf<double>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
+    static shuffleNative(vector: Vector256_1<CLROf<short>>, indices: Vector256_1<CLROf<short>>): Vector256_1<CLROf<short>>;
+    static shuffleNative(vector: Vector256_1<CLROf<int>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<int>>;
+    static shuffleNative(vector: Vector256_1<CLROf<long>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<long>>;
+    static shuffleNative(vector: Vector256_1<CLROf<sbyte>>, indices: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
+    static shuffleNative(vector: Vector256_1<CLROf<float>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
+    static shuffleNative(vector: Vector256_1<CLROf<ushort>>, indices: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
+    static shuffleNative(vector: Vector256_1<CLROf<uint>>, indices: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
+    static shuffleNative(vector: Vector256_1<CLROf<ulong>>, indices: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
+    static sin(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static sin(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static sinCos(vector: Vector256_1<CLROf<double>>): ValueTuple_2<Vector256_1<CLROf<double>>, Vector256_1<CLROf<double>>>;
+    static sinCos(vector: Vector256_1<CLROf<float>>): ValueTuple_2<Vector256_1<CLROf<float>>, Vector256_1<CLROf<float>>>;
+    static sqrt<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static store<T>(source: Vector256_1<T>, destination: ptr<T>): void;
+    static storeAligned<T>(source: Vector256_1<T>, destination: ptr<T>): void;
+    static storeAlignedNonTemporal<T>(source: Vector256_1<T>, destination: ptr<T>): void;
+    static storeUnsafe2<T>(source: Vector256_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
+    static storeUnsafe2<T>(source: Vector256_1<T>, destination: { value: ref<T> }): void;
+    static subtract<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static subtractSaturate<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static sum<T>(vector: Vector256_1<T>): T;
+    static toScalar<T>(vector: Vector256_1<T>): T;
+    static toVector512<T>(vector: Vector256_1<T>): Vector512_1<T>;
+    static toVector512Unsafe<T>(vector: Vector256_1<T>): Vector512_1<T>;
+    static truncate(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
+    static truncate(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static tryCopyTo<T>(vector: Vector256_1<T>, destination: Span_1<T>): boolean;
+    static widen(source: Vector256_1<CLROf<byte>>): ValueTuple_2<Vector256_1<CLROf<ushort>>, Vector256_1<CLROf<ushort>>>;
+    static widen(source: Vector256_1<CLROf<short>>): ValueTuple_2<Vector256_1<CLROf<int>>, Vector256_1<CLROf<int>>>;
+    static widen(source: Vector256_1<CLROf<int>>): ValueTuple_2<Vector256_1<CLROf<long>>, Vector256_1<CLROf<long>>>;
+    static widen(source: Vector256_1<CLROf<sbyte>>): ValueTuple_2<Vector256_1<CLROf<short>>, Vector256_1<CLROf<short>>>;
+    static widen(source: Vector256_1<CLROf<float>>): ValueTuple_2<Vector256_1<CLROf<double>>, Vector256_1<CLROf<double>>>;
+    static widen(source: Vector256_1<CLROf<ushort>>): ValueTuple_2<Vector256_1<CLROf<uint>>, Vector256_1<CLROf<uint>>>;
+    static widen(source: Vector256_1<CLROf<uint>>): ValueTuple_2<Vector256_1<CLROf<ulong>>, Vector256_1<CLROf<ulong>>>;
+    static widenLower(source: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<ushort>>;
+    static widenLower(source: Vector256_1<CLROf<short>>): Vector256_1<CLROf<int>>;
+    static widenLower(source: Vector256_1<CLROf<int>>): Vector256_1<CLROf<long>>;
+    static widenLower(source: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<short>>;
+    static widenLower(source: Vector256_1<CLROf<float>>): Vector256_1<CLROf<double>>;
+    static widenLower(source: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<uint>>;
+    static widenLower(source: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ulong>>;
+    static widenUpper(source: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<ushort>>;
+    static widenUpper(source: Vector256_1<CLROf<short>>): Vector256_1<CLROf<int>>;
+    static widenUpper(source: Vector256_1<CLROf<int>>): Vector256_1<CLROf<long>>;
+    static widenUpper(source: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<short>>;
+    static widenUpper(source: Vector256_1<CLROf<float>>): Vector256_1<CLROf<double>>;
+    static widenUpper(source: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<uint>>;
+    static widenUpper(source: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ulong>>;
+    static withElement<T>(vector: Vector256_1<T>, index: int, value: T): Vector256_1<T>;
+    static withLower<T>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
+    static withUpper<T>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
+    static xor<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
 }
 
 
 export type Vector256 = Vector256$instance;
 
 export abstract class Vector512$instance {
-    static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static Add<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static AddSaturate<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static All<T>(vector: Vector512_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
-    static AndNot<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Any<T>(vector: Vector512_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector512_1<TFrom>): Vector512_1<TTo>;
-    static AsByte<T>(vector: Vector512_1<T>): Vector512_1<CLROf<byte>>;
-    static AsDouble<T>(vector: Vector512_1<T>): Vector512_1<CLROf<double>>;
-    static AsInt16<T>(vector: Vector512_1<T>): Vector512_1<CLROf<short>>;
-    static AsInt32<T>(vector: Vector512_1<T>): Vector512_1<CLROf<int>>;
-    static AsInt64<T>(vector: Vector512_1<T>): Vector512_1<CLROf<long>>;
-    static AsNInt<T>(vector: Vector512_1<T>): Vector512_1<CLROf<nint>>;
-    static AsNUInt<T>(vector: Vector512_1<T>): Vector512_1<CLROf<nuint>>;
-    static AsSByte<T>(vector: Vector512_1<T>): Vector512_1<CLROf<sbyte>>;
-    static AsSingle<T>(vector: Vector512_1<T>): Vector512_1<CLROf<float>>;
-    static AsUInt16<T>(vector: Vector512_1<T>): Vector512_1<CLROf<ushort>>;
-    static AsUInt32<T>(vector: Vector512_1<T>): Vector512_1<CLROf<uint>>;
-    static AsUInt64<T>(vector: Vector512_1<T>): Vector512_1<CLROf<ulong>>;
-    static AsVector<T>(value: Vector512_1<T>): Vector_1<T>;
-    static AsVector512<T>(value: Vector_1<T>): Vector512_1<T>;
-    static BitwiseAnd<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static BitwiseOr<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Ceiling(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Ceiling(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Clamp<T>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
-    static ClampNative<T>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
-    static ConditionalSelect<T>(condition: Vector512_1<T>, left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static ConvertToDouble(vector: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
-    static ConvertToDouble(vector: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<double>>;
-    static ConvertToInt32(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<int>>;
-    static ConvertToInt32Native(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<int>>;
-    static ConvertToInt64(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<long>>;
-    static ConvertToInt64Native(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<long>>;
-    static ConvertToSingle(vector: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
-    static ConvertToSingle(vector: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<float>>;
-    static ConvertToUInt32(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<uint>>;
-    static ConvertToUInt32Native(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<uint>>;
-    static ConvertToUInt64(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<ulong>>;
-    static ConvertToUInt64Native(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<ulong>>;
-    static CopySign<T>(value: Vector512_1<T>, sign: Vector512_1<T>): Vector512_1<T>;
-    static CopyTo<T>(vector: Vector512_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector512_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector512_1<T>, destination: T[]): void;
-    static Cos(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Cos(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Count<T>(vector: Vector512_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector512_1<T>;
-    static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte, e16: byte, e17: byte, e18: byte, e19: byte, e20: byte, e21: byte, e22: byte, e23: byte, e24: byte, e25: byte, e26: byte, e27: byte, e28: byte, e29: byte, e30: byte, e31: byte, e32: byte, e33: byte, e34: byte, e35: byte, e36: byte, e37: byte, e38: byte, e39: byte, e40: byte, e41: byte, e42: byte, e43: byte, e44: byte, e45: byte, e46: byte, e47: byte, e48: byte, e49: byte, e50: byte, e51: byte, e52: byte, e53: byte, e54: byte, e55: byte, e56: byte, e57: byte, e58: byte, e59: byte, e60: byte, e61: byte, e62: byte, e63: byte): Vector512_1<CLROf<byte>>;
-    static Create(value: byte): Vector512_1<CLROf<byte>>;
-    static Create(e0: double, e1: double, e2: double, e3: double, e4: double, e5: double, e6: double, e7: double): Vector512_1<CLROf<double>>;
-    static Create(value: double): Vector512_1<CLROf<double>>;
-    static Create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short, e16: short, e17: short, e18: short, e19: short, e20: short, e21: short, e22: short, e23: short, e24: short, e25: short, e26: short, e27: short, e28: short, e29: short, e30: short, e31: short): Vector512_1<CLROf<short>>;
-    static Create(value: short): Vector512_1<CLROf<short>>;
-    static Create(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int, e8: int, e9: int, e10: int, e11: int, e12: int, e13: int, e14: int, e15: int): Vector512_1<CLROf<int>>;
-    static Create(value: int): Vector512_1<CLROf<int>>;
-    static Create(e0: long, e1: long, e2: long, e3: long, e4: long, e5: long, e6: long, e7: long): Vector512_1<CLROf<long>>;
-    static Create(value: long): Vector512_1<CLROf<long>>;
-    static Create(value: nint): Vector512_1<CLROf<nint>>;
-    static Create(lower: Vector256_1<CLROf<byte>>, upper: Vector256_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
-    static Create(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Create(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector512_1<CLROf<short>>;
-    static Create(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector512_1<CLROf<int>>;
-    static Create(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector512_1<CLROf<long>>;
-    static Create(lower: Vector256_1<CLROf<nint>>, upper: Vector256_1<CLROf<nint>>): Vector512_1<CLROf<nint>>;
-    static Create(lower: Vector256_1<CLROf<sbyte>>, upper: Vector256_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
-    static Create(lower: Vector256_1<CLROf<float>>, upper: Vector256_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Create(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
-    static Create(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
-    static Create(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
-    static Create(lower: Vector256_1<CLROf<nuint>>, upper: Vector256_1<CLROf<nuint>>): Vector512_1<CLROf<nuint>>;
-    static Create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte, e32: sbyte, e33: sbyte, e34: sbyte, e35: sbyte, e36: sbyte, e37: sbyte, e38: sbyte, e39: sbyte, e40: sbyte, e41: sbyte, e42: sbyte, e43: sbyte, e44: sbyte, e45: sbyte, e46: sbyte, e47: sbyte, e48: sbyte, e49: sbyte, e50: sbyte, e51: sbyte, e52: sbyte, e53: sbyte, e54: sbyte, e55: sbyte, e56: sbyte, e57: sbyte, e58: sbyte, e59: sbyte, e60: sbyte, e61: sbyte, e62: sbyte, e63: sbyte): Vector512_1<CLROf<sbyte>>;
-    static Create(value: sbyte): Vector512_1<CLROf<sbyte>>;
-    static Create(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float, e8: float, e9: float, e10: float, e11: float, e12: float, e13: float, e14: float, e15: float): Vector512_1<CLROf<float>>;
-    static Create(value: float): Vector512_1<CLROf<float>>;
-    static Create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort, e16: ushort, e17: ushort, e18: ushort, e19: ushort, e20: ushort, e21: ushort, e22: ushort, e23: ushort, e24: ushort, e25: ushort, e26: ushort, e27: ushort, e28: ushort, e29: ushort, e30: ushort, e31: ushort): Vector512_1<CLROf<ushort>>;
-    static Create(value: ushort): Vector512_1<CLROf<ushort>>;
-    static Create(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint, e8: uint, e9: uint, e10: uint, e11: uint, e12: uint, e13: uint, e14: uint, e15: uint): Vector512_1<CLROf<uint>>;
-    static Create(value: uint): Vector512_1<CLROf<uint>>;
-    static Create(e0: ulong, e1: ulong, e2: ulong, e3: ulong, e4: ulong, e5: ulong, e6: ulong, e7: ulong): Vector512_1<CLROf<ulong>>;
-    static Create(value: ulong): Vector512_1<CLROf<ulong>>;
-    static Create(value: nuint): Vector512_1<CLROf<nuint>>;
-    static Create<T>(value: T): Vector512_1<T>;
-    static Create<T>(values: T[], index: int): Vector512_1<T>;
-    static Create<T>(values: T[]): Vector512_1<T>;
-    static Create<T>(value: Vector128_1<T>): Vector512_1<T>;
-    static Create<T>(lower: Vector256_1<T>, upper: Vector256_1<T>): Vector512_1<T>;
-    static Create<T>(value: Vector256_1<T>): Vector512_1<T>;
-    static Create<T>(value: Vector64_1<T>): Vector512_1<T>;
-    static CreateScalar(value: byte): Vector512_1<CLROf<byte>>;
-    static CreateScalar(value: double): Vector512_1<CLROf<double>>;
-    static CreateScalar(value: short): Vector512_1<CLROf<short>>;
-    static CreateScalar(value: int): Vector512_1<CLROf<int>>;
-    static CreateScalar(value: long): Vector512_1<CLROf<long>>;
-    static CreateScalar(value: nint): Vector512_1<CLROf<nint>>;
-    static CreateScalar(value: sbyte): Vector512_1<CLROf<sbyte>>;
-    static CreateScalar(value: float): Vector512_1<CLROf<float>>;
-    static CreateScalar(value: ushort): Vector512_1<CLROf<ushort>>;
-    static CreateScalar(value: uint): Vector512_1<CLROf<uint>>;
-    static CreateScalar(value: ulong): Vector512_1<CLROf<ulong>>;
-    static CreateScalar(value: nuint): Vector512_1<CLROf<nuint>>;
-    static CreateScalar<T>(value: T): Vector512_1<T>;
-    static CreateScalarUnsafe(value: byte): Vector512_1<CLROf<byte>>;
-    static CreateScalarUnsafe(value: double): Vector512_1<CLROf<double>>;
-    static CreateScalarUnsafe(value: short): Vector512_1<CLROf<short>>;
-    static CreateScalarUnsafe(value: int): Vector512_1<CLROf<int>>;
-    static CreateScalarUnsafe(value: long): Vector512_1<CLROf<long>>;
-    static CreateScalarUnsafe(value: nint): Vector512_1<CLROf<nint>>;
-    static CreateScalarUnsafe(value: sbyte): Vector512_1<CLROf<sbyte>>;
-    static CreateScalarUnsafe(value: float): Vector512_1<CLROf<float>>;
-    static CreateScalarUnsafe(value: ushort): Vector512_1<CLROf<ushort>>;
-    static CreateScalarUnsafe(value: uint): Vector512_1<CLROf<uint>>;
-    static CreateScalarUnsafe(value: ulong): Vector512_1<CLROf<ulong>>;
-    static CreateScalarUnsafe(value: nuint): Vector512_1<CLROf<nuint>>;
-    static CreateScalarUnsafe<T>(value: T): Vector512_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector512_1<T>;
-    static DegreesToRadians(degrees: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static DegreesToRadians(degrees: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Divide<T>(left: Vector512_1<T>, right: T): Vector512_1<T>;
-    static Divide<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Dot<T>(left: Vector512_1<T>, right: Vector512_1<T>): T;
-    static Equals<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static EqualsAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static EqualsAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static Exp(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Exp(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static ExtractMostSignificantBits<T>(vector: Vector512_1<T>): ulong;
-    static Floor(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Floor(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static FusedMultiplyAdd(left: Vector512_1<CLROf<double>>, right: Vector512_1<CLROf<double>>, addend: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static FusedMultiplyAdd(left: Vector512_1<CLROf<float>>, right: Vector512_1<CLROf<float>>, addend: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static readonly isHardwareAccelerated: boolean;
+    static abs<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static add<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static addSaturate<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static all<T>(vector: Vector512_1<T>, value: T): boolean;
+    static allWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
+    static andNot<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static any_<T>(vector: Vector512_1<T>, value: T): boolean;
+    static anyWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
+    static as_<TFrom, TTo>(vector: Vector512_1<TFrom>): Vector512_1<TTo>;
+    static asByte<T>(vector: Vector512_1<T>): Vector512_1<CLROf<byte>>;
+    static asDouble<T>(vector: Vector512_1<T>): Vector512_1<CLROf<double>>;
+    static asInt16<T>(vector: Vector512_1<T>): Vector512_1<CLROf<short>>;
+    static asInt32<T>(vector: Vector512_1<T>): Vector512_1<CLROf<int>>;
+    static asInt64<T>(vector: Vector512_1<T>): Vector512_1<CLROf<long>>;
+    static asNInt<T>(vector: Vector512_1<T>): Vector512_1<CLROf<nint>>;
+    static asNUInt<T>(vector: Vector512_1<T>): Vector512_1<CLROf<nuint>>;
+    static asSByte<T>(vector: Vector512_1<T>): Vector512_1<CLROf<sbyte>>;
+    static asSingle<T>(vector: Vector512_1<T>): Vector512_1<CLROf<float>>;
+    static asUInt16<T>(vector: Vector512_1<T>): Vector512_1<CLROf<ushort>>;
+    static asUInt32<T>(vector: Vector512_1<T>): Vector512_1<CLROf<uint>>;
+    static asUInt64<T>(vector: Vector512_1<T>): Vector512_1<CLROf<ulong>>;
+    static asVector<T>(value: Vector512_1<T>): Vector_1<T>;
+    static asVector512<T>(value: Vector_1<T>): Vector512_1<T>;
+    static bitwiseAnd<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static bitwiseOr<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static ceiling2(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static ceiling2(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static clamp<T>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
+    static clampNative<T>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
+    static conditionalSelect<T>(condition: Vector512_1<T>, left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static convertToDouble(vector: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
+    static convertToDouble(vector: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<double>>;
+    static convertToInt32(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<int>>;
+    static convertToInt32Native(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<int>>;
+    static convertToInt64(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<long>>;
+    static convertToInt64Native(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<long>>;
+    static convertToSingle(vector: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
+    static convertToSingle(vector: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<float>>;
+    static convertToUInt32(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<uint>>;
+    static convertToUInt32Native(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<uint>>;
+    static convertToUInt64(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<ulong>>;
+    static convertToUInt64Native(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<ulong>>;
+    static copySign<T>(value: Vector512_1<T>, sign: Vector512_1<T>): Vector512_1<T>;
+    static copyTo3<T>(vector: Vector512_1<T>, destination: Span_1<T>): void;
+    static copyTo3<T>(vector: Vector512_1<T>, destination: T[], startIndex: int): void;
+    static copyTo3<T>(vector: Vector512_1<T>, destination: T[]): void;
+    static cos(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static cos(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static count<T>(vector: Vector512_1<T>, value: T): int;
+    static countWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
+    static create16<T>(values: ReadOnlySpan_1<T>): Vector512_1<T>;
+    static create16(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte, e16: byte, e17: byte, e18: byte, e19: byte, e20: byte, e21: byte, e22: byte, e23: byte, e24: byte, e25: byte, e26: byte, e27: byte, e28: byte, e29: byte, e30: byte, e31: byte, e32: byte, e33: byte, e34: byte, e35: byte, e36: byte, e37: byte, e38: byte, e39: byte, e40: byte, e41: byte, e42: byte, e43: byte, e44: byte, e45: byte, e46: byte, e47: byte, e48: byte, e49: byte, e50: byte, e51: byte, e52: byte, e53: byte, e54: byte, e55: byte, e56: byte, e57: byte, e58: byte, e59: byte, e60: byte, e61: byte, e62: byte, e63: byte): Vector512_1<CLROf<byte>>;
+    static create16(value: byte): Vector512_1<CLROf<byte>>;
+    static create16(e0: double, e1: double, e2: double, e3: double, e4: double, e5: double, e6: double, e7: double): Vector512_1<CLROf<double>>;
+    static create16(value: double): Vector512_1<CLROf<double>>;
+    static create16(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short, e16: short, e17: short, e18: short, e19: short, e20: short, e21: short, e22: short, e23: short, e24: short, e25: short, e26: short, e27: short, e28: short, e29: short, e30: short, e31: short): Vector512_1<CLROf<short>>;
+    static create16(value: short): Vector512_1<CLROf<short>>;
+    static create16(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int, e8: int, e9: int, e10: int, e11: int, e12: int, e13: int, e14: int, e15: int): Vector512_1<CLROf<int>>;
+    static create16(value: int): Vector512_1<CLROf<int>>;
+    static create16(e0: long, e1: long, e2: long, e3: long, e4: long, e5: long, e6: long, e7: long): Vector512_1<CLROf<long>>;
+    static create16(value: long): Vector512_1<CLROf<long>>;
+    static create16(value: nint): Vector512_1<CLROf<nint>>;
+    static create16(lower: Vector256_1<CLROf<byte>>, upper: Vector256_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
+    static create16(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static create16(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector512_1<CLROf<short>>;
+    static create16(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector512_1<CLROf<int>>;
+    static create16(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector512_1<CLROf<long>>;
+    static create16(lower: Vector256_1<CLROf<nint>>, upper: Vector256_1<CLROf<nint>>): Vector512_1<CLROf<nint>>;
+    static create16(lower: Vector256_1<CLROf<sbyte>>, upper: Vector256_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
+    static create16(lower: Vector256_1<CLROf<float>>, upper: Vector256_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static create16(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
+    static create16(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
+    static create16(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
+    static create16(lower: Vector256_1<CLROf<nuint>>, upper: Vector256_1<CLROf<nuint>>): Vector512_1<CLROf<nuint>>;
+    static create16(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte, e32: sbyte, e33: sbyte, e34: sbyte, e35: sbyte, e36: sbyte, e37: sbyte, e38: sbyte, e39: sbyte, e40: sbyte, e41: sbyte, e42: sbyte, e43: sbyte, e44: sbyte, e45: sbyte, e46: sbyte, e47: sbyte, e48: sbyte, e49: sbyte, e50: sbyte, e51: sbyte, e52: sbyte, e53: sbyte, e54: sbyte, e55: sbyte, e56: sbyte, e57: sbyte, e58: sbyte, e59: sbyte, e60: sbyte, e61: sbyte, e62: sbyte, e63: sbyte): Vector512_1<CLROf<sbyte>>;
+    static create16(value: sbyte): Vector512_1<CLROf<sbyte>>;
+    static create16(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float, e8: float, e9: float, e10: float, e11: float, e12: float, e13: float, e14: float, e15: float): Vector512_1<CLROf<float>>;
+    static create16(value: float): Vector512_1<CLROf<float>>;
+    static create16(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort, e16: ushort, e17: ushort, e18: ushort, e19: ushort, e20: ushort, e21: ushort, e22: ushort, e23: ushort, e24: ushort, e25: ushort, e26: ushort, e27: ushort, e28: ushort, e29: ushort, e30: ushort, e31: ushort): Vector512_1<CLROf<ushort>>;
+    static create16(value: ushort): Vector512_1<CLROf<ushort>>;
+    static create16(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint, e8: uint, e9: uint, e10: uint, e11: uint, e12: uint, e13: uint, e14: uint, e15: uint): Vector512_1<CLROf<uint>>;
+    static create16(value: uint): Vector512_1<CLROf<uint>>;
+    static create16(e0: ulong, e1: ulong, e2: ulong, e3: ulong, e4: ulong, e5: ulong, e6: ulong, e7: ulong): Vector512_1<CLROf<ulong>>;
+    static create16(value: ulong): Vector512_1<CLROf<ulong>>;
+    static create16(value: nuint): Vector512_1<CLROf<nuint>>;
+    static create16<T>(value: T): Vector512_1<T>;
+    static create16<T>(values: T[], index: int): Vector512_1<T>;
+    static create16<T>(values: T[]): Vector512_1<T>;
+    static create16<T>(value: Vector128_1<T>): Vector512_1<T>;
+    static create16<T>(lower: Vector256_1<T>, upper: Vector256_1<T>): Vector512_1<T>;
+    static create16<T>(value: Vector256_1<T>): Vector512_1<T>;
+    static create16<T>(value: Vector64_1<T>): Vector512_1<T>;
+    static createScalar2(value: byte): Vector512_1<CLROf<byte>>;
+    static createScalar2(value: double): Vector512_1<CLROf<double>>;
+    static createScalar2(value: short): Vector512_1<CLROf<short>>;
+    static createScalar2(value: int): Vector512_1<CLROf<int>>;
+    static createScalar2(value: long): Vector512_1<CLROf<long>>;
+    static createScalar2(value: nint): Vector512_1<CLROf<nint>>;
+    static createScalar2(value: sbyte): Vector512_1<CLROf<sbyte>>;
+    static createScalar2(value: float): Vector512_1<CLROf<float>>;
+    static createScalar2(value: ushort): Vector512_1<CLROf<ushort>>;
+    static createScalar2(value: uint): Vector512_1<CLROf<uint>>;
+    static createScalar2(value: ulong): Vector512_1<CLROf<ulong>>;
+    static createScalar2(value: nuint): Vector512_1<CLROf<nuint>>;
+    static createScalar2<T>(value: T): Vector512_1<T>;
+    static createScalarUnsafe2(value: byte): Vector512_1<CLROf<byte>>;
+    static createScalarUnsafe2(value: double): Vector512_1<CLROf<double>>;
+    static createScalarUnsafe2(value: short): Vector512_1<CLROf<short>>;
+    static createScalarUnsafe2(value: int): Vector512_1<CLROf<int>>;
+    static createScalarUnsafe2(value: long): Vector512_1<CLROf<long>>;
+    static createScalarUnsafe2(value: nint): Vector512_1<CLROf<nint>>;
+    static createScalarUnsafe2(value: sbyte): Vector512_1<CLROf<sbyte>>;
+    static createScalarUnsafe2(value: float): Vector512_1<CLROf<float>>;
+    static createScalarUnsafe2(value: ushort): Vector512_1<CLROf<ushort>>;
+    static createScalarUnsafe2(value: uint): Vector512_1<CLROf<uint>>;
+    static createScalarUnsafe2(value: ulong): Vector512_1<CLROf<ulong>>;
+    static createScalarUnsafe2(value: nuint): Vector512_1<CLROf<nuint>>;
+    static createScalarUnsafe2<T>(value: T): Vector512_1<T>;
+    static createSequence<T>(start: T, step: T): Vector512_1<T>;
+    static degreesToRadians(degrees: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static degreesToRadians(degrees: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static divide2<T>(left: Vector512_1<T>, right: T): Vector512_1<T>;
+    static divide2<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static dot<T>(left: Vector512_1<T>, right: Vector512_1<T>): T;
+    static equals<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static equalsAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static equalsAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static exp(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static exp(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static extractMostSignificantBits<T>(vector: Vector512_1<T>): ulong;
+    static floor2(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static floor2(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static fusedMultiplyAdd(left: Vector512_1<CLROf<double>>, right: Vector512_1<CLROf<double>>, addend: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static fusedMultiplyAdd(left: Vector512_1<CLROf<float>>, right: Vector512_1<CLROf<float>>, addend: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
     static get_E<T extends IFloatingPointConstants_1<T>>(): Vector512_1<T>;
     static get_Epsilon<T extends IFloatingPointIeee754_1<T>>(): Vector512_1<T>;
     static get_NaN<T extends IFloatingPointIeee754_1<T>>(): Vector512_1<T>;
@@ -939,297 +947,297 @@ export abstract class Vector512$instance {
     static get_Pi<T extends IFloatingPointConstants_1<T>>(): Vector512_1<T>;
     static get_PositiveInfinity<T extends IFloatingPointIeee754_1<T>>(): Vector512_1<T>;
     static get_Tau<T extends IFloatingPointConstants_1<T>>(): Vector512_1<T>;
-    static GetElement<T>(vector: Vector512_1<T>, index: int): T;
-    static GetLower<T>(vector: Vector512_1<T>): Vector256_1<T>;
-    static GetUpper<T>(vector: Vector512_1<T>): Vector256_1<T>;
-    static GreaterThan<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static GreaterThanAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static Hypot(x: Vector512_1<CLROf<double>>, y: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Hypot(x: Vector512_1<CLROf<float>>, y: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static IndexOf<T>(vector: Vector512_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsFinite<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNaN<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNegative<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNormal<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsOddInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsPositive<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsSubnormal<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsZero<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static LastIndexOf<T>(vector: Vector512_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
-    static Lerp(x: Vector512_1<CLROf<double>>, y: Vector512_1<CLROf<double>>, amount: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Lerp(x: Vector512_1<CLROf<float>>, y: Vector512_1<CLROf<float>>, amount: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static LessThan<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static LessThanAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static LessThanAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector512_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector512_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector512_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }, elementOffset: nuint): Vector512_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }): Vector512_1<T>;
-    static Log(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Log(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Log2(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Log2(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Max<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxMagnitude<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxNative<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Min<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinMagnitude<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinNative<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Multiply<T>(left: T, right: Vector512_1<T>): Vector512_1<T>;
-    static Multiply<T>(left: Vector512_1<T>, right: T): Vector512_1<T>;
-    static Multiply<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MultiplyAddEstimate(left: Vector512_1<CLROf<double>>, right: Vector512_1<CLROf<double>>, addend: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static MultiplyAddEstimate(left: Vector512_1<CLROf<float>>, right: Vector512_1<CLROf<float>>, addend: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Narrow(lower: Vector512_1<CLROf<double>>, upper: Vector512_1<CLROf<double>>): Vector512_1<CLROf<float>>;
-    static Narrow(lower: Vector512_1<CLROf<short>>, upper: Vector512_1<CLROf<short>>): Vector512_1<CLROf<sbyte>>;
-    static Narrow(lower: Vector512_1<CLROf<int>>, upper: Vector512_1<CLROf<int>>): Vector512_1<CLROf<short>>;
-    static Narrow(lower: Vector512_1<CLROf<long>>, upper: Vector512_1<CLROf<long>>): Vector512_1<CLROf<int>>;
-    static Narrow(lower: Vector512_1<CLROf<ushort>>, upper: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<byte>>;
-    static Narrow(lower: Vector512_1<CLROf<uint>>, upper: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ushort>>;
-    static Narrow(lower: Vector512_1<CLROf<ulong>>, upper: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<uint>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<double>>, upper: Vector512_1<CLROf<double>>): Vector512_1<CLROf<float>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<short>>, upper: Vector512_1<CLROf<short>>): Vector512_1<CLROf<sbyte>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<int>>, upper: Vector512_1<CLROf<int>>): Vector512_1<CLROf<short>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<long>>, upper: Vector512_1<CLROf<long>>): Vector512_1<CLROf<int>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<ushort>>, upper: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<byte>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<uint>>, upper: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ushort>>;
-    static NarrowWithSaturation(lower: Vector512_1<CLROf<ulong>>, upper: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<uint>>;
-    static Negate<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static None<T>(vector: Vector512_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static RadiansToDegrees(radians: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static RadiansToDegrees(radians: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static Round(vector: Vector512_1<CLROf<double>>, mode: MidpointRounding): Vector512_1<CLROf<double>>;
-    static Round(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Round(vector: Vector512_1<CLROf<float>>, mode: MidpointRounding): Vector512_1<CLROf<float>>;
-    static Round(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<byte>>, shiftCount: int): Vector512_1<CLROf<byte>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<ushort>>, shiftCount: int): Vector512_1<CLROf<ushort>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<uint>>, shiftCount: int): Vector512_1<CLROf<uint>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<ulong>>, shiftCount: int): Vector512_1<CLROf<ulong>>;
-    static ShiftLeft(vector: Vector512_1<CLROf<nuint>>, shiftCount: int): Vector512_1<CLROf<nuint>>;
-    static ShiftRightArithmetic(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
-    static ShiftRightArithmetic(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
-    static ShiftRightArithmetic(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
-    static ShiftRightArithmetic(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
-    static ShiftRightArithmetic(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<byte>>, shiftCount: int): Vector512_1<CLROf<byte>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<ushort>>, shiftCount: int): Vector512_1<CLROf<ushort>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<uint>>, shiftCount: int): Vector512_1<CLROf<uint>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<ulong>>, shiftCount: int): Vector512_1<CLROf<ulong>>;
-    static ShiftRightLogical(vector: Vector512_1<CLROf<nuint>>, shiftCount: int): Vector512_1<CLROf<nuint>>;
-    static Shuffle(vector: Vector512_1<CLROf<byte>>, indices: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
-    static Shuffle(vector: Vector512_1<CLROf<double>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
-    static Shuffle(vector: Vector512_1<CLROf<short>>, indices: Vector512_1<CLROf<short>>): Vector512_1<CLROf<short>>;
-    static Shuffle(vector: Vector512_1<CLROf<int>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<int>>;
-    static Shuffle(vector: Vector512_1<CLROf<long>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<long>>;
-    static Shuffle(vector: Vector512_1<CLROf<sbyte>>, indices: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
-    static Shuffle(vector: Vector512_1<CLROf<float>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
-    static Shuffle(vector: Vector512_1<CLROf<ushort>>, indices: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
-    static Shuffle(vector: Vector512_1<CLROf<uint>>, indices: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
-    static Shuffle(vector: Vector512_1<CLROf<ulong>>, indices: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<byte>>, indices: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<double>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<short>>, indices: Vector512_1<CLROf<short>>): Vector512_1<CLROf<short>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<int>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<int>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<long>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<long>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<sbyte>>, indices: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<float>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<ushort>>, indices: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<uint>>, indices: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
-    static ShuffleNative(vector: Vector512_1<CLROf<ulong>>, indices: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
-    static Sin(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Sin(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static SinCos(vector: Vector512_1<CLROf<double>>): ValueTuple_2<Vector512_1<CLROf<double>>, Vector512_1<CLROf<double>>>;
-    static SinCos(vector: Vector512_1<CLROf<float>>): ValueTuple_2<Vector512_1<CLROf<float>>, Vector512_1<CLROf<float>>>;
-    static Sqrt<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static Store<T>(source: Vector512_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector512_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector512_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector512_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector512_1<T>, destination: { value: ref<T> }): void;
-    static Subtract<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static SubtractSaturate<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Sum<T>(vector: Vector512_1<T>): T;
-    static ToScalar<T>(vector: Vector512_1<T>): T;
-    static Truncate(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static Truncate(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static TryCopyTo<T>(vector: Vector512_1<T>, destination: Span_1<T>): boolean;
-    static Widen(source: Vector512_1<CLROf<byte>>): ValueTuple_2<Vector512_1<CLROf<ushort>>, Vector512_1<CLROf<ushort>>>;
-    static Widen(source: Vector512_1<CLROf<short>>): ValueTuple_2<Vector512_1<CLROf<int>>, Vector512_1<CLROf<int>>>;
-    static Widen(source: Vector512_1<CLROf<int>>): ValueTuple_2<Vector512_1<CLROf<long>>, Vector512_1<CLROf<long>>>;
-    static Widen(source: Vector512_1<CLROf<sbyte>>): ValueTuple_2<Vector512_1<CLROf<short>>, Vector512_1<CLROf<short>>>;
-    static Widen(source: Vector512_1<CLROf<float>>): ValueTuple_2<Vector512_1<CLROf<double>>, Vector512_1<CLROf<double>>>;
-    static Widen(source: Vector512_1<CLROf<ushort>>): ValueTuple_2<Vector512_1<CLROf<uint>>, Vector512_1<CLROf<uint>>>;
-    static Widen(source: Vector512_1<CLROf<uint>>): ValueTuple_2<Vector512_1<CLROf<ulong>>, Vector512_1<CLROf<ulong>>>;
-    static WidenLower(source: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<ushort>>;
-    static WidenLower(source: Vector512_1<CLROf<short>>): Vector512_1<CLROf<int>>;
-    static WidenLower(source: Vector512_1<CLROf<int>>): Vector512_1<CLROf<long>>;
-    static WidenLower(source: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<short>>;
-    static WidenLower(source: Vector512_1<CLROf<float>>): Vector512_1<CLROf<double>>;
-    static WidenLower(source: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<uint>>;
-    static WidenLower(source: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ulong>>;
-    static WidenUpper(source: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<ushort>>;
-    static WidenUpper(source: Vector512_1<CLROf<short>>): Vector512_1<CLROf<int>>;
-    static WidenUpper(source: Vector512_1<CLROf<int>>): Vector512_1<CLROf<long>>;
-    static WidenUpper(source: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<short>>;
-    static WidenUpper(source: Vector512_1<CLROf<float>>): Vector512_1<CLROf<double>>;
-    static WidenUpper(source: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<uint>>;
-    static WidenUpper(source: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ulong>>;
-    static WithElement<T>(vector: Vector512_1<T>, index: int, value: T): Vector512_1<T>;
-    static WithLower<T>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
-    static WithUpper<T>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
-    static Xor<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static getElement<T>(vector: Vector512_1<T>, index: int): T;
+    static getLower<T>(vector: Vector512_1<T>): Vector256_1<T>;
+    static getUpper<T>(vector: Vector512_1<T>): Vector256_1<T>;
+    static greaterThan<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static greaterThanAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static greaterThanAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static greaterThanOrEqual<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static greaterThanOrEqualAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static greaterThanOrEqualAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static hypot(x: Vector512_1<CLROf<double>>, y: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static hypot(x: Vector512_1<CLROf<float>>, y: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static indexOf<T>(vector: Vector512_1<T>, value: T): int;
+    static indexOfWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
+    static isEvenInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isFinite<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isNaN<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isNegative<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isNegativeInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isNormal<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isOddInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isPositive<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isPositiveInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isSubnormal<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static isZero<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static lastIndexOf<T>(vector: Vector512_1<T>, value: T): int;
+    static lastIndexOfWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
+    static lerp(x: Vector512_1<CLROf<double>>, y: Vector512_1<CLROf<double>>, amount: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static lerp(x: Vector512_1<CLROf<float>>, y: Vector512_1<CLROf<float>>, amount: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static lessThan<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static lessThanAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static lessThanAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static lessThanOrEqual<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static lessThanOrEqualAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static lessThanOrEqualAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static load<T>(source: ptr<T>): Vector512_1<T>;
+    static loadAligned<T>(source: ptr<T>): Vector512_1<T>;
+    static loadAlignedNonTemporal<T>(source: ptr<T>): Vector512_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }, elementOffset: nuint): Vector512_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }): Vector512_1<T>;
+    static log(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static log(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static log22(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static log22(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static max<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static maxMagnitude<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static maxMagnitudeNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static maxNative<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static maxNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static min<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static minMagnitude<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static minMagnitudeNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static minNative<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static minNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static multiply3<T>(left: T, right: Vector512_1<T>): Vector512_1<T>;
+    static multiply3<T>(left: Vector512_1<T>, right: T): Vector512_1<T>;
+    static multiply3<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static multiplyAddEstimate(left: Vector512_1<CLROf<double>>, right: Vector512_1<CLROf<double>>, addend: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static multiplyAddEstimate(left: Vector512_1<CLROf<float>>, right: Vector512_1<CLROf<float>>, addend: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static narrow(lower: Vector512_1<CLROf<double>>, upper: Vector512_1<CLROf<double>>): Vector512_1<CLROf<float>>;
+    static narrow(lower: Vector512_1<CLROf<short>>, upper: Vector512_1<CLROf<short>>): Vector512_1<CLROf<sbyte>>;
+    static narrow(lower: Vector512_1<CLROf<int>>, upper: Vector512_1<CLROf<int>>): Vector512_1<CLROf<short>>;
+    static narrow(lower: Vector512_1<CLROf<long>>, upper: Vector512_1<CLROf<long>>): Vector512_1<CLROf<int>>;
+    static narrow(lower: Vector512_1<CLROf<ushort>>, upper: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<byte>>;
+    static narrow(lower: Vector512_1<CLROf<uint>>, upper: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ushort>>;
+    static narrow(lower: Vector512_1<CLROf<ulong>>, upper: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<uint>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<double>>, upper: Vector512_1<CLROf<double>>): Vector512_1<CLROf<float>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<short>>, upper: Vector512_1<CLROf<short>>): Vector512_1<CLROf<sbyte>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<int>>, upper: Vector512_1<CLROf<int>>): Vector512_1<CLROf<short>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<long>>, upper: Vector512_1<CLROf<long>>): Vector512_1<CLROf<int>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<ushort>>, upper: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<byte>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<uint>>, upper: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ushort>>;
+    static narrowWithSaturation(lower: Vector512_1<CLROf<ulong>>, upper: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<uint>>;
+    static negate<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static none<T>(vector: Vector512_1<T>, value: T): boolean;
+    static noneWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
+    static onesComplement<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static radiansToDegrees(radians: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static radiansToDegrees(radians: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static round3(vector: Vector512_1<CLROf<double>>, mode: MidpointRounding): Vector512_1<CLROf<double>>;
+    static round3(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static round3(vector: Vector512_1<CLROf<float>>, mode: MidpointRounding): Vector512_1<CLROf<float>>;
+    static round3(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static shiftLeft(vector: Vector512_1<CLROf<byte>>, shiftCount: int): Vector512_1<CLROf<byte>>;
+    static shiftLeft(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
+    static shiftLeft(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
+    static shiftLeft(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
+    static shiftLeft(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
+    static shiftLeft(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
+    static shiftLeft(vector: Vector512_1<CLROf<ushort>>, shiftCount: int): Vector512_1<CLROf<ushort>>;
+    static shiftLeft(vector: Vector512_1<CLROf<uint>>, shiftCount: int): Vector512_1<CLROf<uint>>;
+    static shiftLeft(vector: Vector512_1<CLROf<ulong>>, shiftCount: int): Vector512_1<CLROf<ulong>>;
+    static shiftLeft(vector: Vector512_1<CLROf<nuint>>, shiftCount: int): Vector512_1<CLROf<nuint>>;
+    static shiftRightArithmetic(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
+    static shiftRightArithmetic(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
+    static shiftRightArithmetic(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
+    static shiftRightArithmetic(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
+    static shiftRightArithmetic(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<byte>>, shiftCount: int): Vector512_1<CLROf<byte>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<ushort>>, shiftCount: int): Vector512_1<CLROf<ushort>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<uint>>, shiftCount: int): Vector512_1<CLROf<uint>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<ulong>>, shiftCount: int): Vector512_1<CLROf<ulong>>;
+    static shiftRightLogical(vector: Vector512_1<CLROf<nuint>>, shiftCount: int): Vector512_1<CLROf<nuint>>;
+    static shuffle(vector: Vector512_1<CLROf<byte>>, indices: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
+    static shuffle(vector: Vector512_1<CLROf<double>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
+    static shuffle(vector: Vector512_1<CLROf<short>>, indices: Vector512_1<CLROf<short>>): Vector512_1<CLROf<short>>;
+    static shuffle(vector: Vector512_1<CLROf<int>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<int>>;
+    static shuffle(vector: Vector512_1<CLROf<long>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<long>>;
+    static shuffle(vector: Vector512_1<CLROf<sbyte>>, indices: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
+    static shuffle(vector: Vector512_1<CLROf<float>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
+    static shuffle(vector: Vector512_1<CLROf<ushort>>, indices: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
+    static shuffle(vector: Vector512_1<CLROf<uint>>, indices: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
+    static shuffle(vector: Vector512_1<CLROf<ulong>>, indices: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
+    static shuffleNative(vector: Vector512_1<CLROf<byte>>, indices: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
+    static shuffleNative(vector: Vector512_1<CLROf<double>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
+    static shuffleNative(vector: Vector512_1<CLROf<short>>, indices: Vector512_1<CLROf<short>>): Vector512_1<CLROf<short>>;
+    static shuffleNative(vector: Vector512_1<CLROf<int>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<int>>;
+    static shuffleNative(vector: Vector512_1<CLROf<long>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<long>>;
+    static shuffleNative(vector: Vector512_1<CLROf<sbyte>>, indices: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
+    static shuffleNative(vector: Vector512_1<CLROf<float>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
+    static shuffleNative(vector: Vector512_1<CLROf<ushort>>, indices: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
+    static shuffleNative(vector: Vector512_1<CLROf<uint>>, indices: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
+    static shuffleNative(vector: Vector512_1<CLROf<ulong>>, indices: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
+    static sin(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static sin(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static sinCos(vector: Vector512_1<CLROf<double>>): ValueTuple_2<Vector512_1<CLROf<double>>, Vector512_1<CLROf<double>>>;
+    static sinCos(vector: Vector512_1<CLROf<float>>): ValueTuple_2<Vector512_1<CLROf<float>>, Vector512_1<CLROf<float>>>;
+    static sqrt<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static store<T>(source: Vector512_1<T>, destination: ptr<T>): void;
+    static storeAligned<T>(source: Vector512_1<T>, destination: ptr<T>): void;
+    static storeAlignedNonTemporal<T>(source: Vector512_1<T>, destination: ptr<T>): void;
+    static storeUnsafe2<T>(source: Vector512_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
+    static storeUnsafe2<T>(source: Vector512_1<T>, destination: { value: ref<T> }): void;
+    static subtract<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static subtractSaturate<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static sum<T>(vector: Vector512_1<T>): T;
+    static toScalar<T>(vector: Vector512_1<T>): T;
+    static truncate(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
+    static truncate(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static tryCopyTo<T>(vector: Vector512_1<T>, destination: Span_1<T>): boolean;
+    static widen(source: Vector512_1<CLROf<byte>>): ValueTuple_2<Vector512_1<CLROf<ushort>>, Vector512_1<CLROf<ushort>>>;
+    static widen(source: Vector512_1<CLROf<short>>): ValueTuple_2<Vector512_1<CLROf<int>>, Vector512_1<CLROf<int>>>;
+    static widen(source: Vector512_1<CLROf<int>>): ValueTuple_2<Vector512_1<CLROf<long>>, Vector512_1<CLROf<long>>>;
+    static widen(source: Vector512_1<CLROf<sbyte>>): ValueTuple_2<Vector512_1<CLROf<short>>, Vector512_1<CLROf<short>>>;
+    static widen(source: Vector512_1<CLROf<float>>): ValueTuple_2<Vector512_1<CLROf<double>>, Vector512_1<CLROf<double>>>;
+    static widen(source: Vector512_1<CLROf<ushort>>): ValueTuple_2<Vector512_1<CLROf<uint>>, Vector512_1<CLROf<uint>>>;
+    static widen(source: Vector512_1<CLROf<uint>>): ValueTuple_2<Vector512_1<CLROf<ulong>>, Vector512_1<CLROf<ulong>>>;
+    static widenLower(source: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<ushort>>;
+    static widenLower(source: Vector512_1<CLROf<short>>): Vector512_1<CLROf<int>>;
+    static widenLower(source: Vector512_1<CLROf<int>>): Vector512_1<CLROf<long>>;
+    static widenLower(source: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<short>>;
+    static widenLower(source: Vector512_1<CLROf<float>>): Vector512_1<CLROf<double>>;
+    static widenLower(source: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<uint>>;
+    static widenLower(source: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ulong>>;
+    static widenUpper(source: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<ushort>>;
+    static widenUpper(source: Vector512_1<CLROf<short>>): Vector512_1<CLROf<int>>;
+    static widenUpper(source: Vector512_1<CLROf<int>>): Vector512_1<CLROf<long>>;
+    static widenUpper(source: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<short>>;
+    static widenUpper(source: Vector512_1<CLROf<float>>): Vector512_1<CLROf<double>>;
+    static widenUpper(source: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<uint>>;
+    static widenUpper(source: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ulong>>;
+    static withElement<T>(vector: Vector512_1<T>, index: int, value: T): Vector512_1<T>;
+    static withLower<T>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
+    static withUpper<T>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
+    static xor<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
 }
 
 
 export type Vector512 = Vector512$instance;
 
 export abstract class Vector64$instance {
-    static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static Add<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static AddSaturate<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static All<T>(vector: Vector64_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
-    static AndNot<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Any<T>(vector: Vector64_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector64_1<TFrom>): Vector64_1<TTo>;
-    static AsByte<T>(vector: Vector64_1<T>): Vector64_1<CLROf<byte>>;
-    static AsDouble<T>(vector: Vector64_1<T>): Vector64_1<CLROf<double>>;
-    static AsInt16<T>(vector: Vector64_1<T>): Vector64_1<CLROf<short>>;
-    static AsInt32<T>(vector: Vector64_1<T>): Vector64_1<CLROf<int>>;
-    static AsInt64<T>(vector: Vector64_1<T>): Vector64_1<CLROf<long>>;
-    static AsNInt<T>(vector: Vector64_1<T>): Vector64_1<CLROf<nint>>;
-    static AsNUInt<T>(vector: Vector64_1<T>): Vector64_1<CLROf<nuint>>;
-    static AsSByte<T>(vector: Vector64_1<T>): Vector64_1<CLROf<sbyte>>;
-    static AsSingle<T>(vector: Vector64_1<T>): Vector64_1<CLROf<float>>;
-    static AsUInt16<T>(vector: Vector64_1<T>): Vector64_1<CLROf<ushort>>;
-    static AsUInt32<T>(vector: Vector64_1<T>): Vector64_1<CLROf<uint>>;
-    static AsUInt64<T>(vector: Vector64_1<T>): Vector64_1<CLROf<ulong>>;
-    static BitwiseAnd<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static BitwiseOr<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Ceiling(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Ceiling(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Clamp<T>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
-    static ClampNative<T>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
-    static ConditionalSelect<T>(condition: Vector64_1<T>, left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static ConvertToDouble(vector: Vector64_1<CLROf<long>>): Vector64_1<CLROf<double>>;
-    static ConvertToDouble(vector: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<double>>;
-    static ConvertToInt32(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<int>>;
-    static ConvertToInt32Native(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<int>>;
-    static ConvertToInt64(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<long>>;
-    static ConvertToInt64Native(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<long>>;
-    static ConvertToSingle(vector: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
-    static ConvertToSingle(vector: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<float>>;
-    static ConvertToUInt32(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<uint>>;
-    static ConvertToUInt32Native(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<uint>>;
-    static ConvertToUInt64(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<ulong>>;
-    static ConvertToUInt64Native(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<ulong>>;
-    static CopySign<T>(value: Vector64_1<T>, sign: Vector64_1<T>): Vector64_1<T>;
-    static CopyTo<T>(vector: Vector64_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector64_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector64_1<T>, destination: T[]): void;
-    static Cos(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Cos(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Count<T>(vector: Vector64_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector64_1<T>;
-    static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte): Vector64_1<CLROf<byte>>;
-    static Create(value: byte): Vector64_1<CLROf<byte>>;
-    static Create(value: double): Vector64_1<CLROf<double>>;
-    static Create(e0: short, e1: short, e2: short, e3: short): Vector64_1<CLROf<short>>;
-    static Create(value: short): Vector64_1<CLROf<short>>;
-    static Create(e0: int, e1: int): Vector64_1<CLROf<int>>;
-    static Create(value: int): Vector64_1<CLROf<int>>;
-    static Create(value: long): Vector64_1<CLROf<long>>;
-    static Create(value: nint): Vector64_1<CLROf<nint>>;
-    static Create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte): Vector64_1<CLROf<sbyte>>;
-    static Create(value: sbyte): Vector64_1<CLROf<sbyte>>;
-    static Create(e0: float, e1: float): Vector64_1<CLROf<float>>;
-    static Create(value: float): Vector64_1<CLROf<float>>;
-    static Create(e0: ushort, e1: ushort, e2: ushort, e3: ushort): Vector64_1<CLROf<ushort>>;
-    static Create(value: ushort): Vector64_1<CLROf<ushort>>;
-    static Create(e0: uint, e1: uint): Vector64_1<CLROf<uint>>;
-    static Create(value: uint): Vector64_1<CLROf<uint>>;
-    static Create(value: ulong): Vector64_1<CLROf<ulong>>;
-    static Create(value: nuint): Vector64_1<CLROf<nuint>>;
-    static Create<T>(value: T): Vector64_1<T>;
-    static Create<T>(values: T[], index: int): Vector64_1<T>;
-    static Create<T>(values: T[]): Vector64_1<T>;
-    static CreateScalar(value: byte): Vector64_1<CLROf<byte>>;
-    static CreateScalar(value: double): Vector64_1<CLROf<double>>;
-    static CreateScalar(value: short): Vector64_1<CLROf<short>>;
-    static CreateScalar(value: int): Vector64_1<CLROf<int>>;
-    static CreateScalar(value: long): Vector64_1<CLROf<long>>;
-    static CreateScalar(value: nint): Vector64_1<CLROf<nint>>;
-    static CreateScalar(value: sbyte): Vector64_1<CLROf<sbyte>>;
-    static CreateScalar(value: float): Vector64_1<CLROf<float>>;
-    static CreateScalar(value: ushort): Vector64_1<CLROf<ushort>>;
-    static CreateScalar(value: uint): Vector64_1<CLROf<uint>>;
-    static CreateScalar(value: ulong): Vector64_1<CLROf<ulong>>;
-    static CreateScalar(value: nuint): Vector64_1<CLROf<nuint>>;
-    static CreateScalar<T>(value: T): Vector64_1<T>;
-    static CreateScalarUnsafe(value: byte): Vector64_1<CLROf<byte>>;
-    static CreateScalarUnsafe(value: double): Vector64_1<CLROf<double>>;
-    static CreateScalarUnsafe(value: short): Vector64_1<CLROf<short>>;
-    static CreateScalarUnsafe(value: int): Vector64_1<CLROf<int>>;
-    static CreateScalarUnsafe(value: long): Vector64_1<CLROf<long>>;
-    static CreateScalarUnsafe(value: nint): Vector64_1<CLROf<nint>>;
-    static CreateScalarUnsafe(value: sbyte): Vector64_1<CLROf<sbyte>>;
-    static CreateScalarUnsafe(value: float): Vector64_1<CLROf<float>>;
-    static CreateScalarUnsafe(value: ushort): Vector64_1<CLROf<ushort>>;
-    static CreateScalarUnsafe(value: uint): Vector64_1<CLROf<uint>>;
-    static CreateScalarUnsafe(value: ulong): Vector64_1<CLROf<ulong>>;
-    static CreateScalarUnsafe(value: nuint): Vector64_1<CLROf<nuint>>;
-    static CreateScalarUnsafe<T>(value: T): Vector64_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector64_1<T>;
-    static DegreesToRadians(degrees: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static DegreesToRadians(degrees: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Divide<T>(left: Vector64_1<T>, right: T): Vector64_1<T>;
-    static Divide<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Dot<T>(left: Vector64_1<T>, right: Vector64_1<T>): T;
-    static Equals<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static EqualsAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static EqualsAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static Exp(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Exp(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static ExtractMostSignificantBits<T>(vector: Vector64_1<T>): uint;
-    static Floor(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Floor(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static FusedMultiplyAdd(left: Vector64_1<CLROf<double>>, right: Vector64_1<CLROf<double>>, addend: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static FusedMultiplyAdd(left: Vector64_1<CLROf<float>>, right: Vector64_1<CLROf<float>>, addend: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static readonly isHardwareAccelerated: boolean;
+    static abs<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static add<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static addSaturate<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static all<T>(vector: Vector64_1<T>, value: T): boolean;
+    static allWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
+    static andNot<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static any_<T>(vector: Vector64_1<T>, value: T): boolean;
+    static anyWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
+    static as_<TFrom, TTo>(vector: Vector64_1<TFrom>): Vector64_1<TTo>;
+    static asByte<T>(vector: Vector64_1<T>): Vector64_1<CLROf<byte>>;
+    static asDouble<T>(vector: Vector64_1<T>): Vector64_1<CLROf<double>>;
+    static asInt16<T>(vector: Vector64_1<T>): Vector64_1<CLROf<short>>;
+    static asInt32<T>(vector: Vector64_1<T>): Vector64_1<CLROf<int>>;
+    static asInt64<T>(vector: Vector64_1<T>): Vector64_1<CLROf<long>>;
+    static asNInt<T>(vector: Vector64_1<T>): Vector64_1<CLROf<nint>>;
+    static asNUInt<T>(vector: Vector64_1<T>): Vector64_1<CLROf<nuint>>;
+    static asSByte<T>(vector: Vector64_1<T>): Vector64_1<CLROf<sbyte>>;
+    static asSingle<T>(vector: Vector64_1<T>): Vector64_1<CLROf<float>>;
+    static asUInt16<T>(vector: Vector64_1<T>): Vector64_1<CLROf<ushort>>;
+    static asUInt32<T>(vector: Vector64_1<T>): Vector64_1<CLROf<uint>>;
+    static asUInt64<T>(vector: Vector64_1<T>): Vector64_1<CLROf<ulong>>;
+    static bitwiseAnd<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static bitwiseOr<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static ceiling2(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static ceiling2(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static clamp<T>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
+    static clampNative<T>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
+    static conditionalSelect<T>(condition: Vector64_1<T>, left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static convertToDouble(vector: Vector64_1<CLROf<long>>): Vector64_1<CLROf<double>>;
+    static convertToDouble(vector: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<double>>;
+    static convertToInt32(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<int>>;
+    static convertToInt32Native(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<int>>;
+    static convertToInt64(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<long>>;
+    static convertToInt64Native(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<long>>;
+    static convertToSingle(vector: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
+    static convertToSingle(vector: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<float>>;
+    static convertToUInt32(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<uint>>;
+    static convertToUInt32Native(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<uint>>;
+    static convertToUInt64(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<ulong>>;
+    static convertToUInt64Native(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<ulong>>;
+    static copySign<T>(value: Vector64_1<T>, sign: Vector64_1<T>): Vector64_1<T>;
+    static copyTo3<T>(vector: Vector64_1<T>, destination: Span_1<T>): void;
+    static copyTo3<T>(vector: Vector64_1<T>, destination: T[], startIndex: int): void;
+    static copyTo3<T>(vector: Vector64_1<T>, destination: T[]): void;
+    static cos(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static cos(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static count<T>(vector: Vector64_1<T>, value: T): int;
+    static countWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
+    static create16<T>(values: ReadOnlySpan_1<T>): Vector64_1<T>;
+    static create16(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte): Vector64_1<CLROf<byte>>;
+    static create16(value: byte): Vector64_1<CLROf<byte>>;
+    static create16(value: double): Vector64_1<CLROf<double>>;
+    static create16(e0: short, e1: short, e2: short, e3: short): Vector64_1<CLROf<short>>;
+    static create16(value: short): Vector64_1<CLROf<short>>;
+    static create16(e0: int, e1: int): Vector64_1<CLROf<int>>;
+    static create16(value: int): Vector64_1<CLROf<int>>;
+    static create16(value: long): Vector64_1<CLROf<long>>;
+    static create16(value: nint): Vector64_1<CLROf<nint>>;
+    static create16(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte): Vector64_1<CLROf<sbyte>>;
+    static create16(value: sbyte): Vector64_1<CLROf<sbyte>>;
+    static create16(e0: float, e1: float): Vector64_1<CLROf<float>>;
+    static create16(value: float): Vector64_1<CLROf<float>>;
+    static create16(e0: ushort, e1: ushort, e2: ushort, e3: ushort): Vector64_1<CLROf<ushort>>;
+    static create16(value: ushort): Vector64_1<CLROf<ushort>>;
+    static create16(e0: uint, e1: uint): Vector64_1<CLROf<uint>>;
+    static create16(value: uint): Vector64_1<CLROf<uint>>;
+    static create16(value: ulong): Vector64_1<CLROf<ulong>>;
+    static create16(value: nuint): Vector64_1<CLROf<nuint>>;
+    static create16<T>(value: T): Vector64_1<T>;
+    static create16<T>(values: T[], index: int): Vector64_1<T>;
+    static create16<T>(values: T[]): Vector64_1<T>;
+    static createScalar2(value: byte): Vector64_1<CLROf<byte>>;
+    static createScalar2(value: double): Vector64_1<CLROf<double>>;
+    static createScalar2(value: short): Vector64_1<CLROf<short>>;
+    static createScalar2(value: int): Vector64_1<CLROf<int>>;
+    static createScalar2(value: long): Vector64_1<CLROf<long>>;
+    static createScalar2(value: nint): Vector64_1<CLROf<nint>>;
+    static createScalar2(value: sbyte): Vector64_1<CLROf<sbyte>>;
+    static createScalar2(value: float): Vector64_1<CLROf<float>>;
+    static createScalar2(value: ushort): Vector64_1<CLROf<ushort>>;
+    static createScalar2(value: uint): Vector64_1<CLROf<uint>>;
+    static createScalar2(value: ulong): Vector64_1<CLROf<ulong>>;
+    static createScalar2(value: nuint): Vector64_1<CLROf<nuint>>;
+    static createScalar2<T>(value: T): Vector64_1<T>;
+    static createScalarUnsafe2(value: byte): Vector64_1<CLROf<byte>>;
+    static createScalarUnsafe2(value: double): Vector64_1<CLROf<double>>;
+    static createScalarUnsafe2(value: short): Vector64_1<CLROf<short>>;
+    static createScalarUnsafe2(value: int): Vector64_1<CLROf<int>>;
+    static createScalarUnsafe2(value: long): Vector64_1<CLROf<long>>;
+    static createScalarUnsafe2(value: nint): Vector64_1<CLROf<nint>>;
+    static createScalarUnsafe2(value: sbyte): Vector64_1<CLROf<sbyte>>;
+    static createScalarUnsafe2(value: float): Vector64_1<CLROf<float>>;
+    static createScalarUnsafe2(value: ushort): Vector64_1<CLROf<ushort>>;
+    static createScalarUnsafe2(value: uint): Vector64_1<CLROf<uint>>;
+    static createScalarUnsafe2(value: ulong): Vector64_1<CLROf<ulong>>;
+    static createScalarUnsafe2(value: nuint): Vector64_1<CLROf<nuint>>;
+    static createScalarUnsafe2<T>(value: T): Vector64_1<T>;
+    static createSequence<T>(start: T, step: T): Vector64_1<T>;
+    static degreesToRadians(degrees: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static degreesToRadians(degrees: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static divide2<T>(left: Vector64_1<T>, right: T): Vector64_1<T>;
+    static divide2<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static dot<T>(left: Vector64_1<T>, right: Vector64_1<T>): T;
+    static equals<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static equalsAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static equalsAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static exp(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static exp(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static extractMostSignificantBits<T>(vector: Vector64_1<T>): uint;
+    static floor2(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static floor2(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static fusedMultiplyAdd(left: Vector64_1<CLROf<double>>, right: Vector64_1<CLROf<double>>, addend: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static fusedMultiplyAdd(left: Vector64_1<CLROf<float>>, right: Vector64_1<CLROf<float>>, addend: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
     static get_E<T extends IFloatingPointConstants_1<T>>(): Vector64_1<T>;
     static get_Epsilon<T extends IFloatingPointIeee754_1<T>>(): Vector64_1<T>;
     static get_NaN<T extends IFloatingPointIeee754_1<T>>(): Vector64_1<T>;
@@ -1239,169 +1247,169 @@ export abstract class Vector64$instance {
     static get_Pi<T extends IFloatingPointConstants_1<T>>(): Vector64_1<T>;
     static get_PositiveInfinity<T extends IFloatingPointIeee754_1<T>>(): Vector64_1<T>;
     static get_Tau<T extends IFloatingPointConstants_1<T>>(): Vector64_1<T>;
-    static GetElement<T>(vector: Vector64_1<T>, index: int): T;
-    static GreaterThan<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static GreaterThanAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static Hypot(x: Vector64_1<CLROf<double>>, y: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Hypot(x: Vector64_1<CLROf<float>>, y: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static IndexOf<T>(vector: Vector64_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsFinite<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNaN<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNegative<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNormal<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsOddInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsPositive<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsSubnormal<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsZero<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static LastIndexOf<T>(vector: Vector64_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
-    static Lerp(x: Vector64_1<CLROf<double>>, y: Vector64_1<CLROf<double>>, amount: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Lerp(x: Vector64_1<CLROf<float>>, y: Vector64_1<CLROf<float>>, amount: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static LessThan<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static LessThanAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static LessThanAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector64_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector64_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector64_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }, elementOffset: nuint): Vector64_1<T>;
-    static LoadUnsafe<T>(source: { value: ref<T> }): Vector64_1<T>;
-    static Log(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Log(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Log2(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Log2(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Max<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxMagnitude<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxNative<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Min<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinMagnitude<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinNative<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Multiply<T>(left: T, right: Vector64_1<T>): Vector64_1<T>;
-    static Multiply<T>(left: Vector64_1<T>, right: T): Vector64_1<T>;
-    static Multiply<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MultiplyAddEstimate(left: Vector64_1<CLROf<double>>, right: Vector64_1<CLROf<double>>, addend: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static MultiplyAddEstimate(left: Vector64_1<CLROf<float>>, right: Vector64_1<CLROf<float>>, addend: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Narrow(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector64_1<CLROf<float>>;
-    static Narrow(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector64_1<CLROf<sbyte>>;
-    static Narrow(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector64_1<CLROf<short>>;
-    static Narrow(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector64_1<CLROf<int>>;
-    static Narrow(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<byte>>;
-    static Narrow(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ushort>>;
-    static Narrow(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<uint>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector64_1<CLROf<float>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector64_1<CLROf<sbyte>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector64_1<CLROf<short>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector64_1<CLROf<int>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<byte>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ushort>>;
-    static NarrowWithSaturation(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<uint>>;
-    static Negate<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static None<T>(vector: Vector64_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static RadiansToDegrees(radians: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static RadiansToDegrees(radians: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static Round(vector: Vector64_1<CLROf<double>>, mode: MidpointRounding): Vector64_1<CLROf<double>>;
-    static Round(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Round(vector: Vector64_1<CLROf<float>>, mode: MidpointRounding): Vector64_1<CLROf<float>>;
-    static Round(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<byte>>, shiftCount: int): Vector64_1<CLROf<byte>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<ushort>>, shiftCount: int): Vector64_1<CLROf<ushort>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<uint>>, shiftCount: int): Vector64_1<CLROf<uint>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<ulong>>, shiftCount: int): Vector64_1<CLROf<ulong>>;
-    static ShiftLeft(vector: Vector64_1<CLROf<nuint>>, shiftCount: int): Vector64_1<CLROf<nuint>>;
-    static ShiftRightArithmetic(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
-    static ShiftRightArithmetic(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
-    static ShiftRightArithmetic(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
-    static ShiftRightArithmetic(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
-    static ShiftRightArithmetic(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<byte>>, shiftCount: int): Vector64_1<CLROf<byte>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<ushort>>, shiftCount: int): Vector64_1<CLROf<ushort>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<uint>>, shiftCount: int): Vector64_1<CLROf<uint>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<ulong>>, shiftCount: int): Vector64_1<CLROf<ulong>>;
-    static ShiftRightLogical(vector: Vector64_1<CLROf<nuint>>, shiftCount: int): Vector64_1<CLROf<nuint>>;
-    static Shuffle(vector: Vector64_1<CLROf<byte>>, indices: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<byte>>;
-    static Shuffle(vector: Vector64_1<CLROf<short>>, indices: Vector64_1<CLROf<short>>): Vector64_1<CLROf<short>>;
-    static Shuffle(vector: Vector64_1<CLROf<int>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<int>>;
-    static Shuffle(vector: Vector64_1<CLROf<sbyte>>, indices: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<sbyte>>;
-    static Shuffle(vector: Vector64_1<CLROf<float>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
-    static Shuffle(vector: Vector64_1<CLROf<ushort>>, indices: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<ushort>>;
-    static Shuffle(vector: Vector64_1<CLROf<uint>>, indices: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<uint>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<byte>>, indices: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<byte>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<short>>, indices: Vector64_1<CLROf<short>>): Vector64_1<CLROf<short>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<int>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<int>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<sbyte>>, indices: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<sbyte>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<float>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<ushort>>, indices: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<ushort>>;
-    static ShuffleNative(vector: Vector64_1<CLROf<uint>>, indices: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<uint>>;
-    static Sin(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Sin(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static SinCos(vector: Vector64_1<CLROf<double>>): ValueTuple_2<Vector64_1<CLROf<double>>, Vector64_1<CLROf<double>>>;
-    static SinCos(vector: Vector64_1<CLROf<float>>): ValueTuple_2<Vector64_1<CLROf<float>>, Vector64_1<CLROf<float>>>;
-    static Sqrt<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static Store<T>(source: Vector64_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector64_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector64_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector64_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector64_1<T>, destination: { value: ref<T> }): void;
-    static Subtract<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static SubtractSaturate<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Sum<T>(vector: Vector64_1<T>): T;
-    static ToScalar<T>(vector: Vector64_1<T>): T;
-    static ToVector128<T>(vector: Vector64_1<T>): Vector128_1<T>;
-    static ToVector128Unsafe<T>(vector: Vector64_1<T>): Vector128_1<T>;
-    static Truncate(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static Truncate(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static TryCopyTo<T>(vector: Vector64_1<T>, destination: Span_1<T>): boolean;
-    static Widen(source: Vector64_1<CLROf<byte>>): ValueTuple_2<Vector64_1<CLROf<ushort>>, Vector64_1<CLROf<ushort>>>;
-    static Widen(source: Vector64_1<CLROf<short>>): ValueTuple_2<Vector64_1<CLROf<int>>, Vector64_1<CLROf<int>>>;
-    static Widen(source: Vector64_1<CLROf<int>>): ValueTuple_2<Vector64_1<CLROf<long>>, Vector64_1<CLROf<long>>>;
-    static Widen(source: Vector64_1<CLROf<sbyte>>): ValueTuple_2<Vector64_1<CLROf<short>>, Vector64_1<CLROf<short>>>;
-    static Widen(source: Vector64_1<CLROf<float>>): ValueTuple_2<Vector64_1<CLROf<double>>, Vector64_1<CLROf<double>>>;
-    static Widen(source: Vector64_1<CLROf<ushort>>): ValueTuple_2<Vector64_1<CLROf<uint>>, Vector64_1<CLROf<uint>>>;
-    static Widen(source: Vector64_1<CLROf<uint>>): ValueTuple_2<Vector64_1<CLROf<ulong>>, Vector64_1<CLROf<ulong>>>;
-    static WidenLower(source: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<ushort>>;
-    static WidenLower(source: Vector64_1<CLROf<short>>): Vector64_1<CLROf<int>>;
-    static WidenLower(source: Vector64_1<CLROf<int>>): Vector64_1<CLROf<long>>;
-    static WidenLower(source: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<short>>;
-    static WidenLower(source: Vector64_1<CLROf<float>>): Vector64_1<CLROf<double>>;
-    static WidenLower(source: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<uint>>;
-    static WidenLower(source: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ulong>>;
-    static WidenUpper(source: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<ushort>>;
-    static WidenUpper(source: Vector64_1<CLROf<short>>): Vector64_1<CLROf<int>>;
-    static WidenUpper(source: Vector64_1<CLROf<int>>): Vector64_1<CLROf<long>>;
-    static WidenUpper(source: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<short>>;
-    static WidenUpper(source: Vector64_1<CLROf<float>>): Vector64_1<CLROf<double>>;
-    static WidenUpper(source: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<uint>>;
-    static WidenUpper(source: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ulong>>;
-    static WithElement<T>(vector: Vector64_1<T>, index: int, value: T): Vector64_1<T>;
-    static Xor<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static getElement<T>(vector: Vector64_1<T>, index: int): T;
+    static greaterThan<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static greaterThanAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static greaterThanAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static greaterThanOrEqual<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static greaterThanOrEqualAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static greaterThanOrEqualAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static hypot(x: Vector64_1<CLROf<double>>, y: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static hypot(x: Vector64_1<CLROf<float>>, y: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static indexOf<T>(vector: Vector64_1<T>, value: T): int;
+    static indexOfWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
+    static isEvenInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isFinite<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isNaN<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isNegative<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isNegativeInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isNormal<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isOddInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isPositive<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isPositiveInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isSubnormal<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static isZero<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static lastIndexOf<T>(vector: Vector64_1<T>, value: T): int;
+    static lastIndexOfWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
+    static lerp(x: Vector64_1<CLROf<double>>, y: Vector64_1<CLROf<double>>, amount: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static lerp(x: Vector64_1<CLROf<float>>, y: Vector64_1<CLROf<float>>, amount: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static lessThan<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static lessThanAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static lessThanAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static lessThanOrEqual<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static lessThanOrEqualAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static lessThanOrEqualAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static load<T>(source: ptr<T>): Vector64_1<T>;
+    static loadAligned<T>(source: ptr<T>): Vector64_1<T>;
+    static loadAlignedNonTemporal<T>(source: ptr<T>): Vector64_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }, elementOffset: nuint): Vector64_1<T>;
+    static loadUnsafe2<T>(source: { value: ref<T> }): Vector64_1<T>;
+    static log(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static log(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static log22(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static log22(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static max<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static maxMagnitude<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static maxMagnitudeNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static maxNative<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static maxNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static min<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static minMagnitude<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static minMagnitudeNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static minNative<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static minNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static multiply3<T>(left: T, right: Vector64_1<T>): Vector64_1<T>;
+    static multiply3<T>(left: Vector64_1<T>, right: T): Vector64_1<T>;
+    static multiply3<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static multiplyAddEstimate(left: Vector64_1<CLROf<double>>, right: Vector64_1<CLROf<double>>, addend: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static multiplyAddEstimate(left: Vector64_1<CLROf<float>>, right: Vector64_1<CLROf<float>>, addend: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static narrow(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector64_1<CLROf<float>>;
+    static narrow(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector64_1<CLROf<sbyte>>;
+    static narrow(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector64_1<CLROf<short>>;
+    static narrow(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector64_1<CLROf<int>>;
+    static narrow(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<byte>>;
+    static narrow(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ushort>>;
+    static narrow(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<uint>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector64_1<CLROf<float>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector64_1<CLROf<sbyte>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector64_1<CLROf<short>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector64_1<CLROf<int>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<byte>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ushort>>;
+    static narrowWithSaturation(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<uint>>;
+    static negate<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static none<T>(vector: Vector64_1<T>, value: T): boolean;
+    static noneWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
+    static onesComplement<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static radiansToDegrees(radians: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static radiansToDegrees(radians: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static round3(vector: Vector64_1<CLROf<double>>, mode: MidpointRounding): Vector64_1<CLROf<double>>;
+    static round3(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static round3(vector: Vector64_1<CLROf<float>>, mode: MidpointRounding): Vector64_1<CLROf<float>>;
+    static round3(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static shiftLeft(vector: Vector64_1<CLROf<byte>>, shiftCount: int): Vector64_1<CLROf<byte>>;
+    static shiftLeft(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
+    static shiftLeft(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
+    static shiftLeft(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
+    static shiftLeft(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
+    static shiftLeft(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
+    static shiftLeft(vector: Vector64_1<CLROf<ushort>>, shiftCount: int): Vector64_1<CLROf<ushort>>;
+    static shiftLeft(vector: Vector64_1<CLROf<uint>>, shiftCount: int): Vector64_1<CLROf<uint>>;
+    static shiftLeft(vector: Vector64_1<CLROf<ulong>>, shiftCount: int): Vector64_1<CLROf<ulong>>;
+    static shiftLeft(vector: Vector64_1<CLROf<nuint>>, shiftCount: int): Vector64_1<CLROf<nuint>>;
+    static shiftRightArithmetic(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
+    static shiftRightArithmetic(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
+    static shiftRightArithmetic(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
+    static shiftRightArithmetic(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
+    static shiftRightArithmetic(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<byte>>, shiftCount: int): Vector64_1<CLROf<byte>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<ushort>>, shiftCount: int): Vector64_1<CLROf<ushort>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<uint>>, shiftCount: int): Vector64_1<CLROf<uint>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<ulong>>, shiftCount: int): Vector64_1<CLROf<ulong>>;
+    static shiftRightLogical(vector: Vector64_1<CLROf<nuint>>, shiftCount: int): Vector64_1<CLROf<nuint>>;
+    static shuffle(vector: Vector64_1<CLROf<byte>>, indices: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<byte>>;
+    static shuffle(vector: Vector64_1<CLROf<short>>, indices: Vector64_1<CLROf<short>>): Vector64_1<CLROf<short>>;
+    static shuffle(vector: Vector64_1<CLROf<int>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<int>>;
+    static shuffle(vector: Vector64_1<CLROf<sbyte>>, indices: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<sbyte>>;
+    static shuffle(vector: Vector64_1<CLROf<float>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
+    static shuffle(vector: Vector64_1<CLROf<ushort>>, indices: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<ushort>>;
+    static shuffle(vector: Vector64_1<CLROf<uint>>, indices: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<uint>>;
+    static shuffleNative(vector: Vector64_1<CLROf<byte>>, indices: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<byte>>;
+    static shuffleNative(vector: Vector64_1<CLROf<short>>, indices: Vector64_1<CLROf<short>>): Vector64_1<CLROf<short>>;
+    static shuffleNative(vector: Vector64_1<CLROf<int>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<int>>;
+    static shuffleNative(vector: Vector64_1<CLROf<sbyte>>, indices: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<sbyte>>;
+    static shuffleNative(vector: Vector64_1<CLROf<float>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
+    static shuffleNative(vector: Vector64_1<CLROf<ushort>>, indices: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<ushort>>;
+    static shuffleNative(vector: Vector64_1<CLROf<uint>>, indices: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<uint>>;
+    static sin(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static sin(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static sinCos(vector: Vector64_1<CLROf<double>>): ValueTuple_2<Vector64_1<CLROf<double>>, Vector64_1<CLROf<double>>>;
+    static sinCos(vector: Vector64_1<CLROf<float>>): ValueTuple_2<Vector64_1<CLROf<float>>, Vector64_1<CLROf<float>>>;
+    static sqrt<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static store<T>(source: Vector64_1<T>, destination: ptr<T>): void;
+    static storeAligned<T>(source: Vector64_1<T>, destination: ptr<T>): void;
+    static storeAlignedNonTemporal<T>(source: Vector64_1<T>, destination: ptr<T>): void;
+    static storeUnsafe2<T>(source: Vector64_1<T>, destination: { value: ref<T> }, elementOffset: nuint): void;
+    static storeUnsafe2<T>(source: Vector64_1<T>, destination: { value: ref<T> }): void;
+    static subtract<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static subtractSaturate<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static sum<T>(vector: Vector64_1<T>): T;
+    static toScalar<T>(vector: Vector64_1<T>): T;
+    static toVector128<T>(vector: Vector64_1<T>): Vector128_1<T>;
+    static toVector128Unsafe<T>(vector: Vector64_1<T>): Vector128_1<T>;
+    static truncate(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
+    static truncate(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static tryCopyTo<T>(vector: Vector64_1<T>, destination: Span_1<T>): boolean;
+    static widen(source: Vector64_1<CLROf<byte>>): ValueTuple_2<Vector64_1<CLROf<ushort>>, Vector64_1<CLROf<ushort>>>;
+    static widen(source: Vector64_1<CLROf<short>>): ValueTuple_2<Vector64_1<CLROf<int>>, Vector64_1<CLROf<int>>>;
+    static widen(source: Vector64_1<CLROf<int>>): ValueTuple_2<Vector64_1<CLROf<long>>, Vector64_1<CLROf<long>>>;
+    static widen(source: Vector64_1<CLROf<sbyte>>): ValueTuple_2<Vector64_1<CLROf<short>>, Vector64_1<CLROf<short>>>;
+    static widen(source: Vector64_1<CLROf<float>>): ValueTuple_2<Vector64_1<CLROf<double>>, Vector64_1<CLROf<double>>>;
+    static widen(source: Vector64_1<CLROf<ushort>>): ValueTuple_2<Vector64_1<CLROf<uint>>, Vector64_1<CLROf<uint>>>;
+    static widen(source: Vector64_1<CLROf<uint>>): ValueTuple_2<Vector64_1<CLROf<ulong>>, Vector64_1<CLROf<ulong>>>;
+    static widenLower(source: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<ushort>>;
+    static widenLower(source: Vector64_1<CLROf<short>>): Vector64_1<CLROf<int>>;
+    static widenLower(source: Vector64_1<CLROf<int>>): Vector64_1<CLROf<long>>;
+    static widenLower(source: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<short>>;
+    static widenLower(source: Vector64_1<CLROf<float>>): Vector64_1<CLROf<double>>;
+    static widenLower(source: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<uint>>;
+    static widenLower(source: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ulong>>;
+    static widenUpper(source: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<ushort>>;
+    static widenUpper(source: Vector64_1<CLROf<short>>): Vector64_1<CLROf<int>>;
+    static widenUpper(source: Vector64_1<CLROf<int>>): Vector64_1<CLROf<long>>;
+    static widenUpper(source: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<short>>;
+    static widenUpper(source: Vector64_1<CLROf<float>>): Vector64_1<CLROf<double>>;
+    static widenUpper(source: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<uint>>;
+    static widenUpper(source: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ulong>>;
+    static withElement<T>(vector: Vector64_1<T>, index: int, value: T): Vector64_1<T>;
+    static xor<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
 }