# System.Runtime.Intrinsics.Arm.Arm64

``` diff
-namespace System.Runtime.Intrinsics.Arm.Arm64 {
 {
-    public static class Aes {
 {
-        public static bool IsSupported { get; }

-        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey);

-        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey);

-        public static Vector128<byte> InverseMixColumns(Vector128<byte> value);

-        public static Vector128<byte> MixColumns(Vector128<byte> value);

-    }
-    public static class Base {
 {
-        public static bool IsSupported { get; }

-        public static int LeadingSignCount(int value);

-        public static int LeadingSignCount(long value);

-        public static int LeadingZeroCount(int value);

-        public static int LeadingZeroCount(long value);

-        public static int LeadingZeroCount(uint value);

-        public static int LeadingZeroCount(ulong value);

-    }
-    public static class Sha1 {
 {
-        public static bool IsSupported { get; }

-        public static uint FixedRotate(uint hash_e);

-        public static Vector128<uint> HashChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);

-        public static Vector128<uint> HashMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);

-        public static Vector128<uint> HashParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);

-        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11);

-        public static Vector128<uint> SchedulePart2(Vector128<uint> tw0_3, Vector128<uint> w12_15);

-    }
-    public static class Sha256 {
 {
-        public static bool IsSupported { get; }

-        public static Vector128<uint> HashLower(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk);

-        public static Vector128<uint> HashUpper(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk);

-        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7);

-        public static Vector128<uint> SchedulePart2(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15);

-    }
-    public static class Simd {
 {
-        public static bool IsSupported { get; }

-        public static Vector128<double> Abs(Vector128<double> value);

-        public static Vector128<ushort> Abs(Vector128<short> value);

-        public static Vector128<uint> Abs(Vector128<int> value);

-        public static Vector128<ulong> Abs(Vector128<long> value);

-        public static Vector128<byte> Abs(Vector128<sbyte> value);

-        public static Vector128<float> Abs(Vector128<float> value);

-        public static Vector64<ushort> Abs(Vector64<short> value);

-        public static Vector64<uint> Abs(Vector64<int> value);

-        public static Vector64<byte> Abs(Vector64<sbyte> value);

-        public static Vector64<float> Abs(Vector64<float> value);

-        public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> Add<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> And<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> And<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> AndNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> AndNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> BitwiseSelect<T>(Vector128<T> sel, Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> BitwiseSelect<T>(Vector64<T> sel, Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> CompareEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> CompareEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> CompareEqualZero<T>(Vector128<T> value) where T : struct;

-        public static Vector64<T> CompareEqualZero<T>(Vector64<T> value) where T : struct;

-        public static Vector128<T> CompareGreaterThan<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> CompareGreaterThan<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> CompareGreaterThanOrEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> CompareGreaterThanOrEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> CompareGreaterThanOrEqualZero<T>(Vector128<T> value) where T : struct;

-        public static Vector64<T> CompareGreaterThanOrEqualZero<T>(Vector64<T> value) where T : struct;

-        public static Vector128<T> CompareGreaterThanZero<T>(Vector128<T> value) where T : struct;

-        public static Vector64<T> CompareGreaterThanZero<T>(Vector64<T> value) where T : struct;

-        public static Vector128<T> CompareLessThanOrEqualZero<T>(Vector128<T> value) where T : struct;

-        public static Vector64<T> CompareLessThanOrEqualZero<T>(Vector64<T> value) where T : struct;

-        public static Vector128<T> CompareLessThanZero<T>(Vector128<T> value) where T : struct;

-        public static Vector64<T> CompareLessThanZero<T>(Vector64<T> value) where T : struct;

-        public static Vector128<T> CompareTest<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> CompareTest<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right);

-        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right);

-        public static Vector64<float> Divide(Vector64<float> left, Vector64<float> right);

-        public static T Extract<T>(Vector128<T> vector, byte index) where T : struct;

-        public static T Extract<T>(Vector64<T> vector, byte index) where T : struct;

-        public static Vector128<T> Insert<T>(Vector128<T> vector, byte index, T data) where T : struct;

-        public static Vector64<T> Insert<T>(Vector64<T> vector, byte index, T data) where T : struct;

-        public static Vector128<short> LeadingSignCount(Vector128<short> value);

-        public static Vector128<int> LeadingSignCount(Vector128<int> value);

-        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value);

-        public static Vector64<short> LeadingSignCount(Vector64<short> value);

-        public static Vector64<int> LeadingSignCount(Vector64<int> value);

-        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value);

-        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value);

-        public static Vector128<short> LeadingZeroCount(Vector128<short> value);

-        public static Vector128<int> LeadingZeroCount(Vector128<int> value);

-        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value);

-        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value);

-        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value);

-        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value);

-        public static Vector64<short> LeadingZeroCount(Vector64<short> value);

-        public static Vector64<int> LeadingZeroCount(Vector64<int> value);

-        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value);

-        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value);

-        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value);

-        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right);

-        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right);

-        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right);

-        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right);

-        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right);

-        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right);

-        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right);

-        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right);

-        public static Vector64<byte> Max(Vector64<byte> left, Vector64<byte> right);

-        public static Vector64<short> Max(Vector64<short> left, Vector64<short> right);

-        public static Vector64<int> Max(Vector64<int> left, Vector64<int> right);

-        public static Vector64<sbyte> Max(Vector64<sbyte> left, Vector64<sbyte> right);

-        public static Vector64<float> Max(Vector64<float> left, Vector64<float> right);

-        public static Vector64<ushort> Max(Vector64<ushort> left, Vector64<ushort> right);

-        public static Vector64<uint> Max(Vector64<uint> left, Vector64<uint> right);

-        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right);

-        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right);

-        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right);

-        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right);

-        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right);

-        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right);

-        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right);

-        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right);

-        public static Vector64<byte> Min(Vector64<byte> left, Vector64<byte> right);

-        public static Vector64<short> Min(Vector64<short> left, Vector64<short> right);

-        public static Vector64<int> Min(Vector64<int> left, Vector64<int> right);

-        public static Vector64<sbyte> Min(Vector64<sbyte> left, Vector64<sbyte> right);

-        public static Vector64<float> Min(Vector64<float> left, Vector64<float> right);

-        public static Vector64<ushort> Min(Vector64<ushort> left, Vector64<ushort> right);

-        public static Vector64<uint> Min(Vector64<uint> left, Vector64<uint> right);

-        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right);

-        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right);

-        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right);

-        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right);

-        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right);

-        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right);

-        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right);

-        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right);

-        public static Vector64<byte> Multiply(Vector64<byte> left, Vector64<byte> right);

-        public static Vector64<short> Multiply(Vector64<short> left, Vector64<short> right);

-        public static Vector64<int> Multiply(Vector64<int> left, Vector64<int> right);

-        public static Vector64<sbyte> Multiply(Vector64<sbyte> left, Vector64<sbyte> right);

-        public static Vector64<float> Multiply(Vector64<float> left, Vector64<float> right);

-        public static Vector64<ushort> Multiply(Vector64<ushort> left, Vector64<ushort> right);

-        public static Vector64<uint> Multiply(Vector64<uint> left, Vector64<uint> right);

-        public static Vector128<double> Negate(Vector128<double> value);

-        public static Vector128<short> Negate(Vector128<short> value);

-        public static Vector128<int> Negate(Vector128<int> value);

-        public static Vector128<long> Negate(Vector128<long> value);

-        public static Vector128<sbyte> Negate(Vector128<sbyte> value);

-        public static Vector128<float> Negate(Vector128<float> value);

-        public static Vector64<short> Negate(Vector64<short> value);

-        public static Vector64<int> Negate(Vector64<int> value);

-        public static Vector64<sbyte> Negate(Vector64<sbyte> value);

-        public static Vector64<float> Negate(Vector64<float> value);

-        public static Vector128<T> Not<T>(Vector128<T> value) where T : struct;

-        public static Vector64<T> Not<T>(Vector64<T> value) where T : struct;

-        public static Vector128<T> Or<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> Or<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> OrNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> OrNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<byte> PopCount(Vector128<byte> value);

-        public static Vector128<sbyte> PopCount(Vector128<sbyte> value);

-        public static Vector64<byte> PopCount(Vector64<byte> value);

-        public static Vector64<sbyte> PopCount(Vector64<sbyte> value);

-        public static Vector128<T> SetAllVector128<T>(T value) where T : struct;

-        public static Vector64<T> SetAllVector64<T>(T value) where T : struct;

-        public static Vector128<double> Sqrt(Vector128<double> value);

-        public static Vector128<float> Sqrt(Vector128<float> value);

-        public static Vector64<float> Sqrt(Vector64<float> value);

-        public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> Subtract<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-        public static Vector128<T> Xor<T>(Vector128<T> left, Vector128<T> right) where T : struct;

-        public static Vector64<T> Xor<T>(Vector64<T> left, Vector64<T> right) where T : struct;

-    }
-}
```

