class AdvSimd.Arm64
{
            /// <summary>
            /// float64x2_t vld1q_dup_f64 (float64_t const * ptr)
            ///   A64: LD1R { Vt.2D }, [Xn]
            /// </summary>
            public static unsafe Vector128<double> LoadAndReplicateToVector128(double* address) => LoadAndReplicateToVector128(address);

            /// <summary>
            /// int64x2_t vld1q_dup_s64 (int64_t const * ptr)
            ///   A64: LD1R { Vt.2D }, [Xn]
            /// </summary>
            public static unsafe Vector128<long> LoadAndReplicateToVector128(long* address) => LoadAndReplicateToVector128(address);

            /// <summary>
            /// uint64x2_t vld1q_dup_u64 (uint64_t const * ptr)
            ///   A64: LD1R { Vt.2D }, [Xn]
            /// </summary>
            public static unsafe Vector128<ulong> LoadAndReplicateToVector128(ulong* address) => LoadAndReplicateToVector128(address);
}
class AdvSimd
{
        /// <summary>
        /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr)
        ///   A32: VLD1.8 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.8B }, [Xn]
        /// </summary>
        public static unsafe Vector64<byte> LoadAndReplicateToVector64(byte* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// int16x4_t vld1_dup_s16 (int16_t const * ptr)
        ///   A32: VLD1.16 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.4H }, [Xn]
        /// </summary>
        public static unsafe Vector64<short> LoadAndReplicateToVector64(short* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// int32x2_t vld1_dup_s32 (int32_t const * ptr)
        ///   A32: VLD1.32 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.2S }, [Xn]
        /// </summary>
        public static unsafe Vector64<int> LoadAndReplicateToVector64(int* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// int8x8_t vld1_dup_s8 (int8_t const * ptr)
        ///   A32: VLD1.8 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.8B }, [Xn]
        /// </summary>
        public static unsafe Vector64<sbyte> LoadAndReplicateToVector64(sbyte* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// float32x2_t vld1_dup_f32 (float32_t const * ptr)
        ///   A32: VLD1.32 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.2S }, [Xn]
        /// </summary>
        public static unsafe Vector64<float> LoadAndReplicateToVector64(float* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// uint16x4_t vld1_dup_u16 (uint16_t const * ptr)
        ///   A32: VLD1.16 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.4H }, [Xn]
        /// </summary>
        public static unsafe Vector64<ushort> LoadAndReplicateToVector64(ushort* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// uint32x2_t vld1_dup_u32 (uint32_t const * ptr)
        ///   A32: VLD1.32 { Dd[] }, [Rn]
        ///   A64: LD1R { Vt.2S }, [Xn]
        /// </summary>
        public static unsafe Vector64<uint> LoadAndReplicateToVector64(uint* address) => LoadAndReplicateToVector64(address);

        /// <summary>
        /// uint8x16_t vld1q_dup_u8 (uint8_t const * ptr)
        ///   A32: VLD1.8 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.16B }, [Xn]
        /// </summary>
        public static unsafe Vector128<byte> LoadAndReplicateToVector128(byte* address) => LoadAndReplicateToVector128(address);

        /// <summary>
        /// int16x8_t vld1q_dup_s16 (int16_t const * ptr)
        ///   A32: VLD1.16 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.8H }, [Xn]
        /// </summary>
        public static unsafe Vector128<short> LoadAndReplicateToVector128(short* address) => LoadAndReplicateToVector128(address);

        /// <summary>
        /// int32x4_t vld1q_dup_s32 (int32_t const * ptr)
        ///   A32: VLD1.32 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.4S }, [Xn]
        /// </summary>
        public static unsafe Vector128<int> LoadAndReplicateToVector128(int* address) => LoadAndReplicateToVector128(address);

        /// <summary>
        /// int8x16_t vld1q_dup_s8 (int8_t const * ptr)
        ///   A32: VLD1.8 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.16B }, [Xn]
        /// </summary>
        public static unsafe Vector128<sbyte> LoadAndReplicateToVector128(sbyte* address) => LoadAndReplicateToVector128(address);

        /// <summary>
        /// float32x4_t vld1q_dup_f32 (float32_t const * ptr)
        ///   A32: VLD1.32 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.4S }, [Xn]
        /// </summary>
        public static unsafe Vector128<float> LoadAndReplicateToVector128(float* address) => LoadAndReplicateToVector128(address);

        /// <summary>
        /// uint16x8_t vld1q_dup_u16 (uint16_t const * ptr)
        ///   A32: VLD1.16 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.8H }, [Xn]
        /// </summary>
        public static unsafe Vector128<ushort> LoadAndReplicateToVector128(ushort* address) => LoadAndReplicateToVector128(address);

        /// <summary>
        /// uint32x4_t vld1q_dup_u32 (uint32_t const * ptr)
        ///   A32: VLD1.32 { Dd[], Dd+1[] }, [Rn]
        ///   A64: LD1R { Vt.4S }, [Xn]
        /// </summary>
        public static unsafe Vector128<uint> LoadAndReplicateToVector128(uint* address) => LoadAndReplicateToVector128(address);
}