diff --git a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
index 8c36cca72907..8ab12cd8c705 100644
--- a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
+++ b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
@@ -136,6 +136,210 @@ internal Arm64() { }
             /// </summary>
             public static Vector128<sbyte> ReverseElementBits(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
 
+            /// <summary>
+            /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b)
+            ///   A64: UZP1 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<byte> UnzipEven(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b)
+            ///   A64: UZP1 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<short> UnzipEven(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b)
+            ///   A64: UZP1 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<int> UnzipEven(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b)
+            ///   A64: UZP1 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<sbyte> UnzipEven(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b)
+            ///   A64: UZP1 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<float> UnzipEven(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b)
+            ///   A64: UZP1 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<ushort> UnzipEven(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b)
+            ///   A64: UZP1 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<uint> UnzipEven(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b)
+            ///   A64: UZP1 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<byte> UnzipEven(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b)
+            ///   A64: UZP1 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<double> UnzipEven(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b)
+            ///   A64: UZP1 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<short> UnzipEven(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b)
+            ///   A64: UZP1 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<int> UnzipEven(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b)
+            ///   A64: UZP1 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<long> UnzipEven(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b)
+            ///   A64: UZP1 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<sbyte> UnzipEven(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b)
+            ///   A64: UZP1 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<float> UnzipEven(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b)
+            ///   A64: UZP1 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<ushort> UnzipEven(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b)
+            ///   A64: UZP1 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<uint> UnzipEven(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b)
+            ///   A64: UZP1 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<ulong> UnzipEven(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b)
+            ///   A64: UZP2 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<byte> UnzipOdd(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b)
+            ///   A64: UZP2 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<short> UnzipOdd(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b)
+            ///   A64: UZP2 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<int> UnzipOdd(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b)
+            ///   A64: UZP2 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<sbyte> UnzipOdd(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b)
+            ///   A64: UZP2 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<float> UnzipOdd(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b)
+            ///   A64: UZP2 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<ushort> UnzipOdd(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b)
+            ///   A64: UZP2 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<uint> UnzipOdd(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b)
+            ///   A64: UZP2 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<byte> UnzipOdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b)
+            ///   A64: UZP2 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<double> UnzipOdd(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b)
+            ///   A64: UZP2 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<short> UnzipOdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b)
+            ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<int> UnzipOdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b)
+            ///   A64: UZP2 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<long> UnzipOdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b)
+            ///   A64: UZP2 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<sbyte> UnzipOdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// float32x4_t vuzp2_f32(float32x4_t a, float32x4_t b)
+            ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<float> UnzipOdd(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b)
+            ///   A64: UZP2 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<ushort> UnzipOdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b)
+            ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<uint> UnzipOdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b)
+            ///   A64: UZP2 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<ulong> UnzipOdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
             /// <summary>
             /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b)
             ///   A64: ZIP2 Vd.8B, Vn.8B, Vm.8B
diff --git a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.cs b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.cs
index 0629fa663e52..4907e7b8f7f8 100644
--- a/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.cs
+++ b/src/System.Private.CoreLib/shared/System/Runtime/Intrinsics/Arm/AdvSimd.cs
@@ -138,6 +138,210 @@ internal Arm64() { }
             /// </summary>
             public static Vector128<sbyte> ReverseElementBits(Vector128<sbyte> value) => ReverseElementBits(value);
 
+            /// <summary>
+            /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b)
+            ///   A64: UZP1 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<byte> UnzipEven(Vector64<byte> left, Vector64<byte> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b)
+            ///   A64: UZP1 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<short> UnzipEven(Vector64<short> left, Vector64<short> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b)
+            ///   A64: UZP1 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<int> UnzipEven(Vector64<int> left, Vector64<int> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b)
+            ///   A64: UZP1 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<sbyte> UnzipEven(Vector64<sbyte> left, Vector64<sbyte> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b)
+            ///   A64: UZP1 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<float> UnzipEven(Vector64<float> left, Vector64<float> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b)
+            ///   A64: UZP1 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<ushort> UnzipEven(Vector64<ushort> left, Vector64<ushort> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b)
+            ///   A64: UZP1 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<uint> UnzipEven(Vector64<uint> left, Vector64<uint> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b)
+            ///   A64: UZP1 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<byte> UnzipEven(Vector128<byte> left, Vector128<byte> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b)
+            ///   A64: UZP1 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<double> UnzipEven(Vector128<double> left, Vector128<double> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b)
+            ///   A64: UZP1 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<short> UnzipEven(Vector128<short> left, Vector128<short> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b)
+            ///   A64: UZP1 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<int> UnzipEven(Vector128<int> left, Vector128<int> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b)
+            ///   A64: UZP1 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<long> UnzipEven(Vector128<long> left, Vector128<long> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b)
+            ///   A64: UZP1 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<sbyte> UnzipEven(Vector128<sbyte> left, Vector128<sbyte> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b)
+            ///   A64: UZP1 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<float> UnzipEven(Vector128<float> left, Vector128<float> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b)
+            ///   A64: UZP1 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<ushort> UnzipEven(Vector128<ushort> left, Vector128<ushort> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b)
+            ///   A64: UZP1 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<uint> UnzipEven(Vector128<uint> left, Vector128<uint> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b)
+            ///   A64: UZP1 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<ulong> UnzipEven(Vector128<ulong> left, Vector128<ulong> right) => UnzipEven(left, right);
+
+            /// <summary>
+            /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b)
+            ///   A64: UZP2 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<byte> UnzipOdd(Vector64<byte> left, Vector64<byte> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b)
+            ///   A64: UZP2 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<short> UnzipOdd(Vector64<short> left, Vector64<short> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b)
+            ///   A64: UZP2 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<int> UnzipOdd(Vector64<int> left, Vector64<int> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b)
+            ///   A64: UZP2 Vd.8B, Vn.8B, Vm.8B
+            /// </summary>
+            public static Vector64<sbyte> UnzipOdd(Vector64<sbyte> left, Vector64<sbyte> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b)
+            ///   A64: UZP2 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<float> UnzipOdd(Vector64<float> left, Vector64<float> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b)
+            ///   A64: UZP2 Vd.4H, Vn.4H, Vm.4H
+            /// </summary>
+            public static Vector64<ushort> UnzipOdd(Vector64<ushort> left, Vector64<ushort> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b)
+            ///   A64: UZP2 Vd.2S, Vn.2S, Vm.2S
+            /// </summary>
+            public static Vector64<uint> UnzipOdd(Vector64<uint> left, Vector64<uint> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b)
+            ///   A64: UZP2 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<byte> UnzipOdd(Vector128<byte> left, Vector128<byte> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b)
+            ///   A64: UZP2 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<double> UnzipOdd(Vector128<double> left, Vector128<double> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b)
+            ///   A64: UZP2 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<short> UnzipOdd(Vector128<short> left, Vector128<short> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b)
+            ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<int> UnzipOdd(Vector128<int> left, Vector128<int> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b)
+            ///   A64: UZP2 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<long> UnzipOdd(Vector128<long> left, Vector128<long> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b)
+            ///   A64: UZP2 Vd.16B, Vn.16B, Vm.16B
+            /// </summary>
+            public static Vector128<sbyte> UnzipOdd(Vector128<sbyte> left, Vector128<sbyte> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// float32x4_t vuzp2q_f32(float32x4_t a, float32x4_t b)
+            ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<float> UnzipOdd(Vector128<float> left, Vector128<float> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b)
+            ///   A64: UZP2 Vd.8H, Vn.8H, Vm.8H
+            /// </summary>
+            public static Vector128<ushort> UnzipOdd(Vector128<ushort> left, Vector128<ushort> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b)
+            ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
+            /// </summary>
+            public static Vector128<uint> UnzipOdd(Vector128<uint> left, Vector128<uint> right) => UnzipOdd(left, right);
+
+            /// <summary>
+            /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b)
+            ///   A64: UZP2 Vd.2D, Vn.2D, Vm.2D
+            /// </summary>
+            public static Vector128<ulong> UnzipOdd(Vector128<ulong> left, Vector128<ulong> right) => UnzipOdd(left, right);
+
             /// <summary>
             /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b)
             ///   A64: ZIP2 Vd.8B, Vn.8B, Vm.8B